CratePlatform::getSubstringExpression() - Code Metrics - Inspection of "Code Highlight changes" - crate/crate-dbal - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — cc/snow-sprint ( 09dbf9 )

unknown

created 2016-01-26 22:28 UTC

CratePlatform::getSubstringExpression() A

↳ Parent: CratePlatform

Complexity

Conditions	2
Paths	2

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	8
rs	9.4285
cc	2
eloc	4
nc	2
nop	3

<?php
/**
 * Licensed to CRATE Technology GmbH("Crate") under one or more contributor
 * license agreements.  See the NOTICE file distributed with this work for
 * additional information regarding copyright ownership.  Crate licenses
 * this file to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.  You may
 * obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 * However, if you have executed another commercial license agreement
 * with Crate these terms will supersede the license and you may use the
 * software solely pursuant to the terms of the relevant commercial agreement.
 */
namespace Crate\DBAL\Platforms;

use Crate\DBAL\Types\MapType;
use Crate\DBAL\Types\TimestampType;
use Doctrine\DBAL\DBALException;
use Doctrine\DBAL\Event\SchemaCreateTableColumnEventArgs;
use Doctrine\DBAL\Event\SchemaCreateTableEventArgs;
use Doctrine\DBAL\Events;
use Doctrine\DBAL\Platforms\AbstractPlatform;
use Doctrine\DBAL\Schema\Identifier;
use Doctrine\DBAL\Schema\Index;
use Doctrine\DBAL\Schema\Table;
use Doctrine\DBAL\Schema\TableDiff;
use Doctrine\DBAL\Types\Type;
use Doctrine\DBAL\Schema\ForeignKeyConstraint;

class CratePlatform extends AbstractPlatform
{

    const TIMESTAMP_FORMAT =  'Y-m-d\TH:i:s';
    const TIMESTAMP_FORMAT_TZ =  'Y-m-d\TH:i:sO';

    /**
     * {@inheritDoc}
     */
    public function __construct()
    {
        parent::__construct();
        $this->initializeDoctrineTypeMappings();
        if (!Type::hasType(MapType::NAME)) {
            Type::addType(MapType::NAME, 'Crate\DBAL\Types\MapType');
        }
        if (!Type::hasType(TimestampType::NAME)) {
            Type::addType(TimestampType::NAME, 'Crate\DBAL\Types\TimestampType');
        }
        Type::overrideType('array', 'Crate\DBAL\Types\ArrayType');
    }

    /**
     * {@inheritDoc}
     */
    public function getSubstringExpression($value, $from = 0, $length = null)
    {
        if ($length === null) {
            return 'SUBSTR(' . $value . ', ' . $from . ')';
        }

        return 'SUBSTR(' . $value . ', ' . $from . ', ' . $length . ')';
    }

    /**
     * {@inheritDoc}
     */
    public function getNowExpression()
    {
        throw DBALException::notSupported(__METHOD__);
    }

    /**
     * {@inheritDoc}
     */
    public function getRegexpExpression()
    {
        return 'LIKE';
    }

    /**
     * {@inheritDoc}
     */
    public function getDateDiffExpression($date1, $date2)
    {
        throw DBALException::notSupported(__METHOD__);
    }

    /**
     * {@inheritDoc}
     */
    public function supportsSequences()
    {
        return false;
    }

    /**
     * If we want to support Schemas, we need to implement 
     * getListNamespacesSQL and getCreateSchemaSQL methods
     * 
     * {@inheritDoc}
     */
    public function supportsSchemas()
    {
        return false;
    }

    /**
     * {@inheritDoc}
     */
    public function supportsIdentityColumns()
    {
        return true;
    }

    /**
     * {@inheritDoc}
     */
    public function supportsIndexes()
    {
        return false;
    }

    /**
     * {@inheritDoc}
     */
    public function supportsCommentOnStatement()
    {
        return false;
    }

    /**
     * {@inheritDoc}
     */
    public function supportsForeignKeyConstraints()
    {
        return false;
    }

    /**
     * {@inheritDoc}
     */
    public function supportsForeignKeyOnUpdate()
    {
        return false;
    }

    /**
     * {@inheritDoc}
     */
    public function supportsViews()
    {
        return false;
    }

    /**
     * {@inheritDoc}
     */
    public function prefersSequences()
    {
        return false;
    }

    /**
     * {@inheritDoc}
     */
    public function getListDatabasesSQL()
    {
        throw DBALException::notSupported(__METHOD__);
    }

    /**
     * {@inheritDoc}
     */
    public function getListTablesSQL()
    {
        return "SELECT table_name, schema_name FROM information_schema.tables " .
            "WHERE schema_name = 'doc' OR schema_name = 'blob'";
    }

    /**
     * {@inheritDoc}
     */
    public function getListTableColumnsSQL($table, $database = null)
    {
        $t = explode('.', $table);
        if (count($t) == 1) {
            array_unshift($t, 'doc');
        }
        // todo: make safe
        return "SELECT * from information_schema.columns " .
            "WHERE table_name = '$t[1]' AND schema_name = '$t[0]'";
    }

    /**
     * {@inheritDoc}
     */
    public function getListTableConstraintsSQL($table, $database = null)

    {
        $t = explode('.', $table);
        if (count($t) == 1) {
            array_unshift($t, 'doc');
        }
        // todo: make safe
        return "SELECT constraint_name, constraint_type from information_schema.table_constraints " .
            "WHERE table_name = '$t[1]' AND schema_name = '$t[0]' AND constraint_type = 'PRIMARY_KEY'";
    }

