OracleProcessor::incrementBySequence() - Code Metrics - yajra/laravel-oci8 - Measure and Improve Code Quality continuously with Scrutinizer

OracleProcessor::incrementBySequence() B
last analyzed 2017-05-29 03:03 UTC

↳ Parent: OracleProcessor

Complexity

Conditions	5
Paths	4

Size

Total Lines	16
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	30

Importance

Changes

Metric	Value
cc	5
eloc	9
nc	4
nop	2
dl	0
loc	16
ccs	0
cts	12
cp	0
crap	30
rs	8.8571
c	0
b	0
f	0

<?php

namespace Yajra\Oci8\Query\Processors;

use Illuminate\Database\Query\Builder;
use Illuminate\Database\Query\Processors\Processor;
use PDO;

class OracleProcessor extends Processor
{
    /**
     * Process an "insert get ID" query.
     *
     * @param  Builder $query
     * @param  string $sql
     * @param  array $values
     * @param  string $sequence
     * @return int
     */
    public function processInsertGetId(Builder $query, $sql, $values, $sequence = null)
    {
        $id        = 0;
        $parameter = 0;
        $statement = $this->prepareStatement($query, $sql);
        $values    = $this->incrementBySequence($values, $sequence);
        $parameter = $this->bindValues($values, $statement, $parameter);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        $statement->bindParam($parameter, $id, PDO::PARAM_INT, 10);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $statement->execute();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        return (int) $id;
    }

    /**
     * Get prepared statement.
     *
     * @param Builder $query
     * @param string $sql
     * @return \PDOStatement|\Yajra\Pdo\Oci8
     */
    private function prepareStatement(Builder $query, $sql)
    {
        /** @var \Yajra\Oci8\Oci8Connection $connection */
        $connection = $query->getConnection();
        $pdo        = $connection->getPdo();

        return $pdo->prepare($sql);
    }

    /**
     * Insert a new record and get the value of the primary key.
     *
     * @param array $values
     * @param string $sequence
     * @return array
     */
    protected function incrementBySequence(array $values, $sequence)
    {
        $builder     = debug_backtrace(DEBUG_BACKTRACE_PROVIDE_OBJECT, 5)[4]['object'];
        $builderArgs = debug_backtrace(DEBUG_BACKTRACE_PROVIDE_OBJECT, 5)[3]['args'];

        if (! isset($builderArgs[1][0][$sequence])) {
            if (method_exists($builder, 'getModel')) {
                $model = $builder->getModel();
                if ($model->sequence && $model->incrementing) {
                    $values[] = (int) $model->getConnection()->getSequence()->nextValue($model->sequence);
                }
            }
        }

        return $values;
    }

    /**
     * Bind values to PDO statement.
     *
     * @param array $values
     * @param \PDOStatement $statement
     * @param int $parameter
     * @return int
     */
    private function bindValues(&$values, $statement, $parameter)
    {
        $count = count($values);
        for ($i = 0; $i < $count; $i++) {
            if (is_object($values[$i])) {
                $values[$i] = (string) $values[$i];
            }
            $type = $this->getPdoType($values[$i]);
            $statement->bindParam($parameter, $values[$i], $type);
            $parameter++;
        }

        return $parameter;
    }

    /**
     * Get PDO Type depending on value.
     *
     * @param mixed $value
     * @return int
     */
    private function getPdoType($value)
    {
        if (is_int($value)) {
            return PDO::PARAM_INT;
        } elseif (is_bool($value)) {
            return PDO::PARAM_BOOL;
        } elseif (is_null($value)) {
            return PDO::PARAM_NULL;
        } else {
            return PDO::PARAM_STR;
        }
    }

    /**
     * Save Query with Blob returning primary key value.
     *
     * @param  Builder $query
     * @param  string $sql
     * @param  array $values
     * @param  array $binaries
     * @return int
     */
    public function saveLob(Builder $query, $sql, array $values, array $binaries)
    {
        $id        = 0;
        $parameter = 0;
        $statement = $this->prepareStatement($query, $sql);

        $parameter = $this->bindValues($values, $statement, $parameter);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $countBinary = count($binaries);
        for ($i = 0; $i < $countBinary; $i++) {
            $statement->bindParam($parameter, $binaries[$i], PDO::PARAM_LOB, -1);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            $parameter++;
        }

        // bind output param for the returning clause.
        $statement->bindParam($parameter, $id, PDO::PARAM_INT, 10);

        if (! $statement->execute()) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            return false;
        }

        return (int) $id;
    }

    /**
     * Process the results of a column listing query.
     *
     * @param  array $results
     * @return array
     */
    public function processColumnListing($results)
    {
        $mapping = function ($r) {
            $r = (object) $r;

            return $r->column_name;
        };

        return array_map($mapping, $results);
    }
}


