AbstractPlatform.php

Ir para a documentação deste ficheiro.

<?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\Platforms;
 
use Doctrine\DBAL\DBALException,
    Doctrine\DBAL\Connection,
    Doctrine\DBAL\Types,
    Doctrine\DBAL\Schema\Table,
    Doctrine\DBAL\Schema\Index,
    Doctrine\DBAL\Schema\ForeignKeyConstraint,
    Doctrine\DBAL\Schema\TableDiff;
 
abstract class AbstractPlatform
{
    const CREATE_INDEXES = 1;
 
    const CREATE_FOREIGNKEYS = 2;
 
    const TRIM_UNSPECIFIED = 0;
 
    const TRIM_LEADING = 1;
 
    const TRIM_TRAILING = 2;
 
    const TRIM_BOTH = 3;
 
    protected $doctrineTypeMapping = null;
 
    public function __construct() {}
 
    abstract public function getBooleanTypeDeclarationSQL(array $columnDef);
 
    abstract public function getIntegerTypeDeclarationSQL(array $columnDef);
 
    abstract public function getBigIntTypeDeclarationSQL(array $columnDef);
 
    abstract public function getSmallIntTypeDeclarationSQL(array $columnDef);
 
    abstract protected function _getCommonIntegerTypeDeclarationSQL(array $columnDef);
 
    abstract protected function initializeDoctrineTypeMappings();
 
    abstract public function getVarcharTypeDeclarationSQL(array $field);
 
    abstract public function getClobTypeDeclarationSQL(array $field);
 
    abstract public function getName();
 
    public function registerDoctrineTypeMapping($dbType, $doctrineType)
    {
        if ($this->doctrineTypeMapping === null) {
            $this->initializeDoctrineTypeMappings();
        }
 
        if (!Types\Type::hasType($doctrineType)) {
            throw DBALException::typeNotFound($doctrineType);
        }
 
        $dbType = strtolower($dbType);
        $this->doctrineTypeMapping[$dbType] = $doctrineType;
    }
 
    public function getDoctrineTypeMapping($dbType)
    {
        if ($this->doctrineTypeMapping === null) {
            $this->initializeDoctrineTypeMappings();
        }
        
        $dbType = strtolower($dbType);
        if (isset($this->doctrineTypeMapping[$dbType])) {
            return $this->doctrineTypeMapping[$dbType];
        } else {
            throw new \Doctrine\DBAL\DBALException("Unknown database type ".$dbType." requested, " . get_class($this) . " may not support it.");
        }
    }
 
    public function hasDoctrineTypeMappingFor($dbType)
    {
        if ($this->doctrineTypeMapping === null) {
            $this->initializeDoctrineTypeMappings();
        }
 
        $dbType = strtolower($dbType);
        return isset($this->doctrineTypeMapping[$dbType]);
    }
 
    public function getIdentifierQuoteCharacter()
    {
        return '"';
    }
 
    public function getSqlCommentStartString()
    {
        return "--";
    }
 
    public function getSqlCommentEndString()
    {
        return "\n";
    }
 
    public function getVarcharMaxLength()
    {
        return 4000;
    }
 
    public function getVarcharDefaultLength()
    {
        return 255;
    }
 
    public function getWildcards()
    {
        return array('%', '_');
    }
 
    public function getRegexpExpression()
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    public function getAvgExpression($column)
    {
        return 'AVG(' .  $column . ')';
    }
 
    public function getCountExpression($column)
    {
        return 'COUNT(' . $column . ')';
    }
 
    public function getMaxExpression($column)
    {
        return 'MAX(' . $column . ')';
    }
 
    public function getMinExpression($column)
    {
        return 'MIN(' . $column . ')';
    }
 
    public function getSumExpression($column)
    {
        return 'SUM(' . $column . ')';
    }
 
    // scalar functions
 
    public function getMd5Expression($column)
    {
        return 'MD5(' . $column . ')';
    }
 
    public function getLengthExpression($column)
    {
        return 'LENGTH(' . $column . ')';
    }
 
    public function getRoundExpression($column, $decimals = 0)
    {
        return 'ROUND(' . $column . ', ' . $decimals . ')';
    }
 
    public function getModExpression($expression1, $expression2)
    {
        return 'MOD(' . $expression1 . ', ' . $expression2 . ')';
    }
 
