QueryBuilder::addCommentOnColumn() - Code Metrics - Inspection of "Update README.md" - rob006/yii2-dev - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ecd2dc...aafa57 )

by Robert

created 2017-03-01 11:05 UTC

QueryBuilder::addCommentOnColumn() A

↳ Parent: QueryBuilder

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
ccs	0
cts	2
cp	0
cc	1
eloc	2
nc	1
nop	3
crap	2

<?php
/**
 * @link http://www.yiiframework.com/
 * @copyright Copyright (c) 2008 Yii Software LLC
 * @license http://www.yiiframework.com/license/
 */

namespace yii\db\sqlite;

use yii\db\Connection;
use yii\db\Exception;
use yii\base\InvalidParamException;
use yii\base\NotSupportedException;
use yii\db\Expression;
use yii\db\Query;

/**
 * QueryBuilder is the query builder for SQLite databases.
 *
 * @author Qiang Xue <[email protected]>
 * @since 2.0
 */
class QueryBuilder extends \yii\db\QueryBuilder
{
    /**
     * @var array mapping from abstract column types (keys) to physical column types (values).
     */
    public $typeMap = [
        Schema::TYPE_PK => 'integer PRIMARY KEY AUTOINCREMENT NOT NULL',
        Schema::TYPE_UPK => 'integer UNSIGNED PRIMARY KEY AUTOINCREMENT NOT NULL',
        Schema::TYPE_BIGPK => 'integer PRIMARY KEY AUTOINCREMENT NOT NULL',
        Schema::TYPE_UBIGPK => 'integer UNSIGNED PRIMARY KEY AUTOINCREMENT NOT NULL',
        Schema::TYPE_CHAR => 'char(1)',
        Schema::TYPE_STRING => 'varchar(255)',
        Schema::TYPE_TEXT => 'text',
        Schema::TYPE_SMALLINT => 'smallint',
        Schema::TYPE_INTEGER => 'integer',
        Schema::TYPE_BIGINT => 'bigint',
        Schema::TYPE_FLOAT => 'float',
        Schema::TYPE_DOUBLE => 'double',
        Schema::TYPE_DECIMAL => 'decimal(10,0)',
        Schema::TYPE_DATETIME => 'datetime',
        Schema::TYPE_TIMESTAMP => 'timestamp',
        Schema::TYPE_TIME => 'time',
        Schema::TYPE_DATE => 'date',
        Schema::TYPE_BINARY => 'blob',
        Schema::TYPE_BOOLEAN => 'boolean',
        Schema::TYPE_MONEY => 'decimal(19,4)',
    ];

    /**
     * @inheritdoc
     */
    protected $likeEscapeCharacter = '\\';

    /**
     * Generates a batch INSERT SQL statement.
     * For example,
     *
     * ```php
     * $connection->createCommand()->batchInsert('user', ['name', 'age'], [
     *     ['Tom', 30],
     *     ['Jane', 20],
     *     ['Linda', 25],
     * ])->execute();
     * ```
     *
     * Note that the values in each row must match the corresponding column names.
     *
     * @param string $table the table that new rows will be inserted into.
     * @param array $columns the column names
     * @param array $rows the rows to be batch inserted into the table
     * @return string the batch INSERT SQL statement
     */
    public function batchInsert($table, $columns, $rows)
    {
        if (empty($rows)) {
            return '';
        }

        // SQLite supports batch insert natively since 3.7.11
        // http://www.sqlite.org/releaselog/3_7_11.html
        $this->db->open(); // ensure pdo is not null
        if (version_compare($this->db->pdo->getAttribute(\PDO::ATTR_SERVER_VERSION), '3.7.11', '>=')) {
            return parent::batchInsert($table, $columns, $rows);
        }

        $schema = $this->db->getSchema();
        if (($tableSchema = $schema->getTableSchema($table)) !== null) {
            $columnSchemas = $tableSchema->columns;
        } else {
            $columnSchemas = [];
        }

        $values = [];
        foreach ($rows as $row) {
            $vs = [];
            foreach ($row as $i => $value) {
                if (!is_array($value) && isset($columnSchemas[$columns[$i]])) {
                    $value = $columnSchemas[$columns[$i]]->dbTypecast($value);
                }
                if (is_string($value)) {
                    $value = $schema->quoteValue($value);
                } elseif ($value === false) {
                    $value = 0;
                } elseif ($value === null) {
                    $value = 'NULL';
                }
                $vs[] = $value;
            }
            $values[] = implode(', ', $vs);
        }
        if (empty($values)) {
            return '';
        }

        foreach ($columns as $i => $name) {
            $columns[$i] = $schema->quoteColumnName($name);
        }

        return 'INSERT INTO ' . $schema->quoteTableName($table)
        . ' (' . implode(', ', $columns) . ') SELECT ' . implode(' UNION SELECT ', $values);
    }