1			<?php
2
3			namespace Yajra\Oci8\Query\Processors;
4
5			use Illuminate\Database\Query\Builder;
6			use Illuminate\Database\Query\Processors\Processor;
7			use PDO;
8
9			class OracleProcessor extends Processor
10			{
11			/**
12			* Process an "insert get ID" query.
13			*
14			* @param Builder $query
15			* @param string $sql
16			* @param array $values
17			* @param string $sequence
18			* @return int
19			*/
20			public function processInsertGetId(Builder $query, $sql, $values, $sequence = null)
21			{
22			$id = 0;
23			$parameter = 0;
24			$statement = $this->prepareStatement($query, $sql);
25			$values = $this->incrementBySequence($values, $sequence);
26			$parameter = $this->bindValues($values, $statement, $parameter);
			0 ignored issues – show Bug introduced 2016-08-24 02:35 UTC by Report Bug Copy Issue Report It seems like `$statement` defined by `$this->prepareStatement($query, $sql)` on line `24` can also be of type `object<Yajra\Pdo\Oci8>`; however, `Yajra\Oci8\Query\Process...Processor::bindValues()` does only seem to accept `object<PDOStatement>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
27			$statement->bindParam($parameter, $id, PDO::PARAM_INT, 10);
			0 ignored issues – show Bug introduced 2016-08-24 02:35 UTC by Report Bug Copy Issue Report The method `bindParam` does only exist in `PDOStatement`, but not in `Yajra\Pdo\Oci8`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
28			$statement->execute();
			0 ignored issues – show Bug introduced 2016-08-24 02:35 UTC by Report Bug Copy Issue Report The method `execute` does only exist in `PDOStatement`, but not in `Yajra\Pdo\Oci8`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
29
30			return (int) $id;
31			}
32
33			/**
34			* Get prepared statement.
35			*
36			* @param Builder $query
37			* @param string $sql
38			* @return \PDOStatement\|\Yajra\Pdo\Oci8
39			*/
40			private function prepareStatement(Builder $query, $sql)
41			{
42			/** @var \Yajra\Oci8\Oci8Connection $connection */
43			$connection = $query->getConnection();
44			$pdo = $connection->getPdo();
45
46			return $pdo->prepare($sql);
47			}
48
49			/**
50			* Insert a new record and get the value of the primary key.
51			*
52			* @param array $values
53			* @param string $sequence
54			* @return array
55			*/
56			protected function incrementBySequence(array $values, $sequence)
57			{
58			$builder = debug_backtrace(DEBUG_BACKTRACE_PROVIDE_OBJECT, 5)[4]['object'];
59			$builderArgs = debug_backtrace(DEBUG_BACKTRACE_PROVIDE_OBJECT, 5)[3]['args'];
60
61			if (! isset($builderArgs[1][0][$sequence])) {
62			if (method_exists($builder, 'getModel')) {
63			$model = $builder->getModel();
64			if ($model->sequence && $model->incrementing) {
65			$values[] = (int) $model->getConnection()->getSequence()->nextValue($model->sequence);
66			}
67			}
68			}
69
70			return $values;
71			}
72
73			/**
74			* Bind values to PDO statement.
75			*
76			* @param array $values
77			* @param \PDOStatement $statement
78			* @param int $parameter
79			* @return int
80			*/
81			private function bindValues(&$values, $statement, $parameter)
82			{
83			$count = count($values);
84			for ($i = 0; $i < $count; $i++) {
85			if (is_object($values[$i])) {
86			$values[$i] = (string) $values[$i];
87			}
88			$type = $this->getPdoType($values[$i]);
89			$statement->bindParam($parameter, $values[$i], $type);
90			$parameter++;
91			}
92
93			return $parameter;
94			}
95
96			/**
97			* Get PDO Type depending on value.
98			*
99			* @param mixed $value
100			* @return int
101			*/
102			private function getPdoType($value)
103			{
104			if (is_int($value)) {
105			return PDO::PARAM_INT;
106			} elseif (is_bool($value)) {
107			return PDO::PARAM_BOOL;
108			} elseif (is_null($value)) {
109			return PDO::PARAM_NULL;
110			} else {
111			return PDO::PARAM_STR;
112			}
113			}
114
115			/**
116			* Save Query with Blob returning primary key value.
117			*
118			* @param Builder $query
119			* @param string $sql
120			* @param array $values
121			* @param array $binaries
122			* @return int
123			*/
124			public function saveLob(Builder $query, $sql, array $values, array $binaries)
125			{
126			$id = 0;
127			$parameter = 0;
128			$statement = $this->prepareStatement($query, $sql);
129
130			$parameter = $this->bindValues($values, $statement, $parameter);
			0 ignored issues – show Bug introduced 2016-08-24 02:35 UTC by Report Bug Copy Issue Report It seems like `$statement` defined by `$this->prepareStatement($query, $sql)` on line `128` can also be of type `object<Yajra\Pdo\Oci8>`; however, `Yajra\Oci8\Query\Process...Processor::bindValues()` does only seem to accept `object<PDOStatement>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
131
132			$countBinary = count($binaries);
133			for ($i = 0; $i < $countBinary; $i++) {
134			$statement->bindParam($parameter, $binaries[$i], PDO::PARAM_LOB, -1);
			0 ignored issues – show Bug introduced 2016-08-24 02:35 UTC by Report Bug Copy Issue Report The method `bindParam` does only exist in `PDOStatement`, but not in `Yajra\Pdo\Oci8`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
135			$parameter++;
136			}
137
138			// bind output param for the returning clause.
139			$statement->bindParam($parameter, $id, PDO::PARAM_INT, 10);
140
141			if (! $statement->execute()) {
			0 ignored issues – show Bug introduced 2016-08-24 02:35 UTC by Report Bug Copy Issue Report The method `execute` does only exist in `PDOStatement`, but not in `Yajra\Pdo\Oci8`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
142			return false;
143			}
144
145			return (int) $id;
146			}
147
148			/**
149			* Process the results of a column listing query.
150			*
151			* @param array $results
152			* @return array
153			*/
154			public function processColumnListing($results)
155			{
156			$mapping = function ($r) {
157			$r = (object) $r;
158
159			return $r->column_name;
160			};
161
162			return array_map($mapping, $results);
163			}
164			}
165

yajra / laravel-oci8

OracleProcessor::incrementBySequence() B last analyzed 2017-05-29 03:03 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

OracleProcessor::incrementBySequence() B
last analyzed 2017-05-29 03:03 UTC