Commit ⋅ doctrine/orm

 */
class QuantifiedExpression extends Node
{
    /** @var string */
    public $type;
    public string $type;

    /** @param Subselect $subselect */
    public function __construct(public $subselect)
    {
    }

    /** @return bool */
    public function isAll()
    public function isAll(): bool
    {
        return strtoupper($this->type) === 'ALL';
    }

    /** @return bool */
    public function isAny()
    public function isAny(): bool
    {
        return strtoupper($this->type) === 'ANY';
    }

    /** @return bool */
    public function isSome()
    public function isSome(): bool
    {
        return strtoupper($this->type) === 'SOME';
    }

@@ -13,12 +13,8 @@

 */
class IndexBy extends Node
{
    /** @var PathExpression */
    public $singleValuedPathExpression = null;

    public function __construct(PathExpression $singleValuedPathExpression)
    public function __construct(public PathExpression $singleValuedPathExpression)
    {
        $this->singleValuedPathExpression = $singleValuedPathExpression;
    }

    public function dispatch(SqlWalker $walker): string

@@ -8,29 +8,17 @@


class BetweenExpression extends Node
{
    /** @var ArithmeticExpression */
    public $expression;

    /** @var ArithmeticExpression */
    public $leftBetweenExpression;

    /** @var ArithmeticExpression */
    public $rightBetweenExpression;

    /** @var bool */
    public $not;

