クラス yii\db\mssql\QueryBuilder

                public function __call($name, $params)
{
    throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
}

            

                public function __construct($connection, $config = [])
{
    $this->db = $connection;
    parent::__construct($config);
}

            

                public function __get($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        return $this->$getter();
    } elseif (method_exists($this, 'set' . $name)) {
        throw new InvalidCallException('Getting write-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Getting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __isset($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        return $this->$getter() !== null;
    }
    return false;
}

            

                public function __set($name, $value)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        $this->$setter($value);
    } elseif (method_exists($this, 'get' . $name)) {
        throw new InvalidCallException('Setting read-only property: ' . get_class($this) . '::' . $name);
    } else {
        throw new UnknownPropertyException('Setting unknown property: ' . get_class($this) . '::' . $name);
    }
}

            

                public function __unset($name)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        $this->$setter(null);
    } elseif (method_exists($this, 'get' . $name)) {
        throw new InvalidCallException('Unsetting read-only property: ' . get_class($this) . '::' . $name);
    }
}

            

                public function addCheck($name, $table, $expression)
{
    return 'ALTER TABLE ' . $this->db->quoteTableName($table) . ' ADD CONSTRAINT '
        . $this->db->quoteColumnName($name) . ' CHECK (' . $this->db->quoteSql($expression) . ')';
}

            

                public function addColumn($table, $column, $type)
{
    return 'ALTER TABLE ' . $this->db->quoteTableName($table)
        . ' ADD ' . $this->db->quoteColumnName($column) . ' '
        . $this->getColumnType($type);
}

            

                public function addForeignKey($name, $table, $columns, $refTable, $refColumns, $delete = null, $update = null)
{
    $sql = 'ALTER TABLE ' . $this->db->quoteTableName($table)
        . ' ADD CONSTRAINT ' . $this->db->quoteColumnName($name)
        . ' FOREIGN KEY (' . $this->buildColumns($columns) . ')'
        . ' REFERENCES ' . $this->db->quoteTableName($refTable)
        . ' (' . $this->buildColumns($refColumns) . ')';
    if ($delete !== null) {
        $sql .= ' ON DELETE ' . $delete;
    }
    if ($update !== null) {
        $sql .= ' ON UPDATE ' . $update;
    }
    return $sql;
}

            

                public function addPrimaryKey($name, $table, $columns)
{
    if (is_string($columns)) {
        $columns = preg_split('/\s*,\s*/', $columns, -1, PREG_SPLIT_NO_EMPTY);
    }
    foreach ($columns as $i => $col) {
        $columns[$i] = $this->db->quoteColumnName($col);
    }
    return 'ALTER TABLE ' . $this->db->quoteTableName($table) . ' ADD CONSTRAINT '
        . $this->db->quoteColumnName($name) . ' PRIMARY KEY ('
        . implode(', ', $columns) . ')';
}

            

                public function addUnique($name, $table, $columns)
{
    if (is_string($columns)) {
        $columns = preg_split('/\s*,\s*/', $columns, -1, PREG_SPLIT_NO_EMPTY);
    }
    foreach ($columns as $i => $col) {
        $columns[$i] = $this->db->quoteColumnName($col);
    }
    return 'ALTER TABLE ' . $this->db->quoteTableName($table) . ' ADD CONSTRAINT '
        . $this->db->quoteColumnName($name) . ' UNIQUE ('
        . implode(', ', $columns) . ')';
}

            

                public function batchInsert($table, $columns, $rows, &$params = [])
{
    if (empty($rows)) {
        return '';
    }
    $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 (isset($columns[$i], $columnSchemas[$columns[$i]])) {
                $value = $columnSchemas[$columns[$i]]->dbTypecast($value);
            }
            if (is_string($value)) {
                $value = $schema->quoteValue($value);
            } elseif (is_float($value)) {
                // ensure type cast always has . as decimal separator in all locales
                $value = StringHelper::floatToString($value);
            } elseif ($value === false) {
                $value = 0;
            } elseif ($value === null) {
                $value = 'NULL';
            } elseif ($value instanceof ExpressionInterface) {
                $value = $this->buildExpression($value, $params);
            }
            $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) . ') VALUES ' . implode(', ', $values);
}

            

                public function bindParam($value, &$params)
{
    $phName = self::PARAM_PREFIX . count($params);
    $params[$phName] = $value;
    return $phName;
}

            

                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 ExpressionInterface) {
                $this->buildExpression($expression, $params);
            }
        }
    }
    if (!empty($query->groupBy)) {
        foreach ($query->groupBy as $expression) {
            if ($expression instanceof ExpressionInterface) {
                $this->buildExpression($expression, $params);
            }
        }
    }
    $union = $this->buildUnion($query->union, $params);
    if ($union !== '') {
        $sql = "($sql){$this->separator}$union";
    }
    $with = $this->buildWithQueries($query->withQueries, $params);
    if ($with !== '') {
        $sql = "$with{$this->separator}$sql";
    }
    return [$sql, $params];
}

            

                public function buildAndCondition($operator, $operands, &$params)
{
    array_unshift($operands, $operator);
    return $this->buildCondition($operands, $params);
}

            

                public function buildBetweenCondition($operator, $operands, &$params)
{
    array_unshift($operands, $operator);
    return $this->buildCondition($operands, $params);
}

            

                public function buildColumns($columns)
{
    if (!is_array($columns)) {
        if (strpos($columns, '(') !== false) {
            return $columns;
        }
        $rawColumns = $columns;
        $columns = preg_split('/\s*,\s*/', $columns, -1, PREG_SPLIT_NO_EMPTY);
        if ($columns === false) {
            throw new InvalidArgumentException("$rawColumns is not valid columns.");
        }
    }
    foreach ($columns as $i => $column) {
        if ($column instanceof ExpressionInterface) {
            $columns[$i] = $this->buildExpression($column);
        } elseif (strpos($column, '(') === false) {
            $columns[$i] = $this->db->quoteColumnName($column);
        }
    }
    return implode(', ', $columns);
}

            

                public function buildCondition($condition, &$params)
{
    if (is_array($condition)) {
        if (empty($condition)) {
            return '';
        }
        $condition = $this->createConditionFromArray($condition);
    }
    if ($condition instanceof ExpressionInterface) {
        return $this->buildExpression($condition, $params);
    }
    return (string)$condition;
}

            

                public function buildExistsCondition($operator, $operands, &$params)
{
    array_unshift($operands, $operator);
    return $this->buildCondition($operands, $params);
}

            

                public function buildExpression(ExpressionInterface $expression, &$params = [])
{
    $builder = $this->getExpressionBuilder($expression);
    return $builder->build($expression, $params);
}

            

                public function buildFrom($tables, &$params)
{
    if (empty($tables)) {
        return '';
    }
    $tables = $this->quoteTableNames($tables, $params);
    return 'FROM ' . implode(', ', $tables);
}

            

                public function buildGroupBy($columns)
{
    if (empty($columns)) {
        return '';
    }
    foreach ($columns as $i => $column) {
        if ($column instanceof ExpressionInterface) {
            $columns[$i] = $this->buildExpression($column);
        } elseif (strpos($column, '(') === false) {
            $columns[$i] = $this->db->quoteColumnName($column);
        }
    }
    return 'GROUP BY ' . implode(', ', $columns);
}

            

                public function buildHashCondition($condition, &$params)
{
    return $this->buildCondition(new HashCondition($condition), $params);
}

            

                public function buildHaving($condition, &$params)
{
    $having = $this->buildCondition($condition, $params);
    return $having === '' ? '' : 'HAVING ' . $having;
}

            

                public function buildInCondition($operator, $operands, &$params)
{
    array_unshift($operands, $operator);
    return $this->buildCondition($operands, $params);
}

            

                public function buildJoin($joins, &$params)
{
    if (empty($joins)) {
        return '';
    }
    foreach ($joins as $i => $join) {
        if (!is_array($join) || !isset($join[0], $join[1])) {
            throw new Exception('A join clause must be specified as an array of join type, join table, and optionally join condition.');
        }
        // 0:join type, 1:join table, 2:on-condition (optional)
        list($joinType, $table) = $join;
        $tables = $this->quoteTableNames((array)$table, $params);
        $table = reset($tables);
        $joins[$i] = "$joinType $table";
        if (isset($join[2])) {
            $condition = $this->buildCondition($join[2], $params);
            if ($condition !== '') {
                $joins[$i] .= ' ON ' . $condition;
            }
        }
    }
    return implode($this->separator, $joins);
}

            

                public function buildLikeCondition($operator, $operands, &$params)
{
    array_unshift($operands, $operator);
    return $this->buildCondition($operands, $params);
}

            

                public function buildLimit($limit, $offset)
{
    $sql = '';
    if ($this->hasLimit($limit)) {
        $sql = 'LIMIT ' . $limit;
    }
    if ($this->hasOffset($offset)) {
        $sql .= ' OFFSET ' . $offset;
    }
    return ltrim($sql);
}

            

                public function buildNotCondition($operator, $operands, &$params)
{
    array_unshift($operands, $operator);
    return $this->buildCondition($operands, $params);
}

            

                public function buildOrderBy($columns)
{
    if (empty($columns)) {
        return '';
    }
    $orders = [];
    foreach ($columns as $name => $direction) {
        if ($direction instanceof ExpressionInterface) {
            $orders[] = $this->buildExpression($direction);
        } else {
            $orders[] = $this->db->quoteColumnName($name) . ($direction === SORT_DESC ? ' DESC' : '');
        }
    }
    return 'ORDER BY ' . implode(', ', $orders);
}

            

                public function buildSelect($columns, &$params, $distinct = false, $selectOption = null)
{
    $select = $distinct ? 'SELECT DISTINCT' : 'SELECT';
    if ($selectOption !== null) {
        $select .= ' ' . $selectOption;
    }
    if (empty($columns)) {
        return $select . ' *';
    }
    foreach ($columns as $i => $column) {
        if ($column instanceof ExpressionInterface) {
            if (is_int($i)) {
                $columns[$i] = $this->buildExpression($column, $params);
            } else {
                $columns[$i] = $this->buildExpression($column, $params) . ' AS ' . $this->db->quoteColumnName($i);
            }
        } elseif ($column instanceof Query) {
            list($sql, $params) = $this->build($column, $params);
            $columns[$i] = "($sql) AS " . $this->db->quoteColumnName($i);
        } elseif (is_string($i) && $i !== $column) {
            if (strpos($column, '(') === false) {
                $column = $this->db->quoteColumnName($column);
            }
            $columns[$i] = "$column AS " . $this->db->quoteColumnName($i);
        } elseif (strpos($column, '(') === false) {
            if (preg_match('/^(.*?)(?i:\s+as\s+|\s+)([\w\-_\.]+)$/', $column, $matches)) {
                $columns[$i] = $this->db->quoteColumnName($matches[1]) . ' AS ' . $this->db->quoteColumnName($matches[2]);
            } else {
                $columns[$i] = $this->db->quoteColumnName($column);
            }
        }
    }
    return $select . ' ' . implode(', ', $columns);
}

            

                public function buildSimpleCondition($operator, $operands, &$params)
{
    array_unshift($operands, $operator);
    return $this->buildCondition($operands, $params);
}

            

                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);
}

            

                public function buildWhere($condition, &$params)
{
    $where = $this->buildCondition($condition, $params);
    return $where === '' ? '' : 'WHERE ' . $where;
}

            

                public function buildWithQueries($withs, &$params)
{
    if (empty($withs)) {
        return '';
    }
    $recursive = false;
    $result = [];
    foreach ($withs as $i => $with) {
        if ($with['recursive']) {
            $recursive = true;
        }
        $query = $with['query'];
        if ($query instanceof Query) {
            list($with['query'], $params) = $this->build($query, $params);
        }
        $result[] = $with['alias'] . ' AS (' . $with['query'] . ')';
    }
    return 'WITH ' . ($recursive ? 'RECURSIVE ' : '') . implode(', ', $result);
}

            

                public function canGetProperty($name, $checkVars = true)
{
    return method_exists($this, 'get' . $name) || $checkVars && property_exists($this, $name);
}

            

                public function canSetProperty($name, $checkVars = true)
{
    return method_exists($this, 'set' . $name) || $checkVars && property_exists($this, $name);
}

            

                public static function className()
{
    return get_called_class();
}

            

                public function createConditionFromArray($condition)
{
    if (isset($condition[0])) { // operator format: operator, operand 1, operand 2, ...
        $operator = strtoupper(array_shift($condition));
        if (isset($this->conditionClasses[$operator])) {
            $className = $this->conditionClasses[$operator];
        } else {
            $className = 'yii\db\conditions\SimpleCondition';
        }
        /** @var ConditionInterface $className */
        return $className::fromArrayDefinition($operator, $condition);
    }
    // hash format: 'column1' => 'value1', 'column2' => 'value2', ...
    return new HashCondition($condition);
}

            

                public function createIndex($name, $table, $columns, $unique = false)
{
    return ($unique ? 'CREATE UNIQUE INDEX ' : 'CREATE INDEX ')
        . $this->db->quoteTableName($name) . ' ON '
        . $this->db->quoteTableName($table)
        . ' (' . $this->buildColumns($columns) . ')';
}

            

                public function createTable($table, $columns, $options = null)
{
    $cols = [];
    foreach ($columns as $name => $type) {
        if (is_string($name)) {
            $cols[] = "\t" . $this->db->quoteColumnName($name) . ' ' . $this->getColumnType($type);
        } else {
            $cols[] = "\t" . $type;
        }
    }
    $sql = 'CREATE TABLE ' . $this->db->quoteTableName($table) . " (\n" . implode(",\n", $cols) . "\n)";
    return $options === null ? $sql : $sql . ' ' . $options;
}

            

                public function createView($viewName, $subQuery)
{
    if ($subQuery instanceof Query) {
        list($rawQuery, $params) = $this->build($subQuery);
        array_walk(
            $params,
            function (&$param) {
                $param = $this->db->quoteValue($param);
            }
        );
        $subQuery = strtr($rawQuery, $params);
    }
    return 'CREATE VIEW ' . $this->db->quoteTableName($viewName) . ' AS ' . $subQuery;
}

            

                protected function defaultConditionClasses()
{
    return [
        'NOT' => 'yii\db\conditions\NotCondition',
        'AND' => 'yii\db\conditions\AndCondition',
        'OR' => 'yii\db\conditions\OrCondition',
        'BETWEEN' => 'yii\db\conditions\BetweenCondition',
        'NOT BETWEEN' => 'yii\db\conditions\BetweenCondition',
        'IN' => 'yii\db\conditions\InCondition',
        'NOT IN' => 'yii\db\conditions\InCondition',
        'LIKE' => 'yii\db\conditions\LikeCondition',
        'NOT LIKE' => 'yii\db\conditions\LikeCondition',
        'OR LIKE' => 'yii\db\conditions\LikeCondition',
        'OR NOT LIKE' => 'yii\db\conditions\LikeCondition',
        'EXISTS' => 'yii\db\conditions\ExistsCondition',
        'NOT EXISTS' => 'yii\db\conditions\ExistsCondition',
    ];
}

            

                public function delete($table, $condition, &$params)
{
    $sql = 'DELETE FROM ' . $this->db->quoteTableName($table);
    $where = $this->buildWhere($condition, $params);
    return $where === '' ? $sql : $sql . ' ' . $where;
}

            

                public function dropCheck($name, $table)
{
    return 'ALTER TABLE ' . $this->db->quoteTableName($table)
        . ' DROP CONSTRAINT ' . $this->db->quoteColumnName($name);
}

            

                public function dropForeignKey($name, $table)
{
    return 'ALTER TABLE ' . $this->db->quoteTableName($table)
        . ' DROP CONSTRAINT ' . $this->db->quoteColumnName($name);
}

            

                public function dropIndex($name, $table)
{
    return 'DROP INDEX ' . $this->db->quoteTableName($name) . ' ON ' . $this->db->quoteTableName($table);
}

            

                public function dropPrimaryKey($name, $table)
{
    return 'ALTER TABLE ' . $this->db->quoteTableName($table)
        . ' DROP CONSTRAINT ' . $this->db->quoteColumnName($name);
}

            

                public function dropTable($table)
{
    return 'DROP TABLE ' . $this->db->quoteTableName($table);
}

            

                public function dropUnique($name, $table)
{
    return 'ALTER TABLE ' . $this->db->quoteTableName($table)
        . ' DROP CONSTRAINT ' . $this->db->quoteColumnName($name);
}

            

                public function dropView($viewName)
{
    return 'DROP VIEW ' . $this->db->quoteTableName($viewName);
}

            

                public function executeResetSequence($table, $value = null)
{
    $this->db->createCommand()->resetSequence($table, $value)->execute();
}

            

                public function getExpressionBuilder(ExpressionInterface $expression)
{
    $className = get_class($expression);
    if (!isset($this->expressionBuilders[$className])) {
        foreach (array_reverse($this->expressionBuilders) as $expressionClass => $builderClass) {
            if (is_subclass_of($expression, $expressionClass)) {
                $this->expressionBuilders[$className] = $builderClass;
                break;
            }
        }
        if (!isset($this->expressionBuilders[$className])) {
            throw new InvalidArgumentException('Expression of class ' . $className . ' can not be built in ' . get_class($this));
        }
    }
    if ($this->expressionBuilders[$className] === __CLASS__) {
        return $this;
    }
    if (!is_object($this->expressionBuilders[$className])) {
        $this->expressionBuilders[$className] = new $this->expressionBuilders[$className]($this);
    }
    return $this->expressionBuilders[$className];
}

            

                protected function hasLimit($limit)
{
    return ($limit instanceof ExpressionInterface) || ctype_digit((string)$limit);
}

            

                public function hasMethod($name)
{
    return method_exists($this, $name);
}

            

                protected function hasOffset($offset)
{
    return ($offset instanceof ExpressionInterface) || ctype_digit((string)$offset) && (string)$offset !== '0';
}

            

                public function hasProperty($name, $checkVars = true)
{
    return $this->canGetProperty($name, $checkVars) || $this->canSetProperty($name, false);
}

            

                public function init()
{
    parent::init();
    $this->expressionBuilders = array_merge($this->defaultExpressionBuilders(), $this->expressionBuilders);
    $this->conditionClasses = array_merge($this->defaultConditionClasses(), $this->conditionClasses);
}

            

                protected function prepareInsertSelectSubQuery($columns, $schema, $params = [])
{
    if (!is_array($columns->select) || empty($columns->select) || in_array('*', $columns->select)) {
        throw new InvalidArgumentException('Expected select query object with enumerated (named) parameters');
    }
    list($values, $params) = $this->build($columns, $params);
    $names = [];
    $values = ' ' . $values;
    foreach ($columns->select as $title => $field) {
        if (is_string($title)) {
            $names[] = $schema->quoteColumnName($title);
        } elseif (preg_match('/^(.*?)(?i:\s+as\s+|\s+)([\w\-_\.]+)$/', $field, $matches)) {
            $names[] = $schema->quoteColumnName($matches[2]);
        } else {
            $names[] = $schema->quoteColumnName($field);
        }
    }
    return [$names, $values, $params];
}

            

                protected function prepareInsertValues($table, $columns, $params = [])
{
    $schema = $this->db->getSchema();
    $tableSchema = $schema->getTableSchema($table);
    $columnSchemas = $tableSchema !== null ? $tableSchema->columns : [];
    $names = [];
    $placeholders = [];
    $values = ' DEFAULT VALUES';
    if ($columns instanceof Query) {
        list($names, $values, $params) = $this->prepareInsertSelectSubQuery($columns, $schema, $params);
    } else {
        foreach ($columns as $name => $value) {
            $names[] = $schema->quoteColumnName($name);
            $value = isset($columnSchemas[$name]) ? $columnSchemas[$name]->dbTypecast($value) : $value;
            if ($value instanceof ExpressionInterface) {
                $placeholders[] = $this->buildExpression($value, $params);
            } elseif ($value instanceof \yii\db\Query) {
                list($sql, $params) = $this->build($value, $params);
                $placeholders[] = "($sql)";
            } else {
                $placeholders[] = $this->bindParam($value, $params);
            }
        }
    }
    return [$names, $placeholders, $values, $params];
}

            

                protected function prepareUpdateSets($table, $columns, $params = [])
{
    $tableSchema = $this->db->getTableSchema($table);
    $columnSchemas = $tableSchema !== null ? $tableSchema->columns : [];
    $sets = [];
    foreach ($columns as $name => $value) {
        $value = isset($columnSchemas[$name]) ? $columnSchemas[$name]->dbTypecast($value) : $value;
        if ($value instanceof ExpressionInterface) {
            $placeholder = $this->buildExpression($value, $params);
        } else {
            $placeholder = $this->bindParam($value, $params);
        }
        $sets[] = $this->db->quoteColumnName($name) . '=' . $placeholder;
    }
    return [$sets, $params];
}

            

                protected function prepareUpsertColumns($table, $insertColumns, $updateColumns, &$constraints = [])
{
    if ($insertColumns instanceof Query) {
        list($insertNames) = $this->prepareInsertSelectSubQuery($insertColumns, $this->db->getSchema());
    } else {
        $insertNames = array_map([$this->db, 'quoteColumnName'], array_keys($insertColumns));
    }
    $uniqueNames = $this->getTableUniqueColumnNames($table, $insertNames, $constraints);
    $uniqueNames = array_map([$this->db, 'quoteColumnName'], $uniqueNames);
    if ($updateColumns !== true) {
        return [$uniqueNames, $insertNames, null];
    }
    return [$uniqueNames, $insertNames, array_diff($insertNames, $uniqueNames)];
}

            

                public function setConditionClasses($classes)
{
    $this->conditionClasses = array_merge($this->conditionClasses, $classes);
}

            

                public function setExpressionBuilders($builders)
{
    $this->expressionBuilders = array_merge($this->expressionBuilders, $builders);
}

            

                public function truncateTable($table)
{
    return 'TRUNCATE TABLE ' . $this->db->quoteTableName($table);
}