Oci8Connection::getDefaultSchemaGrammar() - Code Metrics - Inspection of "WIP: Fix #558." - yajra/laravel-oci8 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#562)

by Arjay

created 2020-02-11 03:50 UTC

Oci8Connection::getDefaultSchemaGrammar() A

↳ Parent: Oci8Connection

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
nc	1
nop	0
dl	0
loc	4
ccs	0
cts	0
cp	0
crap	2
rs	10
c	0
b	0
f	0

<?php

namespace Yajra\Oci8;

use Doctrine\DBAL\Connection as DoctrineConnection;
use Doctrine\DBAL\Driver\OCI8\Driver as DoctrineDriver;
use Exception;
use Illuminate\Database\Connection;
use Illuminate\Database\Grammar;
use Illuminate\Support\Str;
use PDO;
use PDOStatement;
use Throwable;
use Yajra\Oci8\Query\Grammars\OracleGrammar as QueryGrammar;
use Yajra\Oci8\Query\OracleBuilder as QueryBuilder;
use Yajra\Oci8\Query\Processors\OracleProcessor as Processor;
use Yajra\Oci8\Schema\Grammars\OracleGrammar as SchemaGrammar;
use Yajra\Oci8\Schema\OracleBuilder as SchemaBuilder;
use Yajra\Oci8\Schema\Sequence;
use Yajra\Oci8\Schema\Trigger;
use Yajra\Pdo\Oci8\Statement;

class Oci8Connection extends Connection
{
    const RECONNECT_ERRORS = 'reconnect_errors';

    /**
     * @var string
     */
    protected $schema;

    /**
     * @var \Yajra\Oci8\Schema\Sequence
     */
    protected $sequence;

    /**
     * @var \Yajra\Oci8\Schema\Trigger
     */
    protected $trigger;

    /**
     * @param PDO|\Closure $pdo
     * @param string       $database
     * @param string       $tablePrefix
     * @param array        $config
     */
    public function __construct($pdo, $database = '', $tablePrefix = '', array $config = [])
    {
        parent::__construct($pdo, $database, $tablePrefix, $config);
        $this->sequence = new Sequence($this);
        $this->trigger  = new Trigger($this);
    }

    /**
     * Get current schema.
     *
     * @return string
     */
    public function getSchema()
    {
        return $this->schema;
    }

    /**
     * Set current schema.
     *
     * @param string $schema
     * @return $this
     */
    public function setSchema($schema)
    {
        $this->schema = $schema;
        $sessionVars  = [
            'CURRENT_SCHEMA' => $schema,
        ];

        return $this->setSessionVars($sessionVars);
    }

    /**
     * Update oracle session variables.
     *
     * @param array $sessionVars
     * @return $this
     */
    public function setSessionVars(array $sessionVars)
    {
        $vars = [];
        foreach ($sessionVars as $option => $value) {
            if (strtoupper($option) == 'CURRENT_SCHEMA' || strtoupper($option) == 'EDITION') {
                $vars[] = "$option  = $value";
            } else {
                $vars[] = "$option  = '$value'";
            }
        }

        if ($vars) {

            $sql = 'ALTER SESSION SET ' . implode(' ', $vars);
            $this->statement($sql);
        }

        return $this;
    }

    /**
     * Get sequence class.
     *
     * @return \Yajra\Oci8\Schema\Sequence
     */
    public function getSequence()
    {
        return $this->sequence;
    }

    /**
     * Set sequence class.
     *
     * @param \Yajra\Oci8\Schema\Sequence $sequence
     * @return \Yajra\Oci8\Schema\Sequence
     */
    public function setSequence(Sequence $sequence)
    {
        return $this->sequence = $sequence;
    }

    /**
     * Get oracle trigger class.
     *
     * @return \Yajra\Oci8\Schema\Trigger
     */
    public function getTrigger()
    {
        return $this->trigger;
    }