    /**
     * {@inheritDoc}
     */
    public function getAlterTableSQL(TableDiff $diff)
    {
        $sql = array();
        $commentsSQL = array();
        $columnSql = array();

        foreach ($diff->addedColumns as $column) {
            if ($this->onSchemaAlterTableAddColumn($column, $diff, $columnSql)) {
                continue;
            }

            $query = 'ADD ' . $this->getColumnDeclarationSQL($column->getQuotedName($this), $column->toArray());
            $sql[] = 'ALTER TABLE ' . $diff->name . ' ' . $query;
            if ($comment = $this->getColumnComment($column)) {
                $commentsSQL[] = $this->getCommentOnColumnSQL($diff->name, $column->getName(), $comment);
            }
        }

        if (count($diff->removedColumns) > 0) {
            throw DBALException::notSupported("Alter Table: drop columns");
        }
        if (count($diff->changedColumns) > 0) {
            throw DBALException::notSupported("Alter Table: change column options");
        }
        if (count($diff->renamedColumns) > 0) {
            throw DBALException::notSupported("Alter Table: rename columns");
        }

        $tableSql = array();

        if (!$this->onSchemaAlterTable($diff, $tableSql)) {
            if ($diff->newName !== false) {
                throw DBALException::notSupported("Alter Table: rename table");
            }

            $sql = array_merge($sql, $this->_getAlterTableIndexForeignKeySQL($diff), $commentsSQL);
        }

        return array_merge($sql, $tableSql, $columnSql);
    }

    /**
     * {@inheritDoc}
     */
    public function getColumnDeclarationSQL($name, array $field)
    {
        if (isset($field['columnDefinition'])) {
            $columnDef = $this->getCustomTypeDeclarationSQL($field);
        } else {
            $typeDecl = $field['type']->getSqlDeclaration($field, $this);
            $columnDef = $typeDecl;
        }

        return $name . ' ' . $columnDef;
    }

    /**
     * Generate table index column declaration
     * @codeCoverageIgnore
     */
    public function getIndexDeclarationSQL($name, Index $index)
    {
        $columns = $index->getQuotedColumns($this);
        $name = new Identifier($name);

        if (count($columns) == 0) {
            throw new \InvalidArgumentException("Incomplete definition. 'columns' required.");
        }

        return 'INDEX ' . $name->getQuotedName($this) . ' USING FULLTEXT ('. $this->getIndexFieldDeclarationListSQL($columns) . ')';
    }

    /**
     * {@inheritDoc}
     *
     * Crate wants boolean values converted to the strings 'true'/'false'.
     */
    public function convertBooleans($item)
    {
        if (is_array($item)) {
            foreach ($item as $key => $value) {
                if (is_bool($value)) {
                    $item[$key] = ($value) ? 'true' : 'false';
                } elseif (is_numeric($value)) {
                    $item[$key] = ($value > 0) ? 'true' : 'false';
                }
            }
        } else {
            if (is_bool($item)) {
                $item = ($item) ? 'true' : 'false';
            } elseif (is_numeric($item)) {
                $item = ($item > 0) ? 'true' : 'false';
            }
        }

        return $item;
    }

    /**
     * {@inheritDoc}
     */
    public function getBooleanTypeDeclarationSQL(array $field)
    {
        return 'BOOLEAN';
    }

    /**
     * {@inheritDoc}
     */
    public function getIntegerTypeDeclarationSQL(array $field)
    {
        return 'INTEGER';
    }

    /**
     * {@inheritDoc}
     */
    public function getBigIntTypeDeclarationSQL(array $field)
    {
        return 'LONG';
    }

    /**
     * {@inheritDoc}
     */
    public function getSmallIntTypeDeclarationSQL(array $field)
    {
        return 'SHORT';
    }

    /**
     * {@inheritDoc}
     */
    public function getFloatDeclarationSQL(array $field)
    {
        return 'DOUBLE';
    }

    /**
     * {@inheritDoc}
     */
    public function getDecimalTypeDeclarationSQL(array $columnDef)
    {
        return 'DOUBLE';
    }

    /**
     * {@inheritDoc}
     */
    public function getDateTimeTypeDeclarationSQL(array $fieldDeclaration)
    {
        return 'TIMESTAMP';
    }

    /**
     * {@inheritDoc}
     */
    public function getDateTimeTzTypeDeclarationSQL(array $fieldDeclaration)
    {
        return 'TIMESTAMP';
    }

    /**
     * {@inheritDoc}
     */
    public function getDateTypeDeclarationSQL(array $fieldDeclaration)
    {
        return 'TIMESTAMP';
    }

    /**
     * {@inheritDoc}
     */
    public function getTimeTypeDeclarationSQL(array $fieldDeclaration)
    {
        return 'TIMESTAMP';
    }

    /**
     * {@inheritDoc}
     */
    protected function _getCommonIntegerTypeDeclarationSQL(array $columnDef)
    {
        return '';
    }

    /**
     * {@inheritDoc}
     */
    protected function getVarcharTypeDeclarationSQLSnippet($length, $fixed)
    {
        return 'STRING';
    }

    /**
     * {@inheritDoc}
     */
    public function getClobTypeDeclarationSQL(array $field)
    {
        return 'STRING';
    }

