Abstract Class Yiisoft\Db\QueryBuilder\AbstractDMLQueryBuilder

                public function __construct(
    protected QueryBuilderInterface $queryBuilder,
    protected QuoterInterface $quoter,
    protected SchemaInterface $schema,
) {}

            

                protected function buildSimpleSelect(array $columns): string
{
    $quoter = $this->quoter;
    foreach ($columns as $name => &$column) {
        $column .= ' AS ' . $quoter->quoteSimpleColumnName($name);
    }
    return 'SELECT ' . implode(', ', $columns);
}

            

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

            

                protected function extractColumnNames(array|Iterator $rows, array $columns): array
{
    $columns = $this->getNormalizedColumnNames($columns);
    if (!empty($columns)) {
        return $columns;
    }
    if ($rows instanceof Iterator) {
        $row = $rows->current();
    } else {
        $row = reset($rows);
    }
    $row = match (gettype($row)) {
        'array' => $row,
        'object' => $row instanceof Traversable
            ? iterator_to_array($row)
            : get_object_vars($row),
        default => [],
    };
    if (array_key_exists(0, $row)) {
        return [];
    }
    /** @var string[] $columnNames */
    $columnNames = array_keys($row);
    return array_combine($columnNames, $columnNames);
}

            

                protected function getNormalizedColumnNames(array $columns): array
{
    foreach ($columns as &$name) {
        $name = $this->quoter->ensureColumnName($name);
        $name = $this->quoter->unquoteSimpleColumnName($name);
    }
    return $columns;
}

            

                protected function getQueryColumnNames(QueryInterface $query, array &$params = []): array
{
    /** @var string[] $select */
    $select = $query->getSelect();
    if (empty($select) || in_array('*', $select, true)) {
        throw new InvalidArgumentException('Expected select query object with enumerated (named) parameters');
    }
    $names = [];
    foreach ($select as $title => $field) {
        if (is_string($title)) {
            $names[] = $title;
        } else {
            if ($field instanceof ExpressionInterface) {
                $field = $this->queryBuilder->buildExpression($field, $params);
            }
            if (preg_match('/^(.*?)(?i:\s+as\s+|\s+)([\w\-_.]+)$/', $field, $matches)) {
                $names[] = $matches[2];
            } else {
                $names[] = $field;
            }
        }
    }
    return $this->getNormalizedColumnNames($names);
}

            

                public function insert(string $table, array|QueryInterface $columns, array &$params = []): string
{
    [$names, $placeholders, $values, $params] = $this->prepareInsertValues($table, $columns, $params);
    $quotedNames = array_map($this->quoter->quoteColumnName(...), $names);
    return 'INSERT INTO ' . $this->quoter->quoteTableName($table)
        . (!empty($quotedNames) ? ' (' . implode(', ', $quotedNames) . ')' : '')
        . (!empty($placeholders) ? ' VALUES (' . implode(', ', $placeholders) . ')' : ' ' . $values);
}

            

                public function insertBatch(string $table, iterable $rows, array $columns = [], array &$params = []): string
{
    if (!is_array($rows)) {
        $rows = $this->prepareTraversable($rows);
    }
    if (empty($rows)) {
        return '';
    }
    $columns = $this->extractColumnNames($rows, $columns);
    $values = $this->prepareBatchInsertValues($table, $rows, $columns, $params);
    $query = 'INSERT INTO ' . $this->quoter->quoteTableName($table);
    if (count($columns) > 0) {
        $quotedColumnNames = array_map($this->quoter->quoteColumnName(...), $columns);
        $query .= ' (' . implode(', ', $quotedColumnNames) . ')';
    }
    return $query . ' VALUES (' . implode('), (', $values) . ')';
}

            

                public function insertReturningPks(string $table, array|QueryInterface $columns, array &$params = []): string
{
    throw new NotSupportedException(__METHOD__ . '() is not supported by this DBMS.');
}

            

                public function isTypecastingEnabled(): bool
{
    return $this->typecasting;
}

            

                protected function normalizeColumnNames(array $columns): array
{
    /** @var string[] $columnNames */
    $columnNames = array_keys($columns);
    $normalizedNames = $this->getNormalizedColumnNames($columnNames);
    return array_combine($normalizedNames, $columns);
}

            

                protected function prepareBatchInsertValues(string $table, iterable $rows, array $columnNames, array &$params): array
{
    $values = [];
    $names = array_values($columnNames);
    $keys = array_fill_keys($names, false);
    $columns = $this->typecasting ? $this->schema->getTableSchema($table)?->getColumns() ?? [] : [];
    $queryBuilder = $this->queryBuilder;
    foreach ($rows as $row) {
        $i = 0;
        $placeholders = $keys;
        /** @var int|string $key */
        foreach ($row as $key => $value) {
            $columnName = $columnNames[$key] ?? (isset($keys[$key]) ? $key : $names[$i] ?? $i);
            if (isset($columns[$columnName])) {
                $value = $columns[$columnName]->dbTypecast($value);
            }
            $placeholders[$columnName] = $queryBuilder->buildValue($value, $params);
            ++$i;
        }
        $values[] = implode(', ', $placeholders);
    }
    return $values;
}

            

                protected function prepareInsertValues(string $table, array|QueryInterface $columns, array $params = []): array
{
    if (empty($columns)) {
        return [[], [], 'DEFAULT VALUES', []];
    }
    if ($columns instanceof QueryInterface) {
        $names = $this->getQueryColumnNames($columns, $params);
        [$values, $params] = $this->queryBuilder->build($columns, $params);
        return [$names, [], $values, $params];
    }
    $placeholders = [];
    $columns = $this->normalizeColumnNames($columns);
    $tableColumns = $this->typecasting ? $this->schema->getTableSchema($table)?->getColumns() ?? [] : [];
    foreach ($columns as $name => $value) {
        if (isset($tableColumns[$name])) {
            $value = $tableColumns[$name]->dbTypecast($value);
        }
        $placeholders[] = $this->queryBuilder->buildValue($value, $params);
    }
    return [array_keys($columns), $placeholders, '', $params];
}

            

                final protected function prepareTraversable(Traversable $rows): Iterator|array
{
    while ($rows instanceof IteratorAggregate) {
        $rows = $rows->getIterator();
    }
    /** @var Iterator $rows */
    if (!$rows->valid()) {
        return [];
    }
    return $rows;
}

            

                protected function prepareUpdateSets(
    string $table,
    array $columns,
    array &$params,
    bool $forUpsert = false,
    bool $useTableName = false,
): array {
    $sets = [];
    $columns = $this->normalizeColumnNames($columns);
    $tableColumns = $this->schema->getTableSchema($table)?->getColumns() ?? [];
    $typecastColumns = $this->typecasting ? $tableColumns : [];
    $queryBuilder = $this->queryBuilder;
    $quoter = $this->quoter;
    if ($useTableName) {
        $quotedTableName = $quoter->quoteTableName($table);
        $columnPrefix = "$quotedTableName.";
    } else {
        $columnPrefix = '';
    }
    foreach ($columns as $name => $value) {
        if (isset($typecastColumns[$name])) {
            $value = $typecastColumns[$name]->dbTypecast($value);
        }
        $quotedName = $quoter->quoteSimpleColumnName($name);
        if ($forUpsert && $value instanceof MultiOperandFunction && empty($value->getOperands())) {
            $quotedTableName ??= $quoter->quoteTableName($table);
            $value->add(new Expression("$quotedTableName.$quotedName"))
                ->add(new Expression("EXCLUDED.$quotedName"));
            if (isset($tableColumns[$name]) && $value instanceof ArrayMerge) {
                $value->type($tableColumns[$name]);
            }
            $builtValue = $queryBuilder->buildExpression($value, $params);
        } else {
            $builtValue = $queryBuilder->buildValue($value, $params);
        }
        $sets[] = "$columnPrefix$quotedName=$builtValue";
    }
    return $sets;
}

            

                protected function prepareUpsertColumns(
    string $table,
    array|QueryInterface $insertColumns,
    array|bool $updateColumns,
    array &$constraints = [],
): array {
    if ($insertColumns instanceof QueryInterface) {
        $insertNames = $this->getQueryColumnNames($insertColumns);
    } else {
        $insertNames = $this->getNormalizedColumnNames(array_keys($insertColumns));
    }
    $uniqueNames = $this->getTableUniqueColumnNames($table, $insertNames, $constraints);
    if ($updateColumns === true) {
        return [$uniqueNames, $insertNames, array_diff($insertNames, $uniqueNames)];
    }
    return [$uniqueNames, $insertNames, null];
}

            

                protected function prepareUpsertSets(
    string $table,
    array|bool $updateColumns,
    ?array $updateNames,
    array &$params,
): array {
    if ($updateColumns === true) {
        $quoter = $this->quoter;
        $sets = [];
        /** @var string[] $updateNames */
        foreach ($updateNames as $name) {
            $quotedName = $quoter->quoteSimpleColumnName($name);
            $sets[] = "$quotedName=EXCLUDED.$quotedName";
        }
        return $sets;
    }
    return $this->prepareUpdateSets($table, $updateColumns, $params, true);
}

            

                public function resetSequence(string $table, int|string|null $value = null): string
{
    throw new NotSupportedException(__METHOD__ . '() is not supported by this DBMS.');
}

            

                public function update(
    string $table,
    array $columns,
    array|ExpressionInterface|string $condition,
    array|ExpressionInterface|string|null $from = null,
    array &$params = [],
): string {
    $updates = $this->prepareUpdateSets($table, $columns, $params);
    $sql = 'UPDATE ' . $this->quoter->quoteTableName($table) . ' SET ' . implode(', ', $updates);
    $where = $this->queryBuilder->buildWhere($condition, $params);
    if ($from !== null) {
        $from = DbArrayHelper::normalizeExpressions($from);
        $fromClause = $this->queryBuilder->buildFrom($from, $params);
        $sql .=  $fromClause === '' ? '' : ' ' . $fromClause;
    }
    return $where === '' ? $sql : $sql . ' ' . $where;
}

            

                public function upsert(
    string $table,
    array|QueryInterface $insertColumns,
    array|bool $updateColumns = true,
    array &$params = [],
): string {
    throw new NotSupportedException(__METHOD__ . ' is not supported by this DBMS.');
}

            

                public function upsertReturning(
    string $table,
    array|QueryInterface $insertColumns,
    array|bool $updateColumns = true,
    ?array $returnColumns = null,
    array &$params = [],
): string {
    throw new NotSupportedException(__METHOD__ . '() is not supported by this DBMS.');
}

            

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