    public function getTrimExpression($str, $pos = self::TRIM_UNSPECIFIED, $char = false)
    {
        $posStr = '';
        $trimChar = ($char != false) ? $char . ' FROM ' : '';
        
        if ($pos == self::TRIM_LEADING) {
            $posStr = 'LEADING '.$trimChar;
        } else if($pos == self::TRIM_TRAILING) {
            $posStr = 'TRAILING '.$trimChar;
        } else if($pos == self::TRIM_BOTH) {
            $posStr = 'BOTH '.$trimChar;
        }
 
        return 'TRIM(' . $posStr . $str . ')';
    }
 
    public function getRtrimExpression($str)
    {
        return 'RTRIM(' . $str . ')';
    }
 
    public function getLtrimExpression($str)
    {
        return 'LTRIM(' . $str . ')';
    }
 
    public function getUpperExpression($str)
    {
        return 'UPPER(' . $str . ')';
    }
 
    public function getLowerExpression($str)
    {
        return 'LOWER(' . $str . ')';
    }
 
    public function getLocateExpression($str, $substr, $startPos = false)
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    public function getNowExpression()
    {
        return 'NOW()';
    }
 
    public function getSubstringExpression($value, $from, $len = null)
    {
        if ($len === null)
            return 'SUBSTRING(' . $value . ' FROM ' . $from . ')';
        else {
            return 'SUBSTRING(' . $value . ' FROM ' . $from . ' FOR ' . $len . ')';
        }
    }
 
    public function getConcatExpression()
    {
        return join(' || ' , func_get_args());
    }
 
    public function getNotExpression($expression)
    {
        return 'NOT(' . $expression . ')';
    }
 
    public function getInExpression($column, $values)
    {
        if ( ! is_array($values)) {
            $values = array($values);
        }
        $values = $this->getIdentifiers($values);
 
        if (count($values) == 0) {
            throw \InvalidArgumentException('Values must not be empty.');
        }
        return $column . ' IN (' . implode(', ', $values) . ')';
    }
 
    public function getIsNullExpression($expression)
    {
        return $expression . ' IS NULL';
    }
 
    public function getIsNotNullExpression($expression)
    {
        return $expression . ' IS NOT NULL';
    }
 
    public function getBetweenExpression($expression, $value1, $value2)
    {
        return $expression . ' BETWEEN ' .$value1 . ' AND ' . $value2;
    }
 
    public function getAcosExpression($value)
    {
        return 'ACOS(' . $value . ')';
    }
 
    public function getSinExpression($value)
    {
        return 'SIN(' . $value . ')';
    }
 
    public function getPiExpression()
    {
        return 'PI()';
    }
 
    public function getCosExpression($value)
    {
        return 'COS(' . $value . ')';
    }
 
    public function getForUpdateSQL()
    {
        return 'FOR UPDATE';
    }
 
    public function appendLockHint($fromClause, $lockMode)
    {
        return $fromClause;
    }
 
    public function getReadLockSQL()
    {
        return $this->getForUpdateSQL();
    }
 
    public function getWriteLockSQL()
    {
        return $this->getForUpdateSQL();
    }
 
    public function getDropDatabaseSQL($database)
    {
        return 'DROP DATABASE ' . $database;
    }
 
    public function getDropTableSQL($table)
    {
        if ($table instanceof \Doctrine\DBAL\Schema\Table) {
            $table = $table->getQuotedName($this);
        }
 
        return 'DROP TABLE ' . $table;
    }
 
    public function getDropIndexSQL($index, $table=null)
    {
        if($index instanceof \Doctrine\DBAL\Schema\Index) {
            $index = $index->getQuotedName($this);
        } else if(!is_string($index)) {
            throw new \InvalidArgumentException('AbstractPlatform::getDropIndexSQL() expects $index parameter to be string or \Doctrine\DBAL\Schema\Index.');
        }
 
        return 'DROP INDEX ' . $index;
    }
 
    public function getDropConstraintSQL($constraint, $table)
    {
        if ($constraint instanceof \Doctrine\DBAL\Schema\Constraint) {
            $constraint = $constraint->getQuotedName($this);
        }
 
        if ($table instanceof \Doctrine\DBAL\Schema\Table) {
            $table = $table->getQuotedName($this);
        }
 
        return 'ALTER TABLE ' . $table . ' DROP CONSTRAINT ' . $constraint;
    }
 