    /**
     * Creates a SQL statement for resetting the sequence value of a table's primary key.
     * The sequence will be reset such that the primary key of the next new row inserted
     * will have the specified value or 1.
     * @param string $tableName the name of the table whose primary key sequence will be reset
     * @param mixed $value the value for the primary key of the next new row inserted. If this is not set,
     * the next new row's primary key will have a value 1.
     * @return string the SQL statement for resetting sequence
     * @throws InvalidParamException if the table does not exist or there is no sequence associated with the table.
     */
    public function resetSequence($tableName, $value = null)
    {
        $db = $this->db;
        $table = $db->getTableSchema($tableName);
        if ($table !== null && $table->sequenceName !== null) {
            if ($value === null) {
                $key = reset($table->primaryKey);
                $tableName = $db->quoteTableName($tableName);
                $value = $this->db->useMaster(function (Connection $db) use ($key, $tableName) {
                    return $db->createCommand("SELECT MAX($key) FROM $tableName")->queryScalar();
                });
            } else {
                $value = (int) $value - 1;
            }
            try {
                return "UPDATE sqlite_sequence SET seq='$value' WHERE name='{$table->name}'";
            } catch (Exception $e) {
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
                // it's possible that sqlite_sequence does not exist
            }
        } elseif ($table === null) {
            throw new InvalidParamException("Table not found: $tableName");
        } else {
            throw new InvalidParamException("There is not sequence associated with table '$tableName'.'");
        }
    }

    /**
     * Enables or disables integrity check.
     * @param bool $check whether to turn on or off the integrity check.
     * @param string $schema the schema of the tables. Meaningless for SQLite.
     * @param string $table the table name. Meaningless for SQLite.
     * @return string the SQL statement for checking integrity
     * @throws NotSupportedException this is not supported by SQLite
     */
    public function checkIntegrity($check = true, $schema = '', $table = '')
    {
        return 'PRAGMA foreign_keys='.(int) $check;
    }

    /**
     * Builds a SQL statement for truncating a DB table.
     * @param string $table the table to be truncated. The name will be properly quoted by the method.
     * @return string the SQL statement for truncating a DB table.
     */
    public function truncateTable($table)
    {
        return 'DELETE FROM ' . $this->db->quoteTableName($table);
    }

    /**
     * Builds a SQL statement for dropping an index.
     * @param string $name the name of the index to be dropped. The name will be properly quoted by the method.
     * @param string $table the table whose index is to be dropped. The name will be properly quoted by the method.
     * @return string the SQL statement for dropping an index.
     */
    public function dropIndex($name, $table)
    {
        return 'DROP INDEX ' . $this->db->quoteTableName($name);
    }

    /**
     * Builds a SQL statement for dropping a DB column.
     * @param string $table the table whose column is to be dropped. The name will be properly quoted by the method.
     * @param string $column the name of the column to be dropped. The name will be properly quoted by the method.
     * @return string the SQL statement for dropping a DB column.
     * @throws NotSupportedException this is not supported by SQLite
     */
    public function dropColumn($table, $column)
    {
        throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
    }

    /**
     * Builds a SQL statement for renaming a column.
     * @param string $table the table whose column is to be renamed. The name will be properly quoted by the method.
     * @param string $oldName the old name of the column. The name will be properly quoted by the method.
     * @param string $newName the new name of the column. The name will be properly quoted by the method.
     * @return string the SQL statement for renaming a DB column.
     * @throws NotSupportedException this is not supported by SQLite
     */
    public function renameColumn($table, $oldName, $newName)
    {
        throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
    }

