ConcreteQueryBuilder.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\Query\Expression\CompositeExpression;
use Doctrine\DBAL\Query\From;
use Doctrine\DBAL\Query\Join;
use Doctrine\DBAL\Query\QueryBuilder as DoctrineQueryBuilder;
use Doctrine\DBAL\Query\QueryType;
use ‪TYPO3\CMS\Core\Database\Connection;
 
class ‪ConcreteQueryBuilder extends DoctrineQueryBuilder
{
    protected QueryType ‪$type = QueryType::SELECT;
 
    protected array ‪$select = [];
 
    protected bool ‪$distinct = false;
 
    protected array ‪$from = [];
 
    protected array ‪$join = [];
 
    protected string|CompositeExpression|null ‪$where = null;
 
    protected array ‪$groupBy = [];
 
    protected string|CompositeExpression|null ‪$having = null;
 
    protected array ‪$orderBy = [];
 
    public function ‪__construct(protected readonly ‪Connection $connection)
    {
        parent::__construct($this->connection);
    }
 
    public function ‪__clone()
    {
        parent::__clone();
        foreach ($this->‪from as $key => ‪$from) {
            $this->‪from[$key] = clone ‪$from;
        }
        foreach ($this->join as $fromAlias => $joins) {
            foreach ($joins as $key => ‪$join) {
                $this->join[$fromAlias][$key] = clone ‪$join;
            }
        }
        if (is_object($this->‪where)) {
            $this->‪where = clone ‪$this->where;
        }
        if (is_object($this->‪having)) {
            $this->‪having = clone ‪$this->having;
        }
    }
 
    public function ‪select(string ...$expressions): self
    {
        parent::select(...$expressions);
        $this->type = QueryType::SELECT;
        if (count($expressions) < 1) {
            return $this;
        }
        $this->‪select = $expressions;
        return $this;
    }
 
    public function ‪distinct(bool ‪$distinct = true): self
    {
        parent::distinct(‪$distinct);
        $this->‪distinct = ‪$distinct;
        return $this;
    }
 
    public function ‪addSelect(string $expression, string ...$expressions): self
    {
        parent::addSelect($expression, ...$expressions);
        $this->type = QueryType::SELECT;
        $this->‪select = array_merge($this->‪select, [$expression], $expressions);
        return $this;
    }
 
    public function delete(string $table): self
    {
        parent::delete($table);
        $this->type = QueryType::DELETE;
        return $this;
    }
 
    public function ‪update(string $table): self
    {
        parent::update($table);
        $this->type = QueryType::UPDATE;
        return $this;
    }
 
    public function ‪insert(string $table): self
    {
        parent::insert($table);
        $this->type = QueryType::INSERT;
        return $this;
    }
 
    public function ‪from(string $table, ?string $alias = null): self
    {
        parent::from($table, $alias);
        $this->‪from[] = new From($table, $alias);
        return $this;
    }
 
    public function ‪innerJoin(string $fromAlias, string ‪$join, string $alias, ?string $condition = null): self
    {
        parent::innerJoin($fromAlias, ‪$join, $alias, $condition);
        $this->join[$fromAlias][] = Join::inner(‪$join, $alias, $condition);
        return $this;
    }
 
    public function ‪leftJoin(string $fromAlias, string ‪$join, string $alias, ?string $condition = null): self
    {
        parent::leftJoin($fromAlias, ‪$join, $alias, $condition);
        $this->join[$fromAlias][] = Join::left(‪$join, $alias, $condition);
        return $this;
    }
 
    public function ‪rightJoin(string $fromAlias, string ‪$join, string $alias, ?string $condition = null): self
    {
        parent::rightJoin($fromAlias, ‪$join, $alias, $condition);
        $this->join[$fromAlias][] = Join::right(‪$join, $alias, $condition);
        return $this;
    }
 
    public function ‪where(string|CompositeExpression $predicate, string|CompositeExpression ...$predicates): self
    {
        ‪$where = $this->‪where = $this->‪createPredicate($predicate, ...$predicates);
        parent::where(‪$where);
        return $this;
    }
 
    public function ‪andWhere(string|CompositeExpression $predicate, string|CompositeExpression ...$predicates): self
    {
        ‪$where = $this->‪where = $this->‪appendToPredicate(
            $this->‪where,
            CompositeExpression::TYPE_AND,
            $predicate,
            ...$predicates,
        );
        $this->‪where(‪$where);
        return $this;
    }
 
