OCI8Statement::bindValue() - Code Metrics - ecphp/doctrine-oci8 - Measure and Improve Code Quality continuously with Scrutinizer

OCI8Statement::bindValue() A
last analyzed 2022-10-13 20:12 UTC

↳ Parent: OCI8Statement
Complexity

Conditions	3
Paths	2
Size

Total Lines	9
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	12
Importance

Changes
Metric	Value
cc	3
eloc	4
c	0
b	0
f	0
nc	2
nop	3
dl	0
loc	9
ccs	0
cts	5
cp	0
crap	12
rs	10
<?php

/**
 * For the full copyright and license information, please view
 * the LICENSE file that was distributed with this source code.
 *
 * @see https://github.com/ecphp
 */

declare(strict_types=1);

namespace EcPhp\DoctrineOci8\Doctrine\DBAL\Driver\OCI8;

use Doctrine\DBAL\Driver\OCI8\OCI8Statement as BaseStatement;
use Doctrine\DBAL\ParameterType;
use LogicException;
use PDO;

use function array_map;
use function count;
use function is_array;
use function is_numeric;
use function is_resource;
use function max;
use function oci_bind_array_by_name;
use function oci_bind_by_name;
use function reset;

use const OCI_B_BLOB;
use const OCI_B_CLOB;
use const OCI_B_CURSOR;
use const OCI_BOTH;
use const SQLT_AFC;
use const SQLT_CHR;
use const SQLT_INT;

class OCI8Statement extends BaseStatement
class OCI8Statement extends /** @scrutinizer ignore-deprecated */ BaseStatement
{
    protected bool $checkedForCursorFields = false;

    protected array $cursorFields = [];

    private array $references = [];

    /**
     * Used because parent::fetchAll() calls $this->fetch().
     */
    private bool $returningCursors = false;

    /**
     * Used because parent::fetchAll() calls $this->fetch().
     */
    private bool $returningResources = false;

    public function bindParam($column, &$variable, $type = ParameterType::STRING, $length = null): bool
    {
        $origCol = $column;

        $column = $this->_paramMap[$column] ?? $column;

        [$type, $ociType] = $this->normalizeType($type);

        // Type: Cursor.
        if (PDO::PARAM_STMT === $type || OCI_B_CURSOR === $ociType) {
            /** @var OCI8Connection $conn Because my IDE complains. */
            $conn = $this->_conn;
            $variable = $conn->newCursor();

            return $this->bindByName($column, $variable->_sth, -1, OCI_B_CURSOR);
        }

        // Type: Null. (Must come *after* types that can expect $variable to be null, like 'cursor'.)
        if (null === $variable) {
            return $this->bindByName($column, $variable);
        }

        // Type: Array.
        if (is_array($variable)) {
            $length = $length ?? -1;

            if (!$ociType) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
                $ociType = PDO::PARAM_INT === $type ? SQLT_INT : SQLT_CHR;
            }

            return $this->bindArrayByName(
                $column,
                $variable,
                max(count($variable), 1),
                empty($variable) ? 0 : $length,
                $ociType
            );
        }