    /**
     * Builds a SQL statement for adding a foreign key constraint to an existing table.
     * The method will properly quote the table and column names.
     * @param string $name the name of the foreign key constraint.
     * @param string $table the table that the foreign key constraint will be added to.
     * @param string|array $columns the name of the column to that the constraint will be added on.
     * If there are multiple columns, separate them with commas or use an array to represent them.
     * @param string $refTable the table that the foreign key references to.
     * @param string|array $refColumns the name of the column that the foreign key references to.
     * If there are multiple columns, separate them with commas or use an array to represent them.
     * @param string $delete the ON DELETE option. Most DBMS support these options: RESTRICT, CASCADE, NO ACTION, SET DEFAULT, SET NULL
     * @param string $update the ON UPDATE option. Most DBMS support these options: RESTRICT, CASCADE, NO ACTION, SET DEFAULT, SET NULL
     * @return string the SQL statement for adding a foreign key constraint to an existing table.
     * @throws NotSupportedException this is not supported by SQLite
     */
    public function addForeignKey($name, $table, $columns, $refTable, $refColumns, $delete = null, $update = null)
    {
        throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
    }

    /**
     * Builds a SQL statement for dropping a foreign key constraint.
     * @param string $name the name of the foreign key constraint to be dropped. The name will be properly quoted by the method.
     * @param string $table the table whose foreign is to be dropped. The name will be properly quoted by the method.
     * @return string the SQL statement for dropping a foreign key constraint.
     * @throws NotSupportedException this is not supported by SQLite
     */
    public function dropForeignKey($name, $table)
    {
        throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
    }

    /**
     * Builds a SQL statement for renaming a DB table.
     *
     * @param string $table the table to be renamed. The name will be properly quoted by the method.
     * @param string $newName the new table name. The name will be properly quoted by the method.
     * @return string the SQL statement for renaming a DB table.
     */
    public function renameTable($table, $newName)
    {
        return 'ALTER TABLE ' . $this->db->quoteTableName($table) . ' RENAME TO ' . $this->db->quoteTableName($newName);
    }

    /**
     * Builds a SQL statement for changing the definition of a column.
     * @param string $table the table whose column is to be changed. The table name will be properly quoted by the method.
     * @param string $column the name of the column to be changed. The name will be properly quoted by the method.
     * @param string $type the new column type. The [[getColumnType()]] method will be invoked to convert abstract
     * column type (if any) into the physical one. Anything that is not recognized as abstract type will be kept
     * in the generated SQL. For example, 'string' will be turned into 'varchar(255)', while 'string not null'
     * will become 'varchar(255) not null'.
     * @return string the SQL statement for changing the definition of a column.
     * @throws NotSupportedException this is not supported by SQLite
     */
    public function alterColumn($table, $column, $type)
    {
        throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
    }

    /**
     * Builds a SQL statement for adding a primary key constraint to an existing table.
     * @param string $name the name of the primary key constraint.
     * @param string $table the table that the primary key constraint will be added to.
     * @param string|array $columns comma separated string or array of columns that the primary key will consist of.
     * @return string the SQL statement for adding a primary key constraint to an existing table.
     * @throws NotSupportedException this is not supported by SQLite
     */
    public function addPrimaryKey($name, $table, $columns)
    {
        throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
    }

    /**
     * Builds a SQL statement for removing a primary key constraint to an existing table.
     * @param string $name the name of the primary key constraint to be removed.
     * @param string $table the table that the primary key constraint will be removed from.
     * @return string the SQL statement for removing a primary key constraint from an existing table.
     * @throws NotSupportedException this is not supported by SQLite
     */
    public function dropPrimaryKey($name, $table)
    {
        throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
    }

    /**
     * @inheritdoc
     * @throws NotSupportedException
     * @since 2.0.8
     */
    public function addCommentOnColumn($table, $column, $comment)
    {
        throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
    }

    /**
     * @inheritdoc
     * @throws NotSupportedException
     * @since 2.0.8
     */
    public function addCommentOnTable($table, $comment)
    {
        throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
    }

    /**
     * @inheritdoc
     * @throws NotSupportedException
     * @since 2.0.8
     */
    public function dropCommentFromColumn($table, $column)
    {
        throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
    }

    /**
     * @inheritdoc
     * @throws NotSupportedException
     * @since 2.0.8
     */
    public function dropCommentFromTable($table)
    {
        throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
    }

    /**
     * @inheritdoc
     */
    public function buildLimit($limit, $offset)
    {
        $sql = '';
        if ($this->hasLimit($limit)) {
            $sql = 'LIMIT ' . $limit;
            if ($this->hasOffset($offset)) {
                $sql .= ' OFFSET ' . $offset;
            }
        } elseif ($this->hasOffset($offset)) {
            // limit is not optional in SQLite
            // http://www.sqlite.org/syntaxdiagrams.html#select-stmt
            $sql = "LIMIT 9223372036854775807 OFFSET $offset"; // 2^63-1
        }

        return $sql;
    }