    /**
     * Gets the SQL snippet used to declare an OBJECT column type.
     *
     * @param array $field
     *
     * @return string
     */
    public function getMapTypeDeclarationSQL(array $field, array $options)

    {
        $type = array_key_exists('type', $options) ? $options['type'] : MapType::DYNAMIC;

        $fields = array_key_exists('fields', $options) ? $options['fields'] : array();
        $columns = array();
        foreach ($fields as $field) {
            $columns[$field->getQuotedName($this)] = $this->prepareColumnData($field);
        }
        $objectFields = $this->getColumnDeclarationListSQL($columns);

        $declaration = count($columns) > 0 ? ' AS ( ' . $objectFields . ' )' : '';
        return 'OBJECT ( ' . $type . ' )' . $declaration ;
    }

    /**
     * Gets the SQL snippet used to declare an ARRAY column type.
     *
     * @param array $field
     *
     * @return string
     */
    public function getArrayTypeDeclarationSQL(array $field, array $options)
    {
        $type = array_key_exists('type', $options) ? $options['type'] : Type::STRING;
        return 'ARRAY ( ' . Type::getType($type)->getSQLDeclaration($field, $this) . ' )';
    }

    /**
     * {@inheritDoc}
     */
    public function getName()
    {
        return 'crate';
    }

    /**
     * {@inheritDoc}
     *
     * PostgreSQL returns all column names in SQL result sets in lowercase.
     */
    public function getSQLResultCasing($column)
    {
        return strtolower($column);
    }

    /**
     * {@inheritDoc}
     */
    public function getDateTimeTzFormatString()
    {
        return self::TIMESTAMP_FORMAT_TZ;
    }

    /**
     * {@inheritDoc}
     */
    public function getDateTimeFormatString()
    {
        return self::TIMESTAMP_FORMAT;
    }

    /**
     * {@inheritDoc}
     */
    public function getDateFormatString()
    {
        return self::TIMESTAMP_FORMAT;
    }

    /**
     * {@inheritDoc}
     */
    public function getTimeFormatString()
    {
        return self::TIMESTAMP_FORMAT;
    }

    /**
     * {@inheritDoc}
     */
    public function getTruncateTableSQL($tableName, $cascade = false)
    {
        throw DBALException::notSupported(__METHOD__);
    }

    /**
     * {@inheritDoc}
     */
    public function getReadLockSQL()
    {
        throw DBALException::notSupported(__METHOD__);
    }

    /**
     * {@inheritDoc}
     */
    protected function initializeDoctrineTypeMappings()
    {
        $this->doctrineTypeMapping = array(
            'short'         => 'smallint',
            'integer'       => 'integer',
            'long'          => 'bigint',
            'int'           => 'integer',
            'bool'          => 'boolean',
            'boolean'       => 'boolean',
            'string'        => 'string',
            'float'         => 'float',
            'double'        => 'float',
            'timestamp'     => 'timestamp',
            'object'        => 'map',
            'string_array'  => 'array',
            'float_array'   => 'array',
            'double_array'  => 'array',
            'integer_array' => 'array',
            'object_array'  => 'array',
            'array'         => 'array',
        );
    }

    /**
     * {@inheritDoc}
     */
    public function getVarcharMaxLength()
    {
        return PHP_INT_MAX;
    }

    /**
     * {@inheritDoc}
     */
    protected function getReservedKeywordsClass()
    {
        return 'Crate\DBAL\Platforms\Keywords\CrateKeywords';
    }

    /**
     * {@inheritDoc}
     */
    public function getBlobTypeDeclarationSQL(array $field)
    {
        throw DBALException::notSupported(__METHOD__);
    }