    /**
     * Set oracle trigger class.
     *
     * @param \Yajra\Oci8\Schema\Trigger $trigger
     * @return \Yajra\Oci8\Schema\Trigger
     */
    public function setTrigger(Trigger $trigger)
    {
        return $this->trigger = $trigger;
    }

    /**
     * Get a schema builder instance for the connection.
     *
     * @return \Yajra\Oci8\Schema\OracleBuilder
     */
    public function getSchemaBuilder()
    {
        if (is_null($this->schemaGrammar)) {
            $this->useDefaultSchemaGrammar();
        }

        return new SchemaBuilder($this);
    }

    /**
     * Get a new query builder instance.
     *
     * @return \Illuminate\Database\Query\Builder
     */
    public function query()
    {
        return new QueryBuilder(
            $this, $this->getQueryGrammar(), $this->getPostProcessor()
        );
    }

    /**
     * Set oracle session date format.
     *
     * @param string $format
     * @return $this
     */
    public function setDateFormat($format = 'YYYY-MM-DD HH24:MI:SS')
    {
        $sessionVars = [
            'NLS_DATE_FORMAT'      => $format,
            'NLS_TIMESTAMP_FORMAT' => $format,
        ];

        return $this->setSessionVars($sessionVars);
    }

    /**
     * Get doctrine connection.
     *
     * @return \Doctrine\DBAL\Connection
     */
    public function getDoctrineConnection()
    {
        if (is_null($this->doctrineConnection)) {
            $data                     = ['pdo' => $this->getPdo(), 'user' => $this->getConfig('username')];
            $this->doctrineConnection = new DoctrineConnection(
                $data,
                $this->getDoctrineDriver()
            );
        }

        return $this->doctrineConnection;
    }

    /**
     * Get doctrine driver.
     *
     * @return \Doctrine\DBAL\Driver\OCI8\Driver
     */
    protected function getDoctrineDriver()
    {
        return new DoctrineDriver();
    }

    /**
     * Execute a PL/SQL Function and return its value.
     * Usage: DB::executeFunction('function_name(:binding_1,:binding_n)', [':binding_1' => 'hi', ':binding_n' =>
     * 'bye'], PDO::PARAM_LOB).
     *
     * @param string $functionName
     * @param array  $bindings (kvp array)
     * @param int    $returnType (PDO::PARAM_*)
     * @param int    $length
     * @return mixed $returnType
     */
    public function executeFunction($functionName, array $bindings = [], $returnType = PDO::PARAM_STR, $length = null)
    {
        $stmt = $this->createStatementFromFunction($functionName, $bindings);

        $stmt = $this->addBindingsToStatement($stmt, $bindings);

        $stmt->bindParam(':result', $result, $returnType, $length);
        $stmt->execute();

        return $result;
    }

    /**
     * Execute a PL/SQL Procedure and return its results.
     *
     * Usage: DB::executeProcedure($procedureName, $bindings).
     * $bindings looks like:
     *         $bindings = [
     *                  'p_userid'  => $id
     *         ];
     *
     * @param  string $procedureName
     * @param  array  $bindings
     * @return bool
     */
    public function executeProcedure($procedureName, array $bindings = [])
    {
        $stmt = $this->createStatementFromProcedure($procedureName, $bindings);

        $stmt = $this->addBindingsToStatement($stmt, $bindings);

        return $stmt->execute();
    }

    /**
     * Execute a PL/SQL Procedure and return its cursor result.
     * Usage: DB::executeProcedureWithCursor($procedureName, $bindings).
     *
     * https://docs.oracle.com/cd/E17781_01/appdev.112/e18555/ch_six_ref_cur.htm#TDPPH218
     *
     * @param  string $procedureName
     * @param  array  $bindings
     * @param  string $cursorName
     * @return array
     */
    public function executeProcedureWithCursor($procedureName, array $bindings = [], $cursorName = ':cursor')
    {
        $stmt = $this->createStatementFromProcedure($procedureName, $bindings, $cursorName);

        $stmt = $this->addBindingsToStatement($stmt, $bindings);

        $cursor = null;
        $stmt->bindParam($cursorName, $cursor, PDO::PARAM_STMT);
        $stmt->execute();

        $statement = new Statement($cursor, $this->getPdo(), $this->getPdo()->getOptions());
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        $statement->execute();
        $results = $statement->fetchAll(PDO::FETCH_OBJ);
        $statement->closeCursor();

        return $results;
    }