    /**
     * @inheritdoc
     * @throws NotSupportedException if `$columns` is an array
     */
    protected function buildSubqueryInCondition($operator, $columns, $values, &$params)
    {
        if (is_array($columns)) {
            throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
        }
        return parent::buildSubqueryInCondition($operator, $columns, $values, $params);
    }

    /**
     * Builds SQL for IN condition
     *
     * @param string $operator
     * @param array $columns
     * @param array $values
     * @param array $params
     * @return string SQL
     */
    protected function buildCompositeInCondition($operator, $columns, $values, &$params)
    {
        $quotedColumns = [];
        foreach ($columns as $i => $column) {
            $quotedColumns[$i] = strpos($column, '(') === false ? $this->db->quoteColumnName($column) : $column;
        }
        $vss = [];
        foreach ($values as $value) {
            $vs = [];
            foreach ($columns as $i => $column) {
                if (isset($value[$column])) {
                    $phName = self::PARAM_PREFIX . count($params);
                    $params[$phName] = $value[$column];
                    $vs[] = $quotedColumns[$i] . ($operator === 'IN' ? ' = ' : ' != ') . $phName;
                } else {
                    $vs[] = $quotedColumns[$i] . ($operator === 'IN' ? ' IS' : ' IS NOT') . ' NULL';
                }
            }
            $vss[] = '(' . implode($operator === 'IN' ? ' AND ' : ' OR ', $vs) . ')';
        }

        return '(' . implode($operator === 'IN' ? ' OR ' : ' AND ', $vss) . ')';
    }

    /**
     * @inheritdoc
     */
    public function build($query, $params = [])
    {
        $query = $query->prepare($this);

        $params = empty($params) ? $query->params : array_merge($params, $query->params);

        $clauses = [
            $this->buildSelect($query->select, $params, $query->distinct, $query->selectOption),
            $this->buildFrom($query->from, $params),
            $this->buildJoin($query->join, $params),
            $this->buildWhere($query->where, $params),
            $this->buildGroupBy($query->groupBy),
            $this->buildHaving($query->having, $params),
        ];

        $sql = implode($this->separator, array_filter($clauses));
        $sql = $this->buildOrderByAndLimit($sql, $query->orderBy, $query->limit, $query->offset);

        if (!empty($query->orderBy)) {
            foreach ($query->orderBy as $expression) {
                if ($expression instanceof Expression) {
                    $params = array_merge($params, $expression->params);
                }
            }
        }
        if (!empty($query->groupBy)) {
            foreach ($query->groupBy as $expression) {
                if ($expression instanceof Expression) {
                    $params = array_merge($params, $expression->params);
                }
            }
        }

        $union = $this->buildUnion($query->union, $params);
        if ($union !== '') {
            $sql = "$sql{$this->separator}$union";
        }

        return [$sql, $params];
    }

    /**
     * @inheritdoc
     */
    public function buildUnion($unions, &$params)
    {
        if (empty($unions)) {
            return '';
        }

        $result = '';

        foreach ($unions as $i => $union) {
            $query = $union['query'];
            if ($query instanceof Query) {
                list($unions[$i]['query'], $params) = $this->build($query, $params);
            }

            $result .= ' UNION ' . ($union['all'] ? 'ALL ' : '') . ' ' . $unions[$i]['query'];
        }

        return trim($result);
    }
}


