類別 yii\db\sqlite\Command

                public function __call($name, $params)
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $object) {
        if ($object->hasMethod($name)) {
            return call_user_func_array([$object, $name], $params);
        }
    }
    throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
}

            

                public function __clone()
{
    $this->_events = [];
    $this->_eventWildcards = [];
    $this->_behaviors = null;
}

            

                public function __construct($config = [])
{
    if (!empty($config)) {
        Yii::configure($this, $config);
    }
    $this->init();
}

            

                public function __get($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        // read property, e.g. getName()
        return $this->$getter();
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name;
        }
    }
    if (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;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name !== null;
        }
    }
    return false;
}

            

                public function __set($name, $value)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        // set property
        $this->$setter($value);
        return;
    } elseif (strncmp($name, 'on ', 3) === 0) {
        // on event: attach event handler
        $this->on(trim(substr($name, 3)), $value);
        return;
    } elseif (strncmp($name, 'as ', 3) === 0) {
        // as behavior: attach behavior
        $name = trim(substr($name, 3));
        $this->attachBehavior($name, $value instanceof Behavior ? $value : Yii::createObject($value));
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = $value;
            return;
        }
    }
    if (method_exists($this, 'get' . $name)) {
        throw new InvalidCallException('Setting read-only property: ' . get_class($this) . '::' . $name);
    }
    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);
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = null;
            return;
        }
    }
    throw new InvalidCallException('Unsetting an unknown or read-only property: ' . get_class($this) . '::' . $name);
}

            

                public function addCheck($name, $table, $expression)
{
    $sql = $this->db->getQueryBuilder()->addCheck($name, $table, $expression);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function addColumn($table, $column, $type)
{
    $sql = $this->db->getQueryBuilder()->addColumn($table, $column, $type);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function addCommentOnColumn($table, $column, $comment)
{
    $sql = $this->db->getQueryBuilder()->addCommentOnColumn($table, $column, $comment);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function addCommentOnTable($table, $comment)
{
    $sql = $this->db->getQueryBuilder()->addCommentOnTable($table, $comment);
    return $this->setSql($sql);
}

            

                public function addDefaultValue($name, $table, $column, $value)
{
    $sql = $this->db->getQueryBuilder()->addDefaultValue($name, $table, $column, $value);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function addForeignKey($name, $table, $columns, $refTable, $refColumns, $delete = null, $update = null)
{
    $sql = $this->db->getQueryBuilder()->addForeignKey($name, $table, $columns, $refTable, $refColumns, $delete, $update);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function addPrimaryKey($name, $table, $columns)
{
    $sql = $this->db->getQueryBuilder()->addPrimaryKey($name, $table, $columns);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function addUnique($name, $table, $columns)
{
    $sql = $this->db->getQueryBuilder()->addUnique($name, $table, $columns);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function alterColumn($table, $column, $type)
{
    $sql = $this->db->getQueryBuilder()->alterColumn($table, $column, $type);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function attachBehavior($name, $behavior)
{
    $this->ensureBehaviors();
    return $this->attachBehaviorInternal($name, $behavior);
}

            

                public function attachBehaviors($behaviors)
{
    $this->ensureBehaviors();
    foreach ($behaviors as $name => $behavior) {
        $this->attachBehaviorInternal($name, $behavior);
    }
}

            

                public function batchInsert($table, $columns, $rows)
{
    $table = $this->db->quoteSql($table);
    $columns = array_map(function ($column) {
        return $this->db->quoteSql($column);
    }, $columns);
    $params = [];
    $sql = $this->db->getQueryBuilder()->batchInsert($table, $columns, $rows, $params);
    $this->setRawSql($sql);
    $this->bindValues($params);
    return $this;
}

            

                public function behaviors()
{
    return [];
}

            

                public function bindParam($name, &$value, $dataType = null, $length = null, $driverOptions = null)
{
    $this->prepare();
    if ($dataType === null) {
        $dataType = $this->db->getSchema()->getPdoType($value);
    }
    if ($length === null) {
        $this->pdoStatement->bindParam($name, $value, $dataType);
    } elseif ($driverOptions === null) {
        $this->pdoStatement->bindParam($name, $value, $dataType, $length);
    } else {
        $this->pdoStatement->bindParam($name, $value, $dataType, $length, $driverOptions);
    }
    $this->params[$name] = &$value;
    return $this;
}

            

                protected function bindPendingParams()
{
    foreach ($this->pendingParams as $name => $value) {
        $this->pdoStatement->bindValue($name, $value[0], $value[1]);
    }
    $this->pendingParams = [];
}

            

                public function bindValue($name, $value, $dataType = null)
{
    if ($dataType === null) {
        $dataType = $this->db->getSchema()->getPdoType($value);
    }
    $this->pendingParams[$name] = [$value, $dataType];
    $this->params[$name] = $value;
    return $this;
}

            

                public function bindValues($values)
{
    if (empty($values)) {
        return $this;
    }
    $schema = $this->db->getSchema();
    foreach ($values as $name => $value) {
        if (is_array($value)) { // TODO: Drop in Yii 2.1
            $this->pendingParams[$name] = $value;
            $this->params[$name] = $value[0];
        } elseif ($value instanceof PdoValue) {
            $this->pendingParams[$name] = [$value->getValue(), $value->getType()];
            $this->params[$name] = $value->getValue();
        } else {
            if (version_compare(PHP_VERSION, '8.1.0') >= 0) {
                if ($value instanceof \BackedEnum) {
                    $value = $value->value;
                } elseif ($value instanceof \UnitEnum) {
                    $value = $value->name;
                }
            }
            $type = $schema->getPdoType($value);
            $this->pendingParams[$name] = [$value, $type];
            $this->params[$name] = $value;
        }
    }
    return $this;
}

            

                public function cache($duration = null, $dependency = null)
{
    $this->queryCacheDuration = $duration === null ? $this->db->queryCacheDuration : $duration;
    $this->queryCacheDependency = $dependency;
    return $this;
}

            

                public function canGetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'get' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canGetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function canSetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'set' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canSetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function cancel()
{
    $this->pdoStatement = null;
}

            

                public function checkIntegrity($check = true, $schema = '', $table = '')
{
    $sql = $this->db->getQueryBuilder()->checkIntegrity($check, $schema, $table);
    return $this->setSql($sql);
}

            

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

            

                public function createIndex($name, $table, $columns, $unique = false)
{
    $sql = $this->db->getQueryBuilder()->createIndex($name, $table, $columns, $unique);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function createTable($table, $columns, $options = null)
{
    $sql = $this->db->getQueryBuilder()->createTable($table, $columns, $options);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function createView($viewName, $subquery)
{
    $sql = $this->db->getQueryBuilder()->createView($viewName, $subquery);
    return $this->setSql($sql)->requireTableSchemaRefresh($viewName);
}

            

                public function delete($table, $condition = '', $params = [])
{
    $sql = $this->db->getQueryBuilder()->delete($table, $condition, $params);
    return $this->setSql($sql)->bindValues($params);
}

            

                public function detachBehavior($name)
{
    $this->ensureBehaviors();
    if (isset($this->_behaviors[$name])) {
        $behavior = $this->_behaviors[$name];
        unset($this->_behaviors[$name]);
        $behavior->detach();
        return $behavior;
    }
    return null;
}

            

                public function detachBehaviors()
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $name => $behavior) {
        $this->detachBehavior($name);
    }
}

            

                public function dropCheck($name, $table)
{
    $sql = $this->db->getQueryBuilder()->dropCheck($name, $table);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function dropColumn($table, $column)
{
    $sql = $this->db->getQueryBuilder()->dropColumn($table, $column);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function dropCommentFromColumn($table, $column)
{
    $sql = $this->db->getQueryBuilder()->dropCommentFromColumn($table, $column);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function dropCommentFromTable($table)
{
    $sql = $this->db->getQueryBuilder()->dropCommentFromTable($table);
    return $this->setSql($sql);
}

            

                public function dropDefaultValue($name, $table)
{
    $sql = $this->db->getQueryBuilder()->dropDefaultValue($name, $table);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function dropForeignKey($name, $table)
{
    $sql = $this->db->getQueryBuilder()->dropForeignKey($name, $table);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function dropIndex($name, $table)
{
    $sql = $this->db->getQueryBuilder()->dropIndex($name, $table);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function dropPrimaryKey($name, $table)
{
    $sql = $this->db->getQueryBuilder()->dropPrimaryKey($name, $table);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function dropTable($table)
{
    $sql = $this->db->getQueryBuilder()->dropTable($table);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function dropUnique($name, $table)
{
    $sql = $this->db->getQueryBuilder()->dropUnique($name, $table);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function dropView($viewName)
{
    $sql = $this->db->getQueryBuilder()->dropView($viewName);
    return $this->setSql($sql)->requireTableSchemaRefresh($viewName);
}

            

                public function ensureBehaviors()
{
    if ($this->_behaviors === null) {
        $this->_behaviors = [];
        foreach ($this->behaviors() as $name => $behavior) {
            $this->attachBehaviorInternal($name, $behavior);
        }
    }
}

            

                public function executeResetSequence($table, $value = null)
{
    return $this->db->getQueryBuilder()->executeResetSequence($table, $value);
}

            

                public function getBehavior($name)
{
    $this->ensureBehaviors();
    return isset($this->_behaviors[$name]) ? $this->_behaviors[$name] : null;
}

            

                public function getBehaviors()
{
    $this->ensureBehaviors();
    return $this->_behaviors;
}

            

                protected function getCacheKey($method, $fetchMode, $rawSql)
{
    $params = $this->params;
    ksort($params);
    return [
        __CLASS__,
        $method,
        $fetchMode,
        $this->db->dsn,
        $this->db->username,
        $this->getSql(),
        json_encode($params),
    ];
}

            

                public function getRawSql()
{
    if (empty($this->params)) {
        return $this->_sql;
    }
    $params = [];
    foreach ($this->params as $name => $value) {
        if (is_string($name) && strncmp(':', $name, 1)) {
            $name = ':' . $name;
        }
        if (is_string($value) || $value instanceof Expression) {
            $params[$name] = $this->db->quoteValue((string)$value);
        } elseif (is_bool($value)) {
            $params[$name] = ($value ? 'TRUE' : 'FALSE');
        } elseif ($value === null) {
            $params[$name] = 'NULL';
        } elseif (!is_object($value) && !is_resource($value)) {
            $params[$name] = $value;
        }
    }
    if (!isset($params[1])) {
        return preg_replace_callback('#(:\w+)#', function ($matches) use ($params) {
            $m = $matches[1];
            return isset($params[$m]) ? $params[$m] : $m;
        }, $this->_sql);
    }
    $sql = '';
    foreach (explode('?', $this->_sql) as $i => $part) {
        $sql .= (isset($params[$i]) ? $params[$i] : '') . $part;
    }
    return $sql;
}

            

                public function getSql()
{
    return $this->_sql;
}

            

                public function hasEventHandlers($name)
{
    $this->ensureBehaviors();
    if (!empty($this->_events[$name])) {
        return true;
    }
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (!empty($handlers) && StringHelper::matchWildcard($wildcard, $name)) {
            return true;
        }
    }
    return Event::hasHandlers($this, $name);
}

            

                public function hasMethod($name, $checkBehaviors = true)
{
    if (method_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->hasMethod($name)) {
                return true;
            }
        }
    }
    return false;
}

            

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

            

                public function init()
{
}

            

                public function insert($table, $columns)
{
    $params = [];
    $sql = $this->db->getQueryBuilder()->insert($table, $columns, $params);
    return $this->setSql($sql)->bindValues($params);
}

            

                protected function internalExecute($rawSql)
{
    $attempt = 0;
    while (true) {
        try {
            if (
                ++$attempt === 1
                && $this->_isolationLevel !== false
                && $this->db->getTransaction() === null
            ) {
                $this->db->transaction(function () use ($rawSql) {
                    $this->internalExecute($rawSql);
                }, $this->_isolationLevel);
            } else {
                $this->pdoStatement->execute();
            }
            break;
        } catch (\Exception $e) {
            $rawSql = $rawSql ?: $this->getRawSql();
            $e = $this->db->getSchema()->convertException($e, $rawSql);
            if ($this->_retryHandler === null || !call_user_func($this->_retryHandler, $e, $attempt)) {
                throw $e;
            }
        }
    }
}

            

                protected function logQuery($category)
{
    if ($this->db->enableLogging) {
        $rawSql = $this->getRawSql();
        Yii::info($rawSql, $category);
    }
    if (!$this->db->enableProfiling) {
        return [false, isset($rawSql) ? $rawSql : null];
    }
    return [true, isset($rawSql) ? $rawSql : $this->getRawSql()];
}

            

                public function noCache()
{
    $this->queryCacheDuration = -1;
    return $this;
}

            

                public function off($name, $handler = null)
{
    $this->ensureBehaviors();
    if (empty($this->_events[$name]) && empty($this->_eventWildcards[$name])) {
        return false;
    }
    if ($handler === null) {
        unset($this->_events[$name], $this->_eventWildcards[$name]);
        return true;
    }
    $removed = false;
    // plain event names
    if (isset($this->_events[$name])) {
        foreach ($this->_events[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_events[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_events[$name] = array_values($this->_events[$name]);
            return true;
        }
    }
    // wildcard event names
    if (isset($this->_eventWildcards[$name])) {
        foreach ($this->_eventWildcards[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_eventWildcards[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_eventWildcards[$name] = array_values($this->_eventWildcards[$name]);
            // remove empty wildcards to save future redundant regex checks:
            if (empty($this->_eventWildcards[$name])) {
                unset($this->_eventWildcards[$name]);
            }
        }
    }
    return $removed;
}

            

                public function on($name, $handler, $data = null, $append = true)
{
    $this->ensureBehaviors();
    if (strpos($name, '*') !== false) {
        if ($append || empty($this->_eventWildcards[$name])) {
            $this->_eventWildcards[$name][] = [$handler, $data];
        } else {
            array_unshift($this->_eventWildcards[$name], [$handler, $data]);
        }
        return;
    }
    if ($append || empty($this->_events[$name])) {
        $this->_events[$name][] = [$handler, $data];
    } else {
        array_unshift($this->_events[$name], [$handler, $data]);
    }
}

            

                public function prepare($forRead = null)
{
    if ($this->pdoStatement) {
        $this->bindPendingParams();
        return;
    }
    $sql = $this->getSql();
    if ($sql === '') {
        return;
    }
    if ($this->db->getTransaction()) {
        // master is in a transaction. use the same connection.
        $forRead = false;
    }
    if ($forRead || $forRead === null && $this->db->getSchema()->isReadQuery($sql)) {
        $pdo = $this->db->getSlavePdo(true);
    } else {
        $pdo = $this->db->getMasterPdo();
    }
    try {
        $this->pdoStatement = $pdo->prepare($sql);
        $this->bindPendingParams();
    } catch (\Exception $e) {
        $message = $e->getMessage() . "\nFailed to prepare SQL: $sql";
        $errorInfo = $e instanceof \PDOException ? $e->errorInfo : null;
        throw new Exception($message, $errorInfo, $e->getCode(), $e);
    } catch (\Throwable $e) {
        $message = $e->getMessage() . "\nFailed to prepare SQL: $sql";
        throw new Exception($message, null, $e->getCode(), $e);
    }
}

            

                public function query()
{
    return $this->queryInternal('');
}

            

                public function queryAll($fetchMode = null)
{
    return $this->queryInternal('fetchAll', $fetchMode);
}

            

                public function queryColumn()
{
    return $this->queryInternal('fetchAll', \PDO::FETCH_COLUMN);
}

            

                public function queryOne($fetchMode = null)
{
    return $this->queryInternal('fetch', $fetchMode);
}

            

                public function queryScalar()
{
    $result = $this->queryInternal('fetchColumn', 0);
    if (is_resource($result) && get_resource_type($result) === 'stream') {
        return stream_get_contents($result);
    }
    return $result;
}

            

                protected function refreshTableSchema()
{
    if ($this->_refreshTableName !== null) {
        $this->db->getSchema()->refreshTableSchema($this->_refreshTableName);
    }
}

            

                public function renameColumn($table, $oldName, $newName)
{
    $sql = $this->db->getQueryBuilder()->renameColumn($table, $oldName, $newName);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function renameTable($table, $newName)
{
    $sql = $this->db->getQueryBuilder()->renameTable($table, $newName);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                protected function requireTableSchemaRefresh($name)
{
    $this->_refreshTableName = $name;
    return $this;
}

            

                protected function requireTransaction($isolationLevel = null)
{
    $this->_isolationLevel = $isolationLevel;
    return $this;
}

            

                protected function reset()
{
    $this->_sql = null;
    $this->pendingParams = [];
    $this->params = [];
    $this->_refreshTableName = null;
    $this->_isolationLevel = false;
}

            

                public function resetSequence($table, $value = null)
{
    $sql = $this->db->getQueryBuilder()->resetSequence($table, $value);
    return $this->setSql($sql);
}

            

                public function setRawSql($sql)
{
    if ($sql !== $this->_sql) {
        $this->cancel();
        $this->reset();
        $this->_sql = $sql;
    }
    return $this;
}

            

                protected function setRetryHandler(callable $handler)
{
    $this->_retryHandler = $handler;
    return $this;
}

            

                public function setSql($sql)
{
    if ($sql !== $this->_sql) {
        $this->cancel();
        $this->reset();
        $this->_sql = $this->db->quoteSql($sql);
    }
    return $this;
}

            

                public function trigger($name, Event $event = null)
{
    $this->ensureBehaviors();
    $eventHandlers = [];
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (StringHelper::matchWildcard($wildcard, $name)) {
            $eventHandlers[] = $handlers;
        }
    }
    if (!empty($this->_events[$name])) {
        $eventHandlers[] = $this->_events[$name];
    }
    if (!empty($eventHandlers)) {
        $eventHandlers = call_user_func_array('array_merge', $eventHandlers);
        if ($event === null) {
            $event = new Event();
        }
        if ($event->sender === null) {
            $event->sender = $this;
        }
        $event->handled = false;
        $event->name = $name;
        foreach ($eventHandlers as $handler) {
            $event->data = $handler[1];
            call_user_func($handler[0], $event);
            // stop further handling if the event is handled
            if ($event->handled) {
                return;
            }
        }
    }
    // invoke class-level attached handlers
    Event::trigger($this, $name, $event);
}

            

                public function truncateTable($table)
{
    $sql = $this->db->getQueryBuilder()->truncateTable($table);
    return $this->setSql($sql);
}

            

                public function update($table, $columns, $condition = '', $params = [])
{
    $sql = $this->db->getQueryBuilder()->update($table, $columns, $condition, $params);
    return $this->setSql($sql)->bindValues($params);
}

            

                public function upsert($table, $insertColumns, $updateColumns = true, $params = [])
{
    $sql = $this->db->getQueryBuilder()->upsert($table, $insertColumns, $updateColumns, $params);
    return $this->setSql($sql)->bindValues($params);
}