QueryBuilder.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
namespace ‪TYPO3\CMS\Core\Database\Query;
 
use Doctrine\DBAL\ArrayParameterType;
use Doctrine\DBAL\Driver\Statement as DriverStatement;
use Doctrine\DBAL\ParameterType;
use Doctrine\DBAL\Platforms\MariaDBPlatform as DoctrineMariaDBPlatform;
use Doctrine\DBAL\Platforms\MySQLPlatform as DoctrineMySQLPlatform;
use Doctrine\DBAL\Platforms\PostgreSQLPlatform as DoctrinePostgreSQLPlatform;
use Doctrine\DBAL\Platforms\SQLitePlatform as DoctrineSQLitePlatform;
use Doctrine\DBAL\Query\Expression\CompositeExpression;
use Doctrine\DBAL\Query\From;
use Doctrine\DBAL\Query\Join;
use Doctrine\DBAL\Query\QueryType;
use Doctrine\DBAL\Result;
use Doctrine\DBAL\Statement;
use Doctrine\DBAL\Types\StringType;
use Doctrine\DBAL\Types\Type;
use ‪TYPO3\CMS\Core\Database\Connection;
use ‪TYPO3\CMS\Core\Database\Platform\PlatformHelper;
use ‪TYPO3\CMS\Core\Database\Query\Expression\ExpressionBuilder;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\DefaultRestrictionContainer;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\LimitToTablesRestrictionContainer;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\QueryRestrictionContainerInterface;
use ‪TYPO3\CMS\Core\Database\Query\Restriction\QueryRestrictionInterface;
use ‪TYPO3\CMS\Core\Database\RelationHandler;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
use ‪TYPO3\CMS\Extbase\Persistence\Generic\Storage\Typo3DbBackend;
use ‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\Generic\Storage\Typo3DbQueryParserTest;
 
class QueryBuilder extends ConcreteQueryBuilder
{
    protected ConcreteQueryBuilder $concreteQueryBuilder;
 
    protected QueryRestrictionContainerInterface $restrictionContainer;
 
    protected array $additionalRestrictions;
 
    private array $restrictionsAppliedInJoinCondition = [];
 
    public function __construct(
        Connection $connection,
        QueryRestrictionContainerInterface $restrictionContainer = null,
        ConcreteQueryBuilder $concreteQueryBuilder = null,
        array $additionalRestrictions = null
    ) {
        parent::__construct($connection);
        $this->additionalRestrictions = $additionalRestrictions ?: ‪$GLOBALS['TYPO3_CONF_VARS']['DB']['additionalQueryRestrictions'] ?? [];
        $this->setRestrictions($restrictionContainer ?: GeneralUtility::makeInstance(DefaultRestrictionContainer::class));
        $this->concreteQueryBuilder = $concreteQueryBuilder ?: GeneralUtility::makeInstance(ConcreteQueryBuilder::class, $connection);
    }
 
    public function __clone()
    {
        $this->concreteQueryBuilder = clone $this->concreteQueryBuilder;
        $this->restrictionContainer = clone $this->restrictionContainer;
    }
 
    public function __toString(): string
    {
        return $this->getSQL();
    }
 
    public function getRestrictions(): QueryRestrictionContainerInterface
    {
        return $this->restrictionContainer;
    }
 
    public function setRestrictions(QueryRestrictionContainerInterface $restrictionContainer): void
    {
        foreach ($this->additionalRestrictions as $restrictionClass => $options) {
            if (empty($options['disabled'])) {
                $restriction = GeneralUtility::makeInstance($restrictionClass);
                $restrictionContainer->add($restriction);
            }
        }
        $this->restrictionContainer = $restrictionContainer;
    }
 
    public function limitRestrictionsToTables(array $tableAliases): void
    {
        $this->restrictionContainer = GeneralUtility::makeInstance(LimitToTablesRestrictionContainer::class)->addForTables($this->restrictionContainer, $tableAliases);
    }
 
    public function resetRestrictions(): void
    {
        $this->setRestrictions(GeneralUtility::makeInstance(DefaultRestrictionContainer::class));
    }
 
    public function expr(): ExpressionBuilder
    {
        return $this->connection->getExpressionBuilder();
    }
 
    public function getConnection(): Connection
    {
        return $this->connection;
    }
 