1		<?php
2		/**
3		* @link http://www.yiiframework.com/
4		* @copyright Copyright (c) 2008 Yii Software LLC
5		* @license http://www.yiiframework.com/license/
6		*/
7
8		namespace yii\db\sqlite;
9
10		use yii\db\Connection;
11		use yii\db\Exception;
12		use yii\base\InvalidParamException;
13		use yii\base\NotSupportedException;
14		use yii\db\Expression;
15		use yii\db\Query;
16
17		/**
18		* QueryBuilder is the query builder for SQLite databases.
19		*
20		* @author Qiang Xue <[email protected]>
21		* @since 2.0
22		*/
23		class QueryBuilder extends \yii\db\QueryBuilder
24		{
25		/**
26		* @var array mapping from abstract column types (keys) to physical column types (values).
27		*/
28		public $typeMap = [
29		Schema::TYPE_PK => 'integer PRIMARY KEY AUTOINCREMENT NOT NULL',
30		Schema::TYPE_UPK => 'integer UNSIGNED PRIMARY KEY AUTOINCREMENT NOT NULL',
31		Schema::TYPE_BIGPK => 'integer PRIMARY KEY AUTOINCREMENT NOT NULL',
32		Schema::TYPE_UBIGPK => 'integer UNSIGNED PRIMARY KEY AUTOINCREMENT NOT NULL',
33		Schema::TYPE_CHAR => 'char(1)',
34		Schema::TYPE_STRING => 'varchar(255)',
35		Schema::TYPE_TEXT => 'text',
36		Schema::TYPE_SMALLINT => 'smallint',
37		Schema::TYPE_INTEGER => 'integer',
38		Schema::TYPE_BIGINT => 'bigint',
39		Schema::TYPE_FLOAT => 'float',
40		Schema::TYPE_DOUBLE => 'double',
41		Schema::TYPE_DECIMAL => 'decimal(10,0)',
42		Schema::TYPE_DATETIME => 'datetime',
43		Schema::TYPE_TIMESTAMP => 'timestamp',
44		Schema::TYPE_TIME => 'time',
45		Schema::TYPE_DATE => 'date',
46		Schema::TYPE_BINARY => 'blob',
47		Schema::TYPE_BOOLEAN => 'boolean',
48		Schema::TYPE_MONEY => 'decimal(19,4)',
49		];
50
51		/**
52		* @inheritdoc
53		*/
54		protected $likeEscapeCharacter = '\\';
55
56		/**
57		* Generates a batch INSERT SQL statement.
58		* For example,
59		*
60		* ```php
61		* $connection->createCommand()->batchInsert('user', ['name', 'age'], [
62		* ['Tom', 30],
63		* ['Jane', 20],
64		* ['Linda', 25],
65		* ])->execute();
66		* ```
67		*
68		* Note that the values in each row must match the corresponding column names.
69		*
70		* @param string $table the table that new rows will be inserted into.
71		* @param array $columns the column names
72		* @param array $rows the rows to be batch inserted into the table
73		* @return string the batch INSERT SQL statement
74		*/
75	10	public function batchInsert($table, $columns, $rows)
76		{
77	10	if (empty($rows)) {
78	2	return '';
79		}
80
81		// SQLite supports batch insert natively since 3.7.11
82		// http://www.sqlite.org/releaselog/3_7_11.html
83	9	$this->db->open(); // ensure pdo is not null
84	9	if (version_compare($this->db->pdo->getAttribute(\PDO::ATTR_SERVER_VERSION), '3.7.11', '>=')) {
85	9	return parent::batchInsert($table, $columns, $rows);
86		}
87
88		$schema = $this->db->getSchema();
89		if (($tableSchema = $schema->getTableSchema($table)) !== null) {
90		$columnSchemas = $tableSchema->columns;
91		} else {
92		$columnSchemas = [];
93		}
94
95		$values = [];
96		foreach ($rows as $row) {
97		$vs = [];
98		foreach ($row as $i => $value) {
99		if (!is_array($value) && isset($columnSchemas[$columns[$i]])) {
100		$value = $columnSchemas[$columns[$i]]->dbTypecast($value);
101		}
102		if (is_string($value)) {
103		$value = $schema->quoteValue($value);
104		} elseif ($value === false) {
105		$value = 0;
106		} elseif ($value === null) {
107		$value = 'NULL';
108		}
109		$vs[] = $value;
110		}
111		$values[] = implode(', ', $vs);
112		}
113		if (empty($values)) {
114		return '';
115		}
116
117		foreach ($columns as $i => $name) {
118		$columns[$i] = $schema->quoteColumnName($name);
119		}
120
121		return 'INSERT INTO ' . $schema->quoteTableName($table)
122		. ' (' . implode(', ', $columns) . ') SELECT ' . implode(' UNION SELECT ', $values);
123		}
124
125		/**
126		* Creates a SQL statement for resetting the sequence value of a table's primary key.
127		* The sequence will be reset such that the primary key of the next new row inserted
128		* will have the specified value or 1.
129		* @param string $tableName the name of the table whose primary key sequence will be reset
130		* @param mixed $value the value for the primary key of the next new row inserted. If this is not set,
131		* the next new row's primary key will have a value 1.
132		* @return string the SQL statement for resetting sequence
133		* @throws InvalidParamException if the table does not exist or there is no sequence associated with the table.
134		*/
135	3	public function resetSequence($tableName, $value = null)
136		{
137	3	$db = $this->db;
138	3	$table = $db->getTableSchema($tableName);
139	3	if ($table !== null && $table->sequenceName !== null) {
140	3	if ($value === null) {
141	1	$key = reset($table->primaryKey);
142	1	$tableName = $db->quoteTableName($tableName);
143	1	$value = $this->db->useMaster(function (Connection $db) use ($key, $tableName) {
144	1	return $db->createCommand("SELECT MAX($key) FROM $tableName")->queryScalar();
145	1	});
146	1	} else {
147	3	$value = (int) $value - 1;
148		}
149		try {
150	3	return "UPDATE sqlite_sequence SET seq='$value' WHERE name='{$table->name}'";
151		} catch (Exception $e) {
		0 ignored issues – show Unused Code introduced 2017-03-01 11:23 UTC by Report Bug Copy Issue Report `catch (\yii\db\Exception $e) { }` does not seem to be reachable. This check looks for unreachable code. It uses sophisticated control flow analysis techniques to find statements which will never be executed. Unreachable code is most often the result of `return`, `die` or `exit` statements that have been added for debug purposes. function fx() { try { doSomething(); return true; } catch (\Exception $e) { return false; } return false; } In the above example, the last `return false` will never be executed, because a return statement has already been met in every possible execution path. Loading history...
152		// it's possible that sqlite_sequence does not exist
153		}
154		} elseif ($table === null) {
155		throw new InvalidParamException("Table not found: $tableName");
156		} else {
157		throw new InvalidParamException("There is not sequence associated with table '$tableName'.'");
158		}
159		}
160
161		/**
162		* Enables or disables integrity check.
163		* @param bool $check whether to turn on or off the integrity check.
164		* @param string $schema the schema of the tables. Meaningless for SQLite.
165		* @param string $table the table name. Meaningless for SQLite.
166		* @return string the SQL statement for checking integrity
167		* @throws NotSupportedException this is not supported by SQLite
168		*/
169	2	public function checkIntegrity($check = true, $schema = '', $table = '')
170		{
171	2	return 'PRAGMA foreign_keys='.(int) $check;
172		}
173
174		/**
175		* Builds a SQL statement for truncating a DB table.
176		* @param string $table the table to be truncated. The name will be properly quoted by the method.
177		* @return string the SQL statement for truncating a DB table.
178		*/
179	1	public function truncateTable($table)
180		{
181	1	return 'DELETE FROM ' . $this->db->quoteTableName($table);
182		}
183
184		/**
185		* Builds a SQL statement for dropping an index.
186		* @param string $name the name of the index to be dropped. The name will be properly quoted by the method.
187		* @param string $table the table whose index is to be dropped. The name will be properly quoted by the method.
188		* @return string the SQL statement for dropping an index.
189		*/
190		public function dropIndex($name, $table)
191		{
192		return 'DROP INDEX ' . $this->db->quoteTableName($name);
193		}
194
195		/**
196		* Builds a SQL statement for dropping a DB column.
197		* @param string $table the table whose column is to be dropped. The name will be properly quoted by the method.
198		* @param string $column the name of the column to be dropped. The name will be properly quoted by the method.
199		* @return string the SQL statement for dropping a DB column.
200		* @throws NotSupportedException this is not supported by SQLite
201		*/
202		public function dropColumn($table, $column)
203		{
204		throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
205		}
206
207		/**
208		* Builds a SQL statement for renaming a column.
209		* @param string $table the table whose column is to be renamed. The name will be properly quoted by the method.
210		* @param string $oldName the old name of the column. The name will be properly quoted by the method.
211		* @param string $newName the new name of the column. The name will be properly quoted by the method.
212		* @return string the SQL statement for renaming a DB column.
213		* @throws NotSupportedException this is not supported by SQLite
214		*/
215		public function renameColumn($table, $oldName, $newName)
216		{
217		throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
218		}
219
220		/**
221		* Builds a SQL statement for adding a foreign key constraint to an existing table.
222		* The method will properly quote the table and column names.
223		* @param string $name the name of the foreign key constraint.
224		* @param string $table the table that the foreign key constraint will be added to.
225		* @param string\|array $columns the name of the column to that the constraint will be added on.
226		* If there are multiple columns, separate them with commas or use an array to represent them.
227		* @param string $refTable the table that the foreign key references to.
228		* @param string\|array $refColumns the name of the column that the foreign key references to.
229		* If there are multiple columns, separate them with commas or use an array to represent them.
230		* @param string $delete the ON DELETE option. Most DBMS support these options: RESTRICT, CASCADE, NO ACTION, SET DEFAULT, SET NULL
231		* @param string $update the ON UPDATE option. Most DBMS support these options: RESTRICT, CASCADE, NO ACTION, SET DEFAULT, SET NULL
232		* @return string the SQL statement for adding a foreign key constraint to an existing table.
233		* @throws NotSupportedException this is not supported by SQLite
234		*/
235		public function addForeignKey($name, $table, $columns, $refTable, $refColumns, $delete = null, $update = null)
236		{
237		throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
238		}
239
240		/**
241		* Builds a SQL statement for dropping a foreign key constraint.
242		* @param string $name the name of the foreign key constraint to be dropped. The name will be properly quoted by the method.
243		* @param string $table the table whose foreign is to be dropped. The name will be properly quoted by the method.
244		* @return string the SQL statement for dropping a foreign key constraint.
245		* @throws NotSupportedException this is not supported by SQLite
246		*/
247		public function dropForeignKey($name, $table)
248		{
249		throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
250		}
251
252		/**
253		* Builds a SQL statement for renaming a DB table.
254		*
255		* @param string $table the table to be renamed. The name will be properly quoted by the method.
256		* @param string $newName the new table name. The name will be properly quoted by the method.
257		* @return string the SQL statement for renaming a DB table.
258		*/
259	2	public function renameTable($table, $newName)
260		{
261	2	return 'ALTER TABLE ' . $this->db->quoteTableName($table) . ' RENAME TO ' . $this->db->quoteTableName($newName);
262		}
263
264		/**
265		* Builds a SQL statement for changing the definition of a column.
266		* @param string $table the table whose column is to be changed. The table name will be properly quoted by the method.
267		* @param string $column the name of the column to be changed. The name will be properly quoted by the method.
268		* @param string $type the new column type. The [[getColumnType()]] method will be invoked to convert abstract
269		* column type (if any) into the physical one. Anything that is not recognized as abstract type will be kept
270		* in the generated SQL. For example, 'string' will be turned into 'varchar(255)', while 'string not null'
271		* will become 'varchar(255) not null'.
272		* @return string the SQL statement for changing the definition of a column.
273		* @throws NotSupportedException this is not supported by SQLite
274		*/
275		public function alterColumn($table, $column, $type)
276		{
277		throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
278		}
279
280		/**
281		* Builds a SQL statement for adding a primary key constraint to an existing table.
282		* @param string $name the name of the primary key constraint.
283		* @param string $table the table that the primary key constraint will be added to.
284		* @param string\|array $columns comma separated string or array of columns that the primary key will consist of.
285		* @return string the SQL statement for adding a primary key constraint to an existing table.
286		* @throws NotSupportedException this is not supported by SQLite
287		*/
288		public function addPrimaryKey($name, $table, $columns)
289		{
290		throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
291		}
292
293		/**
294		* Builds a SQL statement for removing a primary key constraint to an existing table.
295		* @param string $name the name of the primary key constraint to be removed.
296		* @param string $table the table that the primary key constraint will be removed from.
297		* @return string the SQL statement for removing a primary key constraint from an existing table.
298		* @throws NotSupportedException this is not supported by SQLite
299		*/
300		public function dropPrimaryKey($name, $table)
301		{
302		throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
303		}
304
305		/**
306		* @inheritdoc
307		* @throws NotSupportedException
308		* @since 2.0.8
309		*/
310		public function addCommentOnColumn($table, $column, $comment)
311		{
312		throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
313		}
314
315		/**
316		* @inheritdoc
317		* @throws NotSupportedException
318		* @since 2.0.8
319		*/
320		public function addCommentOnTable($table, $comment)
321		{
322		throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
323		}
324
325		/**
326		* @inheritdoc
327		* @throws NotSupportedException
328		* @since 2.0.8
329		*/
330		public function dropCommentFromColumn($table, $column)
331		{
332		throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
333		}
334
335		/**
336		* @inheritdoc
337		* @throws NotSupportedException
338		* @since 2.0.8
339		*/
340		public function dropCommentFromTable($table)
341		{
342		throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
343		}
344
345		/**
346		* @inheritdoc
347		*/
348	241	public function buildLimit($limit, $offset)
349		{
350	241	$sql = '';
351	241	if ($this->hasLimit($limit)) {
352	20	$sql = 'LIMIT ' . $limit;
353	20	if ($this->hasOffset($offset)) {
354	2	$sql .= ' OFFSET ' . $offset;
355	2	}
356	241	} elseif ($this->hasOffset($offset)) {
357		// limit is not optional in SQLite
358		// http://www.sqlite.org/syntaxdiagrams.html#select-stmt
359	2	$sql = "LIMIT 9223372036854775807 OFFSET $offset"; // 2^63-1
360	2	}
361
362	241	return $sql;
363		}
364
365		/**
366		* @inheritdoc
367		* @throws NotSupportedException if `$columns` is an array
368		*/
369	2	protected function buildSubqueryInCondition($operator, $columns, $values, &$params)
370		{
371	2	if (is_array($columns)) {
372		throw new NotSupportedException(__METHOD__ . ' is not supported by SQLite.');
373		}
374	2	return parent::buildSubqueryInCondition($operator, $columns, $values, $params);
375		}
376
377		/**
378		* Builds SQL for IN condition
379		*
380		* @param string $operator
381		* @param array $columns
382		* @param array $values
383		* @param array $params
384		* @return string SQL
385		*/
386	5	protected function buildCompositeInCondition($operator, $columns, $values, &$params)
387		{
388	5	$quotedColumns = [];
389	5	foreach ($columns as $i => $column) {
390	5	$quotedColumns[$i] = strpos($column, '(') === false ? $this->db->quoteColumnName($column) : $column;
391	5	}
392	5	$vss = [];
393	5	foreach ($values as $value) {
394	5	$vs = [];
395	5	foreach ($columns as $i => $column) {
396	5	if (isset($value[$column])) {
397	5	$phName = self::PARAM_PREFIX . count($params);
398	5	$params[$phName] = $value[$column];
399	5	$vs[] = $quotedColumns[$i] . ($operator === 'IN' ? ' = ' : ' != ') . $phName;
400	5	} else {
401		$vs[] = $quotedColumns[$i] . ($operator === 'IN' ? ' IS' : ' IS NOT') . ' NULL';
402		}
403	5	}
404	5	$vss[] = '(' . implode($operator === 'IN' ? ' AND ' : ' OR ', $vs) . ')';
405	5	}
406
407	5	return '(' . implode($operator === 'IN' ? ' OR ' : ' AND ', $vss) . ')';
408		}
409
410		/**
411		* @inheritdoc
412		*/
413	241	public function build($query, $params = [])
414		{
415	241	$query = $query->prepare($this);
416
417	241	$params = empty($params) ? $query->params : array_merge($params, $query->params);
418
419		$clauses = [
420	241	$this->buildSelect($query->select, $params, $query->distinct, $query->selectOption),
421	241	$this->buildFrom($query->from, $params),
422	241	$this->buildJoin($query->join, $params),
423	241	$this->buildWhere($query->where, $params),
424	241	$this->buildGroupBy($query->groupBy),
425	241	$this->buildHaving($query->having, $params),
426	241	];
427
428	241	$sql = implode($this->separator, array_filter($clauses));
429	241	$sql = $this->buildOrderByAndLimit($sql, $query->orderBy, $query->limit, $query->offset);
430
431	241	if (!empty($query->orderBy)) {
432	59	foreach ($query->orderBy as $expression) {
433	59	if ($expression instanceof Expression) {
434	1	$params = array_merge($params, $expression->params);
435	1	}
436	59	}
437	59	}
438	241	if (!empty($query->groupBy)) {
439	3	foreach ($query->groupBy as $expression) {
440	3	if ($expression instanceof Expression) {
441	1	$params = array_merge($params, $expression->params);
442	1	}
443	3	}
444	3	}
445
446	241	$union = $this->buildUnion($query->union, $params);
447	241	if ($union !== '') {
448	2	$sql = "$sql{$this->separator}$union";
449	2	}
450
451	241	return [$sql, $params];
452		}
453
454		/**
455		* @inheritdoc
456		*/
457	241	public function buildUnion($unions, &$params)
458		{
459	241	if (empty($unions)) {
460	241	return '';
461		}
462
463	2	$result = '';
464
465	2	foreach ($unions as $i => $union) {
466	2	$query = $union['query'];
467	2	if ($query instanceof Query) {
468	2	list($unions[$i]['query'], $params) = $this->build($query, $params);
469	2	}
470
471	2	$result .= ' UNION ' . ($union['all'] ? 'ALL ' : '') . ' ' . $unions[$i]['query'];
472	2	}
473
474	2	return trim($result);
475		}
476		}
477

rob006 / yii2-dev

GitHub Access Token became invalid

Push — master ( ecd2dc...aafa57 )

QueryBuilder::addCommentOnColumn() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like