    /**
     * Creates sql command to run a procedure with bindings.
     *
     * @param  string      $procedureName
     * @param  array       $bindings
     * @param  string|bool $cursor
     * @return string
     */
    public function createSqlFromProcedure($procedureName, array $bindings, $cursor = false)
    {
        $paramsString = implode(',', array_map(function ($param) {
            return ':' . $param;
        }, array_keys($bindings)));

        $prefix = count($bindings) ? ',' : '';
        $cursor = $cursor ? $prefix . $cursor : null;

        return sprintf('begin %s(%s%s); end;', $procedureName, $paramsString, $cursor);
    }

    /**
     * Creates statement from procedure.
     *
     * @param  string      $procedureName
     * @param  array       $bindings
     * @param  string|bool $cursorName
     * @return PDOStatement
     */
    public function createStatementFromProcedure($procedureName, array $bindings, $cursorName = false)
    {
        $sql = $this->createSqlFromProcedure($procedureName, $bindings, $cursorName);

        return $this->getPdo()->prepare($sql);
    }

    /**
     * Create statement from function.
     *
     * @param string $functionName
     * @param array  $bindings
     * @return PDOStatement
     */
    public function createStatementFromFunction($functionName, array $bindings)
    {
        $bindings = $bindings ? ':' . implode(', :', array_keys($bindings)) : '';

        $sql = sprintf('begin :result := %s(%s); end;', $functionName, $bindings);

        return $this->getPdo()->prepare($sql);
    }

    /**
     * Bind values to their parameters in the given statement.
     *
     * @param  \PDOStatement  $statement
     * @param  array  $bindings
     * @return void
     */
    public function bindValues($statement, $bindings)
    {
        foreach ($bindings as $key => $value) {
            $statement->bindValue(
                is_string($key) ? $key : $key + 1, $value,
                is_int($value) || is_null($value) ? PDO::PARAM_INT : PDO::PARAM_STR
            );
        }
    }

    /**
     * Get the default query grammar instance.
     *
     * @return \Illuminate\Database\Grammar|\Yajra\Oci8\Query\Grammars\OracleGrammar
     */
    protected function getDefaultQueryGrammar()
    {
        return $this->withTablePrefix(new QueryGrammar());
    }

    /**
     * Set the table prefix and return the grammar.
     *
     * @param \Illuminate\Database\Grammar|\Yajra\Oci8\Query\Grammars\OracleGrammar|\Yajra\Oci8\Schema\Grammars\OracleGrammar $grammar
     * @return \Illuminate\Database\Grammar
     */
    public function withTablePrefix(Grammar $grammar)
    {
        return $this->withSchemaPrefix(parent::withTablePrefix($grammar));
    }

    /**
     * Set the schema prefix and return the grammar.
     *
     * @param \Illuminate\Database\Grammar|\Yajra\Oci8\Query\Grammars\OracleGrammar|\Yajra\Oci8\Schema\Grammars\OracleGrammar $grammar
     * @return \Illuminate\Database\Grammar
     */
    public function withSchemaPrefix(Grammar $grammar)
    {
        $grammar->setSchemaPrefix($this->getConfigSchemaPrefix());

        return $grammar;
    }

    /**
     * Get config schema prefix.
     *
     * @return string
     */
    protected function getConfigSchemaPrefix()
    {
        return isset($this->config['prefix_schema']) ? $this->config['prefix_schema'] : '';
    }