    public function getDropForeignKeySQL($foreignKey, $table)
    {
        if ($foreignKey instanceof \Doctrine\DBAL\Schema\ForeignKeyConstraint) {
            $foreignKey = $foreignKey->getQuotedName($this);
        }
 
        if ($table instanceof \Doctrine\DBAL\Schema\Table) {
            $table = $table->getQuotedName($this);
        }
 
        return 'ALTER TABLE ' . $table . ' DROP FOREIGN KEY ' . $foreignKey;
    }
 
    public function getCreateTableSQL(Table $table, $createFlags=self::CREATE_INDEXES)
    {
        if ( ! is_int($createFlags)) {
            throw new \InvalidArgumentException("Second argument of AbstractPlatform::getCreateTableSQL() has to be integer.");
        }
 
        if (count($table->getColumns()) == 0) {
            throw DBALException::noColumnsSpecifiedForTable($table->getName());
        }
 
        $tableName = $table->getQuotedName($this);
        $options = $table->getOptions();
        $options['uniqueConstraints'] = array();
        $options['indexes'] = array();
        $options['primary'] = array();
 
        if (($createFlags&self::CREATE_INDEXES) > 0) {
            foreach ($table->getIndexes() AS $index) {
                /* @var $index Index */
                if ($index->isPrimary()) {
                    $options['primary'] = $index->getColumns();
                } else {
                    $options['indexes'][$index->getName()] = $index;
                }
            }
        }
 
        $columns = array();
        foreach ($table->getColumns() AS $column) {
            /* @var \Doctrine\DBAL\Schema\Column $column */
            $columnData = array();
            $columnData['name'] = $column->getQuotedName($this);
            $columnData['type'] = $column->getType();
            $columnData['length'] = $column->getLength();
            $columnData['notnull'] = $column->getNotNull();
            $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) {
                $columnData['length'] = 255;
            }
            $columnData['precision'] = $column->getPrecision();
            $columnData['scale'] = $column->getScale();
            $columnData['default'] = $column->getDefault();
            $columnData['columnDefinition'] = $column->getColumnDefinition();
            $columnData['autoincrement'] = $column->getAutoincrement();
 
            if(in_array($column->getName(), $options['primary'])) {
                $columnData['primary'] = true;
            }
 
            $columns[$columnData['name']] = $columnData;
        }
 
        if (($createFlags&self::CREATE_FOREIGNKEYS) > 0) {
            $options['foreignKeys'] = array();
            foreach ($table->getForeignKeys() AS $fkConstraint) {
                $options['foreignKeys'][] = $fkConstraint;
            }
        }
 