        // Type: Lob
        if (OCI_B_CLOB === $ociType || OCI_B_BLOB === $ociType) {
            $type = PDO::PARAM_LOB;
        } elseif ($ociType) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            return $this->bindByName($column, $variable, $length ?? -1, $ociType);
        }

        return parent::bindParam($origCol, $variable, $type, $length);
    }

    public function bindValue($param, $value, $type = ParameterType::STRING): bool
    {
        [$type, $ociType] = $this->normalizeType($type);

        if (PDO::PARAM_STMT === $type || OCI_B_CURSOR === $ociType) {
            throw new LogicException('You must call "bindParam()" to bind a cursor.');
        }

        return parent::bindValue($param, $value, $type);
    }

    public function fetch($fetchMode = null, $cursorOrientation = PDO::FETCH_ORI_NEXT, $cursorOffset = 0)
    {
        [$fetchMode, $returnResources, $returnCursors] = $this->processFetchMode($fetchMode, true);

        // "Globals" are checked because parent::fetchAll() calls $this->fetch().
        $row = parent::fetch($fetchMode, $cursorOrientation, $cursorOffset);
        $row = /** @scrutinizer ignore-deprecated */ parent::fetch($fetchMode, $cursorOrientation, $cursorOffset);

        if (!$returnResources) {
            $this->fetchCursorFields($row, $fetchMode, $returnCursors);
        }

        return $row;
    }

    /**
     * @param null|mixed $fetchMode
     * @param null|mixed $fetchArgument
     * @param null|mixed $ctorArgs
     *
     * @throws \Doctrine\DBAL\Driver\OCI8\OCI8Exception
     */
    public function fetchAll($fetchMode = null, $fetchArgument = null, $ctorArgs = null)
    {
        [$fetchMode, $this->returningResources, $this->returningCursors] = $this->processFetchMode($fetchMode);

        // "Globals" are set because parent::fetchAll() calls $this->fetch().
        $results = parent::fetchAll($fetchMode, $fetchArgument, $ctorArgs);
        $results = /** @scrutinizer ignore-deprecated */ parent::fetchAll($fetchMode, $fetchArgument, $ctorArgs);

        if (
            !$this->returningResources
            && $results
            && is_array($results)
            && OCI_BOTH !== self::$fetchModeMap[$fetchMode] // handled by $this->fetch() in parent::fetchAll().
        ) {
            if (PDO::FETCH_COLUMN !== $fetchMode) {
                foreach ($results as &$row) {
                    $this->fetchCursorFields($row, $fetchMode, $this->returningCursors);
                }
                unset($row);
            } elseif (is_resource(reset($results))) {
                $results = array_map(function ($value) use ($fetchMode) {
                    return $this->fetchCursorValue($value, $fetchMode, $this->returningCursors);
                }, $results);
            }
        }

        $this->returningResources =
        $this->returningCursors = false;
        $this->resetCursorFields();

        return $results;
    }

    public function fetchColumn($columnIndex = 0, $fetchMode = null)
    {
        [$fetchMode, $returnResources, $returnCursors] = $this->processFetchMode($fetchMode);

        /** @var array|bool|resource|string|null $columnValue */
        $columnValue = parent::fetchColumn($columnIndex);
        $columnValue = /** @scrutinizer ignore-deprecated */ parent::fetchColumn($columnIndex);

        if (!$returnResources && is_resource($columnValue)) {
            return $this->fetchCursorValue($columnValue, $fetchMode, $returnCursors);
        }

        return $columnValue;
    }

    /**
     * @param string $column
     * @param mixed  $variable
     * @param int    $maxTableLength
     * @param int    $maxItemLength
     * @param int    $type
     */
    protected function bindArrayByName(
        $column,
        &$variable,
        $maxTableLength,
        $maxItemLength = -1,
        $type = SQLT_AFC
    ): bool {
        // For PHP 7's OCI8 extension (prevents garbage collection).
        $this->references[$column] = &$variable;

        return oci_bind_array_by_name($this->_sth, $column, $variable, $maxTableLength, $maxItemLength, $type);
    }

    /**
     * @param string $column
     * @param mixed  $variable
     * @param int    $maxLength
     * @param int    $type
     */
    protected function bindByName($column, &$variable, $maxLength = -1, $type = SQLT_CHR): bool
    {
        // For PHP 7's OCI8 extension (prevents garbage collection).
        $this->references[$column] = &$variable;

        return oci_bind_by_name($this->_sth, $column, $variable, $maxLength, $type);
    }

    /**
     * @param array|mixed $row
     * @param int         $fetchMode
     * @param bool        $returnCursors
     *
     * @throws \Doctrine\DBAL\Driver\OCI8\OCI8Exception
     */
    protected function fetchCursorFields(&$row, $fetchMode, $returnCursors): void
    {
        if (!is_array($row)) {
            $this->resetCursorFields();
        } elseif (!$this->checkedForCursorFields) {
            // This will also call fetchCursorField() on each cursor field of the first row.
            $this->findCursorFields($row, $fetchMode, $returnCursors);
        } elseif ($this->cursorFields) {

            $shared = [];

            foreach ($this->cursorFields as $field) {
                $key = (string) $row[$field];

                if (isset($shared[$key])) {
                    $row[$field] = $shared[$key];

                    continue;
                }
                $row[$field] = $this->fetchCursorValue($row[$field], $fetchMode, $returnCursors);
                $shared[$key] = &$row[$field];
            }
        }
    }

    /**
     * @param resource $resource
     * @param int $fetchMode
     * @param bool $returnCursor
     *
     * @throws \Doctrine\DBAL\Driver\OCI8\OCI8Exception
     *
     * @return array|mixed|OCI8Cursor
     */
    protected function fetchCursorValue($resource, $fetchMode, $returnCursor)
    {
        /** @var OCI8Connection $conn Because my IDE complains. */
        $conn = $this->_conn;
        $cursor = $conn->newCursor($resource);

        if ($returnCursor) {
            return $cursor;
        }

        $cursor->execute();
        $results = $cursor->fetchAll($fetchMode);
        $cursor->closeCursor();
        /** @scrutinizer ignore-deprecated */ $cursor->closeCursor();

        return $results;
    }

    /**
     * @param int   $fetchMode
     * @param bool  $returnCursors
     *
     * @throws \Doctrine\DBAL\Driver\OCI8\OCI8Exception
     */
    protected function findCursorFields(array &$row, $fetchMode, $returnCursors): void
    {
        $shared = [];

        foreach ($row as $field => $value) {
            if (!is_resource($value)) {
                continue;
            }
            $this->cursorFields[] = $field;
            $key = (string) $value;

            if (isset($shared[$key])) {
                $row[$field] = $shared[$key];

                continue;
            }
            // We are already here, so might as well process it.
            $row[$field] = $this->fetchCursorValue($row[$field], $fetchMode, $returnCursors);
            $shared[$key] = &$row[$field];
        }
        $this->checkedForCursorFields = true;
    }

    /**
     * @param int|string $type
     */
    protected function normalizeType($type): array
    {
        $ociType = null;

        // Figure out the type.
        if (is_numeric($type)) {
            $type = (int) $type;

            if (OCI8::isParamConstant($type)) {
                $ociType = OCI8::decodeParamConstant($type);
            }
        } elseif ('cursor' === strtolower($type)) {
            $type = PDO::PARAM_STMT;
            $ociType = OCI_B_CURSOR;
        }

        return [$type, $ociType];
    }

    /**
     * @param int  $fetchMode
     * @param bool $checkGlobal
     */
    protected function processFetchMode($fetchMode, $checkGlobal = false): array
    {
        $returnResources = ($checkGlobal && $this->returningResources) || ($fetchMode & OCI8::RETURN_RESOURCES);
        $returnCursors = ($checkGlobal && $this->returningCursors) || ($fetchMode & OCI8::RETURN_CURSORS);
        // Must unset the flags or there will be an error.
        $fetchMode &= ~(OCI8::RETURN_RESOURCES + OCI8::RETURN_CURSORS);
        $fetchMode = (int) ($fetchMode ?: $this->_defaultFetchMode);

        return [$fetchMode, $returnResources, $returnCursors];
    }

    protected function resetCursorFields(): void
    {
        $this->cursorFields = [];
        $this->checkedForCursorFields = false;
    }
}

ecphp / doctrine-oci8

OCI8Statement::bindValue() A last analyzed 2022-10-13 20:12 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

OCI8Statement::bindValue() A
last analyzed 2022-10-13 20:12 UTC