    public function getConcreteQueryBuilder(): \Doctrine\DBAL\Query\QueryBuilder
    {
        return $this->concreteQueryBuilder;
    }
 
    public function prepare(): Statement
    {
        $connection = $this->getConnection();
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $originalWhereConditions = null;
        try {
            if ($concreteQueryBuilder->type === QueryType::SELECT) {
                $originalWhereConditions = $this->addAdditionalWhereConditions();
            }
            $sql = $concreteQueryBuilder->getSQL();
            $params = $concreteQueryBuilder->getParameters();
            $types = $concreteQueryBuilder->getParameterTypes();
            $this->throwExceptionOnInvalidPreparedStatementParamArrayType($types);
            $this->throwExceptionOnNamedParameterForPreparedStatement($params);
            $statement = $connection->prepare($sql)->getWrappedStatement();
            $this->bindTypedValues($statement, $params, $types);
        } finally {
            if ($concreteQueryBuilder->type === QueryType::SELECT) {
                $concreteQueryBuilder->resetWhere();
                if ($originalWhereConditions !== null) {
                    $concreteQueryBuilder->where($originalWhereConditions);
                }
            }
        }
        return new Statement($connection, $statement, $sql);
    }
 
    public function executeQuery(): Result
    {
        // Set additional query restrictions
        $originalWhereConditions = $this->addAdditionalWhereConditions();
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        try {
            return $concreteQueryBuilder->executeQuery();
        } finally {
            $concreteQueryBuilder->resetWhere();
            if ($originalWhereConditions !== null) {
                $concreteQueryBuilder->where($originalWhereConditions);
            }
        }
    }
 
