提交代码

vendor/doctrine/dbal/lib/Doctrine/DBAL/Portability/Connection.php

@@ -0,0 +1,132 @@
+<?php
+
+namespace Doctrine\DBAL\Portability;
+
+use Doctrine\DBAL\Cache\QueryCacheProfile;
+use Doctrine\DBAL\ColumnCase;
+use Doctrine\DBAL\Driver\PDOConnection;
+use PDO;
+use const CASE_LOWER;
+use const CASE_UPPER;
+use function func_get_args;
+
+/**
+ * Portability wrapper for a Connection.
+ */
+class Connection extends \Doctrine\DBAL\Connection
+{
+    public const PORTABILITY_ALL           = 255;
+    public const PORTABILITY_NONE          = 0;
+    public const PORTABILITY_RTRIM         = 1;
+    public const PORTABILITY_EMPTY_TO_NULL = 4;
+    public const PORTABILITY_FIX_CASE      = 8;
+
+    public const PORTABILITY_DB2          = 13;
+    public const PORTABILITY_ORACLE       = 9;
+    public const PORTABILITY_POSTGRESQL   = 13;
+    public const PORTABILITY_SQLITE       = 13;
+    public const PORTABILITY_OTHERVENDORS = 12;
+    public const PORTABILITY_DRIZZLE      = 13;
+    public const PORTABILITY_SQLANYWHERE  = 13;
+    public const PORTABILITY_SQLSRV       = 13;
+
+    /** @var int */
+    private $portability = self::PORTABILITY_NONE;
+
+    /** @var int */
+    private $case;
+
+    /**
+     * {@inheritdoc}
+     */
+    public function connect()
+    {
+        $ret = parent::connect();
+        if ($ret) {
+            $params = $this->getParams();
+            if (isset($params['portability'])) {
+                if ($this->getDatabasePlatform()->getName() === 'oracle') {
+                    $params['portability'] &= self::PORTABILITY_ORACLE;
+                } elseif ($this->getDatabasePlatform()->getName() === 'postgresql') {
+                    $params['portability'] &= self::PORTABILITY_POSTGRESQL;
+                } elseif ($this->getDatabasePlatform()->getName() === 'sqlite') {
+                    $params['portability'] &= self::PORTABILITY_SQLITE;
+                } elseif ($this->getDatabasePlatform()->getName() === 'drizzle') {
+                    $params['portability'] &= self::PORTABILITY_DRIZZLE;
+                } elseif ($this->getDatabasePlatform()->getName() === 'sqlanywhere') {
+                    $params['portability'] &= self::PORTABILITY_SQLANYWHERE;
+                } elseif ($this->getDatabasePlatform()->getName() === 'db2') {
+                    $params['portability'] &= self::PORTABILITY_DB2;
+                } elseif ($this->getDatabasePlatform()->getName() === 'mssql') {
+                    $params['portability'] &= self::PORTABILITY_SQLSRV;
+                } else {
+                    $params['portability'] &= self::PORTABILITY_OTHERVENDORS;
+                }
+                $this->portability = $params['portability'];
+            }
+
+            if (isset($params['fetch_case']) && $this->portability & self::PORTABILITY_FIX_CASE) {
+                if ($this->_conn instanceof PDOConnection) {
+                    // make use of c-level support for case handling
+                    $this->_conn->setAttribute(PDO::ATTR_CASE, $params['fetch_case']);
+                } else {
+                    $this->case = $params['fetch_case'] === ColumnCase::LOWER ? CASE_LOWER : CASE_UPPER;
+                }
+            }
+        }
+
+        return $ret;
+    }
+
+    /**
+     * @return int
+     */
+    public function getPortability()
+    {
+        return $this->portability;
+    }
+
+    /**
+     * @return int
+     */
+    public function getFetchCase()
+    {
+        return $this->case;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function executeQuery($query, array $params = [], $types = [], ?QueryCacheProfile $qcp = null)
+    {
+        $stmt = new Statement(parent::executeQuery($query, $params, $types, $qcp), $this);
+        $stmt->setFetchMode($this->defaultFetchMode);
+
+        return $stmt;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function prepare($statement)
+    {
+        $stmt = new Statement(parent::prepare($statement), $this);
+        $stmt->setFetchMode($this->defaultFetchMode);
+
+        return $stmt;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function query()
+    {
+        $this->connect();
+
+        $stmt = $this->_conn->query(...func_get_args());
+        $stmt = new Statement($stmt, $this);
+        $stmt->setFetchMode($this->defaultFetchMode);
+
+        return $stmt;
+    }
+}

vendor/doctrine/dbal/lib/Doctrine/DBAL/Portability/Statement.php

@@ -0,0 +1,233 @@
+<?php
+
+namespace Doctrine\DBAL\Portability;
+
+use Doctrine\DBAL\Driver\Statement as DriverStatement;
+use Doctrine\DBAL\Driver\StatementIterator;
+use Doctrine\DBAL\FetchMode;
+use Doctrine\DBAL\ParameterType;
+use IteratorAggregate;
+use PDO;
+use function array_change_key_case;
+use function is_string;
+use function rtrim;
+
+/**
+ * Portability wrapper for a Statement.
+ */
+class Statement implements IteratorAggregate, DriverStatement
+{
+    /** @var int */
+    private $portability;
+
+    /** @var DriverStatement */
+    private $stmt;
+
+    /** @var int */
+    private $case;
+
+    /** @var int */
+    private $defaultFetchMode = FetchMode::MIXED;
+
+    /**
+     * Wraps <tt>Statement</tt> and applies portability measures.
+     *
+     * @param DriverStatement $stmt
+     */
+    public function __construct($stmt, Connection $conn)
+    {
+        $this->stmt        = $stmt;
+        $this->portability = $conn->getPortability();
+        $this->case        = $conn->getFetchCase();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function bindParam($column, &$variable, $type = ParameterType::STRING, $length = null)
+    {
+        return $this->stmt->bindParam($column, $variable, $type, $length);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function bindValue($param, $value, $type = ParameterType::STRING)
+    {
+        return $this->stmt->bindValue($param, $value, $type);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function closeCursor()
+    {
+        return $this->stmt->closeCursor();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function columnCount()
+    {
+        return $this->stmt->columnCount();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function errorCode()
+    {
+        return $this->stmt->errorCode();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function errorInfo()
+    {
+        return $this->stmt->errorInfo();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function execute($params = null)
+    {
+        return $this->stmt->execute($params);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function setFetchMode($fetchMode, $arg1 = null, $arg2 = null)
+    {
+        $this->defaultFetchMode = $fetchMode;
+
+        return $this->stmt->setFetchMode($fetchMode, $arg1, $arg2);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getIterator()
+    {
+        return new StatementIterator($this);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function fetch($fetchMode = null, $cursorOrientation = PDO::FETCH_ORI_NEXT, $cursorOffset = 0)
+    {
+        $fetchMode = $fetchMode ?: $this->defaultFetchMode;
+
+        $row = $this->stmt->fetch($fetchMode);
+
+        $iterateRow = $this->portability & (Connection::PORTABILITY_EMPTY_TO_NULL|Connection::PORTABILITY_RTRIM);
+        $fixCase    = $this->case !== null
+            && ($fetchMode === FetchMode::ASSOCIATIVE || $fetchMode === FetchMode::MIXED)
+            && ($this->portability & Connection::PORTABILITY_FIX_CASE);
+
+        $row = $this->fixRow($row, $iterateRow, $fixCase);
+
+        return $row;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function fetchAll($fetchMode = null, $fetchArgument = null, $ctorArgs = null)
+    {
+        $fetchMode = $fetchMode ?: $this->defaultFetchMode;
+
+        if ($fetchArgument) {
+            $rows = $this->stmt->fetchAll($fetchMode, $fetchArgument);
+        } else {
+            $rows = $this->stmt->fetchAll($fetchMode);
+        }
+
+        $iterateRow = $this->portability & (Connection::PORTABILITY_EMPTY_TO_NULL|Connection::PORTABILITY_RTRIM);
+        $fixCase    = $this->case !== null
+            && ($fetchMode === FetchMode::ASSOCIATIVE || $fetchMode === FetchMode::MIXED)
+            && ($this->portability & Connection::PORTABILITY_FIX_CASE);
+
+        if (! $iterateRow && ! $fixCase) {
+            return $rows;
+        }
+
+        if ($fetchMode === FetchMode::COLUMN) {
+            foreach ($rows as $num => $row) {
+                $rows[$num] = [$row];
+            }
+        }
+
+        foreach ($rows as $num => $row) {
+            $rows[$num] = $this->fixRow($row, $iterateRow, $fixCase);
+        }
+
+        if ($fetchMode === FetchMode::COLUMN) {
+            foreach ($rows as $num => $row) {
+                $rows[$num] = $row[0];
+            }
+        }
+
+        return $rows;
+    }
+
+    /**
+     * @param mixed $row
+     * @param int   $iterateRow
+     * @param bool  $fixCase
+     *
+     * @return mixed
+     */
+    protected function fixRow($row, $iterateRow, $fixCase)
+    {
+        if (! $row) {
+            return $row;
+        }
+
+        if ($fixCase) {
+            $row = array_change_key_case($row, $this->case);
+        }
+
+        if ($iterateRow) {
+            foreach ($row as $k => $v) {
+                if (($this->portability & Connection::PORTABILITY_EMPTY_TO_NULL) && $v === '') {
+                    $row[$k] = null;
+                } elseif (($this->portability & Connection::PORTABILITY_RTRIM) && is_string($v)) {
+                    $row[$k] = rtrim($v);
+                }
+            }
+        }
+
+        return $row;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function fetchColumn($columnIndex = 0)
+    {
+        $value = $this->stmt->fetchColumn($columnIndex);
+
+        if ($this->portability & (Connection::PORTABILITY_EMPTY_TO_NULL|Connection::PORTABILITY_RTRIM)) {
+            if (($this->portability & Connection::PORTABILITY_EMPTY_TO_NULL) && $value === '') {
+                $value = null;
+            } elseif (($this->portability & Connection::PORTABILITY_RTRIM) && is_string($value)) {
+                $value = rtrim($value);
+            }
+        }
+
+        return $value;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function rowCount()
+    {
+        return $this->stmt->rowCount();
+    }
+}