[DBAL-56] Add portability wrapping layer porting MDB2 functionality to fix...

[DBAL-56] Add portability wrapping layer porting MDB2 functionality to fix case, rtrim strings and convert empty strings to null.

lib/Doctrine/DBAL/Platforms/AbstractPlatform.php

@@ -880,6 +880,7 @@ abstract class AbstractPlatform
             $columnData['type'] = $column->getType();
             $columnData['length'] = $column->getLength();
             $columnData['notnull'] = $column->getNotNull();
+            $columnData['fixed'] = $column->getFixed();
             $columnData['unique'] = false; // TODO: what do we do about this?
             $columnData['version'] = ($column->hasPlatformOption("version"))?$column->getPlatformOption('version'):false;
             if(strtolower($columnData['type']) == "string" && $columnData['length'] === null) {

lib/Doctrine/DBAL/Portability/Connection.php

+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+
+namespace Doctrine\DBAL\Portability;
+
+use Doctrine\Common\EventManager;
+use Doctrine\DBAL\Configuration;
+use Doctrine\DBAL\Driver;
+
+class Connection extends \Doctrine\DBAL\Connection
+{
+    const PORTABILITY_ALL               = 255;
+    const PORTABILITY_NONE              = 0;
+    const PORTABILITY_RTRIM             = 1;
+    const PORTABILITY_EMPTY_TO_NULL     = 4;
+    const PORTABILITY_FIX_CASE          = 8;
+    
+    const PORTABILITY_ORACLE            = 9;
+    const PORTABILITY_POSTGRESQL        = 13;
+    const PORTABILITY_SQLITE            = 13;
+    const PORTABILITY_OTHERVENDORS      = 12;
+    
+    /**
+     * @var int
+     */
+    private $portability = self::PORTABILITY_NONE;
+    
+    /**
+     * @var int
+     */
+    private $case = \PDO::CASE_NATURAL;
+    
+    public function connect()
+    {
+        $ret = parent::connect();
+        if ($ret) {       
+            $params = $this->getParams();
+            if (isset($params['portability'])) {
+                if ($this->_platform->getName() === "oracle") {
+                    $params['portability'] = $params['portability'] & self::PORTABILITY_ORACLE;
+                } else if ($this->_platform->getName() === "postgresql") {
+                    $params['portability'] = $params['portability'] & self::PORTABILITY_POSTGRESQL;
+                } else if ($this->_platform->getName() === "sqlite") {
+                    $params['portability'] = $params['portability'] & self::PORTABILITY_SQLITE;
+                } else {
+                    $params['portability'] = $params['portability'] & self::PORTABILITY_OTHERVENDORS;
+                }
+                $this->portability = $params['portability'];
+            }
+            if (isset($params['fetch_case']) && $this->portability & self::PORTABILITY_FIX_CASE) {
+                if ($this->_conn instanceof \Doctrine\DBAL\Driver\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'] == \PDO::CASE_LOWER) ? CASE_LOWER : CASE_UPPER;
+                }
+            }    
+        }
+        return $ret;
+    }
+    
+    public function getPortability()
+    {
+        return $this->portability;
+    }
+    
+    public function getFetchCase()
+    {
+        return $this->case;
+    }
+    
+    public function executeQuery($query, array $params = array(), $types = array())
+    {
+        return new Statement(parent::executeQuery($query, $params, $types), $this);
+    }
+    
+    /**
+     * Prepares an SQL statement.
+     *
+     * @param string $statement The SQL statement to prepare.
+     * @return Doctrine\DBAL\Driver\Statement The prepared statement.
+     */
+    public function prepare($statement)
+    {
+        return new Statement(parent::prepare($statement), $this);
+    }
+    
+    public function query()
+    {
+        $this->connect();
+
+        $stmt = call_user_func_array(array($this->_conn, 'query'), func_get_args());
+        return new Statement($stmt, $this);
+    }
+}

lib/Doctrine/DBAL/Portability/Statement.php

+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\DBAL\Portability;
+
+use PDO;
+
+/**
+ * Portability Wrapper for a Statement
+ *
+ * @license     http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link        www.doctrine-project.com
+ * @since       2.0
+ * @author      Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class Statement implements \Doctrine\DBAL\Driver\Statement
+{
+
+    /**
+     * @var int
+     */
+    private $portability;
+    
+    /**
+     * @var Doctrine\DBAL\Driver\Statement
+     */
+    private $stmt;
+    
+    /**
+     * @var int
+     */
+    private $case;
+
+    /**
+     * Wraps <tt>Statement</tt> and applies portability measures
+     *
+     * @param Doctrine\DBAL\Driver\Statement $stmt
+     * @param Doctrine\DBAL\Connection $conn
+     */
+    public function __construct($stmt, Connection $conn)
+    {
+        $this->stmt = $stmt;
+        $this->portability = $conn->getPortability();
+        $this->case = $conn->getFetchCase();
+    }
+
+    public function bindParam($column, &$variable, $type = null)
+    {
+        return $this->stmt->bindParam($column, $variable, $type);
+    }
+
+    public function bindValue($param, $value, $type = null)
+    {
+        return $this->stmt->bindValue($param, $value, $type);
+    }
+
+    public function closeCursor()
+    {
+        return $this->stmt->closeCursor();
+    }
+
+    public function columnCount()
+    {
+        return $this->stmt->columnCount();
+    }
+
+    public function errorCode()
+    {
+        return $this->stmt->errorCode();
+    }
+
+    public function errorInfo()
+    {
+        return $this->stmt->errorInfo();
+    }
+
+    public function execute($params = null)
+    {
+        return $this->stmt->execute($params);
+    }
+
+    public function fetch($fetchStyle = PDO::FETCH_BOTH)
+    {
+        $row = $this->stmt->fetch($fetchStyle);
+        
+        $row = $this->fixRow($row,
+            $this->portability & (Connection::PORTABILITY_EMPTY_TO_NULL|Connection::PORTABILITY_RTRIM),
+            ($fetchStyle == PDO::FETCH_ASSOC || $fetchStyle == PDO::FETCH_BOTH) && ($this->portability & Connection::PORTABILITY_FIX_CASE)
+        );
+        
+        return $row;
+    }
+
+    public function fetchAll($fetchStyle = PDO::FETCH_BOTH, $columnIndex = 0)
+    {
+        if ($columnIndex != 0) {
+            $rows = $this->stmt->fetchAll($fetchStyle, $columnIndex);
+        } else {
+            $rows = $this->stmt->fetchAll($fetchStyle);
+        }
+        
+        $iterateRow = $this->portability & (Connection::PORTABILITY_EMPTY_TO_NULL|Connection::PORTABILITY_RTRIM);
+        $fixCase = ($fetchStyle == PDO::FETCH_ASSOC || $fetchStyle == PDO::FETCH_BOTH) && ($this->portability & Connection::PORTABILITY_FIX_CASE);
+        if (!$iterateRow && !$fixCase) {
+            return $rows;
+        }
+
+        foreach ($rows AS $num => $row) {
+            $rows[$num] = $this->fixRow($row, $iterateRow, $fixCase);
+        }
+        
+        return $rows;
+    }
+    
+    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;
+                } else if (($this->portability & Connection::PORTABILITY_RTRIM) && is_string($v)) {
+                    $row[$k] = rtrim($v);
+                }
+            }
+        }
+        return $row;
+    }
+
+    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;
+            } else if (($this->portability & Connection::PORTABILITY_RTRIM) && is_string($value)) {
+                $value = rtrim($value);
+            }
+        }
+        
+        return $value;
+    }
+
+    public function rowCount()
+    {
+        return $this->stmt->rowCount();
+    }
+
+}
\ No newline at end of file