    public function executeStatement(): int
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        return $concreteQueryBuilder->executeStatement();
    }
 
    public function getSQL(): string
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        if ($concreteQueryBuilder->type !== QueryType::SELECT) {
            return $concreteQueryBuilder->getSQL();
        }
        // Set additional query restrictions
        $originalWhereConditions =  $this->addAdditionalWhereConditions();
        try {
            $sql = $concreteQueryBuilder->getSQL();
        } finally {
            $concreteQueryBuilder->resetWhere();
            if ($originalWhereConditions !== null) {
                $concreteQueryBuilder->where($originalWhereConditions);
            }
        }
        return $sql;
    }
 
    public function setParameter(
        int|string $key,
        mixed $value,
        string|ParameterType|Type|ArrayParameterType $type = ParameterType::STRING,
    ): QueryBuilder {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->setParameter($key, $value, $type);
        return $this;
    }
 
    public function setParameters(array $params, array $types = []): QueryBuilder
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->setParameters($params, $types);
        return $this;
    }
 
    public function getParameters(): array
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        return $concreteQueryBuilder->getParameters();
    }
 
    public function getParameter(string|int $key): mixed
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        return $concreteQueryBuilder->getParameter($key);
    }
 
    public function getParameterTypes(): array
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        return $concreteQueryBuilder->getParameterTypes();
    }
 
    public function getParameterType(string|int $key): string|ParameterType|Type|ArrayParameterType
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        return $concreteQueryBuilder->getParameterType($key);
    }
 
    public function setFirstResult(int $firstResult): QueryBuilder
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->setFirstResult($firstResult);
        return $this;
    }
 
    public function getFirstResult(): int
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        return $concreteQueryBuilder->getFirstResult();
    }
 
    public function setMaxResults(int|null $maxResults = null): QueryBuilder
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->setMaxResults($maxResults);
        return $this;
    }
 
    public function getMaxResults(): int|null
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        return $concreteQueryBuilder->getMaxResults();
    }
 
    public function count(string $item): QueryBuilder
    {
        $countExpr = $this->getCountExpression(
            $item === '*' ? $item : $this->quoteIdentifier($item)
        );
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->select($countExpr);
 
        return $this;
    }
 
    protected function getCountExpression(string $column): string
    {
        return 'COUNT(' . $column . ')';
    }
 
    public function select(string ...$selects): QueryBuilder
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->select(...$this->quoteIdentifiersForSelect($selects));
        return $this;
    }
 
    public function distinct(bool $distinct = true): QueryBuilder
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->distinct($distinct);
        return $this;
    }
 
    public function addSelect(string ...$selects): QueryBuilder
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->addSelect(...$this->quoteIdentifiersForSelect($selects));
        return $this;
    }
 
    public function selectLiteral(string ...$selects): QueryBuilder
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->select(...$selects);
        return $this;
    }
 
    public function addSelectLiteral(string ...$selects): QueryBuilder
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->addSelect(...$selects);
        return $this;
    }
 
    public function delete(string $table): QueryBuilder
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->delete($this->quoteIdentifier($table));
        return $this;
    }
 
    public function update(string $table): QueryBuilder
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->update($this->quoteIdentifier($table));
        return $this;
    }
 
    public function insert(string $table): QueryBuilder
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->insert($this->quoteIdentifier($table));
        return $this;
    }
 
    public function from(string $table, string $alias = null): QueryBuilder
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->from(
            $this->quoteIdentifier($table),
            empty($alias) ? $alias : $this->quoteIdentifier($alias)
        );
        return $this;
    }
 
    public function join(string $fromAlias, string $join, string $alias, string $condition = null): QueryBuilder
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->innerJoin(
            $this->quoteIdentifier($fromAlias),
            $this->quoteIdentifier($join),
            $this->quoteIdentifier($alias),
            $condition
        );
        return $this;
    }
 
    public function innerJoin(string $fromAlias, string $join, string $alias, string $condition = null): QueryBuilder
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->innerJoin(
            $this->quoteIdentifier($fromAlias),
            $this->quoteIdentifier($join),
            $this->quoteIdentifier($alias),
            $condition
        );
        return $this;
    }
 
    public function leftJoin(string $fromAlias, string $join, string $alias, CompositeExpression|string $condition = null): QueryBuilder
    {
        $conditionExpression = (string)$this->expr()->and(
            $condition,
            $this->restrictionContainer->buildExpression([$alias ?? $join => $join], $this->expr())
        );
        $this->restrictionsAppliedInJoinCondition[] = $alias ?? $join;
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->leftJoin(
            $this->quoteIdentifier($fromAlias),
            $this->quoteIdentifier($join),
            $this->quoteIdentifier($alias),
            $conditionExpression
        );
        return $this;
    }
 
    public function rightJoin(string $fromAlias, string $join, string $alias, string $condition = null): QueryBuilder
    {
        $fromTable = $fromAlias;
        // find the table belonging to the $fromAlias, if it's an alias at all
        foreach ($this->concreteQueryBuilder->from as $from) {
            if (is_string($from->alias) && $from->alias !== '' && $this->unquoteSingleIdentifier($from->alias) === $fromAlias) {
                $fromTable = $this->unquoteSingleIdentifier($from->alias);
                break;
            }
        }
        $conditionExpression = (string)$this->expr()->and(
            $condition,
            $this->restrictionContainer->buildExpression([$fromAlias => $fromTable], $this->expr())
        );
        $this->restrictionsAppliedInJoinCondition[] = $fromAlias;
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->rightJoin(
            $this->quoteIdentifier($fromAlias),
            $this->quoteIdentifier($join),
            $this->quoteIdentifier($alias),
            $conditionExpression
        );
        return $this;
    }
 
    public function set(string $key, $value, bool $createNamedParameter = true, ParameterType|ArrayParameterType $type = ‪Connection::PARAM_STR): QueryBuilder
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->set(
            $this->quoteIdentifier($key),
            $createNamedParameter ? $this->createNamedParameter($value, $type) : $value
        );
        return $this;
    }
 
    public function where(...$predicates): QueryBuilder
    {
        // Doctrine DBAL 3.x requires a non-empty $predicate, however TYPO3 uses static values
        // such as PageRepository->$where_hid_del which could be empty
        $predicates = array_filter($predicates, static fn(CompositeExpression|string|null $value): bool => !self::isEmptyPart($value));
        if (empty($predicates)) {
            $this->resetWhere();
            return $this;
        }
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->where(...$predicates);
        return $this;
    }
 
    public function andWhere(...$predicates): QueryBuilder
    {
        // Doctrine DBAL 3.x requires a non-empty $predicate, however TYPO3 uses static values
        // such as PageRepository->$where_hid_del which could be empty
        $predicates = array_filter($predicates, static fn(CompositeExpression|string|null $value): bool => !self::isEmptyPart($value));
        if (empty($predicates)) {
            return $this;
        }
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->andWhere(...$predicates);
        return $this;
    }
 
    public function orWhere(...$predicates): QueryBuilder
    {
        // Doctrine DBAL 3.x requires a non-empty $predicate, however TYPO3 uses static values
        // such as PageRepository->$where_hid_del which could be empty
        $predicates = array_filter($predicates, static fn(CompositeExpression|string|null $value): bool => !self::isEmptyPart($value));
        if (empty($predicates)) {
            return $this;
        }
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->orWhere(...$predicates);
        return $this;
    }
 
    public function groupBy(...$groupBy): QueryBuilder
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->groupBy(...$this->quoteIdentifiers($groupBy));
        return $this;
    }
 
    public function addGroupBy(...$groupBy): QueryBuilder
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->addGroupBy(...$this->quoteIdentifiers($groupBy));
        return $this;
    }
 
    public function setValue(string $column, $value, bool $createNamedParameter = true): QueryBuilder
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->setValue(
            $this->quoteIdentifier($column),
            $createNamedParameter ? $this->createNamedParameter($value) : $value
        );
        return $this;
    }
 
    public function values(array $values, bool $createNamedParameters = true): QueryBuilder
    {
        if ($createNamedParameters === true) {
            foreach ($values as &$value) {
                $value = $this->createNamedParameter($value);
            }
        }
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->values($this->quoteColumnValuePairs($values));
        return $this;
    }
 
    public function having(...$predicates): QueryBuilder
    {
        $predicates = array_filter($predicates, static fn(CompositeExpression|string|null $value): bool => !self::isEmptyPart($value));
        if (empty($predicates)) {
            $this->resetHaving();
            return $this;
        }
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->having(...$predicates);
        return $this;
    }
 
    public function andHaving(...$predicates): QueryBuilder
    {
        $predicates = array_filter($predicates, static fn(CompositeExpression|string|null $value): bool => !self::isEmptyPart($value));
        if (empty($predicates)) {
            return $this;
        }
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->andHaving(...$predicates);
        return $this;
    }
 
    public function orHaving(...$predicates): QueryBuilder
    {
        $predicates = array_filter($predicates, static fn(CompositeExpression|string|null $value): bool => !self::isEmptyPart($value));
        if (empty($predicates)) {
            return $this;
        }
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->orHaving(...$predicates);
        return $this;
    }
 
    public function orderBy(string $fieldName, string $order = null): QueryBuilder
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->orderBy($this->connection->quoteIdentifier($fieldName), $order);
        return $this;
    }
 
    public function addOrderBy(string $fieldName, string $order = null): QueryBuilder
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->addOrderBy($this->connection->quoteIdentifier($fieldName), $order);
        return $this;
    }
 
    public function resetWhere(): self
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->resetWhere();
        return $this;
    }
 
    public function resetGroupBy(): self
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->resetGroupBy();
        return $this;
    }
 
    public function resetHaving(): self
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->resetHaving();
        return $this;
    }
 
    public function resetOrderBy(): self
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        $concreteQueryBuilder->resetOrderBy();
        return $this;
    }
 
    public function createNamedParameter(
        mixed $value,
        string|ParameterType|Type|ArrayParameterType $type = ParameterType::STRING,
        string $placeHolder = null
    ): string {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        return $concreteQueryBuilder->createNamedParameter($value, $type, $placeHolder);
    }
 
    public function createPositionalParameter(
        mixed $value,
        string|ParameterType|Type|ArrayParameterType $type = ParameterType::STRING,
    ): string {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        return $concreteQueryBuilder->createPositionalParameter($value, $type);
    }
 
    public function escapeLikeWildcards(string $value): string
    {
        return $this->connection->escapeLikeWildcards($value);
    }
 
    public function quote(string $input): string
    {
        return $this->getConnection()->quote($input);
    }
 
    public function quoteIdentifier(string ‪$identifier): string
    {
        return $this->getConnection()->quoteIdentifier(‪$identifier);
    }
 
    public function quoteIdentifiers(array $input): array
    {
        return $this->getConnection()->quoteIdentifiers($input);
    }
 
    public function quoteIdentifiersForSelect(array $input): array
    {
        foreach ($input as &$select) {
            [$fieldName, $alias, $suffix] = array_pad(
                ‪GeneralUtility::trimExplode(
                    ' AS ',
                    str_ireplace(' as ', ' AS ', $select),
                    true,
                    3
                ),
                3,
                null
            );
            if (!empty($suffix)) {
                throw new \InvalidArgumentException(
                    'QueryBuilder::quoteIdentifiersForSelect() could not parse the select ' . $select . '.',
                    1461170686
                );
            }
 
            // The SQL * operator must not be quoted. As it can only occur either by itself
            // or preceded by a tablename (tablename.*) check if the last character of a select
            // expression is the * and quote only prepended table name. In all other cases the
            // full expression is being quoted.
            if (substr($fieldName, -2) === '.*') {
                $select = $this->quoteIdentifier(substr($fieldName, 0, -2)) . '.*';
            } elseif ($fieldName !== '*') {
                $select = $this->quoteIdentifier($fieldName);
            }
 
            // Quote the alias for the current fieldName, if given
            if (!empty($alias)) {
                $select .= ' AS ' . $this->quoteIdentifier($alias);
            }
        }
        return $input;
    }
 
    public function quoteColumnValuePairs(array $input): array
    {
        return $this->getConnection()->quoteColumnValuePairs($input);
    }
 
    public function quoteArrayBasedValueListToIntegerList(array $values): string
    {
        if (empty($values)) {
            return 'NULL';
        }
        // Ensure values are all integer
        $values = ‪GeneralUtility::intExplode(',', implode(',', $values));
        // Ensure all values are quoted as int for used dbms
        $connection = $this;
        array_walk($values, static function (mixed &$value) use ($connection): void {
            $value = $connection->quote((string)$value);
        });
        return implode(',', $values);
    }
 
    public function quoteArrayBasedValueListToStringList(array $values): string
    {
        if (empty($values)) {
            return 'NULL';
        }
        // Ensure values are all strings
        $values = ‪GeneralUtility::trimExplode(',', implode(',', $values));
        // Ensure all values are quoted as string values for used dbmns
        $connection = $this;
        array_walk($values, static function (mixed &$value) use ($connection): void {
            $value = $connection->quote((string)$value);
        });
        return implode(',', $values);
    }
 
    public function castFieldToTextType(string $fieldName): string
    {
        $databasePlatform = $this->connection->getDatabasePlatform();
        // https://dev.mysql.com/doc/refman/5.7/en/cast-functions.html#function_convert
        if ($databasePlatform instanceof DoctrineMariaDBPlatform || $databasePlatform instanceof DoctrineMySQLPlatform) {
            return sprintf('CONVERT(%s, CHAR)', $this->connection->quoteIdentifier($fieldName));
        }
        // https://www.postgresql.org/docs/current/sql-createcast.html
        if ($databasePlatform instanceof DoctrinePostgreSQLPlatform) {
            return sprintf('%s::text', $this->connection->quoteIdentifier($fieldName));
        }
        // https://www.sqlite.org/lang_expr.html#castexpr
        if ($databasePlatform instanceof DoctrineSQLitePlatform) {
            return sprintf('CAST(%s as TEXT)', $this->connection->quoteIdentifier($fieldName));
        }
        throw new \RuntimeException(
            sprintf(
                '%s is not implemented for the used database platform "%s", yet!',
                __METHOD__,
                get_class($this->connection->getDatabasePlatform())
            ),
            1584637096
        );
    }
 
    protected function unquoteSingleIdentifier(string ‪$identifier): string
    {
        ‪$identifier = trim(‪$identifier);
        $quoteChar = GeneralUtility::makeInstance(PlatformHelper::class)
            ->getIdentifierQuoteCharacter($this->getConnection()->getDatabasePlatform());
        ‪$identifier = trim(‪$identifier, $quoteChar);
        ‪$identifier = str_replace($quoteChar . $quoteChar, $quoteChar, ‪$identifier);
        return ‪$identifier;
    }
 
    protected function getIdentifierQuoteCharacter(): string
    {
        return substr($this->connection->getDatabasePlatform()->quoteSingleIdentifier('fake'), 0, 1);
    }
 
    public function getSelect(): array
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        return $concreteQueryBuilder->select;
    }
 
    public function getFrom()
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        return $concreteQueryBuilder->from;
    }
 
    public function getWhere(): CompositeExpression|string|null
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        return $concreteQueryBuilder->where;
    }
 
    public function getHaving(): CompositeExpression|string|null
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        return $concreteQueryBuilder->having;
    }
 
    public function getOrderBy(): array
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        return $concreteQueryBuilder->orderBy;
    }
 
    public function getGroupBy(): array
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        return $concreteQueryBuilder->groupBy;
    }
 
    public function getJoin(): array
    {
        $concreteQueryBuilder = $this->concreteQueryBuilder;
        return $concreteQueryBuilder->join;
    }
 
    protected function getQueriedTables(): array
    {
        $queriedTables = [];
        // Loop through all FROM tables
        foreach ($this->concreteQueryBuilder->from as $from) {
            $tableName = $this->unquoteSingleIdentifier($from->table);
            $tableAlias = is_string($from->alias) && $from->alias !== '' ? $this->unquoteSingleIdentifier($from->alias) : $tableName;
            if (!in_array($tableAlias, $this->restrictionsAppliedInJoinCondition, true)) {
                $queriedTables[$tableAlias] = $tableName;
            }
        }
 
        // Loop through all JOIN tables
        foreach ($this->concreteQueryBuilder->join as $fromTable => $joins) {
            foreach ($joins as $join) {
                $tableName = $this->unquoteSingleIdentifier($join->table);
                $tableAlias = is_string($join->alias) && $join->alias !== '' ? $this->unquoteSingleIdentifier($join->alias) : $tableName;
                if (!in_array($tableAlias, $this->restrictionsAppliedInJoinCondition, true)) {
                    $queriedTables[$tableAlias] = $tableName;
                }
            }
        }
        return $queriedTables;
    }
 
    protected function addAdditionalWhereConditions(): CompositeExpression|string|null
    {
        $originalWhereConditions = $this->getWhere();
        $expression = $this->restrictionContainer->buildExpression($this->getQueriedTables(), $this->expr());
        // This check would be obsolete, as the composite expression would not add empty expressions anyway
        // But we keep it here to only clone the previous state, in case we really will change it.
        // Once we remove this state preserving functionality, we can remove the count check here
        // and just add the expression to the query builder.
        if ($expression->count() > 0) {
            $this->concreteQueryBuilder->andWhere($expression);
        }
        return $originalWhereConditions;
    }
 
    private function throwExceptionOnInvalidPreparedStatementParamArrayType(array $types): void
    {
        foreach ($types as $type) {
            $invalidTypeLabel = match ($type) {
                ‪Connection::PARAM_INT_ARRAY => 'PARAM_INT_ARRAY',
                ‪Connection::PARAM_STR_ARRAY => 'PARAM_STR_ARRAY',
                default => false,
            };
            if ($invalidTypeLabel !== false) {
                throw ‪UnsupportedPreparedStatementParameterTypeException::new($invalidTypeLabel);
            }
        }
    }
 
    private function throwExceptionOnNamedParameterForPreparedStatement(array $params): void
    {
        foreach ($params as $key => $value) {
            if (is_string($key) && !‪MathUtility::canBeInterpretedAsInteger($key)) {
                throw ‪NamedParameterNotSupportedForPreparedStatementException::new($key);
            }
        }
    }
 
    private function bindTypedValues(DriverStatement $stmt, array $params, array $types): void
    {
        // Check whether parameters are positional or named. Mixing is not allowed.
        $stringType = new StringType();
        if (is_int(key($params))) {
            $bindIndex = 1;
 
            foreach ($params as $key => $value) {
                $type = (isset($types[$key])) ? $types[$key] : $stringType;
                [$value, $bindingType] = $this->getBindingInfo($value, $type);
                $stmt->bindValue($bindIndex, $value, $bindingType);
 
                ++$bindIndex;
            }
        } else {
            // Named parameters
            foreach ($params as $name => $value) {
                $type = (isset($types[$name])) ? $types[$name] : $stringType;
                [$value, $bindingType] = $this->getBindingInfo($value, $type);
                $stmt->bindValue($name, $value, $bindingType);
            }
        }
    }
 
    private function getBindingInfo(mixed $value, string|ParameterType|Type $type): array
    {
        if (is_string($type)) {
            $type = Type::getType($type);
        }
        if ($type instanceof Type) {
            $value       = $type->convertToDatabaseValue($value, $this->connection->getDatabasePlatform());
            $bindingType = $type->getBindingType();
        } else {
            $bindingType = $type;
        }
        return [$value, $bindingType];
    }
}