Abstract Class Yiisoft\Db\Command\AbstractCommand

                public function __construct(
    protected readonly ConnectionInterface $db,
) {}

            

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

            

                public function addColumn(string $table, string $column, ColumnInterface|string $type): static
{
    $sql = $this->getQueryBuilder()->addColumn($table, $column, $type);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

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

            

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

            

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

            

                public function addForeignKey(
    string $table,
    string $name,
    array|string $columns,
    string $referenceTable,
    array|string $referenceColumns,
    ?string $delete = null,
    ?string $update = null,
): static {
    $sql = $this->getQueryBuilder()->addForeignKey(
        $table,
        $name,
        $columns,
        $referenceTable,
        $referenceColumns,
        $delete,
        $update,
    );
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function addPrimaryKey(string $table, string $name, array|string $columns): static
{
    $sql = $this->getQueryBuilder()->addPrimaryKey($table, $name, $columns);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function addUnique(string $table, string $name, array|string $columns): static
{
    $sql = $this->getQueryBuilder()->addUnique($table, $name, $columns);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function alterColumn(string $table, string $column, ColumnInterface|string $type): static
{
    $sql = $this->getQueryBuilder()->alterColumn($table, $column, $type);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                abstract public function bindValue(int|string $name, mixed $value, ?int $dataType = null): static;

            

                abstract public function bindValues(array $values): static;

            

                public function checkIntegrity(string $schema, string $table, bool $check = true): static
{
    $sql = $this->getQueryBuilder()->checkIntegrity($schema, $table, $check);
    return $this->setSql($sql);
}

            

                public function createIndex(
    string $table,
    string $name,
    array|string $columns,
    ?string $indexType = null,
    ?string $indexMethod = null,
): static {
    $sql = $this->getQueryBuilder()->createIndex($table, $name, $columns, $indexType, $indexMethod);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function createTable(string $table, array $columns, ?string $options = null): static
{
    $sql = $this->getQueryBuilder()->createTable($table, $columns, $options);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

                public function createView(string $viewName, QueryInterface|string $subQuery): static
{
    $sql = $this->getQueryBuilder()->createView($viewName, $subQuery);
    return $this->setSql($sql)->requireTableSchemaRefresh($viewName);
}

            

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

            

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

            

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

            

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

            

                public function dropCommentFromTable(string $table): static
{
    $sql = $this->getQueryBuilder()->dropCommentFromTable($table);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

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

            

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

            

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

            

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

            

                public function dropTable(string $table, bool $ifExists = false, bool $cascade = false): static
{
    $sql = $this->getQueryBuilder()->dropTable($table, $ifExists, $cascade);
    return $this->setSql($sql)->requireTableSchemaRefresh($table);
}

            

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

            

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

            

                public function execute(): int
{
    $sql = $this->getSql();
    if ($sql === '') {
        return 0;
    }
    /** @var bool|int $execute */
    $execute = $this->queryInternal(self::QUERY_MODE_EXECUTE);
    return is_int($execute) ? $execute : 0;
}

            

                public function getParams(bool $asValues = true): array
{
    if (!$asValues) {
        return $this->params;
    }
    $buildParams = [];
    foreach ($this->params as $name => $value) {
        $buildParams[$name] = $value->value;
    }
    return $buildParams;
}

            

                abstract protected function getQueryBuilder(): QueryBuilderInterface;

            

                public function getRawSql(): string
{
    if (empty($this->params)) {
        return $this->sql;
    }
    $queryBuilder = $this->getQueryBuilder();
    $params = array_map($queryBuilder->prepareParam(...), $this->params);
    if (!isset($params[0])) {
        return $queryBuilder->replacePlaceholders($this->sql, $params);
    }
    // Support unnamed placeholders should be dropped
    $sql = '';
    foreach (explode('?', $this->sql) as $i => $part) {
        $sql .= $part . ($params[$i] ?? '');
    }
    return $sql;
}

            

                public function getSql(): string
{
    return $this->sql;
}

            

                public function insert(string $table, array|QueryInterface $columns): static
{
    $params = [];
    $sql = $this->getQueryBuilder()->insert($table, $columns, $params);
    return $this->setSql($sql)->bindValues($params);
}

            

                public function insertBatch(string $table, iterable $rows, array $columns = []): static
{
    $table = $this->getQueryBuilder()->getQuoter()->getRawTableName($table);
    $params = [];
    $sql = $this->getQueryBuilder()->insertBatch($table, $rows, $columns, $params);
    $this->setRawSql($sql);
    $this->bindValues($params);
    return $this;
}

            

                public function insertReturningPks(string $table, array|QueryInterface $columns): array
{
    if (empty($this->db->getSchema()->getTableSchema($table)?->getPrimaryKey())) {
        $this->insert($table, $columns)->execute();
        return [];
    }
    $params = [];
    $sql = $this->getQueryBuilder()->insertReturningPks($table, $columns, $params);
    $this->setSql($sql)->bindValues($params);
    /** @psalm-var array<string, mixed> */
    return $this->queryInternal(self::QUERY_MODE_ROW | self::QUERY_MODE_EXECUTE);
}

            

                abstract protected function internalExecute(): void;

            

                abstract protected function internalGetQueryResult(int $queryMode): mixed;

            

                protected function is(int $value, int $flag): bool
{
    return ($value & $flag) === $flag;
}

            

                public function query(): DataReaderInterface
{
    /** @var DataReaderInterface */
    return $this->queryInternal(self::QUERY_MODE_CURSOR);
}

            

                public function queryAll(): array
{
    /** @psalm-var list<array>|null $results */
    $results = $this->queryInternal(self::QUERY_MODE_ALL);
    return $results ?? [];
}

            

                public function queryColumn(): array
{
    $results = $this->queryInternal(self::QUERY_MODE_COLUMN);
    return is_array($results) ? $results : [];
}

            

                protected function queryInternal(int $queryMode): mixed
{
    $isReadMode = $this->isReadMode($queryMode);
    $this->prepare($isReadMode);
    $this->internalExecute();
    $result = $this->internalGetQueryResult($queryMode);
    if ($isReadMode) {
        return $result;
    }
    if ($this->refreshTableName !== null) {
        $this->db->getSchema()->refreshTableSchema($this->refreshTableName);
    }
    return $result;
}

            

                public function queryOne(): ?array
{
    /** @psalm-var array<string,mixed>|false $results */
    $results = $this->queryInternal(self::QUERY_MODE_ROW);
    return is_array($results) ? $results : null;
}

            

                public function queryScalar(): bool|string|int|float|null
{
    $result = $this->queryInternal(self::QUERY_MODE_SCALAR);
    if (is_resource($result) && get_resource_type($result) === 'stream') {
        return stream_get_contents($result);
    }
    return is_scalar($result) ? $result : null;
}

            

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

            

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

            

                protected function requireTableSchemaRefresh(string $name): static
{
    $this->refreshTableName = $name;
    return $this;
}

            

                protected function reset(): void
{
    $this->sql = '';
    $this->params = [];
    $this->refreshTableName = null;
}

            

                public function resetSequence(string $table, int|string|null $value = null): static
{
    $sql = $this->getQueryBuilder()->resetSequence($table, $value);
    return $this->setSql($sql);
}

            

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

            

                public function setRetryHandler(?Closure $handler): static
{
    $this->retryHandler = $handler;
    return $this;
}

            

                public function setSql(string $sql): static
{
    $this->cancel();
    $this->reset();
    $this->sql = $this->getQueryBuilder()->getQuoter()->quoteSql($sql);
    return $this;
}

            

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

            

                public function update(
    string $table,
    array $columns,
    array|ExpressionInterface|string $condition = '',
    array|ExpressionInterface|string|null $from = null,
    array $params = [],
): static {
    $sql = $this->getQueryBuilder()->update($table, $columns, $condition, $from, $params);
    return $this->setSql($sql)->bindValues($params);
}

            

                public function upsert(
    string $table,
    array|QueryInterface $insertColumns,
    array|bool $updateColumns = true,
): static {
    $params = [];
    $sql = $this->getQueryBuilder()->upsert($table, $insertColumns, $updateColumns, $params);
    return $this->setSql($sql)->bindValues($params);
}

            

                public function upsertReturning(
    string $table,
    array|QueryInterface $insertColumns,
    array|bool $updateColumns = true,
    ?array $returnColumns = null,
): array {
    if ($returnColumns === []) {
        $this->upsert($table, $insertColumns, $updateColumns)->execute();
        return [];
    }
    $params = [];
    $sql = $this->getQueryBuilder()
        ->upsertReturning($table, $insertColumns, $updateColumns, $returnColumns, $params);
    $this->setSql($sql)->bindValues($params);
    /** @psalm-var array<string, mixed> */
    return $this->queryInternal(self::QUERY_MODE_ROW | self::QUERY_MODE_EXECUTE);
}

            

                public function upsertReturningPks(
    string $table,
    array|QueryInterface $insertColumns,
    array|bool $updateColumns = true,
): array {
    $primaryKeys = $this->db->getSchema()->getTableSchema($table)?->getPrimaryKey() ?? [];
    return $this->upsertReturning($table, $insertColumns, $updateColumns, $primaryKeys);
}

            

                public function withDbTypecasting(bool $dbTypecasting = true): static
{
    $new = clone $this;
    $new->dbTypecasting = $dbTypecasting;
    return $new;
}

            

                public function withPhpTypecasting(bool $phpTypecasting = true): static
{
    $new = clone $this;
    $new->phpTypecasting = $phpTypecasting;
    return $new;
}

            

                public function withTypecasting(bool $typecasting = true): static
{
    $new = clone $this;
    $new->dbTypecasting = $typecasting;
    $new->phpTypecasting = $typecasting;
    return $new;
}