    /**
     * {@inheritDoc}
     * Gets the SQL statement(s) to create a table with the specified name, columns and constraints
     * on this platform.
     *
     * @param Table $table The name of the table.
     * @param integer $createFlags
     *
     * @return array The sequence of SQL statements.
     */
    public function getCreateTableSQL(Table $table, $createFlags = self::CREATE_INDEXES)
    {
        if (!is_int($createFlags)) {
            $msg = "Second argument of CratePlatform::getCreateTableSQL() has to be integer.";
            throw new \InvalidArgumentException($msg);
        }

        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()) {
                    $platform = $this;
                    $options['primary'] = array_map(function ($columnName) use ($table, $platform) {
                        return $table->getColumn($columnName)->getQuotedName($platform);
                    }, $index->getColumns());
                    $options['primary_index'] = $index;
                } else {
                    $options['indexes'][$index->getName()] = $index;
                }
            }
        }

        $columnSql = array();
        $columns = array();

        foreach ($table->getColumns() as $column) {
            if (null !== $this->_eventManager &&
                $this->_eventManager->hasListeners(Events::onSchemaCreateTableColumn)) {

                $eventArgs = new SchemaCreateTableColumnEventArgs($column, $table, $this);
                $this->_eventManager->dispatchEvent(Events::onSchemaCreateTableColumn, $eventArgs);

                $columnSql = array_merge($columnSql, $eventArgs->getSql());

                if ($eventArgs->isDefaultPrevented()) {
                    continue;
                }
            }
            $columns[$column->getQuotedName($this)] = $this->prepareColumnData($column, $options['primary']);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

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

        if (null !== $this->_eventManager && $this->_eventManager->hasListeners(Events::onSchemaCreateTable)) {
            $eventArgs = new SchemaCreateTableEventArgs($table, $columns, $options, $this);
            $this->_eventManager->dispatchEvent(Events::onSchemaCreateTable, $eventArgs);

            if ($eventArgs->isDefaultPrevented()) {
                return array_merge($eventArgs->getSql(), $columnSql);
            }
        }

        $sql = $this->_getCreateTableSQL($tableName, $columns, $options);
        if ($this->supportsCommentOnStatement()) {
            foreach ($table->getColumns() as $column) {
                if ($this->getColumnComment($column)) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                    $sql[] = $this->getCommentOnColumnSQL(
                        $tableName,
                        $column->getName(),
                        $this->getColumnComment($column)
                    );
                }
            }
        }

        return array_merge($sql, $columnSql);
    }

    /**
     * {@inheritDoc}
     */
    protected function _getCreateTableSQL($tableName, array $columns, array $options = array())
    {
        $columnListSql = $this->getColumnDeclarationListSQL($columns);

        if (isset($options['primary']) && ! empty($options['primary'])) {
            $keyColumns = array_unique(array_values($options['primary']));
            $columnListSql .= ', PRIMARY KEY(' . implode(', ', $keyColumns) . ')';
        }

        if (isset($options['indexes']) && ! empty($options['indexes'])) {
            foreach ($options['indexes'] as $index => $definition) {
                $columnListSql .= ', ' . $this->getIndexDeclarationSQL($index, $definition);
            }
        }
 
        if (isset($options['foreignKeys'])) {
            throw DBALException::notSupported("Create Table: foreign keys");
        }

        $query = 'CREATE TABLE ' . $tableName . ' (' . $columnListSql . ')';
        return array($query);
    }

    /**
     * @param \Doctrine\DBAL\Schema\Column $column The name of the table.
     * @param array $primaries
     *
     * @return array The column data as associative array.
     */
    public function prepareColumnData($column, $primaries = array())
    {

        $columnData = array();
        $columnData['name'] = $column->getQuotedName($this);
        $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) {
            $columnData['length'] = 255;
        }

        $columnData['unsigned'] = $column->getUnsigned();
        $columnData['precision'] = $column->getPrecision();
        $columnData['scale'] = $column->getScale();
        $columnData['default'] = $column->getDefault();
        $columnData['columnDefinition'] = $column->getColumnDefinition();
        $columnData['autoincrement'] = $column->getAutoincrement();
        $columnData['comment'] = $this->getColumnComment($column);

        $columnData['platformOptions'] = $column->getPlatformOptions();

        if (in_array($column->getName(), $primaries)) {
            $columnData['primary'] = true;
        }
        return $columnData;
    }

    /**
     * {@inheritDoc}
     */
    public function getCreateDatabaseSQL($database)
    {
        throw DBALException::notSupported(__METHOD__);
    }

    /**
     * {@inheritDoc}
     */
    public function getDropDatabaseSQL($database)
    {
        throw DBALException::notSupported(__METHOD__);
    }
    
    /**
     * {@inheritDoc}
     */
    public function getCreateForeignKeySQL(ForeignKeyConstraint $foreignKey, $table)
    {
        throw DBALException::notSupported(__METHOD__);
    }
    
    /**
     * {@inheritDoc}
     */
    public function getGuidTypeDeclarationSQL(array $field)
    {
        throw DBALException::notSupported(__METHOD__);
    }
}