        return $this->_getCreateTableSQL($tableName, $columns, $options);
    }
 
    protected function _getCreateTableSQL($tableName, array $columns, array $options = array())
    {
        $columnListSql = $this->getColumnDeclarationListSQL($columns);
        
        if (isset($options['uniqueConstraints']) && ! empty($options['uniqueConstraints'])) {
            foreach ($options['uniqueConstraints'] as $name => $definition) {
                $columnListSql .= ', ' . $this->getUniqueConstraintDeclarationSQL($name, $definition);
            }
        }
        
        if (isset($options['primary']) && ! empty($options['primary'])) {
            $columnListSql .= ', PRIMARY KEY(' . implode(', ', array_unique(array_values($options['primary']))) . ')';
        }
 
        if (isset($options['indexes']) && ! empty($options['indexes'])) {
            foreach($options['indexes'] as $index => $definition) {
                $columnListSql .= ', ' . $this->getIndexDeclarationSQL($index, $definition);
            }
        }
 
        $query = 'CREATE TABLE ' . $tableName . ' (' . $columnListSql;
 
        $check = $this->getCheckDeclarationSQL($columns);
        if ( ! empty($check)) {
            $query .= ', ' . $check;
        }
        $query .= ')';
 
        $sql[] = $query;
 
        if (isset($options['foreignKeys'])) {
            foreach ((array) $options['foreignKeys'] AS $definition) {
                $sql[] = $this->getCreateForeignKeySQL($definition, $tableName);
            }
        }
 
        return $sql;
    }
    
    public function getCreateTemporaryTableSnippetSQL()
    {
        return "CREATE TEMPORARY TABLE";
    }
 
    public function getCreateSequenceSQL(\Doctrine\DBAL\Schema\Sequence $sequence)
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    public function getCreateConstraintSQL(\Doctrine\DBAL\Schema\Constraint $constraint, $table)
    {
        if ($table instanceof \Doctrine\DBAL\Schema\Table) {
            $table = $table->getQuotedName($this);
        }
 
        $query = 'ALTER TABLE ' . $table . ' ADD CONSTRAINT ' . $constraint->getQuotedName($this);
 
        $columns = array();
        foreach ($constraint->getColumns() as $column) {
            $columns[] = $column;
        }
        $columnList = '('. implode(', ', $columns) . ')';
 
        $referencesClause = '';
        if ($constraint instanceof \Doctrine\DBAL\Schema\Index) {
            if($constraint->isPrimary()) {
                $query .= ' PRIMARY KEY';
            } elseif ($constraint->isUnique()) {
                $query .= ' UNIQUE';
            } else {
                throw new \InvalidArgumentException(
                    'Can only create primary or unique constraints, no common indexes with getCreateConstraintSQL().'
                );
            }
        } else if ($constraint instanceof \Doctrine\DBAL\Schema\ForeignKeyConstraint) {
            $query .= ' FOREIGN KEY';
 
            $foreignColumns = array();
            foreach ($constraint->getForeignColumns() AS $column) {
                $foreignColumns[] = $column;
            }
            
            $referencesClause = ' REFERENCES '.$constraint->getForeignTableName(). ' ('.implode(', ', $foreignColumns).')';
        }
        $query .= ' '.$columnList.$referencesClause;
 
        return $query;
    }
 
    public function getCreateIndexSQL(Index $index, $table)
    {
        if ($table instanceof Table) {
            $table = $table->getQuotedName($this);
        }
        $name = $index->getQuotedName($this);
        $columns = $index->getColumns();
 
        if (count($columns) == 0) {
            throw new \InvalidArgumentException("Incomplete definition. 'columns' required.");
        }
 
        $type = '';
        if ($index->isUnique()) {
            $type = 'UNIQUE ';
        }
 
        $query = 'CREATE ' . $type . 'INDEX ' . $name . ' ON ' . $table;
 
        $query .= ' (' . $this->getIndexFieldDeclarationListSQL($columns) . ')';
 
        return $query;
    }
 
    public function quoteIdentifier($str)
    {
        $c = $this->getIdentifierQuoteCharacter();
 
        return $c . $str . $c;
    }
 
    public function getCreateForeignKeySQL(ForeignKeyConstraint $foreignKey, $table)
    {
        if ($table instanceof \Doctrine\DBAL\Schema\Table) {
            $table = $table->getQuotedName($this);
        }
 
        $query = 'ALTER TABLE ' . $table . ' ADD ' . $this->getForeignKeyDeclarationSQL($foreignKey);
 
        return $query;
    }
 
    public function getAlterTableSQL(TableDiff $diff)
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    protected function _getAlterTableIndexForeignKeySQL(TableDiff $diff)
    {
        if ($diff->newName !== false) {
            $tableName = $diff->newName;
        } else {
            $tableName = $diff->name;
        }
 
        $sql = array();
        if ($this->supportsForeignKeyConstraints()) {
            foreach ($diff->removedForeignKeys AS $foreignKey) {
                $sql[] = $this->getDropForeignKeySQL($foreignKey, $tableName);
            }
            foreach ($diff->addedForeignKeys AS $foreignKey) {
                $sql[] = $this->getCreateForeignKeySQL($foreignKey, $tableName);
            }
            foreach ($diff->changedForeignKeys AS $foreignKey) {
                $sql[] = $this->getDropForeignKeySQL($foreignKey, $tableName);
                $sql[] = $this->getCreateForeignKeySQL($foreignKey, $tableName);
            }
        }
 
        foreach ($diff->addedIndexes AS $index) {
            $sql[] = $this->getCreateIndexSQL($index, $tableName);
        }
        foreach ($diff->removedIndexes AS $index) {
            $sql[] = $this->getDropIndexSQL($index, $tableName);
        }
        foreach ($diff->changedIndexes AS $index) {
            $sql[] = $this->getDropIndexSQL($index, $tableName);
            $sql[] = $this->getCreateIndexSQL($index, $tableName);
        }
 
        return $sql;
    }
 
    public function getColumnDeclarationListSQL(array $fields)
    {
        $queryFields = array();
        foreach ($fields as $fieldName => $field) {
            $query = $this->getColumnDeclarationSQL($fieldName, $field);
            $queryFields[] = $query;
        }
        return implode(', ', $queryFields);
    }
 
    public function getColumnDeclarationSQL($name, array $field)
    {
        if (isset($field['columnDefinition'])) {
            $columnDef = $this->getCustomTypeDeclarationSQL($field);
        } else {
            $default = $this->getDefaultValueDeclarationSQL($field);
 
            $charset = (isset($field['charset']) && $field['charset']) ?
                    ' ' . $this->getColumnCharsetDeclarationSQL($field['charset']) : '';
 
            $collation = (isset($field['collation']) && $field['collation']) ?
                    ' ' . $this->getColumnCollationDeclarationSQL($field['collation']) : '';
 
            $notnull = (isset($field['notnull']) && $field['notnull']) ? ' NOT NULL' : '';
 
            $unique = (isset($field['unique']) && $field['unique']) ?
                    ' ' . $this->getUniqueFieldDeclarationSQL() : '';
 
            $check = (isset($field['check']) && $field['check']) ?
                    ' ' . $field['check'] : '';
 
            $typeDecl = $field['type']->getSqlDeclaration($field, $this);
            $columnDef = $typeDecl . $charset . $default . $notnull . $unique . $check . $collation;
        }
 
        return $name . ' ' . $columnDef;
    }
    
    public function getDecimalTypeDeclarationSQL(array $columnDef) 
    {
        $columnDef['precision'] = ( ! isset($columnDef['precision']) || empty($columnDef['precision']))
            ? 10 : $columnDef['precision'];
        $columnDef['scale'] = ( ! isset($columnDef['scale']) || empty($columnDef['scale']))
            ? 0 : $columnDef['scale'];
        
        return 'NUMERIC(' . $columnDef['precision'] . ', ' . $columnDef['scale'] . ')';
    }
 
    public function getDefaultValueDeclarationSQL($field)
    {
        $default = empty($field['notnull']) ? ' DEFAULT NULL' : '';
 
        if (isset($field['default'])) {
            $default = " DEFAULT '".$field['default']."'";
            if (isset($field['type'])) {
                if (in_array((string)$field['type'], array("Integer", "BigInteger", "SmallInteger"))) {
                    $default = " DEFAULT ".$field['default'];
                } else if ((string)$field['type'] == 'DateTime' && $field['default'] == $this->getCurrentTimestampSQL()) {
                    $default = " DEFAULT ".$this->getCurrentTimestampSQL();
                }
            }
        }
        return $default;
    }
 
    public function getCheckDeclarationSQL(array $definition)
    {
        $constraints = array();
        foreach ($definition as $field => $def) {
            if (is_string($def)) {
                $constraints[] = 'CHECK (' . $def . ')';
            } else {
                if (isset($def['min'])) {
                    $constraints[] = 'CHECK (' . $field . ' >= ' . $def['min'] . ')';
                }
 
                if (isset($def['max'])) {
                    $constraints[] = 'CHECK (' . $field . ' <= ' . $def['max'] . ')';
                }
            }
        }
 
        return implode(', ', $constraints);
    }
    
    public function getUniqueConstraintDeclarationSQL($name, Index $index)
    {
        if (count($index->getColumns()) == 0) {
            throw \InvalidArgumentException("Incomplete definition. 'columns' required.");
        }
        
        return 'CONSTRAINT ' . $name . ' UNIQUE ('
             . $this->getIndexFieldDeclarationListSQL($index->getColumns()) 
             . ')';
    }
 
    public function getIndexDeclarationSQL($name, Index $index)
    {
        $type = '';
 
        if($index->isUnique()) {
            $type = 'UNIQUE ';
        }
 
        if (count($index->getColumns()) == 0) {
            throw \InvalidArgumentException("Incomplete definition. 'columns' required.");
        }
 
        return $type . 'INDEX ' . $name . ' ('
             . $this->getIndexFieldDeclarationListSQL($index->getColumns()) 
             . ')';
    }
 
    public function getCustomTypeDeclarationSQL(array $columnDef)
    {
        return $columnDef['columnDefinition'];
    }
 
    public function getIndexFieldDeclarationListSQL(array $fields)
    {
        $ret = array();
        foreach ($fields as $field => $definition) {
            if (is_array($definition)) {
                $ret[] = $field;
            } else {
                $ret[] = $definition;
            }
        }
        return implode(', ', $ret);
    }
 
    public function getTemporaryTableSQL()
    {
        return 'TEMPORARY';
    }
 
    public function getTemporaryTableName($tableName)
    {
        return $tableName;
    }
 
    public function getShowDatabasesSQL()
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    public function getForeignKeyDeclarationSQL(ForeignKeyConstraint $foreignKey)
    {
        $sql  = $this->getForeignKeyBaseDeclarationSQL($foreignKey);
        $sql .= $this->getAdvancedForeignKeyOptionsSQL($foreignKey);
 
        return $sql;
    }
 
    public function getAdvancedForeignKeyOptionsSQL(ForeignKeyConstraint $foreignKey)
    {
        $query = '';
        if ($this->supportsForeignKeyOnUpdate() && $foreignKey->hasOption('onUpdate')) {
            $query .= ' ON UPDATE ' . $this->getForeignKeyReferentialActionSQL($foreignKey->getOption('onUpdate'));
        }
        if ($foreignKey->hasOption('onDelete')) {
            $query .= ' ON DELETE ' . $this->getForeignKeyReferentialActionSQL($foreignKey->getOption('onDelete'));
        }
        return $query;
    }
 
    public function getForeignKeyReferentialActionSQL($action)
    {
        $upper = strtoupper($action);
        switch ($upper) {
            case 'CASCADE':
            case 'SET NULL':
            case 'NO ACTION':
            case 'RESTRICT':
            case 'SET DEFAULT':
                return $upper;
            break;
            default:
                throw new \InvalidArgumentException('Invalid foreign key action: ' . $upper);
        }
    }
 
    public function getForeignKeyBaseDeclarationSQL(ForeignKeyConstraint $foreignKey)
    {
        $sql = '';
        if (strlen($foreignKey->getName())) {
            $sql .= 'CONSTRAINT ' . $foreignKey->getQuotedName($this) . ' ';
        }
        $sql .= 'FOREIGN KEY (';
 
        if (count($foreignKey->getLocalColumns()) == 0) {
            throw new \InvalidArgumentException("Incomplete definition. 'local' required.");
        }
        if (count($foreignKey->getForeignColumns()) == 0) {
            throw new \InvalidArgumentException("Incomplete definition. 'foreign' required.");
        }
        if (strlen($foreignKey->getForeignTableName()) == 0) {
            throw new \InvalidArgumentException("Incomplete definition. 'foreignTable' required.");
        }
 
        $sql .= implode(', ', $foreignKey->getLocalColumns())
              . ') REFERENCES '
              . $foreignKey->getForeignTableName() . '('
              . implode(', ', $foreignKey->getForeignColumns()) . ')';
 
        return $sql;
    }
 
    public function getUniqueFieldDeclarationSQL()
    {
        return 'UNIQUE';
    }
 
    public function getColumnCharsetDeclarationSQL($charset)
    {
        return '';
    }
 
    public function getColumnCollationDeclarationSQL($collation)
    {
        return '';
    }
 
    public function prefersSequences()
    {
        return false;
    }
 
    public function prefersIdentityColumns()
    {
        return false;
    }
 
    public function convertBooleans($item)
    {
        if (is_array($item)) {
            foreach ($item as $k => $value) {
                if (is_bool($value)) {
                    $item[$k] = (int) $value;
                }
            }
        } else if (is_bool($item)) {
            $item = (int) $item;
        }
        return $item;
    }
 
    public function getSetCharsetSQL($charset)
    {
        return "SET NAMES '".$charset."'";
    }
 
    public function getCurrentDateSQL()
    {
        return 'CURRENT_DATE';
    }
 
    public function getCurrentTimeSQL()
    {
        return 'CURRENT_TIME';
    }
 
    public function getCurrentTimestampSQL()
    {
        return 'CURRENT_TIMESTAMP';
    }
 
    protected function _getTransactionIsolationLevelSQL($level)
    {
        switch ($level) {
            case Connection::TRANSACTION_READ_UNCOMMITTED:
                return 'READ UNCOMMITTED';
            case Connection::TRANSACTION_READ_COMMITTED:
                return 'READ COMMITTED';
            case Connection::TRANSACTION_REPEATABLE_READ:
                return 'REPEATABLE READ';
            case Connection::TRANSACTION_SERIALIZABLE:
                return 'SERIALIZABLE';
            default:
                throw new \InvalidArgumentException('Invalid isolation level:' . $level);
        }
    }
 
    public function getListDatabasesSQL()
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    public function getListSequencesSQL($database)
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    public function getListTableConstraintsSQL($table)
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    public function getListTableColumnsSQL($table)
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    public function getListTablesSQL()
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    public function getListUsersSQL()
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    public function getListViewsSQL($database)
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    public function getListTableIndexesSQL($table)
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    public function getListTableForeignKeysSQL($table)
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    public function getCreateViewSQL($name, $sql)
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    public function getDropViewSQL($name)
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    public function getDropSequenceSQL($sequence)
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    public function getSequenceNextValSQL($sequenceName)
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    public function getCreateDatabaseSQL($database)
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    public function getSetTransactionIsolationSQL($level)
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    public function getDateTimeTypeDeclarationSQL(array $fieldDeclaration)
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    public function getDateTimeTzTypeDeclarationSQL(array $fieldDeclaration)
    {
        return $this->getDateTimeTypeDeclarationSQL($fieldDeclaration);
    }
    
    
    public function getDateTypeDeclarationSQL(array $fieldDeclaration)
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    public function getTimeTypeDeclarationSQL(array $fieldDeclaration)
    {
        throw DBALException::notSupported(__METHOD__);
    }
 
    public function getFloatDeclarationSQL(array $fieldDeclaration)
    {
        return 'DOUBLE PRECISION';
    }
 
    public function getDefaultTransactionIsolationLevel()
    {
        return Connection::TRANSACTION_READ_COMMITTED;
    }
 
    /* supports*() metods */
 
    public function supportsSequences()
    {
        return false;
    }
 
    public function supportsIdentityColumns()
    {
        return false;
    }
 
    public function supportsIndexes()
    {
        return true;
    }
 
    public function supportsAlterTable()
    {
        return true;
    }
 
    public function supportsTransactions()
    {
        return true;
    }
 
    public function supportsSavepoints()
    {
        return true;
    }
 
    public function supportsReleaseSavepoints()
    {
        return $this->supportsSavepoints();
    }
 
    public function supportsPrimaryConstraints()
    {
        return true;
    }
 
    public function supportsForeignKeyConstraints()
    {
        return true;
    }
 
    public function supportsForeignKeyOnUpdate()
    {
        return ($this->supportsForeignKeyConstraints() && true);
    }
    
    public function supportsSchemas()
    {
        return false;
    }
 
    public function supportsCreateDropDatabase()
    {
        return true;
    }
 
    public function supportsGettingAffectedRows()
    {
        return true;
    }
 
    public function getIdentityColumnNullInsertSQL()
    {
        return "";
    }
 
    public function getDateTimeFormatString()
    {
        return 'Y-m-d H:i:s';
    }
 
    public function getDateTimeTzFormatString()
    {
        return 'Y-m-d H:i:s';
    }
 
    public function getDateFormatString()
    {
        return 'Y-m-d';
    }
    
    public function getTimeFormatString()
    {
        return 'H:i:s';
    }
 
    public function modifyLimitQuery($query, $limit, $offset = null)
    {
        if ( ! is_null($limit)) {
            $query .= ' LIMIT ' . $limit;
        }
 
        if ( ! is_null($offset)) {
            $query .= ' OFFSET ' . $offset;
        }
 
        return $query;
    }
    
    public function getSQLResultCasing($column)
    {
        return $column;
    }
    
    public function fixSchemaElementName($schemaElementName)
    {
        return $schemaElementName;
    }
 
    public function getMaxIdentifierLength()
    {
        return 63;
    }
 
    public function getEmptyIdentityInsertSQL($tableName, $identifierColumnName)
    {
        return 'INSERT INTO ' . $tableName . ' (' . $identifierColumnName . ') VALUES (null)';
    }
 
    public function getTruncateTableSQL($tableName, $cascade = false)
    {
        return 'TRUNCATE '.$tableName;
    }
 
    public function getDummySelectSQL()
    {
        return 'SELECT 1';
    }
 
    public function createSavePoint($savepoint)
    {
        return 'SAVEPOINT ' . $savepoint;
    }
 
    public function releaseSavePoint($savepoint)
    {
        return 'RELEASE SAVEPOINT ' . $savepoint;
    }
 
    public function rollbackSavePoint($savepoint)
    {
        return 'ROLLBACK TO SAVEPOINT ' . $savepoint;
    }
}