    /**
     * @param ArithmeticExpression $expr
     * @param ArithmeticExpression $leftExpr
     * @param ArithmeticExpression $rightExpr
     * @param ArithmeticExpression $expression
     * @param ArithmeticExpression $leftBetweenExpression
     * @param ArithmeticExpression $rightBetweenExpression
     */
    public function __construct($expr, $leftExpr, $rightExpr, bool $not = false)
    {
        $this->expression             = $expr;
        $this->leftBetweenExpression  = $leftExpr;
        $this->rightBetweenExpression = $rightExpr;
        $this->not                    = $not;
    public function __construct(
        public $expression,
        public $leftBetweenExpression,
        public $rightBetweenExpression,
        public bool $not = false,
    ) {
    }

    public function dispatch(SqlWalker $walker): string

@@ -1020,6 +1020,7 @@

        $this->match(Lexer::T_IDENTIFIER);

        $resultVariable = $this->lexer->token['value'];
        assert(is_string($resultVariable));

        // Defer ResultVariable validation
        $this->deferredResultVariables[] = [

@@ -13,13 +13,9 @@

 */
class CoalesceExpression extends Node
{
    /** @var mixed[] */
    public $scalarExpressions = [];

    /** @param mixed[] $scalarExpressions */
    public function __construct(array $scalarExpressions)
    public function __construct(public array $scalarExpressions)
    {
        $this->scalarExpressions = $scalarExpressions;
    }

    public function dispatch(SqlWalker $walker): string

@@ -17,15 +17,12 @@

 */
class InstanceOfExpression extends Node
{
    /** @var string */
    public $identificationVariable;

    /**
     * @param string                                $identVariable
     * @param string                                $identificationVariable
     * @param non-empty-list<InputParameter|string> $value
     */
    public function __construct(
        $identVariable,
        public $identificationVariable,
        public array $value = [],
        public bool $not = false,
    ) {

@@ -37,8 +34,6 @@

                __METHOD__,
            );
        }

        $this->identificationVariable = $identVariable;
    }

    public function dispatch(SqlWalker $walker): string

@@ -13,18 +13,11 @@


class InputParameter extends Node
{
    /** @var bool */
    public $isNamed;

    /** @var string */
    public $name;

    /**
     * @param string $value
     *
     * @throws QueryException
     */
    public function __construct($value)
    public bool $isNamed;
    public string $name;

    /** @throws QueryException */
    public function __construct(string $value)
    {
        if (strlen($value) === 1) {
            throw QueryException::invalidParameterFormat($value);

@@ -14,8 +14,7 @@

 */
class SimpleSelectExpression extends Node
{
    /** @var string */
    public $fieldIdentificationVariable;
    public string|null $fieldIdentificationVariable = null;

    /** @param Node|string $expression */
    public function __construct(public $expression)

@@ -13,16 +13,11 @@

 */
class GeneralCaseExpression extends Node
{
    /** @var mixed[] */
    public $whenClauses = [];

    /**
     * @param mixed[] $whenClauses
     * @param mixed   $elseScalarExpression
     */
    public function __construct(array $whenClauses, public $elseScalarExpression = null)
    {
        $this->whenClauses = $whenClauses;
    /** @param mixed[] $whenClauses */
    public function __construct(
        public array $whenClauses,
        public mixed $elseScalarExpression = null,
    ) {
    }

    public function dispatch(SqlWalker $walker): string

@@ -17,31 +17,19 @@

 */
class PathExpression extends Node
{
    public const TYPE_COLLECTION_VALUED_ASSOCIATION = 2;
    public const TYPE_SINGLE_VALUED_ASSOCIATION     = 4;
    public const TYPE_STATE_FIELD                   = 8;

    /**
     * @var int|null
     * @psalm-var self::TYPE_*|null
     */
    public $type;

    /**
     * @var int
     * @psalm-var int-mask-of<self::TYPE_*>
     */
    public $expectedType;

    /**
     * @param int         $expectedType
     * @param string      $identificationVariable
     * @param string|null $field
     * @psalm-param int-mask-of<self::TYPE_*> $expectedType
     */
    public function __construct($expectedType, public $identificationVariable, public $field = null)
    {
        $this->expectedType = $expectedType;
    final public const TYPE_COLLECTION_VALUED_ASSOCIATION = 2;
    final public const TYPE_SINGLE_VALUED_ASSOCIATION     = 4;
    final public const TYPE_STATE_FIELD                   = 8;

    /** @psalm-var self::TYPE_*|null */
    public int|null $type;

    /** @psalm-param int-mask-of<self::TYPE_*> $expectedType */
    public function __construct(
        public int $expectedType,
        public string $identificationVariable,
        public string|null $field = null,
    ) {
    }

    public function dispatch(SqlWalker $walker): string

@@ -8,13 +8,9 @@


class GroupByClause extends Node
{
    /** @var mixed[] */
    public $groupByItems = [];

    /** @param mixed[] $groupByItems */
    public function __construct(array $groupByItems)
    public function __construct(public array $groupByItems)
    {
        $this->groupByItems = $groupByItems;
    }

    public function dispatch(SqlWalker $walker): string

@@ -24,8 +24,7 @@

    /** @var PathExpression */
    public $pathExpression;

    /** @var string|null */
    public $fieldMapping;
    public string|null $fieldMapping = null;

    public function getSql(SqlWalker $sqlWalker): string
    {

@@ -14,27 +14,21 @@

 */
class Join extends Node
{
    public const JOIN_TYPE_LEFT      = 1;
    public const JOIN_TYPE_LEFTOUTER = 2;
    public const JOIN_TYPE_INNER     = 3;

    /**
     * @var int
     * @psalm-var self::JOIN_TYPE_*
     */
    public $joinType = self::JOIN_TYPE_INNER;
    final public const JOIN_TYPE_LEFT      = 1;
    final public const JOIN_TYPE_LEFTOUTER = 2;
    final public const JOIN_TYPE_INNER     = 3;

    /** @var ConditionalExpression|null */
    public $conditionalExpression = null;

    /**
     * @param int  $joinType
     * @param Node $joinAssociationDeclaration
     * @psalm-param self::JOIN_TYPE_* $joinType
     */
    public function __construct($joinType, public $joinAssociationDeclaration = null)
    {
        $this->joinType = $joinType;
    public function __construct(
        public int $joinType,
        public $joinAssociationDeclaration = null,
    ) {
    }

    public function dispatch(SqlWalker $walker): string

@@ -6,14 +6,10 @@


class InListExpression extends InExpression
{
    /** @var non-empty-list<mixed> */
    public $literals;

    /** @param non-empty-list<mixed> $literals */
    public function __construct(ArithmeticExpression $expression, array $literals, bool $not = false)
    public function __construct(ArithmeticExpression $expression, public array $literals, bool $not = false)
    {
        $this->literals = $literals;
        $this->not      = $not;
        $this->not = $not;

        parent::__construct($expression);
    }

@@ -13,12 +13,10 @@

 */
class SimpleWhenClause extends Node
{
    /**
     * @param mixed $caseScalarExpression
     * @param mixed $thenScalarExpression
     */
    public function __construct(public $caseScalarExpression = null, public $thenScalarExpression = null)
    {
    public function __construct(
        public mixed $caseScalarExpression = null,
        public mixed $thenScalarExpression = null,
    ) {
    }

    public function dispatch(SqlWalker $walker): string

@@ -13,16 +13,10 @@

 */
class JoinClassPathExpression extends Node
{
    /** @var mixed */
    public $aliasIdentificationVariable;

    /**
     * @param mixed $abstractSchemaName
     * @param mixed $aliasIdentificationVar
     */
    public function __construct(public $abstractSchemaName, $aliasIdentificationVar)
    {
        $this->aliasIdentificationVariable = $aliasIdentificationVar;
    public function __construct(
        public mixed $abstractSchemaName,
        public mixed $aliasIdentificationVariable,
    ) {
    }

    public function dispatch(SqlWalker $walker): string

@@ -13,13 +13,9 @@

 */
class SimpleArithmeticExpression extends Node
{
    /** @var mixed[] */
    public $arithmeticTerms = [];

    /** @param mixed[] $arithmeticTerms */
    public function __construct(array $arithmeticTerms)
    public function __construct(public array $arithmeticTerms)
    {
        $this->arithmeticTerms = $arithmeticTerms;
    }

    public function dispatch(SqlWalker $walker): string

@@ -13,12 +13,11 @@

 */
class SimpleSelectClause extends Node
{
    /**
     * @param SimpleSelectExpression $simpleSelectExpression
     * @param bool                   $isDistinct
     */
    public function __construct(public $simpleSelectExpression, public $isDistinct = false)
    {
    /** @param SimpleSelectExpression $simpleSelectExpression */
    public function __construct(
        public $simpleSelectExpression,
        public bool $isDistinct = false,
    ) {
    }

    public function dispatch(SqlWalker $walker): string

@@ -13,13 +13,9 @@

 */
class ArithmeticTerm extends Node
{
    /** @var mixed[] */
    public $arithmeticFactors;

    /** @param mixed[] $arithmeticFactors */
    public function __construct(array $arithmeticFactors)
    public function __construct(public array $arithmeticFactors)
    {
        $this->arithmeticFactors = $arithmeticFactors;
    }

    public function dispatch(SqlWalker $walker): string

@@ -11,11 +11,10 @@

 */
class SubselectIdentificationVariableDeclaration
{
    /**
     * @param PathExpression $associationPathExpression
     * @param string         $aliasIdentificationVariable
     */
    public function __construct(public $associationPathExpression, public $aliasIdentificationVariable)
    {
    /** @param PathExpression $associationPathExpression */
    public function __construct(
        public $associationPathExpression,
        public string $aliasIdentificationVariable,
    ) {
    }
}

@@ -13,13 +13,9 @@

 */
class FromClause extends Node
{
    /** @var mixed[] */
    public $identificationVariableDeclarations = [];

    /** @param mixed[] $identificationVariableDeclarations */
    public function __construct(array $identificationVariableDeclarations)
    public function __construct(public array $identificationVariableDeclarations)
    {
        $this->identificationVariableDeclarations = $identificationVariableDeclarations;
    }

    public function dispatch(SqlWalker $walker): string

@@ -5,6 +5,7 @@

namespace Doctrine\ORM\Query\AST;

use Doctrine\ORM\Query\SqlWalker;
use Stringable;

use function get_debug_type;
use function get_object_vars;

@@ -20,7 +21,7 @@

 *
 * @link    www.doctrine-project.org
 */
abstract class Node
abstract class Node implements Stringable
{
    /**
     * Double-dispatch method, supposed to dispatch back to the walker.

@@ -36,20 +37,13 @@


    /**
     * Dumps the AST Node into a string representation for information purpose only.
     *
     * @return string
     */
    public function __toString()
    public function __toString(): string
    {
        return $this->dump($this);
    }

    /**
     * @param mixed $value
     *
     * @return string
     */
    public function dump($value)
    public function dump(mixed $value): string
    {
        static $ident = 0;


@@ -19,14 +19,12 @@

    /** @var Subselect|null */
    public $subselect;

    /** @return bool */
    public function isSimpleArithmeticExpression()
    public function isSimpleArithmeticExpression(): bool
    {
        return (bool) $this->simpleArithmeticExpression;
    }

    /** @return bool */
    public function isSubselect()
    public function isSubselect(): bool
    {
        return (bool) $this->subselect;
    }

@@ -18,21 +18,15 @@

 */
class ComparisonExpression extends Node
{
    /** @var Node|string */
    public $leftExpression;

    /** @var Node|string */
    public $rightExpression;

    /**
     * @param Node|string $leftExpr
     * @param string      $operator
     * @param Node|string $rightExpr
     * @param Node|string $leftExpression
     * @param Node|string $rightExpression
     */
    public function __construct($leftExpr, public $operator, $rightExpr)
    {
        $this->leftExpression  = $leftExpr;
        $this->rightExpression = $rightExpr;
    public function __construct(
        public $leftExpression,
        public string $operator,
        public $rightExpression,
    ) {
    }

    public function dispatch(SqlWalker $walker): string

@@ -13,19 +13,13 @@

 */
class UpdateClause extends Node
{
    /** @var string */
    public $aliasIdentificationVariable;
    public string $aliasIdentificationVariable;

    /** @var mixed[] */
    public $updateItems = [];

    /**
     * @param string  $abstractSchemaName
     * @param mixed[] $updateItems
     */
    public function __construct(public $abstractSchemaName, array $updateItems)
    {
        $this->updateItems = $updateItems;
    /** @param mixed[] $updateItems */
    public function __construct(
        public string $abstractSchemaName,
        public array $updateItems,
    ) {
    }

    public function dispatch(SqlWalker $walker): string

@@ -15,11 +15,13 @@

{
    /**
     * @param JoinAssociationPathExpression $joinAssociationPathExpression
     * @param string                        $aliasIdentificationVariable
     * @param IndexBy|null                  $indexBy
     */
    public function __construct(public $joinAssociationPathExpression, public $aliasIdentificationVariable, public $indexBy)
    {
    public function __construct(
        public $joinAssociationPathExpression,
        public string $aliasIdentificationVariable,
        public $indexBy,
    ) {
    }

    public function dispatch(SqlWalker $walker): string

@@ -13,13 +13,9 @@

 */
class ConditionalTerm extends Node
{
    /** @var mixed[] */
    public $conditionalFactors = [];

    /** @param mixed[] $conditionalFactors */
    public function __construct(array $conditionalFactors)
    public function __construct(public array $conditionalFactors)
    {
        $this->conditionalFactors = $conditionalFactors;
    }

    public function dispatch(SqlWalker $walker): string

@@ -13,16 +13,11 @@

 */
class SelectClause extends Node
{
    /** @var mixed[] */
    public $selectExpressions = [];

    /**
     * @param mixed[] $selectExpressions
     * @param bool    $isDistinct
     */
    public function __construct(array $selectExpressions, public $isDistinct)
    {
        $this->selectExpressions = $selectExpressions;
    /** @param mixed[] $selectExpressions */
    public function __construct(
        public array $selectExpressions,
        public bool $isDistinct,
    ) {
    }

    public function dispatch(SqlWalker $walker): string

@@ -6,15 +6,10 @@


class PartialObjectExpression extends Node
{
    /** @var mixed[] */
    public $partialFieldSet;

    /**
     * @param string  $identificationVariable
     * @param mixed[] $partialFieldSet
     */
    public function __construct(public $identificationVariable, array $partialFieldSet)
    {
        $this->partialFieldSet = $partialFieldSet;
    /** @param mixed[] $partialFieldSet */
    public function __construct(
        public string $identificationVariable,
        public array $partialFieldSet,
    ) {
    }
}

@@ -14,13 +14,11 @@

 */
class SelectExpression extends Node
{
    /**
     * @param mixed       $expression
     * @param string|null $fieldIdentificationVariable
     * @param bool        $hiddenAliasResultVariable
     */
    public function __construct(public $expression, public $fieldIdentificationVariable, public $hiddenAliasResultVariable = false)
    {
    public function __construct(
        public mixed $expression,
        public string|null $fieldIdentificationVariable,
        public bool $hiddenAliasResultVariable = false,
    ) {
    }

    public function dispatch(SqlWalker $walker): string

@@ -13,11 +13,7 @@

 */
class NullIfExpression extends Node
{
    /**
     * @param mixed $firstExpression
     * @param mixed $secondExpression
     */
    public function __construct(public $firstExpression, public $secondExpression)
    public function __construct(public mixed $firstExpression, public mixed $secondExpression)
    {
    }


@@ -13,13 +13,9 @@

 */
class OrderByClause extends Node
{
    /** @var OrderByItem[] */
    public $orderByItems = [];

    /** @param OrderByItem[] $orderByItems */
    public function __construct(array $orderByItems)
    public function __construct(public array $orderByItems)
    {
        $this->orderByItems = $orderByItems;
    }

    public function dispatch(SqlWalker $walker): string

@@ -11,11 +11,9 @@

 */
class JoinAssociationPathExpression extends Node
{
    /**
     * @param string $identificationVariable
     * @param string $associationField
     */
    public function __construct(public $identificationVariable, public $associationField)
    {
    public function __construct(
        public string $identificationVariable,
        public string $associationField,
    ) {
    }
}

@@ -19,14 +19,12 @@

    /** @var ConditionalExpression|null */
    public $conditionalExpression;

    /** @return bool */
    public function isSimpleConditionalExpression()
    public function isSimpleConditionalExpression(): bool
    {
        return (bool) $this->simpleConditionalExpression;
    }

    /** @return bool */
    public function isConditionalExpression()
    public function isConditionalExpression(): bool
    {
        return (bool) $this->conditionalExpression;
    }

@@ -13,12 +13,11 @@

 */
class WhenClause extends Node
{
    /**
     * @param ConditionalExpression $caseConditionExpression
     * @param mixed                 $thenScalarExpression
     */
    public function __construct(public $caseConditionExpression, public $thenScalarExpression = null)
    {
    /** @param ConditionalExpression $caseConditionExpression */
    public function __construct(
        public $caseConditionExpression,
        public mixed $thenScalarExpression = null,
    ) {
    }

    public function dispatch(SqlWalker $walker): string

@@ -20,7 +20,7 @@

    public Node $secondStringPrimary;

    /** @psalm-var list<Node> */
    public $concatExpressions = [];
    public array $concatExpressions = [];

    public function getSql(SqlWalker $sqlWalker): string
    {

@@ -13,16 +13,9 @@

 */
class NewObjectExpression extends Node
{
    /** @var mixed[] */
    public $args;

    /**
     * @param string  $className
     * @param mixed[] $args
     */
    public function __construct(public $className, array $args)
    /** @param mixed[] $args */
    public function __construct(public string $className, public array $args)
    {
        $this->args = $args;
    }

    public function dispatch(SqlWalker $walker): string

@@ -13,11 +13,9 @@

 */
class DeleteClause extends Node
{
    /** @var string */
    public $aliasIdentificationVariable;
    public string $aliasIdentificationVariable;

    /** @param string $abstractSchemaName */
    public function __construct(public $abstractSchemaName)
    public function __construct(public string $abstractSchemaName)
    {
    }


@@ -9,20 +9,14 @@

class AggregateExpression extends Node
{
    /**
     * Some aggregate expressions support distinct, eg COUNT.
     *
     * @var bool
     */
    public $isDistinct = false;

    /**
     * @param string                                    $functionName
     * @param PathExpression|SimpleArithmeticExpression $pathExpression
     * @param bool                                      $isDistinct
     * @param bool                                      $isDistinct     Some aggregate expressions support distinct, eg COUNT.
     */
    public function __construct(public $functionName, public $pathExpression, $isDistinct)
    {
        $this->isDistinct = $isDistinct;
    public function __construct(
        public string $functionName,
        public $pathExpression,
        public bool $isDistinct,
    ) {
    }

    public function dispatch(SqlWalker $walker): string

@@ -16,12 +16,11 @@

    /**
     * @param PathExpression $caseOperand
     * @param mixed[]        $simpleWhenClauses
     * @param mixed          $elseScalarExpression
     */
    public function __construct(
        public $caseOperand = null,
        public array $simpleWhenClauses = [],
        public $elseScalarExpression = null,
        public mixed $elseScalarExpression = null,
    ) {
    }


@@ -13,12 +13,7 @@

 */
class ASTException extends QueryException
{
    /**
     * @param Node $node
     *
     * @return ASTException
     */
    public static function noDispatchForNode($node)
    public static function noDispatchForNode(Node $node): self
    {
        return new self('Double-dispatch for node ' . get_debug_type($node) . ' is not supported.');
    }

@@ -13,24 +13,12 @@

 */
class CollectionMemberExpression extends Node
{
    /** @var mixed */
    public $entityExpression;

    /** @var PathExpression */
    public $collectionValuedPathExpression;

    /** @var bool */
    public $not;

    /**
     * @param mixed          $entityExpr
     * @param PathExpression $collValuedPathExpr
     */
    public function __construct($entityExpr, $collValuedPathExpr, bool $not = false)
    {
        $this->entityExpression               = $entityExpr;
        $this->collectionValuedPathExpression = $collValuedPathExpr;
        $this->not                            = $not;
    /** @param PathExpression $collectionValuedPathExpression */
    public function __construct(
        public mixed $entityExpression,
        public $collectionValuedPathExpression,
        public bool $not = false,
    ) {
    }

    public function dispatch(SqlWalker $walker): string

@@ -8,24 +8,15 @@


class Literal extends Node
{
    public const STRING  = 1;
    public const BOOLEAN = 2;
    public const NUMERIC = 3;
    final public const STRING  = 1;
    final public const BOOLEAN = 2;
    final public const NUMERIC = 3;

    /**
     * @var int
     * @psalm-var self::*
     */
    public $type;

    /**
     * @param int   $type
     * @param mixed $value
     * @psalm-param self::* $type
     */
    public function __construct($type, public $value)
    {
        $this->type = $type;
    /** @psalm-param self::* $type */
    public function __construct(
        public int $type,
        public mixed $value,
    ) {
    }

    public function dispatch(SqlWalker $walker): string

@@ -13,17 +13,11 @@

 */
class RangeVariableDeclaration extends Node
{
    /** @var string */
    public $aliasIdentificationVariable;

    /**
     * @param string $abstractSchemaName
     * @param string $aliasIdentificationVar
     * @param bool   $isRoot
     */
    public function __construct(public $abstractSchemaName, $aliasIdentificationVar, public $isRoot = true)
    {
        $this->aliasIdentificationVariable = $aliasIdentificationVar;
    public function __construct(
        public string $abstractSchemaName,
        public string $aliasIdentificationVariable,
        public bool $isRoot = true,
    ) {
    }

    public function dispatch(SqlWalker $walker): string

@@ -15,22 +15,18 @@

 */
class OrderByItem extends Node
{
    /** @var string */
    public $type;
    public string $type;

    /** @param mixed $expression */
    public function __construct(public $expression)
    public function __construct(public mixed $expression)
    {
    }

    /** @return bool */
    public function isAsc()
    public function isAsc(): bool
    {
        return strtoupper($this->type) === 'ASC';
    }

    /** @return bool */
    public function isDesc()
    public function isDesc(): bool
    {
        return strtoupper($this->type) === 'DESC';
    }

@@ -13,30 +13,18 @@

 */
class ArithmeticFactor extends Node
{
    /**
     * NULL represents no sign, TRUE means positive and FALSE means negative sign.
     *
     * @var bool|null
     */
    public $sign;

    /**
     * @param mixed     $arithmeticPrimary
     * @param bool|null $sign
     */
    public function __construct(public $arithmeticPrimary, $sign = null)
    {
        $this->sign = $sign;
    public function __construct(
        public mixed $arithmeticPrimary,
        public bool|null $sign = null,
    ) {
    }

    /** @return bool */
    public function isPositiveSigned()
    public function isPositiveSigned(): bool
    {
        return $this->sign === true;
    }

    /** @return bool */
    public function isNegativeSigned()
    public function isNegativeSigned(): bool
    {
        return $this->sign === false;
    }

@@ -13,13 +13,9 @@

 */
class ConditionalExpression extends Node
{
    /** @var mixed[] */
    public $conditionalTerms = [];

    /** @param mixed[] $conditionalTerms */
    public function __construct(array $conditionalTerms)
    public function __construct(public array $conditionalTerms)
    {
        $this->conditionalTerms = $conditionalTerms;
    }

    public function dispatch(SqlWalker $walker): string

@@ -13,13 +13,9 @@

 */
class SubselectFromClause extends Node
{
    /** @var mixed[] */
    public $identificationVariableDeclarations = [];

    /** @param mixed[] $identificationVariableDeclarations */
    public function __construct(array $identificationVariableDeclarations)
    public function __construct(public array $identificationVariableDeclarations)
    {
        $this->identificationVariableDeclarations = $identificationVariableDeclarations;
    }

    public function dispatch(SqlWalker $walker): string

@@ -11,12 +11,8 @@

 */
class ParenthesisExpression extends Node
{
    /** @var Node */
    public $expression;

    public function __construct(Node $expression)
    public function __construct(public Node $expression)
    {
        $this->expression = $expression;
    }

    public function dispatch(SqlWalker $walker): string

@@ -68,7 +68,7 @@

     *
     * @throws ASTException
     */
    private function dispatchIntervalExpression(SqlWalker $sqlWalker)
    private function dispatchIntervalExpression(SqlWalker $sqlWalker): string
    {
        $sql = $this->intervalExpression->dispatch($sqlWalker);
        assert(is_numeric($sql));

@@ -14,11 +14,10 @@

 */
class InExpression extends Node
{
    /** @var bool */
    public $not;
    public bool $not = false;

    /** @var mixed[] */
    public $literals = [];
    public array $literals = [];

    /** @var Subselect|null */
    public $subselect;

Files		•	•	•	Coverage
lib/Doctrine/ORM	14,602	13,083	0	1,519	89.60%
Project Totals (332 files)	14,602	13,083	0	1,519	89.60%

View CI Build Download

No yaml found.

Create your codecov.yml to customize your Codecov experience

Read the docs

Interact now

The inner-most circle is the entire project, moving away from the center are folders then, finally, a single file. The size and color of each slice is representing the number of statements and the coverage, respectively.

SVG

The top section represents the entire project. Proceeding with folders and finally individual files. The size and color of each slice is representing the number of statements and the coverage, respectively.

SVG

Each block represents a single file in the project. The size and color of each block is represented by the number of statements and the coverage, respectively.

SVG

Learn more about the coverage sunburst graph

1020	1020		$this->match(Lexer::T_IDENTIFIER);
1021	1021
1022	1022		$resultVariable = $this->lexer->token['value'];
	1023	+	assert(is_string($resultVariable));
1023	1024
1024	1025		// Defer ResultVariable validation
1025	1026		$this->deferredResultVariables[] = [

37	34		__METHOD__,
38	35		);
39	36		}
40		-
41		-	$this->identificationVariable = $identVariable;
42	37		}
43	38
44	39		public function dispatch(SqlWalker $walker): string

36	37
37	38		/**
38	39		* Dumps the AST Node into a string representation for information purpose only.
39		-	*
40		-	* @return string
41	40		*/
42		-	public function __toString()
	41	+	public function __toString(): string
43	42		{
44	43		return $this->dump($this);
45	44		}
46	45
47		-	/**
48		-	* @param mixed $value
49		-	*
50		-	* @return string
51		-	*/
52		-	public function dump($value)
	46	+	public function dump(mixed $value): string
53	47		{
54	48		static $ident = 0;
55	49

15	15		*/
16	16		class QuantifiedExpression extends Node
17	17		{
18		-	/** @var string */
19		-	public $type;
	18	+	public string $type;
20	19
21	20		/** @param Subselect $subselect */
22	21		public function __construct(public $subselect)
23	22		{
24	23		}
25	24
26		-	/** @return bool */
27		-	public function isAll()
	25	+	public function isAll(): bool
28	26		{
29	27		return strtoupper($this->type) === 'ALL';
30	28		}
31	29
32		-	/** @return bool */
33		-	public function isAny()
	30	+	public function isAny(): bool
34	31		{
35	32		return strtoupper($this->type) === 'ANY';
36	33		}
37	34
38		-	/** @return bool */
39		-	public function isSome()
	35	+	public function isSome(): bool
40	36		{
41	37		return strtoupper($this->type) === 'SOME';
42	38		}

13	13		*/
14	14		class IndexBy extends Node
15	15		{
16		-	/** @var PathExpression */
17		-	public $singleValuedPathExpression = null;
18		-
19		-	public function __construct(PathExpression $singleValuedPathExpression)
	16	+	public function __construct(public PathExpression $singleValuedPathExpression)
20	17		{
21		-	$this->singleValuedPathExpression = $singleValuedPathExpression;
22	18		}
23	19
24	20		public function dispatch(SqlWalker $walker): string

8	8
9	9		class BetweenExpression extends Node
10	10		{
11		-	/** @var ArithmeticExpression */
12		-	public $expression;
13		-
14		-	/** @var ArithmeticExpression */
15		-	public $leftBetweenExpression;
16		-
17		-	/** @var ArithmeticExpression */
18		-	public $rightBetweenExpression;
19		-
20		-	/** @var bool */
21		-	public $not;
22		-
23	11		/**
24		-	* @param ArithmeticExpression $expr
25		-	* @param ArithmeticExpression $leftExpr
26		-	* @param ArithmeticExpression $rightExpr
	12	+	* @param ArithmeticExpression $expression
	13	+	* @param ArithmeticExpression $leftBetweenExpression
	14	+	* @param ArithmeticExpression $rightBetweenExpression
27	15		*/
28		-	public function __construct($expr, $leftExpr, $rightExpr, bool $not = false)
29		-	{
30		-	$this->expression = $expr;
31		-	$this->leftBetweenExpression = $leftExpr;
32		-	$this->rightBetweenExpression = $rightExpr;
33		-	$this->not = $not;
	16	+	public function __construct(
	17	+	public $expression,
	18	+	public $leftBetweenExpression,
	19	+	public $rightBetweenExpression,
	20	+	public bool $not = false,
	21	+	) {
34	22		}
35	23
36	24		public function dispatch(SqlWalker $walker): string

13	13		*/
14	14		class CoalesceExpression extends Node
15	15		{
16		-	/** @var mixed[] */
17		-	public $scalarExpressions = [];
18		-
19	16		/** @param mixed[] $scalarExpressions */
20		-	public function __construct(array $scalarExpressions)
	17	+	public function __construct(public array $scalarExpressions)
21	18		{
22		-	$this->scalarExpressions = $scalarExpressions;
23	19		}
24	20
25	21		public function dispatch(SqlWalker $walker): string

17	17		*/
18	18		class InstanceOfExpression extends Node
19	19		{
20		-	/** @var string */
21		-	public $identificationVariable;
22		-
23	20		/**
24		-	* @param string $identVariable
	21	+	* @param string $identificationVariable
25	22		* @param non-empty-list<InputParameter\|string> $value
26	23		*/
27	24		public function __construct(
28		-	$identVariable,
	25	+	public $identificationVariable,
29	26		public array $value = [],
30	27		public bool $not = false,
31	28		) {

13	13
14	14		class InputParameter extends Node
15	15		{
16		-	/** @var bool */
17		-	public $isNamed;
18		-
19		-	/** @var string */
20		-	public $name;
21		-
22		-	/**
23		-	* @param string $value
24		-	*
25		-	* @throws QueryException
26		-	*/
27		-	public function __construct($value)
	16	+	public bool $isNamed;
	17	+	public string $name;
	18	+
	19	+	/** @throws QueryException */
	20	+	public function __construct(string $value)
28	21		{
29	22		if (strlen($value) === 1) {
30	23		throw QueryException::invalidParameterFormat($value);

14	14		*/
15	15		class SimpleSelectExpression extends Node
16	16		{
17		-	/** @var string */
18		-	public $fieldIdentificationVariable;
	17	+	public string\|null $fieldIdentificationVariable = null;
19	18
20	19		/** @param Node\|string $expression */
21	20		public function __construct(public $expression)

13	13		*/
14	14		class GeneralCaseExpression extends Node
15	15		{
16		-	/** @var mixed[] */
17		-	public $whenClauses = [];
18		-
19		-	/**
20		-	* @param mixed[] $whenClauses
21		-	* @param mixed $elseScalarExpression
22		-	*/
23		-	public function __construct(array $whenClauses, public $elseScalarExpression = null)
24		-	{
25		-	$this->whenClauses = $whenClauses;
	16	+	/** @param mixed[] $whenClauses */
	17	+	public function __construct(
	18	+	public array $whenClauses,
	19	+	public mixed $elseScalarExpression = null,
	20	+	) {
26	21		}
27	22
28	23		public function dispatch(SqlWalker $walker): string

17	17		*/
18	18		class PathExpression extends Node
19	19		{
20		-	public const TYPE_COLLECTION_VALUED_ASSOCIATION = 2;
21		-	public const TYPE_SINGLE_VALUED_ASSOCIATION = 4;
22		-	public const TYPE_STATE_FIELD = 8;
23		-
24		-	/**
25		-	* @var int\|null
26		-	* @psalm-var self::TYPE_*\|null
27		-	*/
28		-	public $type;
29		-
30		-	/**
31		-	* @var int
32		-	* @psalm-var int-mask-of<self::TYPE_*>
33		-	*/
34		-	public $expectedType;
35		-
36		-	/**
37		-	* @param int $expectedType
38		-	* @param string $identificationVariable
39		-	* @param string\|null $field
40		-	* @psalm-param int-mask-of<self::TYPE_*> $expectedType
41		-	*/
42		-	public function __construct($expectedType, public $identificationVariable, public $field = null)
43		-	{
44		-	$this->expectedType = $expectedType;
	20	+	final public const TYPE_COLLECTION_VALUED_ASSOCIATION = 2;
	21	+	final public const TYPE_SINGLE_VALUED_ASSOCIATION = 4;
	22	+	final public const TYPE_STATE_FIELD = 8;
	23	+
	24	+	/** @psalm-var self::TYPE_\|null /
	25	+	public int\|null $type;
	26	+
	27	+	/** @psalm-param int-mask-of<self::TYPE_> $expectedType /
	28	+	public function __construct(
	29	+	public int $expectedType,
	30	+	public string $identificationVariable,
	31	+	public string\|null $field = null,
	32	+	) {
45	33		}
46	34
47	35		public function dispatch(SqlWalker $walker): string

8	8
9	9		class GroupByClause extends Node
10	10		{
11		-	/** @var mixed[] */
12		-	public $groupByItems = [];
13		-
14	11		/** @param mixed[] $groupByItems */
15		-	public function __construct(array $groupByItems)
	12	+	public function __construct(public array $groupByItems)
16	13		{
17		-	$this->groupByItems = $groupByItems;
18	14		}
19	15
20	16		public function dispatch(SqlWalker $walker): string

24	24		/** @var PathExpression */
25	25		public $pathExpression;
26	26
27		-	/** @var string\|null */
28		-	public $fieldMapping;
	27	+	public string\|null $fieldMapping = null;
29	28
30	29		public function getSql(SqlWalker $sqlWalker): string
31	30		{

14	14		*/
15	15		class Join extends Node
16	16		{
17		-	public const JOIN_TYPE_LEFT = 1;
18		-	public const JOIN_TYPE_LEFTOUTER = 2;
19		-	public const JOIN_TYPE_INNER = 3;
20		-
21		-	/**
22		-	* @var int
23		-	* @psalm-var self::JOIN_TYPE_*
24		-	*/
25		-	public $joinType = self::JOIN_TYPE_INNER;
	17	+	final public const JOIN_TYPE_LEFT = 1;
	18	+	final public const JOIN_TYPE_LEFTOUTER = 2;
	19	+	final public const JOIN_TYPE_INNER = 3;
26	20
27	21		/** @var ConditionalExpression\|null */
28	22		public $conditionalExpression = null;
29	23
30	24		/**
31		-	* @param int $joinType
32	25		* @param Node $joinAssociationDeclaration
33	26		* @psalm-param self::JOIN_TYPE_* $joinType
34	27		*/
35		-	public function __construct($joinType, public $joinAssociationDeclaration = null)
36		-	{
37		-	$this->joinType = $joinType;
	28	+	public function __construct(
	29	+	public int $joinType,
	30	+	public $joinAssociationDeclaration = null,
	31	+	) {
38	32		}
39	33
40	34		public function dispatch(SqlWalker $walker): string

6	6
7	7		class InListExpression extends InExpression
8	8		{
9		-	/** @var non-empty-list<mixed> */
10		-	public $literals;
11		-
12	9		/** @param non-empty-list<mixed> $literals */
13		-	public function __construct(ArithmeticExpression $expression, array $literals, bool $not = false)
	10	+	public function __construct(ArithmeticExpression $expression, public array $literals, bool $not = false)
14	11		{
15		-	$this->literals = $literals;
16		-	$this->not = $not;
	12	+	$this->not = $not;
17	13
18	14		parent::__construct($expression);
19	15		}

13	13		*/
14	14		class SimpleWhenClause extends Node
15	15		{
16		-	/**
17		-	* @param mixed $caseScalarExpression
18		-	* @param mixed $thenScalarExpression
19		-	*/
20		-	public function __construct(public $caseScalarExpression = null, public $thenScalarExpression = null)
21		-	{
	16	+	public function __construct(
	17	+	public mixed $caseScalarExpression = null,
	18	+	public mixed $thenScalarExpression = null,
	19	+	) {
22	20		}
23	21
24	22		public function dispatch(SqlWalker $walker): string

13	13		*/
14	14		class JoinClassPathExpression extends Node
15	15		{
16		-	/** @var mixed */
17		-	public $aliasIdentificationVariable;
18		-
19		-	/**
20		-	* @param mixed $abstractSchemaName
21		-	* @param mixed $aliasIdentificationVar
22		-	*/
23		-	public function __construct(public $abstractSchemaName, $aliasIdentificationVar)
24		-	{
25		-	$this->aliasIdentificationVariable = $aliasIdentificationVar;
	16	+	public function __construct(
	17	+	public mixed $abstractSchemaName,
	18	+	public mixed $aliasIdentificationVariable,
	19	+	) {
26	20		}
27	21
28	22		public function dispatch(SqlWalker $walker): string

13	13		*/
14	14		class SimpleArithmeticExpression extends Node
15	15		{
16		-	/** @var mixed[] */
17		-	public $arithmeticTerms = [];
18		-
19	16		/** @param mixed[] $arithmeticTerms */
20		-	public function __construct(array $arithmeticTerms)
	17	+	public function __construct(public array $arithmeticTerms)
21	18		{
22		-	$this->arithmeticTerms = $arithmeticTerms;
23	19		}
24	20
25	21		public function dispatch(SqlWalker $walker): string

13	13		*/
14	14		class SimpleSelectClause extends Node
15	15		{
16		-	/**
17		-	* @param SimpleSelectExpression $simpleSelectExpression
18		-	* @param bool $isDistinct
19		-	*/
20		-	public function __construct(public $simpleSelectExpression, public $isDistinct = false)
21		-	{
	16	+	/** @param SimpleSelectExpression $simpleSelectExpression */
	17	+	public function __construct(
	18	+	public $simpleSelectExpression,
	19	+	public bool $isDistinct = false,
	20	+	) {
22	21		}
23	22
24	23		public function dispatch(SqlWalker $walker): string

13	13		*/
14	14		class ArithmeticTerm extends Node
15	15		{
16		-	/** @var mixed[] */
17		-	public $arithmeticFactors;
18		-
19	16		/** @param mixed[] $arithmeticFactors */
20		-	public function __construct(array $arithmeticFactors)
	17	+	public function __construct(public array $arithmeticFactors)
21	18		{
22		-	$this->arithmeticFactors = $arithmeticFactors;
23	19		}
24	20
25	21		public function dispatch(SqlWalker $walker): string

11	11		*/
12	12		class SubselectIdentificationVariableDeclaration
13	13		{
14		-	/**
15		-	* @param PathExpression $associationPathExpression
16		-	* @param string $aliasIdentificationVariable
17		-	*/
18		-	public function __construct(public $associationPathExpression, public $aliasIdentificationVariable)
19		-	{
	14	+	/** @param PathExpression $associationPathExpression */
	15	+	public function __construct(
	16	+	public $associationPathExpression,
	17	+	public string $aliasIdentificationVariable,
	18	+	) {
20	19		}
21	20		}

13	13		*/
14	14		class FromClause extends Node
15	15		{
16		-	/** @var mixed[] */
17		-	public $identificationVariableDeclarations = [];
18		-
19	16		/** @param mixed[] $identificationVariableDeclarations */
20		-	public function __construct(array $identificationVariableDeclarations)
	17	+	public function __construct(public array $identificationVariableDeclarations)
21	18		{
22		-	$this->identificationVariableDeclarations = $identificationVariableDeclarations;
23	19		}
24	20
25	21		public function dispatch(SqlWalker $walker): string

Updating our web app

No yaml found.

5	5		namespace Doctrine\ORM\Query\AST;
6	6
7	7		use Doctrine\ORM\Query\SqlWalker;
	8	+	use Stringable;
8	9
9	10		use function get_debug_type;
10	11		use function get_object_vars;

20	21		*
21	22		* @link www.doctrine-project.org
22	23		*/
23		-	abstract class Node
	24	+	abstract class Node implements Stringable
24	25		{
25	26		/**
26	27		* Double-dispatch method, supposed to dispatch back to the walker.

19	19		/** @var Subselect\|null */
20	20		public $subselect;
21	21
22		-	/** @return bool */
23		-	public function isSimpleArithmeticExpression()
	22	+	public function isSimpleArithmeticExpression(): bool
24	23		{
25	24		return (bool) $this->simpleArithmeticExpression;
26	25		}
27	26
28		-	/** @return bool */
29		-	public function isSubselect()
	27	+	public function isSubselect(): bool
30	28		{
31	29		return (bool) $this->subselect;
32	30		}

18	18		*/
19	19		class ComparisonExpression extends Node
20	20		{
21		-	/** @var Node\|string */
22		-	public $leftExpression;
23		-
24		-	/** @var Node\|string */
25		-	public $rightExpression;
26		-
27	21		/**
28		-	* @param Node\|string $leftExpr
29		-	* @param string $operator
30		-	* @param Node\|string $rightExpr
	22	+	* @param Node\|string $leftExpression
	23	+	* @param Node\|string $rightExpression
31	24		*/
32		-	public function __construct($leftExpr, public $operator, $rightExpr)
33		-	{
34		-	$this->leftExpression = $leftExpr;
35		-	$this->rightExpression = $rightExpr;
	25	+	public function __construct(
	26	+	public $leftExpression,
	27	+	public string $operator,
	28	+	public $rightExpression,
	29	+	) {
36	30		}
37	31
38	32		public function dispatch(SqlWalker $walker): string

13	13		*/
14	14		class UpdateClause extends Node
15	15		{
16		-	/** @var string */
17		-	public $aliasIdentificationVariable;
	16	+	public string $aliasIdentificationVariable;
18	17
19		-	/** @var mixed[] */
20		-	public $updateItems = [];
21		-
22		-	/**
23		-	* @param string $abstractSchemaName
24		-	* @param mixed[] $updateItems
25		-	*/
26		-	public function __construct(public $abstractSchemaName, array $updateItems)
27		-	{
28		-	$this->updateItems = $updateItems;
	18	+	/** @param mixed[] $updateItems */
	19	+	public function __construct(
	20	+	public string $abstractSchemaName,
	21	+	public array $updateItems,
	22	+	) {
29	23		}
30	24
31	25		public function dispatch(SqlWalker $walker): string

15	15		{
16	16		/**
17	17		* @param JoinAssociationPathExpression $joinAssociationPathExpression
18		-	* @param string $aliasIdentificationVariable
19	18		* @param IndexBy\|null $indexBy
20	19		*/
21		-	public function __construct(public $joinAssociationPathExpression, public $aliasIdentificationVariable, public $indexBy)
22		-	{
	20	+	public function __construct(
	21	+	public $joinAssociationPathExpression,
	22	+	public string $aliasIdentificationVariable,
	23	+	public $indexBy,
	24	+	) {
23	25		}
24	26
25	27		public function dispatch(SqlWalker $walker): string

13	13		*/
14	14		class ConditionalTerm extends Node
15	15		{
16		-	/** @var mixed[] */
17		-	public $conditionalFactors = [];
18		-
19	16		/** @param mixed[] $conditionalFactors */
20		-	public function __construct(array $conditionalFactors)
	17	+	public function __construct(public array $conditionalFactors)
21	18		{
22		-	$this->conditionalFactors = $conditionalFactors;
23	19		}
24	20
25	21		public function dispatch(SqlWalker $walker): string

13	13		*/
14	14		class SelectClause extends Node
15	15		{
16		-	/** @var mixed[] */
17		-	public $selectExpressions = [];
18		-
19		-	/**
20		-	* @param mixed[] $selectExpressions
21		-	* @param bool $isDistinct
22		-	*/
23		-	public function __construct(array $selectExpressions, public $isDistinct)
24		-	{
25		-	$this->selectExpressions = $selectExpressions;
	16	+	/** @param mixed[] $selectExpressions */
	17	+	public function __construct(
	18	+	public array $selectExpressions,
	19	+	public bool $isDistinct,
	20	+	) {
26	21		}
27	22
28	23		public function dispatch(SqlWalker $walker): string

6	6
7	7		class PartialObjectExpression extends Node
8	8		{
9		-	/** @var mixed[] */
10		-	public $partialFieldSet;
11		-
12		-	/**
13		-	* @param string $identificationVariable
14		-	* @param mixed[] $partialFieldSet
15		-	*/
16		-	public function __construct(public $identificationVariable, array $partialFieldSet)
17		-	{
18		-	$this->partialFieldSet = $partialFieldSet;
	9	+	/** @param mixed[] $partialFieldSet */
	10	+	public function __construct(
	11	+	public string $identificationVariable,
	12	+	public array $partialFieldSet,
	13	+	) {
19	14		}
20	15		}

14	14		*/
15	15		class SelectExpression extends Node
16	16		{
17		-	/**
18		-	* @param mixed $expression
19		-	* @param string\|null $fieldIdentificationVariable
20		-	* @param bool $hiddenAliasResultVariable
21		-	*/
22		-	public function __construct(public $expression, public $fieldIdentificationVariable, public $hiddenAliasResultVariable = false)
23		-	{
	17	+	public function __construct(
	18	+	public mixed $expression,
	19	+	public string\|null $fieldIdentificationVariable,
	20	+	public bool $hiddenAliasResultVariable = false,
	21	+	) {
24	22		}
25	23
26	24		public function dispatch(SqlWalker $walker): string