    public function ‪orWhere(string|CompositeExpression $predicate, string|CompositeExpression ...$predicates): self
    {
        ‪$where = $this->‪where = $this->‪appendToPredicate($this->‪where, CompositeExpression::TYPE_OR, $predicate, ...$predicates);
        $this->‪where(‪$where);
        return $this;
    }
 
    public function ‪groupBy(string $expression, string ...$expressions): self
    {
        ‪$groupBy = $this->‪groupBy = array_merge([$expression], $expressions);
        parent::groupBy(...‪$groupBy);
        return $this;
    }
 
    public function ‪addGroupBy(string $expression, string ...$expressions): self
    {
        ‪$groupBy = $this->‪groupBy = array_merge($this->‪groupBy, [$expression], $expressions);
        $this->‪groupBy(...$groupBy);
        return $this;
    }
 
    public function ‪having(string|CompositeExpression $predicate, string|CompositeExpression ...$predicates): self
    {
        ‪$having = $this->‪having = $this->‪createPredicate($predicate, ...$predicates);
        parent::having(‪$having);
        return $this;
    }
 
    public function ‪andHaving(string|CompositeExpression $predicate, string|CompositeExpression ...$predicates): self
    {
        ‪$having = $this->‪having = $this->‪appendToPredicate(
            $this->‪having,
            CompositeExpression::TYPE_AND,
            $predicate,
            ...$predicates,
        );
        $this->‪having(‪$having);
        return $this;
    }
 
    public function ‪orHaving(string|CompositeExpression $predicate, string|CompositeExpression ...$predicates): self
    {
        ‪$having = $this->‪having = $this->‪appendToPredicate(
            $this->‪having,
            CompositeExpression::TYPE_OR,
            $predicate,
            ...$predicates,
        );
        $this->‪having(‪$having);
        return $this;
    }
 
    private function ‪createPredicate(
        string|CompositeExpression $predicate,
        string|CompositeExpression ...$predicates,
    ): string|CompositeExpression {
        if (count($predicates) === 0) {
            return $predicate;
        }
        $predicates = array_filter($predicates, static fn(CompositeExpression|string|null $value): bool => !self::isEmptyPart($value));
        return new CompositeExpression(CompositeExpression::TYPE_AND, $predicate, ...$predicates);
    }
 
    private function ‪appendToPredicate(
        string|CompositeExpression|null $currentPredicate,
        string ‪$type,
        string|CompositeExpression ...$predicates,
    ): string|CompositeExpression {
        $predicates = array_filter($predicates, static fn(CompositeExpression|string|null $value): bool => !self::isEmptyPart($value));
        if ($currentPredicate instanceof CompositeExpression && $currentPredicate->getType() === ‪$type) {
            return $currentPredicate->with(...$predicates);
        }
        if ($currentPredicate !== null) {
            array_unshift($predicates, $currentPredicate);
        } elseif (count($predicates) === 1) {
            return $predicates[0];
        }
        return new CompositeExpression(‪$type, ...$predicates);
    }
 
    public function ‪orderBy(string $sort, ?string $order = null): self
    {
        parent::orderBy($sort, $order);
        ‪$orderBy = $sort;
        if ($order !== null) {
            ‪$orderBy .= ' ' . $order;
        }
        $this->‪orderBy = [‪$orderBy];
        return $this;
    }
 
    public function ‪addOrderBy(string $sort, ?string $order = null): self
    {
        parent::addOrderBy($sort, $order);
        ‪$orderBy = $sort;
        if ($order !== null) {
            ‪$orderBy .= ' ' . $order;
        }
        $this->‪orderBy[] = ‪$orderBy;
        return $this;
    }
 
    public function ‪resetWhere(): self
    {
        parent::resetWhere();
        $this->‪where = null;
        return $this;
    }
 
    public function ‪resetGroupBy(): self
    {
        parent::resetGroupBy();
        $this->‪groupBy = [];
        return $this;
    }
 
    public function ‪resetHaving(): self
    {
        $this->‪resetHaving();
        $this->‪having = null;
        return $this;
    }
 
    public function ‪resetOrderBy(): self
    {
        parent::resetOrderBy();
        $this->‪orderBy = [];
        return $this;
    }
 
    //##################################################################################################################
    // Below are added methods not originated from Doctrine DBAL QueryBuilder
    //##################################################################################################################
 
    protected static function ‪isEmptyPart(CompositeExpression|string|null $value): bool
    {
        return $value === null
            || ($value instanceof CompositeExpression && $value->count() === 0)
            || trim((string)$value, '() ') === ''
        ;
    }
}