    /**
     * Get the default schema grammar instance.
     *
     * @return \Illuminate\Database\Grammar|\Yajra\Oci8\Schema\Grammars\OracleGrammar
     */
    protected function getDefaultSchemaGrammar()
    {
        return $this->withTablePrefix(new SchemaGrammar());
    }

    /**
     * Get the default post processor instance.
     *
     * @return \Yajra\Oci8\Query\Processors\OracleProcessor
     */
    protected function getDefaultPostProcessor()
    {
        return new Processor();
    }

    /**
     * Add bindings to statement.
     *
     * @param  array        $bindings
     * @param  PDOStatement $stmt
     * @return PDOStatement
     */
    public function addBindingsToStatement(PDOStatement $stmt, array $bindings)
    {
        foreach ($bindings as $key => &$binding) {
            $value  = &$binding;
            $type   = PDO::PARAM_STR;
            $length = -1;

            if (is_array($binding)) {
                $value  = &$binding['value'];
                $type   = array_key_exists('type', $binding) ? $binding['type'] : PDO::PARAM_STR;
                $length = array_key_exists('length', $binding) ? $binding['length'] : -1;
            }

            $stmt->bindParam(':' . $key, $value, $type, $length);
        }

        return $stmt;
    }

    /**
     * Determine if the given exception was caused by a lost connection.
     *
     * @param  \Exception  $e
     * @return bool
     */
    protected function causedByLostConnection(Throwable $e)
    {
        if (parent::causedByLostConnection($e)) {
            return true;
        }

        $lostConnectionErrors = [
            'ORA-03113',    //End-of-file on communication channel
            'ORA-03114',    //Not Connected to Oracle
            'ORA-03135',    //Connection lost contact
            'ORA-12170',    //Connect timeout occurred
            'ORA-12537',    //Connection closed
            'ORA-27146',    //Post/wait initialization failed
            'ORA-25408',    //Can not safely replay call
            'ORA-56600',    //Illegal Call
        ];

        $additionalErrors = null;

        $options = isset($this->config['options']) ? $this->config['options'] : [];
        if (array_key_exists(static::RECONNECT_ERRORS, $options)) {
            $additionalErrors = $this->config['options'][static::RECONNECT_ERRORS];
        }

        if (is_array($additionalErrors)) {
            $lostConnectionErrors = array_merge($lostConnectionErrors,
                $this->config['options'][static::RECONNECT_ERRORS]);
        }

        return Str::contains($e->getMessage(), $lostConnectionErrors);
    }
}