tests/Doctrine/Tests/DBAL/Functional/AllTests.php

@@ -41,6 +41,7 @@ class AllTests
         $suite->addTestSuite('Doctrine\Tests\DBAL\Functional\WriteTest');
         $suite->addTestSuite('Doctrine\Tests\DBAL\Functional\LoggingTest');
         $suite->addTestSuite('Doctrine\Tests\DBAL\Functional\TypeConversionTest');
+        $suite->addTestSuite('Doctrine\Tests\DBAL\Functional\PortabilityTest');
 
         return $suite;
     }

tests/Doctrine/Tests/DBAL/Functional/PortabilityTest.php

+<?php
+
+namespace Doctrine\Tests\DBAL\Functional;
+
+use Doctrine\DBAL\Types\Type;
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\DriverManager;
+use PDO;
+
+require_once __DIR__ . '/../../TestInit.php';
+
+/**
+ * @group DBAL-56
+ */
+class PortabilityTest extends \Doctrine\Tests\DbalFunctionalTestCase
+{
+    static private $hasTable = false;
+    
+    private $portableConnection;
+    
+    public function tearDown()
+    {
+        if ($this->portableConnection) {
+            $this->portableConnection->close();
+        }
+    }
+    
+    private function getPortableConnection($portabilityMode = \Doctrine\DBAL\Portability\Connection::PORTABILITY_ALL, $case = \PDO::CASE_LOWER)
+    {
+        if (!$this->portableConnection) {
+            $params = $this->_conn->getParams();
+            $params['wrapperClass'] = 'Doctrine\DBAL\Portability\Connection';
+            $params['portability'] = $portabilityMode;
+            $params['fetch_case'] = $case;
+            $this->portableConnection = DriverManager::getConnection($params, $this->_conn->getConfiguration(), $this->_conn->getEventManager());
+
+            try {
+                /* @var $sm \Doctrine\DBAL\Schema\AbstractSchemaManager */
+                $table = new \Doctrine\DBAL\Schema\Table("portability_table");
+                $table->addColumn('Test_Int', 'integer');
+                $table->addColumn('Test_String', 'string', array('fixed' => true, 'length' => 32));
+                $table->addColumn('Test_Null', 'string', array('notnull' => false));
+
+                $sm = $this->portableConnection->getSchemaManager();
+                $sm->createTable($table);
+
+                $this->portableConnection->insert('portability_table', array('Test_Int' => 1, 'Test_String' => 'foo', 'Test_Null' => ''));
+                $this->portableConnection->insert('portability_table', array('Test_Int' => 1, 'Test_String' => 'foo  ', 'Test_Null' => null));
+            } catch(\Exception $e) {
+                
+            }
+        }
+        
+        return $this->portableConnection;
+    }
+    
+    public function testFullFetchMode()
+    {
+        $rows = $this->getPortableConnection()->fetchAll('SELECT * FROM portability_table');
+        $this->assertFetchResultRows($rows);
+        
+        $stmt = $this->getPortableConnection()->query('SELECT * FROM portability_table');
+        while ($row = $stmt->fetch(\PDO::FETCH_ASSOC)) {
+            $this->assertFetchResultRow($row);
+        }
+        
+        $stmt = $this->getPortableConnection()->prepare('SELECT * FROM portability_table');
+        $stmt->execute();
+        
+        while ($row = $stmt->fetch(\PDO::FETCH_ASSOC)) {
+            $this->assertFetchResultRow($row);
+        }
+    }
+    
+    public function assertFetchResultRows($rows)
+    {
+        $this->assertEquals(2, count($rows));
+        foreach ($rows AS $row) {
+            $this->assertFetchResultRow($row);
+        }
+    }
+    
+    public function assertFetchResultRow($row)
+    {
+        $this->assertEquals(1, $row['test_int']);
+        $this->assertArrayHasKey('test_string', $row, "Case should be lowered.");
+        $this->assertEquals(3, strlen($row['test_string']), "test_string should be rtrimed to length of three for CHAR(32) column.");
+        $this->assertNull($row['test_null']);
+    }
+}
\ No newline at end of file