1			<?php
2			/**
3			* Licensed to CRATE Technology GmbH("Crate") under one or more contributor
4			* license agreements. See the NOTICE file distributed with this work for
5			* additional information regarding copyright ownership. Crate licenses
6			* this file to you under the Apache License, Version 2.0 (the "License");
7			* you may not use this file except in compliance with the License. You may
8			* obtain a copy of the License at
9			*
10			* http://www.apache.org/licenses/LICENSE-2.0
11			*
12			* Unless required by applicable law or agreed to in writing, software
13			* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
14			* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
15			* License for the specific language governing permissions and limitations
16			* under the License.
17			*
18			* However, if you have executed another commercial license agreement
19			* with Crate these terms will supersede the license and you may use the
20			* software solely pursuant to the terms of the relevant commercial agreement.
21			*/
22			namespace Crate\DBAL\Platforms;
23
24			use Crate\DBAL\Types\MapType;
25			use Crate\DBAL\Types\TimestampType;
26			use Doctrine\DBAL\DBALException;
27			use Doctrine\DBAL\Event\SchemaCreateTableColumnEventArgs;
28			use Doctrine\DBAL\Event\SchemaCreateTableEventArgs;
29			use Doctrine\DBAL\Events;
30			use Doctrine\DBAL\Platforms\AbstractPlatform;
31			use Doctrine\DBAL\Schema\Identifier;
32			use Doctrine\DBAL\Schema\Index;
33			use Doctrine\DBAL\Schema\Table;
34			use Doctrine\DBAL\Schema\TableDiff;
35			use Doctrine\DBAL\Types\Type;
36			use Doctrine\DBAL\Schema\ForeignKeyConstraint;
37
38			class CratePlatform extends AbstractPlatform
39			{
40
41			const TIMESTAMP_FORMAT = 'Y-m-d\TH:i:s';
42			const TIMESTAMP_FORMAT_TZ = 'Y-m-d\TH:i:sO';
43
44			/**
45			* {@inheritDoc}
46			*/
47			public function __construct()
48			{
49			parent::__construct();
50			$this->initializeDoctrineTypeMappings();
51			if (!Type::hasType(MapType::NAME)) {
52			Type::addType(MapType::NAME, 'Crate\DBAL\Types\MapType');
53			}
54			if (!Type::hasType(TimestampType::NAME)) {
55			Type::addType(TimestampType::NAME, 'Crate\DBAL\Types\TimestampType');
56			}
57			Type::overrideType('array', 'Crate\DBAL\Types\ArrayType');
58			}
59
60			/**
61			* {@inheritDoc}
62			*/
63			public function getSubstringExpression($value, $from = 0, $length = null)
64			{
65			if ($length === null) {
66			return 'SUBSTR(' . $value . ', ' . $from . ')';
67			}
68
69			return 'SUBSTR(' . $value . ', ' . $from . ', ' . $length . ')';
70			}
71
72			/**
73			* {@inheritDoc}
74			*/
75			public function getNowExpression()
76			{
77			throw DBALException::notSupported(__METHOD__);
78			}
79
80			/**
81			* {@inheritDoc}
82			*/
83			public function getRegexpExpression()
84			{
85			return 'LIKE';
86			}
87
88			/**
89			* {@inheritDoc}
90			*/
91			public function getDateDiffExpression($date1, $date2)
92			{
93			throw DBALException::notSupported(__METHOD__);
94			}
95
96			/**
97			* {@inheritDoc}
98			*/
99			public function supportsSequences()
100			{
101			return false;
102			}
103
104			/**
105			* If we want to support Schemas, we need to implement
106			* getListNamespacesSQL and getCreateSchemaSQL methods
107			*
108			* {@inheritDoc}
109			*/
110			public function supportsSchemas()
111			{
112			return false;
113			}
114
115			/**
116			* {@inheritDoc}
117			*/
118			public function supportsIdentityColumns()
119			{
120			return true;
121			}
122
123			/**
124			* {@inheritDoc}
125			*/
126			public function supportsIndexes()
127			{
128			return false;
129			}
130
131			/**
132			* {@inheritDoc}
133			*/
134			public function supportsCommentOnStatement()
135			{
136			return false;
137			}
138
139			/**
140			* {@inheritDoc}
141			*/
142			public function supportsForeignKeyConstraints()
143			{
144			return false;
145			}
146
147			/**
148			* {@inheritDoc}
149			*/
150			public function supportsForeignKeyOnUpdate()
151			{
152			return false;
153			}
154
155			/**
156			* {@inheritDoc}
157			*/
158			public function supportsViews()
159			{
160			return false;
161			}
162
163			/**
164			* {@inheritDoc}
165			*/
166			public function prefersSequences()
167			{
168			return false;
169			}
170
171			/**
172			* {@inheritDoc}
173			*/
174			public function getListDatabasesSQL()
175			{
176			throw DBALException::notSupported(__METHOD__);
177			}
178
179			/**
180			* {@inheritDoc}
181			*/
182			public function getListTablesSQL()
183			{
184			return "SELECT table_name, schema_name FROM information_schema.tables " .
185			"WHERE schema_name = 'doc' OR schema_name = 'blob'";
186			}
187
188			/**
189			* {@inheritDoc}
190			*/
191			public function getListTableColumnsSQL($table, $database = null)
192			{
193			$t = explode('.', $table);
194			if (count($t) == 1) {
195			array_unshift($t, 'doc');
196			}
197			// todo: make safe
198			return "SELECT * from information_schema.columns " .
199			"WHERE table_name = '$t[1]' AND schema_name = '$t[0]'";
200			}
201
202			/**
203			* {@inheritDoc}
204			*/
205			public function getListTableConstraintsSQL($table, $database = null)
			0 ignored issues – show Unused Code introduced 2016-01-12 08:42 UTC by Report Bug Copy Issue Report The parameter `$database` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
206			{
207			$t = explode('.', $table);
208			if (count($t) == 1) {
209			array_unshift($t, 'doc');
210			}
211			// todo: make safe
212			return "SELECT constraint_name, constraint_type from information_schema.table_constraints " .
213			"WHERE table_name = '$t[1]' AND schema_name = '$t[0]' AND constraint_type = 'PRIMARY_KEY'";
214			}
215
216			/**
217			* {@inheritDoc}
218			*/
219			public function getAlterTableSQL(TableDiff $diff)
220			{
221			$sql = array();
222			$commentsSQL = array();
223			$columnSql = array();
224
225			foreach ($diff->addedColumns as $column) {
226			if ($this->onSchemaAlterTableAddColumn($column, $diff, $columnSql)) {
227			continue;
228			}
229
230			$query = 'ADD ' . $this->getColumnDeclarationSQL($column->getQuotedName($this), $column->toArray());
231			$sql[] = 'ALTER TABLE ' . $diff->name . ' ' . $query;
232			if ($comment = $this->getColumnComment($column)) {
233			$commentsSQL[] = $this->getCommentOnColumnSQL($diff->name, $column->getName(), $comment);
234			}
235			}
236
237			if (count($diff->removedColumns) > 0) {
238			throw DBALException::notSupported("Alter Table: drop columns");
239			}
240			if (count($diff->changedColumns) > 0) {
241			throw DBALException::notSupported("Alter Table: change column options");
242			}
243			if (count($diff->renamedColumns) > 0) {
244			throw DBALException::notSupported("Alter Table: rename columns");
245			}
246
247			$tableSql = array();
248
249			if (!$this->onSchemaAlterTable($diff, $tableSql)) {
250			if ($diff->newName !== false) {
251			throw DBALException::notSupported("Alter Table: rename table");
252			}
253
254			$sql = array_merge($sql, $this->_getAlterTableIndexForeignKeySQL($diff), $commentsSQL);
255			}
256
257			return array_merge($sql, $tableSql, $columnSql);
258			}
259
260			/**
261			* {@inheritDoc}
262			*/
263			public function getColumnDeclarationSQL($name, array $field)
264			{
265			if (isset($field['columnDefinition'])) {
266			$columnDef = $this->getCustomTypeDeclarationSQL($field);
267			} else {
268			$typeDecl = $field['type']->getSqlDeclaration($field, $this);
269			$columnDef = $typeDecl;
270			}
271
272			return $name . ' ' . $columnDef;
273			}
274
275			/**
276			* Generate table index column declaration
277			* @codeCoverageIgnore
278			*/
279			public function getIndexDeclarationSQL($name, Index $index)
280			{
281			$columns = $index->getQuotedColumns($this);
282			$name = new Identifier($name);
283
284			if (count($columns) == 0) {
285			throw new \InvalidArgumentException("Incomplete definition. 'columns' required.");
286			}
287
288			return 'INDEX ' . $name->getQuotedName($this) . ' USING FULLTEXT ('. $this->getIndexFieldDeclarationListSQL($columns) . ')';
289			}
290
291			/**
292			* {@inheritDoc}
293			*
294			* Crate wants boolean values converted to the strings 'true'/'false'.
295			*/
296			public function convertBooleans($item)
297			{
298			if (is_array($item)) {
299			foreach ($item as $key => $value) {
300			if (is_bool($value)) {
301			$item[$key] = ($value) ? 'true' : 'false';
302			} elseif (is_numeric($value)) {
303			$item[$key] = ($value > 0) ? 'true' : 'false';
304			}
305			}
306			} else {
307			if (is_bool($item)) {
308			$item = ($item) ? 'true' : 'false';
309			} elseif (is_numeric($item)) {
310			$item = ($item > 0) ? 'true' : 'false';
311			}
312			}
313
314			return $item;
315			}
316
317			/**
318			* {@inheritDoc}
319			*/
320			public function getBooleanTypeDeclarationSQL(array $field)
321			{
322			return 'BOOLEAN';
323			}
324
325			/**
326			* {@inheritDoc}
327			*/
328			public function getIntegerTypeDeclarationSQL(array $field)
329			{
330			return 'INTEGER';
331			}
332
333			/**
334			* {@inheritDoc}
335			*/
336			public function getBigIntTypeDeclarationSQL(array $field)
337			{
338			return 'LONG';
339			}
340
341			/**
342			* {@inheritDoc}
343			*/
344			public function getSmallIntTypeDeclarationSQL(array $field)
345			{
346			return 'SHORT';
347			}
348
349			/**
350			* {@inheritDoc}
351			*/
352			public function getFloatDeclarationSQL(array $field)
353			{
354			return 'DOUBLE';
355			}
356
357			/**
358			* {@inheritDoc}
359			*/
360			public function getDecimalTypeDeclarationSQL(array $columnDef)
361			{
362			return 'DOUBLE';
363			}
364
365			/**
366			* {@inheritDoc}
367			*/
368			public function getDateTimeTypeDeclarationSQL(array $fieldDeclaration)
369			{
370			return 'TIMESTAMP';
371			}
372
373			/**
374			* {@inheritDoc}
375			*/
376			public function getDateTimeTzTypeDeclarationSQL(array $fieldDeclaration)
377			{
378			return 'TIMESTAMP';
379			}
380
381			/**
382			* {@inheritDoc}
383			*/
384			public function getDateTypeDeclarationSQL(array $fieldDeclaration)
385			{
386			return 'TIMESTAMP';
387			}
388
389			/**
390			* {@inheritDoc}
391			*/
392			public function getTimeTypeDeclarationSQL(array $fieldDeclaration)
393			{
394			return 'TIMESTAMP';
395			}
396
397			/**
398			* {@inheritDoc}
399			*/
400			protected function _getCommonIntegerTypeDeclarationSQL(array $columnDef)
401			{
402			return '';
403			}
404
405			/**
406			* {@inheritDoc}
407			*/
408			protected function getVarcharTypeDeclarationSQLSnippet($length, $fixed)
409			{
410			return 'STRING';
411			}
412
413			/**
414			* {@inheritDoc}
415			*/
416			public function getClobTypeDeclarationSQL(array $field)
417			{
418			return 'STRING';
419			}
420
421			/**
422			* Gets the SQL snippet used to declare an OBJECT column type.
423			*
424			* @param array $field
425			*
426			* @return string
427			*/
428			public function getMapTypeDeclarationSQL(array $field, array $options)
			0 ignored issues – show Unused Code introduced 2016-01-12 08:42 UTC by Report Bug Copy Issue Report The parameter `$field` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
429			{
430			$type = array_key_exists('type', $options) ? $options['type'] : MapType::DYNAMIC;
431
432			$fields = array_key_exists('fields', $options) ? $options['fields'] : array();
433			$columns = array();
434			foreach ($fields as $field) {
435			$columns[$field->getQuotedName($this)] = $this->prepareColumnData($field);
436			}
437			$objectFields = $this->getColumnDeclarationListSQL($columns);
438
439			$declaration = count($columns) > 0 ? ' AS ( ' . $objectFields . ' )' : '';
440			return 'OBJECT ( ' . $type . ' )' . $declaration ;
441			}
442
443			/**
444			* Gets the SQL snippet used to declare an ARRAY column type.
445			*
446			* @param array $field
447			*
448			* @return string
449			*/
450			public function getArrayTypeDeclarationSQL(array $field, array $options)
451			{
452			$type = array_key_exists('type', $options) ? $options['type'] : Type::STRING;
453			return 'ARRAY ( ' . Type::getType($type)->getSQLDeclaration($field, $this) . ' )';
454			}
455
456			/**
457			* {@inheritDoc}
458			*/
459			public function getName()
460			{
461			return 'crate';
462			}
463
464			/**
465			* {@inheritDoc}
466			*
467			* PostgreSQL returns all column names in SQL result sets in lowercase.
468			*/
469			public function getSQLResultCasing($column)
470			{
471			return strtolower($column);
472			}
473
474			/**
475			* {@inheritDoc}
476			*/
477			public function getDateTimeTzFormatString()
478			{
479			return self::TIMESTAMP_FORMAT_TZ;
480			}
481
482			/**
483			* {@inheritDoc}
484			*/
485			public function getDateTimeFormatString()
486			{
487			return self::TIMESTAMP_FORMAT;
488			}
489
490			/**
491			* {@inheritDoc}
492			*/
493			public function getDateFormatString()
494			{
495			return self::TIMESTAMP_FORMAT;
496			}
497
498			/**
499			* {@inheritDoc}
500			*/
501			public function getTimeFormatString()
502			{
503			return self::TIMESTAMP_FORMAT;
504			}
505
506			/**
507			* {@inheritDoc}
508			*/
509			public function getTruncateTableSQL($tableName, $cascade = false)
510			{
511			throw DBALException::notSupported(__METHOD__);
512			}
513
514			/**
515			* {@inheritDoc}
516			*/
517			public function getReadLockSQL()
518			{
519			throw DBALException::notSupported(__METHOD__);
520			}
521
522			/**
523			* {@inheritDoc}
524			*/
525			protected function initializeDoctrineTypeMappings()
526			{
527			$this->doctrineTypeMapping = array(
528			'short' => 'smallint',
529			'integer' => 'integer',
530			'long' => 'bigint',
531			'int' => 'integer',
532			'bool' => 'boolean',
533			'boolean' => 'boolean',
534			'string' => 'string',
535			'float' => 'float',
536			'double' => 'float',
537			'timestamp' => 'timestamp',
538			'object' => 'map',
539			'string_array' => 'array',
540			'float_array' => 'array',
541			'double_array' => 'array',
542			'integer_array' => 'array',
543			'object_array' => 'array',
544			'array' => 'array',
545			);
546			}
547
548			/**
549			* {@inheritDoc}
550			*/
551			public function getVarcharMaxLength()
552			{
553			return PHP_INT_MAX;
554			}
555
556			/**
557			* {@inheritDoc}
558			*/
559			protected function getReservedKeywordsClass()
560			{
561			return 'Crate\DBAL\Platforms\Keywords\CrateKeywords';
562			}
563
564			/**
565			* {@inheritDoc}
566			*/
567			public function getBlobTypeDeclarationSQL(array $field)
568			{
569			throw DBALException::notSupported(__METHOD__);
570			}
571
572			/**
573			* {@inheritDoc}
574			* Gets the SQL statement(s) to create a table with the specified name, columns and constraints
575			* on this platform.
576			*
577			* @param Table $table The name of the table.
578			* @param integer $createFlags
579			*
580			* @return array The sequence of SQL statements.
581			*/
582			public function getCreateTableSQL(Table $table, $createFlags = self::CREATE_INDEXES)
583			{
584			if (!is_int($createFlags)) {
585			$msg = "Second argument of CratePlatform::getCreateTableSQL() has to be integer.";
586			throw new \InvalidArgumentException($msg);
587			}
588
589			if (count($table->getColumns()) === 0) {
590			throw DBALException::noColumnsSpecifiedForTable($table->getName());
591			}
592
593			$tableName = $table->getQuotedName($this);
594			$options = $table->getOptions();
595			$options['uniqueConstraints'] = array();
596			$options['indexes'] = array();
597			$options['primary'] = array();
598
599			if (($createFlags&self::CREATE_INDEXES) > 0) {
600			foreach ($table->getIndexes() as $index) {
601			/* @var $index Index */
602			if ($index->isPrimary()) {
603			$platform = $this;
604			$options['primary'] = array_map(function ($columnName) use ($table, $platform) {
605			return $table->getColumn($columnName)->getQuotedName($platform);
606			}, $index->getColumns());
607			$options['primary_index'] = $index;
608			} else {
609			$options['indexes'][$index->getName()] = $index;
610			}
611			}
612			}
613
614			$columnSql = array();
615			$columns = array();
616
617			foreach ($table->getColumns() as $column) {
618			if (null !== $this->_eventManager &&
619			$this->_eventManager->hasListeners(Events::onSchemaCreateTableColumn)) {
620
621			$eventArgs = new SchemaCreateTableColumnEventArgs($column, $table, $this);
622			$this->_eventManager->dispatchEvent(Events::onSchemaCreateTableColumn, $eventArgs);
623
624			$columnSql = array_merge($columnSql, $eventArgs->getSql());
625
626			if ($eventArgs->isDefaultPrevented()) {
627			continue;
628			}
629			}
630			$columns[$column->getQuotedName($this)] = $this->prepareColumnData($column, $options['primary']);
			0 ignored issues – show Bug introduced 2016-01-12 08:42 UTC by Report Bug Copy Issue Report It seems like `$options['primary']` can also be of type `object<Doctrine\DBAL\Schema\Index>`; however, `Crate\DBAL\Platforms\Cra...rm::prepareColumnData()` does only seem to accept `array`, 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...
631			}
632
633			if (null !== $this->_eventManager && $this->_eventManager->hasListeners(Events::onSchemaCreateTable)) {
634			$eventArgs = new SchemaCreateTableEventArgs($table, $columns, $options, $this);
635			$this->_eventManager->dispatchEvent(Events::onSchemaCreateTable, $eventArgs);
636
637			if ($eventArgs->isDefaultPrevented()) {
638			return array_merge($eventArgs->getSql(), $columnSql);
639			}
640			}
641
642			$sql = $this->_getCreateTableSQL($tableName, $columns, $options);
643			if ($this->supportsCommentOnStatement()) {
644			foreach ($table->getColumns() as $column) {
645			if ($this->getColumnComment($column)) {
			0 ignored issues – show Bug Best Practice introduced 2016-01-12 08:42 UTC by Report Bug Copy Issue Report The expression `$this->getColumnComment($column)` of type `string\|null` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
646			$sql[] = $this->getCommentOnColumnSQL(
647			$tableName,
648			$column->getName(),
649			$this->getColumnComment($column)
650			);
651			}
652			}
653			}
654
655			return array_merge($sql, $columnSql);
656			}
657
658			/**
659			* {@inheritDoc}
660			*/
661			protected function _getCreateTableSQL($tableName, array $columns, array $options = array())
662			{
663			$columnListSql = $this->getColumnDeclarationListSQL($columns);
664
665			if (isset($options['primary']) && ! empty($options['primary'])) {
666			$keyColumns = array_unique(array_values($options['primary']));
667			$columnListSql .= ', PRIMARY KEY(' . implode(', ', $keyColumns) . ')';
668			}
669
670			if (isset($options['indexes']) && ! empty($options['indexes'])) {
671			foreach ($options['indexes'] as $index => $definition) {
672			$columnListSql .= ', ' . $this->getIndexDeclarationSQL($index, $definition);
673			}
674			}
675
676			if (isset($options['foreignKeys'])) {
677			throw DBALException::notSupported("Create Table: foreign keys");
678			}
679
680			$query = 'CREATE TABLE ' . $tableName . ' (' . $columnListSql . ')';
681			return array($query);
682			}
683
684			/**
685			* @param \Doctrine\DBAL\Schema\Column $column The name of the table.
686			* @param array $primaries
687			*
688			* @return array The column data as associative array.
689			*/
690			public function prepareColumnData($column, $primaries = array())
691			{
692
693			$columnData = array();
694			$columnData['name'] = $column->getQuotedName($this);
695			$columnData['type'] = $column->getType();
696			$columnData['length'] = $column->getLength();
697			$columnData['notnull'] = $column->getNotNull();
698			$columnData['fixed'] = $column->getFixed();
699			$columnData['unique'] = false; // TODO: what do we do about this?
700			$columnData['version'] = $column->hasPlatformOption("version") ? $column->getPlatformOption('version') : false;
701
702			if (strtolower($columnData['type']) == "string" && $columnData['length'] === null) {
703			$columnData['length'] = 255;
704			}
705
706			$columnData['unsigned'] = $column->getUnsigned();
707			$columnData['precision'] = $column->getPrecision();
708			$columnData['scale'] = $column->getScale();
709			$columnData['default'] = $column->getDefault();
710			$columnData['columnDefinition'] = $column->getColumnDefinition();
711			$columnData['autoincrement'] = $column->getAutoincrement();
712			$columnData['comment'] = $this->getColumnComment($column);
713
714			$columnData['platformOptions'] = $column->getPlatformOptions();
715
716			if (in_array($column->getName(), $primaries)) {
717			$columnData['primary'] = true;
718			}
719			return $columnData;
720			}
721
722			/**
723			* {@inheritDoc}
724			*/
725			public function getCreateDatabaseSQL($database)
726			{
727			throw DBALException::notSupported(__METHOD__);
728			}
729
730			/**
731			* {@inheritDoc}
732			*/
733			public function getDropDatabaseSQL($database)
734			{
735			throw DBALException::notSupported(__METHOD__);
736			}
737
738			/**
739			* {@inheritDoc}
740			*/
741			public function getCreateForeignKeySQL(ForeignKeyConstraint $foreignKey, $table)
742			{
743			throw DBALException::notSupported(__METHOD__);
744			}
745
746			/**
747			* {@inheritDoc}
748			*/
749			public function getGuidTypeDeclarationSQL(array $field)
750			{
751			throw DBALException::notSupported(__METHOD__);
752			}
753			}
754

crate / crate-dbal

Push — cc/snow-sprint ( 09dbf9 )

CratePlatform::getSubstringExpression() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like