1			<?php
2
3			namespace Yajra\Oci8;
4
5			use Doctrine\DBAL\Connection as DoctrineConnection;
6			use Doctrine\DBAL\Driver\OCI8\Driver as DoctrineDriver;
7			use Exception;
8			use Illuminate\Database\Connection;
9			use Illuminate\Database\Grammar;
10			use Illuminate\Support\Str;
11			use PDO;
12			use PDOStatement;
13			use Throwable;
14			use Yajra\Oci8\Query\Grammars\OracleGrammar as QueryGrammar;
15			use Yajra\Oci8\Query\OracleBuilder as QueryBuilder;
16			use Yajra\Oci8\Query\Processors\OracleProcessor as Processor;
17			use Yajra\Oci8\Schema\Grammars\OracleGrammar as SchemaGrammar;
18			use Yajra\Oci8\Schema\OracleBuilder as SchemaBuilder;
19			use Yajra\Oci8\Schema\Sequence;
20			use Yajra\Oci8\Schema\Trigger;
21			use Yajra\Pdo\Oci8\Statement;
22
23			class Oci8Connection extends Connection
24			{
25			const RECONNECT_ERRORS = 'reconnect_errors';
26
27			/**
28			* @var string
29			*/
30			protected $schema;
31
32			/**
33			* @var \Yajra\Oci8\Schema\Sequence
34			*/
35			protected $sequence;
36
37			/**
38			* @var \Yajra\Oci8\Schema\Trigger
39			*/
40			protected $trigger;
41
42			/**
43			* @param PDO\|\Closure $pdo
44			* @param string $database
45			* @param string $tablePrefix
46			* @param array $config
47			*/
48			public function __construct($pdo, $database = '', $tablePrefix = '', array $config = [])
49			{
50			parent::__construct($pdo, $database, $tablePrefix, $config);
51			$this->sequence = new Sequence($this);
52			$this->trigger = new Trigger($this);
53			}
54
55			/**
56			* Get current schema.
57			*
58			* @return string
59			*/
60			public function getSchema()
61			{
62			return $this->schema;
63			}
64
65			/**
66			* Set current schema.
67			*
68			* @param string $schema
69			* @return $this
70			*/
71			public function setSchema($schema)
72			{
73			$this->schema = $schema;
74			$sessionVars = [
75			'CURRENT_SCHEMA' => $schema,
76			];
77
78			return $this->setSessionVars($sessionVars);
79			}
80
81			/**
82			* Update oracle session variables.
83			*
84			* @param array $sessionVars
85			* @return $this
86			*/
87			public function setSessionVars(array $sessionVars)
88			{
89			$vars = [];
90			foreach ($sessionVars as $option => $value) {
91			if (strtoupper($option) == 'CURRENT_SCHEMA' \|\| strtoupper($option) == 'EDITION') {
92			$vars[] = "$option = $value";
93			} else {
94			$vars[] = "$option = '$value'";
95			}
96			}
97
98			if ($vars) {
			0 ignored issues – show Bug Best Practice introduced 2016-07-12 04:23 UTC by Report Bug Copy Issue Report The expression `$vars` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
99			$sql = 'ALTER SESSION SET ' . implode(' ', $vars);
100			$this->statement($sql);
101			}
102
103			return $this;
104			}
105
106			/**
107			* Get sequence class.
108			*
109			* @return \Yajra\Oci8\Schema\Sequence
110			*/
111			public function getSequence()
112			{
113			return $this->sequence;
114			}
115
116			/**
117			* Set sequence class.
118			*
119			* @param \Yajra\Oci8\Schema\Sequence $sequence
120			* @return \Yajra\Oci8\Schema\Sequence
121			*/
122			public function setSequence(Sequence $sequence)
123			{
124			return $this->sequence = $sequence;
125			}
126
127			/**
128			* Get oracle trigger class.
129			*
130			* @return \Yajra\Oci8\Schema\Trigger
131			*/
132			public function getTrigger()
133			{
134			return $this->trigger;
135			}
136
137			/**
138			* Set oracle trigger class.
139			*
140			* @param \Yajra\Oci8\Schema\Trigger $trigger
141			* @return \Yajra\Oci8\Schema\Trigger
142			*/
143			public function setTrigger(Trigger $trigger)
144			{
145			return $this->trigger = $trigger;
146			}
147
148			/**
149			* Get a schema builder instance for the connection.
150			*
151			* @return \Yajra\Oci8\Schema\OracleBuilder
152			*/
153			public function getSchemaBuilder()
154			{
155			if (is_null($this->schemaGrammar)) {
156			$this->useDefaultSchemaGrammar();
157			}
158
159			return new SchemaBuilder($this);
160			}
161
162			/**
163			* Get a new query builder instance.
164			*
165			* @return \Illuminate\Database\Query\Builder
166			*/
167			public function query()
168			{
169			return new QueryBuilder(
170			$this, $this->getQueryGrammar(), $this->getPostProcessor()
171			);
172			}
173
174			/**
175			* Set oracle session date format.
176			*
177			* @param string $format
178			* @return $this
179			*/
180			public function setDateFormat($format = 'YYYY-MM-DD HH24:MI:SS')
181			{
182			$sessionVars = [
183			'NLS_DATE_FORMAT' => $format,
184			'NLS_TIMESTAMP_FORMAT' => $format,
185			];
186
187			return $this->setSessionVars($sessionVars);
188			}
189
190			/**
191			* Get doctrine connection.
192			*
193			* @return \Doctrine\DBAL\Connection
194			*/
195			public function getDoctrineConnection()
196			{
197			if (is_null($this->doctrineConnection)) {
198			$data = ['pdo' => $this->getPdo(), 'user' => $this->getConfig('username')];
199			$this->doctrineConnection = new DoctrineConnection(
200			$data,
201			$this->getDoctrineDriver()
202			);
203			}
204
205			return $this->doctrineConnection;
206			}
207
208			/**
209			* Get doctrine driver.
210			*
211			* @return \Doctrine\DBAL\Driver\OCI8\Driver
212			*/
213			protected function getDoctrineDriver()
214			{
215			return new DoctrineDriver();
216			}
217
218			/**
219			* Execute a PL/SQL Function and return its value.
220			* Usage: DB::executeFunction('function_name(:binding_1,:binding_n)', [':binding_1' => 'hi', ':binding_n' =>
221			* 'bye'], PDO::PARAM_LOB).
222			*
223			* @param string $functionName
224			* @param array $bindings (kvp array)
225			* @param int $returnType (PDO::PARAM_*)
226			* @param int $length
227			* @return mixed $returnType
228			*/
229			public function executeFunction($functionName, array $bindings = [], $returnType = PDO::PARAM_STR, $length = null)
230			{
231			$stmt = $this->createStatementFromFunction($functionName, $bindings);
232
233			$stmt = $this->addBindingsToStatement($stmt, $bindings);
234
235			$stmt->bindParam(':result', $result, $returnType, $length);
236			$stmt->execute();
237
238			return $result;
239			}
240
241			/**
242			* Execute a PL/SQL Procedure and return its results.
243			*
244			* Usage: DB::executeProcedure($procedureName, $bindings).
245			* $bindings looks like:
246			* $bindings = [
247			* 'p_userid' => $id
248			* ];
249			*
250			* @param string $procedureName
251			* @param array $bindings
252			* @return bool
253			*/
254			public function executeProcedure($procedureName, array $bindings = [])
255			{
256			$stmt = $this->createStatementFromProcedure($procedureName, $bindings);
257
258			$stmt = $this->addBindingsToStatement($stmt, $bindings);
259
260			return $stmt->execute();
261			}
262
263			/**
264			* Execute a PL/SQL Procedure and return its cursor result.
265			* Usage: DB::executeProcedureWithCursor($procedureName, $bindings).
266			*
267			* https://docs.oracle.com/cd/E17781_01/appdev.112/e18555/ch_six_ref_cur.htm#TDPPH218
268			*
269			* @param string $procedureName
270			* @param array $bindings
271			* @param string $cursorName
272			* @return array
273			*/
274			public function executeProcedureWithCursor($procedureName, array $bindings = [], $cursorName = ':cursor')
275			{
276			$stmt = $this->createStatementFromProcedure($procedureName, $bindings, $cursorName);
277
278			$stmt = $this->addBindingsToStatement($stmt, $bindings);
279
280			$cursor = null;
281			$stmt->bindParam($cursorName, $cursor, PDO::PARAM_STMT);
282			$stmt->execute();
283
284			$statement = new Statement($cursor, $this->getPdo(), $this->getPdo()->getOptions());
			0 ignored issues – show Bug introduced 2016-08-30 01:45 UTC by Report Bug Copy Issue Report It seems like you code against a specific sub-type and not the parent class `PDO` as the method `getOptions()` does only exist in the following sub-classes of `PDO`: `Yajra\Pdo\Oci8`. Maybe you want to `instanceof` check for one of these explicitly? Let’s take a look at an example: abstract class User { /** @return string / abstract public function getPassword(); } class MyUser extends User { public function getPassword() { // return something } public function getDisplayName() { // return some name. } } class AuthSystem { public function authenticate(User $user) { $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName())); // do something. } } In the above example, the authenticate() method works fine as long as you just pass instances of MyUser. However, if you now also want to pass a different sub-classes of User which does not have a getDisplayName() method, the code will break. Available Fixes Change the type-hint for the parameter: class AuthSystem { public function authenticate(MyUser $user) { / ... / } } Add an additional type-check: class AuthSystem { public function authenticate(User $user) { if ($user instanceof MyUser) { $this->logger->info(/* ... /); } // or alternatively if ( ! $user instanceof MyUser) { throw new \LogicException( '$user must be an instance of MyUser, ' .'other instances are not supported.' ); } } } Note:* PHP Analyzer uses reverse abstract interpretation to narrow down the types inside the if block in such a case. Add the method to the parent class: abstract class User { /** @return string / abstract public function getPassword(); /* @return string */ abstract public function getDisplayName(); } Loading history... Compatibility introduced 2016-08-30 01:45 UTC by Report Bug Copy Issue Report `$this->getPdo()` of type `object<PDO>` is not a sub-type of `object<Yajra\Pdo\Oci8>`. It seems like you assume a child class of the class `PDO` to be always present. This check looks for parameters that are defined as one type in their type hint or doc comment but seem to be used as a narrower type, i.e an implementation of an interface or a subclass. Consider changing the type of the parameter or doing an instanceof check before assuming your parameter is of the expected type. Loading history...
285			$statement->execute();
286			$results = $statement->fetchAll(PDO::FETCH_OBJ);
287			$statement->closeCursor();
288
289			return $results;
290			}
291
292			/**
293			* Creates sql command to run a procedure with bindings.
294			*
295			* @param string $procedureName
296			* @param array $bindings
297			* @param string\|bool $cursor
298			* @return string
299			*/
300			public function createSqlFromProcedure($procedureName, array $bindings, $cursor = false)
301			{
302			$paramsString = implode(',', array_map(function ($param) {
303			return ':' . $param;
304			}, array_keys($bindings)));
305
306			$prefix = count($bindings) ? ',' : '';
307			$cursor = $cursor ? $prefix . $cursor : null;
308
309			return sprintf('begin %s(%s%s); end;', $procedureName, $paramsString, $cursor);
310			}
311
312			/**
313			* Creates statement from procedure.
314			*
315			* @param string $procedureName
316			* @param array $bindings
317			* @param string\|bool $cursorName
318			* @return PDOStatement
319			*/
320			public function createStatementFromProcedure($procedureName, array $bindings, $cursorName = false)
321			{
322			$sql = $this->createSqlFromProcedure($procedureName, $bindings, $cursorName);
323
324			return $this->getPdo()->prepare($sql);
325			}
326
327			/**
328			* Create statement from function.
329			*
330			* @param string $functionName
331			* @param array $bindings
332			* @return PDOStatement
333			*/
334			public function createStatementFromFunction($functionName, array $bindings)
335			{
336			$bindings = $bindings ? ':' . implode(', :', array_keys($bindings)) : '';
337
338			$sql = sprintf('begin :result := %s(%s); end;', $functionName, $bindings);
339
340			return $this->getPdo()->prepare($sql);
341			}
342
343			/**
344			* Bind values to their parameters in the given statement.
345			*
346			* @param \PDOStatement $statement
347			* @param array $bindings
348			* @return void
349			*/
350			public function bindValues($statement, $bindings)
351			{
352			foreach ($bindings as $key => $value) {
353			$statement->bindValue(
354			is_string($key) ? $key : $key + 1, $value,
355			is_int($value) \|\| is_null($value) ? PDO::PARAM_INT : PDO::PARAM_STR
356			);
357			}
358			}
359
360			/**
361			* Get the default query grammar instance.
362			*
363			* @return \Illuminate\Database\Grammar\|\Yajra\Oci8\Query\Grammars\OracleGrammar
364			*/
365			protected function getDefaultQueryGrammar()
366			{
367			return $this->withTablePrefix(new QueryGrammar());
368			}
369
370			/**
371			* Set the table prefix and return the grammar.
372			*
373			* @param \Illuminate\Database\Grammar\|\Yajra\Oci8\Query\Grammars\OracleGrammar\|\Yajra\Oci8\Schema\Grammars\OracleGrammar $grammar
374			* @return \Illuminate\Database\Grammar
375			*/
376			public function withTablePrefix(Grammar $grammar)
377			{
378			return $this->withSchemaPrefix(parent::withTablePrefix($grammar));
379			}
380
381			/**
382			* Set the schema prefix and return the grammar.
383			*
384			* @param \Illuminate\Database\Grammar\|\Yajra\Oci8\Query\Grammars\OracleGrammar\|\Yajra\Oci8\Schema\Grammars\OracleGrammar $grammar
385			* @return \Illuminate\Database\Grammar
386			*/
387			public function withSchemaPrefix(Grammar $grammar)
388			{
389			$grammar->setSchemaPrefix($this->getConfigSchemaPrefix());
390
391			return $grammar;
392			}
393
394			/**
395			* Get config schema prefix.
396			*
397			* @return string
398			*/
399			protected function getConfigSchemaPrefix()
400			{
401			return isset($this->config['prefix_schema']) ? $this->config['prefix_schema'] : '';
402			}
403
404			/**
405			* Get the default schema grammar instance.
406			*
407			* @return \Illuminate\Database\Grammar\|\Yajra\Oci8\Schema\Grammars\OracleGrammar
408			*/
409			protected function getDefaultSchemaGrammar()
410			{
411			return $this->withTablePrefix(new SchemaGrammar());
412			}
413
414			/**
415			* Get the default post processor instance.
416			*
417			* @return \Yajra\Oci8\Query\Processors\OracleProcessor
418			*/
419			protected function getDefaultPostProcessor()
420			{
421			return new Processor();
422			}
423
424			/**
425			* Add bindings to statement.
426			*
427			* @param array $bindings
428			* @param PDOStatement $stmt
429			* @return PDOStatement
430			*/
431			public function addBindingsToStatement(PDOStatement $stmt, array $bindings)
432			{
433			foreach ($bindings as $key => &$binding) {
434			$value = &$binding;
435			$type = PDO::PARAM_STR;
436			$length = -1;
437
438			if (is_array($binding)) {
439			$value = &$binding['value'];
440			$type = array_key_exists('type', $binding) ? $binding['type'] : PDO::PARAM_STR;
441			$length = array_key_exists('length', $binding) ? $binding['length'] : -1;
442			}
443
444			$stmt->bindParam(':' . $key, $value, $type, $length);
445			}
446
447			return $stmt;
448			}
449
450			/**
451			* Determine if the given exception was caused by a lost connection.
452			*
453			* @param \Exception $e
454			* @return bool
455			*/
456			protected function causedByLostConnection(Throwable $e)
457			{
458			if (parent::causedByLostConnection($e)) {
459			return true;
460			}
461
462			$lostConnectionErrors = [
463			'ORA-03113', //End-of-file on communication channel
464			'ORA-03114', //Not Connected to Oracle
465			'ORA-03135', //Connection lost contact
466			'ORA-12170', //Connect timeout occurred
467			'ORA-12537', //Connection closed
468			'ORA-27146', //Post/wait initialization failed
469			'ORA-25408', //Can not safely replay call
470			'ORA-56600', //Illegal Call
471			];
472
473			$additionalErrors = null;
474
475			$options = isset($this->config['options']) ? $this->config['options'] : [];
476			if (array_key_exists(static::RECONNECT_ERRORS, $options)) {
477			$additionalErrors = $this->config['options'][static::RECONNECT_ERRORS];
478			}
479
480			if (is_array($additionalErrors)) {
481			$lostConnectionErrors = array_merge($lostConnectionErrors,
482			$this->config['options'][static::RECONNECT_ERRORS]);
483			}
484
485			return Str::contains($e->getMessage(), $lostConnectionErrors);
486			}
487			}
488

yajra / laravel-oci8

Pull Request — master (#562)

Oci8Connection::getDefaultSchemaGrammar() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like