From 6bd59f0c53ed5812c105fc9b3e8a0480d22adf3e Mon Sep 17 00:00:00 2001
From: pfilsx <pfilsx@gmail.com>
Date: Mon, 26 May 2025 13:50:22 +0300
Subject: [PATCH] add doctrine\orm ^3.0 support

---
 composer.json                                 |   2 +-
 src/Enum/TokenType.php                        | 273 ++++++++++++++++++
 src/ORM/Query/AST/ArrayExpression.php         |  18 +-
 .../AbstractAggregateWithFilterFunction.php   |  10 +-
 .../Functions/AbstractJsonBuildFunction.php   |  14 +-
 .../Functions/AbstractSingleNodeFunction.php  |   8 +-
 .../AST/Functions/AbstractToTsFunction.php    |  12 +-
 src/ORM/Query/AST/Functions/ArrayAgg.php      |  18 +-
 src/ORM/Query/AST/Functions/Cast.php          |  12 +-
 src/ORM/Query/AST/Functions/Ceil.php          |   8 +-
 src/ORM/Query/AST/Functions/Contains.php      |  10 +-
 src/ORM/Query/AST/Functions/Extract.php       |  12 +-
 src/ORM/Query/AST/Functions/Floor.php         |   8 +-
 src/ORM/Query/AST/Functions/ILike.php         |  14 +-
 src/ORM/Query/AST/Functions/JsonAgg.php       |  12 +-
 .../AST/Functions/JsonGetArrayElement.php     |  20 +-
 .../Functions/JsonGetArrayElementAsText.php   |  20 +-
 src/ORM/Query/AST/Functions/JsonGetField.php  |  16 +-
 src/ORM/Query/AST/Functions/JsonGetObject.php |  10 +-
 src/ORM/Query/AST/Functions/JsonbAgg.php      |  12 +-
 src/ORM/Query/AST/Functions/JsonbConcat.php   |  10 +-
 src/ORM/Query/AST/Functions/JsonbContains.php |  10 +-
 src/ORM/Query/AST/Functions/JsonbExists.php   |  10 +-
 src/ORM/Query/AST/Functions/JsonbRemove.php   |  10 +-
 src/ORM/Query/AST/Functions/Overlaps.php      |  10 +-
 src/ORM/Query/AST/Functions/Random.php        |   8 +-
 src/ORM/Query/AST/Functions/Round.php         |  12 +-
 src/ORM/Query/AST/Functions/StringAgg.php     |  14 +-
 src/ORM/Query/AST/Functions/TsHeadline.php    |  18 +-
 src/ORM/Query/AST/Functions/TsMatch.php       |  10 +-
 src/ORM/Query/AST/Functions/TsRank.php        |  14 +-
 31 files changed, 454 insertions(+), 181 deletions(-)
 create mode 100644 src/Enum/TokenType.php

diff --git a/composer.json b/composer.json
index 5ebd33f..773fe1a 100644
--- a/composer.json
+++ b/composer.json
@@ -36,7 +36,7 @@
     },
     "require-dev": {
         "friendsofphp/php-cs-fixer": "^3.13",
-        "doctrine/orm": "^2.13",
+        "doctrine/orm": "^2.13|^3.0",
         "symfony/serializer": ">=5.4",
         "symfony/property-info": ">=5.4",
         "phpunit/phpunit": "^10.0",
diff --git a/src/Enum/TokenType.php b/src/Enum/TokenType.php
new file mode 100644
index 0000000..97475b5
--- /dev/null
+++ b/src/Enum/TokenType.php
@@ -0,0 +1,273 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pfilsx\PostgreSQLDoctrine\Enum;
+
+if (\class_exists(\Doctrine\ORM\Query\TokenType::class)) {
+    final class TokenType
+    {
+        public const T_NONE = \Doctrine\ORM\Query\TokenType::T_NONE;
+
+        public const T_INTEGER = \Doctrine\ORM\Query\TokenType::T_INTEGER;
+
+        public const T_STRING = \Doctrine\ORM\Query\TokenType::T_STRING;
+
+        public const T_INPUT_PARAMETER = \Doctrine\ORM\Query\TokenType::T_INPUT_PARAMETER;
+
+        public const T_FLOAT = \Doctrine\ORM\Query\TokenType::T_FLOAT;
+
+        public const T_CLOSE_PARENTHESIS = \Doctrine\ORM\Query\TokenType::T_CLOSE_PARENTHESIS;
+
+        public const T_OPEN_PARENTHESIS = \Doctrine\ORM\Query\TokenType::T_OPEN_PARENTHESIS;
+
+        public const T_COMMA = \Doctrine\ORM\Query\TokenType::T_COMMA;
+
+        public const T_DIVIDE = \Doctrine\ORM\Query\TokenType::T_DIVIDE;
+
+        public const T_DOT = \Doctrine\ORM\Query\TokenType::T_DOT;
+
+        public const T_EQUALS = \Doctrine\ORM\Query\TokenType::T_EQUALS;
+
+        public const T_GREATER_THAN = \Doctrine\ORM\Query\TokenType::T_GREATER_THAN;
+
+        public const T_LOWER_THAN = \Doctrine\ORM\Query\TokenType::T_LOWER_THAN;
+
+        public const T_MINUS = \Doctrine\ORM\Query\TokenType::T_MINUS;
+
+        public const T_MULTIPLY = \Doctrine\ORM\Query\TokenType::T_MULTIPLY;
+
+        public const T_NEGATE = \Doctrine\ORM\Query\TokenType::T_NEGATE;
+
+        public const T_PLUS = \Doctrine\ORM\Query\TokenType::T_PLUS;
+
+        public const T_OPEN_CURLY_BRACE = \Doctrine\ORM\Query\TokenType::T_OPEN_CURLY_BRACE;
+
+        public const T_CLOSE_CURLY_BRACE = \Doctrine\ORM\Query\TokenType::T_CLOSE_CURLY_BRACE;
+
+        public const T_ALIASED_NAME = \Doctrine\ORM\Query\TokenType::T_ALIASED_NAME;
+
+        public const T_FULLY_QUALIFIED_NAME = \Doctrine\ORM\Query\TokenType::T_FULLY_QUALIFIED_NAME;
+
+        public const T_IDENTIFIER = \Doctrine\ORM\Query\TokenType::T_IDENTIFIER;
+
+        public const T_ALL = \Doctrine\ORM\Query\TokenType::T_ALL;
+
+        public const T_AND = \Doctrine\ORM\Query\TokenType::T_AND;
+
+        public const T_ANY = \Doctrine\ORM\Query\TokenType::T_ANY;
+
+        public const T_AS = \Doctrine\ORM\Query\TokenType::T_AS;
+
+        public const T_ASC = \Doctrine\ORM\Query\TokenType::T_ASC;
+
+        public const T_AVG = \Doctrine\ORM\Query\TokenType::T_AVG;
+
+        public const T_BETWEEN = \Doctrine\ORM\Query\TokenType::T_BETWEEN;
+
+        public const T_BOTH = \Doctrine\ORM\Query\TokenType::T_BOTH;
+
+        public const T_BY = \Doctrine\ORM\Query\TokenType::T_BY;
+
+        public const T_CASE = \Doctrine\ORM\Query\TokenType::T_CASE;
+
+        public const T_COALESCE = \Doctrine\ORM\Query\TokenType::T_COALESCE;
+
+        public const T_COUNT = \Doctrine\ORM\Query\TokenType::T_COUNT;
+
+        public const T_DELETE = \Doctrine\ORM\Query\TokenType::T_DELETE;
+
+        public const T_DESC = \Doctrine\ORM\Query\TokenType::T_DESC;
+
+        public const T_DISTINCT = \Doctrine\ORM\Query\TokenType::T_DISTINCT;
+
+        public const T_ELSE = \Doctrine\ORM\Query\TokenType::T_ELSE;
+
+        public const T_EMPTY = \Doctrine\ORM\Query\TokenType::T_EMPTY;
+
+        public const T_END = \Doctrine\ORM\Query\TokenType::T_END;
+
+        public const T_ESCAPE = \Doctrine\ORM\Query\TokenType::T_ESCAPE;
+
+        public const T_EXISTS = \Doctrine\ORM\Query\TokenType::T_EXISTS;
+
+        public const T_FALSE = \Doctrine\ORM\Query\TokenType::T_FALSE;
+
+        public const T_FROM = \Doctrine\ORM\Query\TokenType::T_FROM;
+
+        public const T_GROUP = \Doctrine\ORM\Query\TokenType::T_GROUP;
+
+        public const T_HAVING = \Doctrine\ORM\Query\TokenType::T_HAVING;
+
+        public const T_HIDDEN = \Doctrine\ORM\Query\TokenType::T_HIDDEN;
+
+        public const T_IN = \Doctrine\ORM\Query\TokenType::T_IN;
+
+        public const T_INDEX = \Doctrine\ORM\Query\TokenType::T_INDEX;
+
+        public const T_INNER = \Doctrine\ORM\Query\TokenType::T_INNER;
+
+        public const T_INSTANCE = \Doctrine\ORM\Query\TokenType::T_INSTANCE;
+        public const T_IS = \Doctrine\ORM\Query\TokenType::T_IS;
+        public const T_JOIN = \Doctrine\ORM\Query\TokenType::T_JOIN;
+        public const T_LEADING = \Doctrine\ORM\Query\TokenType::T_LEADING;
+        public const T_LEFT = \Doctrine\ORM\Query\TokenType::T_LEFT;
+        public const T_LIKE = \Doctrine\ORM\Query\TokenType::T_LIKE;
+        public const T_MAX = \Doctrine\ORM\Query\TokenType::T_MAX;
+        public const T_MEMBER = \Doctrine\ORM\Query\TokenType::T_MEMBER;
+        public const T_MIN = \Doctrine\ORM\Query\TokenType::T_MIN;
+        public const T_NEW = \Doctrine\ORM\Query\TokenType::T_NEW;
+        public const T_NOT = \Doctrine\ORM\Query\TokenType::T_NOT;
+        public const T_NULL = \Doctrine\ORM\Query\TokenType::T_NULL;
+        public const T_NULLIF = \Doctrine\ORM\Query\TokenType::T_NULLIF;
+        public const T_OF = \Doctrine\ORM\Query\TokenType::T_OF;
+        public const T_OR = \Doctrine\ORM\Query\TokenType::T_OR;
+        public const T_ORDER = \Doctrine\ORM\Query\TokenType::T_ORDER;
+        public const T_OUTER = \Doctrine\ORM\Query\TokenType::T_OUTER;
+        public const T_PARTIAL = \Doctrine\ORM\Query\TokenType::T_PARTIAL;
+        public const T_SELECT = \Doctrine\ORM\Query\TokenType::T_SELECT;
+        public const T_SET = \Doctrine\ORM\Query\TokenType::T_SET;
+        public const T_SOME = \Doctrine\ORM\Query\TokenType::T_SOME;
+        public const T_SUM = \Doctrine\ORM\Query\TokenType::T_SUM;
+        public const T_THEN = \Doctrine\ORM\Query\TokenType::T_THEN;
+        public const T_TRAILING = \Doctrine\ORM\Query\TokenType::T_TRAILING;
+        public const T_TRUE = \Doctrine\ORM\Query\TokenType::T_TRUE;
+        public const T_UPDATE = \Doctrine\ORM\Query\TokenType::T_UPDATE;
+        public const T_WHEN = \Doctrine\ORM\Query\TokenType::T_WHEN;
+        public const T_WHERE = \Doctrine\ORM\Query\TokenType::T_WHERE;
+        public const T_WITH = \Doctrine\ORM\Query\TokenType::T_WITH;
+    }
+} else {
+    final class TokenType
+    {
+        public const T_NONE = \Doctrine\ORM\Query\Lexer::T_NONE;
+
+        public const T_INTEGER = \Doctrine\ORM\Query\Lexer::T_INTEGER;
+
+        public const T_STRING = \Doctrine\ORM\Query\Lexer::T_STRING;
+
+        public const T_INPUT_PARAMETER = \Doctrine\ORM\Query\Lexer::T_INPUT_PARAMETER;
+
+        public const T_FLOAT = \Doctrine\ORM\Query\Lexer::T_FLOAT;
+
+        public const T_CLOSE_PARENTHESIS = \Doctrine\ORM\Query\Lexer::T_CLOSE_PARENTHESIS;
+
+        public const T_OPEN_PARENTHESIS = \Doctrine\ORM\Query\Lexer::T_OPEN_PARENTHESIS;
+
+        public const T_COMMA = \Doctrine\ORM\Query\Lexer::T_COMMA;
+
+        public const T_DIVIDE = \Doctrine\ORM\Query\Lexer::T_DIVIDE;
+
+        public const T_DOT = \Doctrine\ORM\Query\Lexer::T_DOT;
+
+        public const T_EQUALS = \Doctrine\ORM\Query\Lexer::T_EQUALS;
+
+        public const T_GREATER_THAN = \Doctrine\ORM\Query\Lexer::T_GREATER_THAN;
+
+        public const T_LOWER_THAN = \Doctrine\ORM\Query\Lexer::T_LOWER_THAN;
+
+        public const T_MINUS = \Doctrine\ORM\Query\Lexer::T_MINUS;
+
+        public const T_MULTIPLY = \Doctrine\ORM\Query\Lexer::T_MULTIPLY;
+
+        public const T_NEGATE = \Doctrine\ORM\Query\Lexer::T_NEGATE;
+
+        public const T_PLUS = \Doctrine\ORM\Query\Lexer::T_PLUS;
+
+        public const T_OPEN_CURLY_BRACE = \Doctrine\ORM\Query\Lexer::T_OPEN_CURLY_BRACE;
+
+        public const T_CLOSE_CURLY_BRACE = \Doctrine\ORM\Query\Lexer::T_CLOSE_CURLY_BRACE;
+
+        public const T_ALIASED_NAME = \Doctrine\ORM\Query\Lexer::T_ALIASED_NAME;
+
+        public const T_FULLY_QUALIFIED_NAME = \Doctrine\ORM\Query\Lexer::T_FULLY_QUALIFIED_NAME;
+
+        public const T_IDENTIFIER = \Doctrine\ORM\Query\Lexer::T_IDENTIFIER;
+
+        public const T_ALL = \Doctrine\ORM\Query\Lexer::T_ALL;
+
+        public const T_AND = \Doctrine\ORM\Query\Lexer::T_AND;
+
+        public const T_ANY = \Doctrine\ORM\Query\Lexer::T_ANY;
+
+        public const T_AS = \Doctrine\ORM\Query\Lexer::T_AS;
+
+        public const T_ASC = \Doctrine\ORM\Query\Lexer::T_ASC;
+
+        public const T_AVG = \Doctrine\ORM\Query\Lexer::T_AVG;
+
+        public const T_BETWEEN = \Doctrine\ORM\Query\Lexer::T_BETWEEN;
+
+        public const T_BOTH = \Doctrine\ORM\Query\Lexer::T_BOTH;
+
+        public const T_BY = \Doctrine\ORM\Query\Lexer::T_BY;
+
+        public const T_CASE = \Doctrine\ORM\Query\Lexer::T_CASE;
+
+        public const T_COALESCE = \Doctrine\ORM\Query\Lexer::T_COALESCE;
+
+        public const T_COUNT = \Doctrine\ORM\Query\Lexer::T_COUNT;
+
+        public const T_DELETE = \Doctrine\ORM\Query\Lexer::T_DELETE;
+
+        public const T_DESC = \Doctrine\ORM\Query\Lexer::T_DESC;
+
+        public const T_DISTINCT = \Doctrine\ORM\Query\Lexer::T_DISTINCT;
+
+        public const T_ELSE = \Doctrine\ORM\Query\Lexer::T_ELSE;
+
+        public const T_EMPTY = \Doctrine\ORM\Query\Lexer::T_EMPTY;
+
+        public const T_END = \Doctrine\ORM\Query\Lexer::T_END;
+
+        public const T_ESCAPE = \Doctrine\ORM\Query\Lexer::T_ESCAPE;
+
+        public const T_EXISTS = \Doctrine\ORM\Query\Lexer::T_EXISTS;
+
+        public const T_FALSE = \Doctrine\ORM\Query\Lexer::T_FALSE;
+
+        public const T_FROM = \Doctrine\ORM\Query\Lexer::T_FROM;
+
+        public const T_GROUP = \Doctrine\ORM\Query\Lexer::T_GROUP;
+
+        public const T_HAVING = \Doctrine\ORM\Query\Lexer::T_HAVING;
+
+        public const T_HIDDEN = \Doctrine\ORM\Query\Lexer::T_HIDDEN;
+
+        public const T_IN = \Doctrine\ORM\Query\Lexer::T_IN;
+
+        public const T_INDEX = \Doctrine\ORM\Query\Lexer::T_INDEX;
+
+        public const T_INNER = \Doctrine\ORM\Query\Lexer::T_INNER;
+
+        public const T_INSTANCE = \Doctrine\ORM\Query\Lexer::T_INSTANCE;
+        public const T_IS = \Doctrine\ORM\Query\Lexer::T_IS;
+        public const T_JOIN = \Doctrine\ORM\Query\Lexer::T_JOIN;
+        public const T_LEADING = \Doctrine\ORM\Query\Lexer::T_LEADING;
+        public const T_LEFT = \Doctrine\ORM\Query\Lexer::T_LEFT;
+        public const T_LIKE = \Doctrine\ORM\Query\Lexer::T_LIKE;
+        public const T_MAX = \Doctrine\ORM\Query\Lexer::T_MAX;
+        public const T_MEMBER = \Doctrine\ORM\Query\Lexer::T_MEMBER;
+        public const T_MIN = \Doctrine\ORM\Query\Lexer::T_MIN;
+        public const T_NEW = \Doctrine\ORM\Query\Lexer::T_NEW;
+        public const T_NOT = \Doctrine\ORM\Query\Lexer::T_NOT;
+        public const T_NULL = \Doctrine\ORM\Query\Lexer::T_NULL;
+        public const T_NULLIF = \Doctrine\ORM\Query\Lexer::T_NULLIF;
+        public const T_OF = \Doctrine\ORM\Query\Lexer::T_OF;
+        public const T_OR = \Doctrine\ORM\Query\Lexer::T_OR;
+        public const T_ORDER = \Doctrine\ORM\Query\Lexer::T_ORDER;
+        public const T_OUTER = \Doctrine\ORM\Query\Lexer::T_OUTER;
+        public const T_PARTIAL = \Doctrine\ORM\Query\Lexer::T_PARTIAL;
+        public const T_SELECT = \Doctrine\ORM\Query\Lexer::T_SELECT;
+        public const T_SET = \Doctrine\ORM\Query\Lexer::T_SET;
+        public const T_SOME = \Doctrine\ORM\Query\Lexer::T_SOME;
+        public const T_SUM = \Doctrine\ORM\Query\Lexer::T_SUM;
+        public const T_THEN = \Doctrine\ORM\Query\Lexer::T_THEN;
+        public const T_TRAILING = \Doctrine\ORM\Query\Lexer::T_TRAILING;
+        public const T_TRUE = \Doctrine\ORM\Query\Lexer::T_TRUE;
+        public const T_UPDATE = \Doctrine\ORM\Query\Lexer::T_UPDATE;
+        public const T_WHEN = \Doctrine\ORM\Query\Lexer::T_WHEN;
+        public const T_WHERE = \Doctrine\ORM\Query\Lexer::T_WHERE;
+        public const T_WITH = \Doctrine\ORM\Query\Lexer::T_WITH;
+    }
+}
diff --git a/src/ORM/Query/AST/ArrayExpression.php b/src/ORM/Query/AST/ArrayExpression.php
index 71a94fa..97d856f 100644
--- a/src/ORM/Query/AST/ArrayExpression.php
+++ b/src/ORM/Query/AST/ArrayExpression.php
@@ -6,8 +6,8 @@
 
 use Doctrine\Common\Lexer\Token;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 final class ArrayExpression extends Node
 {
@@ -42,18 +42,18 @@ public static function parse(Parser $parser): self
         }
 
         switch ($type) {
-            case Lexer::T_INPUT_PARAMETER:
+            case TokenType::T_INPUT_PARAMETER:
                 $nodes[] = $parser->InputParameter();
 
                 break;
-            case Lexer::T_INTEGER:
-            case Lexer::T_FLOAT:
-            case Lexer::T_TRUE:
-            case Lexer::T_FALSE:
-            case Lexer::T_STRING:
+            case TokenType::T_INTEGER:
+            case TokenType::T_FLOAT:
+            case TokenType::T_TRUE:
+            case TokenType::T_FALSE:
+            case TokenType::T_STRING:
                 $nodes[] = $parser->Literal();
-                while ($lexer->isNextToken(Lexer::T_COMMA)) {
-                    $parser->match(Lexer::T_COMMA);
+                while ($lexer->isNextToken(TokenType::T_COMMA)) {
+                    $parser->match(TokenType::T_COMMA);
                     $nodes[] = $parser->Literal();
                 }
 
diff --git a/src/ORM/Query/AST/Functions/AbstractAggregateWithFilterFunction.php b/src/ORM/Query/AST/Functions/AbstractAggregateWithFilterFunction.php
index d8fc90e..6a1d0b0 100644
--- a/src/ORM/Query/AST/Functions/AbstractAggregateWithFilterFunction.php
+++ b/src/ORM/Query/AST/Functions/AbstractAggregateWithFilterFunction.php
@@ -5,9 +5,9 @@
 namespace Pfilsx\PostgreSQLDoctrine\ORM\Query\AST\Functions;
 
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 use Pfilsx\PostgreSQLDoctrine\ORM\Query\AST\FilterExpression;
 use Pfilsx\PostgreSQLDoctrine\ORM\Trait\VariadicTokenTrait;
 
@@ -24,7 +24,7 @@ public function parse(Parser $parser): void
 
         $lexer = $parser->getLexer();
 
-        if (!$lexer->isNextToken(Lexer::T_IDENTIFIER)) {
+        if (!$lexer->isNextToken(TokenType::T_IDENTIFIER)) {
             return;
         }
 
@@ -34,12 +34,12 @@ public function parse(Parser $parser): void
             return;
         }
 
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
 
         $this->filterExpression = new FilterExpression($parser->WhereClause());
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     abstract public function parseFunction(Parser $parser): void;
diff --git a/src/ORM/Query/AST/Functions/AbstractJsonBuildFunction.php b/src/ORM/Query/AST/Functions/AbstractJsonBuildFunction.php
index 6600870..b10c14a 100644
--- a/src/ORM/Query/AST/Functions/AbstractJsonBuildFunction.php
+++ b/src/ORM/Query/AST/Functions/AbstractJsonBuildFunction.php
@@ -6,9 +6,9 @@
 
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 abstract class AbstractJsonBuildFunction extends FunctionNode
 {
@@ -21,18 +21,18 @@ abstract protected function getFunctionName(): string;
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
         $this->elements[] = $parser->StringPrimary();
 
-        if (!$parser->getLexer()->isNextToken(Lexer::T_CLOSE_PARENTHESIS)) {
-            while ($parser->getLexer()->isNextToken(Lexer::T_COMMA)) {
-                $parser->match(Lexer::T_COMMA);
+        if (!$parser->getLexer()->isNextToken(TokenType::T_CLOSE_PARENTHESIS)) {
+            while ($parser->getLexer()->isNextToken(TokenType::T_COMMA)) {
+                $parser->match(TokenType::T_COMMA);
                 $this->elements[] = $parser->StringPrimary();
             }
         }
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/AbstractSingleNodeFunction.php b/src/ORM/Query/AST/Functions/AbstractSingleNodeFunction.php
index 633fb31..3f0e947 100644
--- a/src/ORM/Query/AST/Functions/AbstractSingleNodeFunction.php
+++ b/src/ORM/Query/AST/Functions/AbstractSingleNodeFunction.php
@@ -6,9 +6,9 @@
 
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 abstract class AbstractSingleNodeFunction extends FunctionNode
 {
@@ -20,10 +20,10 @@ abstract protected function parseField(Parser $parser): Node;
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
         $this->field = $this->parseField($parser);
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/AbstractToTsFunction.php b/src/ORM/Query/AST/Functions/AbstractToTsFunction.php
index f8252da..1cc41f0 100644
--- a/src/ORM/Query/AST/Functions/AbstractToTsFunction.php
+++ b/src/ORM/Query/AST/Functions/AbstractToTsFunction.php
@@ -6,9 +6,9 @@
 
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 abstract class AbstractToTsFunction extends FunctionNode
 {
@@ -20,22 +20,22 @@ abstract protected function getFunctionName(): string;
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
 
         $firstNode = $parser->StringPrimary();
 
         $lexer = $parser->getLexer();
 
-        if ($lexer->isNextToken(Lexer::T_COMMA)) {
-            $parser->match(Lexer::T_COMMA);
+        if ($lexer->isNextToken(TokenType::T_COMMA)) {
+            $parser->match(TokenType::T_COMMA);
             $this->config = $firstNode;
             $this->document = $parser->StringPrimary();
         } else {
             $this->document = $firstNode;
         }
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/ArrayAgg.php b/src/ORM/Query/AST/Functions/ArrayAgg.php
index 2a3b6bb..8a6e427 100644
--- a/src/ORM/Query/AST/Functions/ArrayAgg.php
+++ b/src/ORM/Query/AST/Functions/ArrayAgg.php
@@ -8,9 +8,9 @@
 use Doctrine\DBAL\Types\Types;
 use Doctrine\ORM\Query\AST\Node;
 use Doctrine\ORM\Query\AST\TypedExpression;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 use Pfilsx\PostgreSQLDoctrine\ORM\Trait\VariadicTokenTrait;
 
 /**
@@ -37,25 +37,25 @@ final class ArrayAgg extends AbstractAggregateWithFilterFunction implements Type
 
     public function parseFunction(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
 
         $lexer = $parser->getLexer();
-        if ($lexer->isNextToken(Lexer::T_DISTINCT)) {
-            $parser->match(Lexer::T_DISTINCT);
+        if ($lexer->isNextToken(TokenType::T_DISTINCT)) {
+            $parser->match(TokenType::T_DISTINCT);
             $this->distinct = true;
         }
 
         $this->expr = $parser->StringPrimary();
 
-        if ($lexer->isNextToken(Lexer::T_COMMA)) {
-            $parser->match(Lexer::T_COMMA);
-            $parser->match(Lexer::T_STRING);
+        if ($lexer->isNextToken(TokenType::T_COMMA)) {
+            $parser->match(TokenType::T_COMMA);
+            $parser->match(TokenType::T_STRING);
 
             $this->returnType = $this->getTokenField($lexer->token, 'value');
         }
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getFunctionSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/Cast.php b/src/ORM/Query/AST/Functions/Cast.php
index e81e5db..eb4cc02 100644
--- a/src/ORM/Query/AST/Functions/Cast.php
+++ b/src/ORM/Query/AST/Functions/Cast.php
@@ -6,9 +6,9 @@
 
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 use Pfilsx\PostgreSQLDoctrine\ORM\Trait\VariadicTokenTrait;
 
 /**
@@ -28,12 +28,12 @@ final class Cast extends FunctionNode
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
         $this->source = $parser->SimpleArithmeticExpression();
 
-        $parser->match(Lexer::T_AS);
-        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(TokenType::T_AS);
+        $parser->match(TokenType::T_IDENTIFIER);
 
         $type = $this->getTokenField($parser->getLexer()->token, 'value');
 
@@ -43,7 +43,7 @@ public function parse(Parser $parser): void
 
         $this->type = $type;
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/Ceil.php b/src/ORM/Query/AST/Functions/Ceil.php
index f6987ad..525013e 100644
--- a/src/ORM/Query/AST/Functions/Ceil.php
+++ b/src/ORM/Query/AST/Functions/Ceil.php
@@ -6,9 +6,9 @@
 
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 /**
  * Implementation of PostgreSql CEIL() function.
@@ -23,12 +23,12 @@ final class Ceil extends FunctionNode
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
 
         $this->field = $parser->ArithmeticPrimary();
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/Contains.php b/src/ORM/Query/AST/Functions/Contains.php
index b6e1800..62690e3 100644
--- a/src/ORM/Query/AST/Functions/Contains.php
+++ b/src/ORM/Query/AST/Functions/Contains.php
@@ -8,9 +8,9 @@
 use Doctrine\ORM\Query\AST\InputParameter;
 use Doctrine\ORM\Query\AST\Literal;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 /**
  * Implementation of PostgreSql contains operator (||).
@@ -31,12 +31,12 @@ final class Contains extends FunctionNode
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
         $this->field = $parser->StringPrimary();
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
         $this->value = $parser->StringPrimary();
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/Extract.php b/src/ORM/Query/AST/Functions/Extract.php
index 9ae39d8..e8bded3 100644
--- a/src/ORM/Query/AST/Functions/Extract.php
+++ b/src/ORM/Query/AST/Functions/Extract.php
@@ -6,9 +6,9 @@
 
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 use Pfilsx\PostgreSQLDoctrine\ORM\Trait\VariadicTokenTrait;
 
 /**
@@ -28,16 +28,16 @@ class Extract extends FunctionNode
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
 
-        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(TokenType::T_IDENTIFIER);
         $this->expr = $this->getTokenField($parser->getLexer()->token, 'value');
-        $parser->match(Lexer::T_FROM);
+        $parser->match(TokenType::T_FROM);
 
         $this->from = $parser->StringPrimary();
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/Floor.php b/src/ORM/Query/AST/Functions/Floor.php
index 54ff255..ee1b5b0 100644
--- a/src/ORM/Query/AST/Functions/Floor.php
+++ b/src/ORM/Query/AST/Functions/Floor.php
@@ -6,9 +6,9 @@
 
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 /**
  * Implementation of PostgreSql FLOOR() function.
@@ -23,12 +23,12 @@ final class Floor extends FunctionNode
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
 
         $this->field = $parser->ArithmeticPrimary();
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/ILike.php b/src/ORM/Query/AST/Functions/ILike.php
index b03123e..c7bf2eb 100644
--- a/src/ORM/Query/AST/Functions/ILike.php
+++ b/src/ORM/Query/AST/Functions/ILike.php
@@ -6,9 +6,9 @@
 
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 /**
  * Implementation of PostgreSql ILIKE() function.
@@ -29,20 +29,20 @@ class ILike extends FunctionNode
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
         $this->field = $parser->StringPrimary();
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
 
         $lexer = $parser->getLexer();
 
-        if ($lexer->isNextToken(Lexer::T_ANY)) {
-            $parser->match(Lexer::T_ANY);
+        if ($lexer->isNextToken(TokenType::T_ANY)) {
+            $parser->match(TokenType::T_ANY);
             $this->multiple = true;
         }
 
         $this->text = $parser->StringPrimary();
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/JsonAgg.php b/src/ORM/Query/AST/Functions/JsonAgg.php
index 063c91d..5fc8b8c 100644
--- a/src/ORM/Query/AST/Functions/JsonAgg.php
+++ b/src/ORM/Query/AST/Functions/JsonAgg.php
@@ -5,9 +5,9 @@
 namespace Pfilsx\PostgreSQLDoctrine\ORM\Query\AST\Functions;
 
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 /**
  * Implementation of PostgreSql JSON_AGG() function.
@@ -27,17 +27,17 @@ final class JsonAgg extends AbstractAggregateWithFilterFunction
 
     public function parseFunction(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
 
         $lexer = $parser->getLexer();
-        if ($lexer->isNextToken(Lexer::T_DISTINCT)) {
-            $parser->match(Lexer::T_DISTINCT);
+        if ($lexer->isNextToken(TokenType::T_DISTINCT)) {
+            $parser->match(TokenType::T_DISTINCT);
             $this->distinct = true;
         }
 
         $this->expr = $parser->StringPrimary();
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getFunctionSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/JsonGetArrayElement.php b/src/ORM/Query/AST/Functions/JsonGetArrayElement.php
index 9619e8b..350fbdc 100644
--- a/src/ORM/Query/AST/Functions/JsonGetArrayElement.php
+++ b/src/ORM/Query/AST/Functions/JsonGetArrayElement.php
@@ -5,8 +5,8 @@
 namespace Pfilsx\PostgreSQLDoctrine\ORM\Query\AST\Functions;
 
 use Doctrine\ORM\Query\AST\Literal;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 use Pfilsx\PostgreSQLDoctrine\ORM\Trait\VariadicTokenTrait;
 
 /**
@@ -22,22 +22,22 @@ class JsonGetArrayElement extends JsonGetField
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
         $this->field = $parser->StringPrimary();
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
 
-        $parser->match(Lexer::T_INTEGER);
+        $parser->match(TokenType::T_INTEGER);
         $this->path[] = new Literal(Literal::NUMERIC, $this->getTokenField($parser->getLexer()->token, 'value'));
 
-        if (!$parser->getLexer()->isNextToken(Lexer::T_CLOSE_PARENTHESIS)) {
-            while ($parser->getLexer()->isNextToken(Lexer::T_COMMA)) {
-                $parser->match(Lexer::T_COMMA);
+        if (!$parser->getLexer()->isNextToken(TokenType::T_CLOSE_PARENTHESIS)) {
+            while ($parser->getLexer()->isNextToken(TokenType::T_COMMA)) {
+                $parser->match(TokenType::T_COMMA);
 
-                $parser->match(Lexer::T_INTEGER);
+                $parser->match(TokenType::T_INTEGER);
                 $this->path[] = new Literal(Literal::NUMERIC, $this->getTokenField($parser->getLexer()->token, 'value'));
             }
         }
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 }
diff --git a/src/ORM/Query/AST/Functions/JsonGetArrayElementAsText.php b/src/ORM/Query/AST/Functions/JsonGetArrayElementAsText.php
index 094e135..d0e2847 100644
--- a/src/ORM/Query/AST/Functions/JsonGetArrayElementAsText.php
+++ b/src/ORM/Query/AST/Functions/JsonGetArrayElementAsText.php
@@ -5,8 +5,8 @@
 namespace Pfilsx\PostgreSQLDoctrine\ORM\Query\AST\Functions;
 
 use Doctrine\ORM\Query\AST\Literal;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 use Pfilsx\PostgreSQLDoctrine\ORM\Trait\VariadicTokenTrait;
 
 /**
@@ -22,24 +22,24 @@ class JsonGetArrayElementAsText extends JsonGetFieldAsText
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
 
         $this->field = $parser->StringPrimary();
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
 
-        $parser->match(Lexer::T_INTEGER);
+        $parser->match(TokenType::T_INTEGER);
         $this->path[] = new Literal(Literal::NUMERIC, $this->getTokenField($parser->getLexer()->token, 'value'));
 
-        if (!$parser->getLexer()->isNextToken(Lexer::T_CLOSE_PARENTHESIS)) {
-            while ($parser->getLexer()->isNextToken(Lexer::T_COMMA)) {
-                $parser->match(Lexer::T_COMMA);
+        if (!$parser->getLexer()->isNextToken(TokenType::T_CLOSE_PARENTHESIS)) {
+            while ($parser->getLexer()->isNextToken(TokenType::T_COMMA)) {
+                $parser->match(TokenType::T_COMMA);
 
-                $parser->match(Lexer::T_INTEGER);
+                $parser->match(TokenType::T_INTEGER);
                 $this->path[] = new Literal(Literal::NUMERIC, $this->getTokenField($parser->getLexer()->token, 'value'));
             }
         }
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 }
diff --git a/src/ORM/Query/AST/Functions/JsonGetField.php b/src/ORM/Query/AST/Functions/JsonGetField.php
index b2be342..f800d63 100644
--- a/src/ORM/Query/AST/Functions/JsonGetField.php
+++ b/src/ORM/Query/AST/Functions/JsonGetField.php
@@ -6,9 +6,9 @@
 
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 /**
  * Implementation of PostgreSql JSON(B) object field retrieval by path.
@@ -28,21 +28,21 @@ class JsonGetField extends FunctionNode
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
 
         $this->field = $parser->StringPrimary();
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
         $this->path[] = $parser->StringPrimary();
 
-        if (!$parser->getLexer()->isNextToken(Lexer::T_CLOSE_PARENTHESIS)) {
-            while ($parser->getLexer()->isNextToken(Lexer::T_COMMA)) {
-                $parser->match(Lexer::T_COMMA);
+        if (!$parser->getLexer()->isNextToken(TokenType::T_CLOSE_PARENTHESIS)) {
+            while ($parser->getLexer()->isNextToken(TokenType::T_COMMA)) {
+                $parser->match(TokenType::T_COMMA);
                 $this->path[] = $parser->StringPrimary();
             }
         }
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/JsonGetObject.php b/src/ORM/Query/AST/Functions/JsonGetObject.php
index ad3be98..d213b2a 100644
--- a/src/ORM/Query/AST/Functions/JsonGetObject.php
+++ b/src/ORM/Query/AST/Functions/JsonGetObject.php
@@ -6,9 +6,9 @@
 
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 /**
  * Implementation of PostgreSql JSON(B) object retrieval by path.
@@ -25,13 +25,13 @@ class JsonGetObject extends FunctionNode
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
 
         $this->field = $parser->StringPrimary();
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
         $this->path = $parser->StringPrimary();
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/JsonbAgg.php b/src/ORM/Query/AST/Functions/JsonbAgg.php
index fc58b3a..a076d86 100644
--- a/src/ORM/Query/AST/Functions/JsonbAgg.php
+++ b/src/ORM/Query/AST/Functions/JsonbAgg.php
@@ -5,9 +5,9 @@
 namespace Pfilsx\PostgreSQLDoctrine\ORM\Query\AST\Functions;
 
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 /**
  * Implementation of PostgreSql JSONB_AGG() function.
@@ -25,17 +25,17 @@ final class JsonbAgg extends AbstractAggregateWithFilterFunction
 
     public function parseFunction(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
 
         $lexer = $parser->getLexer();
-        if ($lexer->isNextToken(Lexer::T_DISTINCT)) {
-            $parser->match(Lexer::T_DISTINCT);
+        if ($lexer->isNextToken(TokenType::T_DISTINCT)) {
+            $parser->match(TokenType::T_DISTINCT);
             $this->distinct = true;
         }
 
         $this->expr = $parser->StringPrimary();
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getFunctionSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/JsonbConcat.php b/src/ORM/Query/AST/Functions/JsonbConcat.php
index 8ef07fa..ec266f2 100644
--- a/src/ORM/Query/AST/Functions/JsonbConcat.php
+++ b/src/ORM/Query/AST/Functions/JsonbConcat.php
@@ -6,9 +6,9 @@
 
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 /**
  * Implementation of PostgreSql JSONB concatenation operator.
@@ -25,12 +25,12 @@ final class JsonbConcat extends FunctionNode
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
         $this->json1 = $parser->StringPrimary();
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
         $this->json2 = $parser->StringPrimary();
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/JsonbContains.php b/src/ORM/Query/AST/Functions/JsonbContains.php
index dbe5940..0151df1 100644
--- a/src/ORM/Query/AST/Functions/JsonbContains.php
+++ b/src/ORM/Query/AST/Functions/JsonbContains.php
@@ -8,9 +8,9 @@
 use Doctrine\ORM\Query\AST\InputParameter;
 use Doctrine\ORM\Query\AST\Literal;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 /**
  * Implementation of PostgreSql JSONB contains operator.
@@ -31,12 +31,12 @@ final class JsonbContains extends FunctionNode
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
         $this->field = $parser->StringPrimary();
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
         $this->value = $parser->StringPrimary();
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/JsonbExists.php b/src/ORM/Query/AST/Functions/JsonbExists.php
index dcfd972..152ff81 100644
--- a/src/ORM/Query/AST/Functions/JsonbExists.php
+++ b/src/ORM/Query/AST/Functions/JsonbExists.php
@@ -6,9 +6,9 @@
 
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 /**
  * Implementation of PostgreSql JSONB key exists operator.
@@ -25,12 +25,12 @@ final class JsonbExists extends FunctionNode
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
         $this->field = $parser->StringPrimary();
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
         $this->key = $parser->StringPrimary();
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/JsonbRemove.php b/src/ORM/Query/AST/Functions/JsonbRemove.php
index bcf4779..87278d1 100644
--- a/src/ORM/Query/AST/Functions/JsonbRemove.php
+++ b/src/ORM/Query/AST/Functions/JsonbRemove.php
@@ -6,9 +6,9 @@
 
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 /**
  * Implementation of PostgreSql JSONB remove by key operator.
@@ -25,12 +25,12 @@ final class JsonbRemove extends FunctionNode
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
         $this->jsonb = $parser->StringPrimary();
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
         $this->key = $parser->StringPrimary();
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/Overlaps.php b/src/ORM/Query/AST/Functions/Overlaps.php
index e31dada..5edc64e 100644
--- a/src/ORM/Query/AST/Functions/Overlaps.php
+++ b/src/ORM/Query/AST/Functions/Overlaps.php
@@ -6,9 +6,9 @@
 
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 /**
  * Implementation of PostgreSql overlaps operator (&&).
@@ -27,12 +27,12 @@ class Overlaps extends FunctionNode
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
         $this->field = $parser->StringPrimary();
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
         $this->value = $parser->StringPrimary();
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/Random.php b/src/ORM/Query/AST/Functions/Random.php
index 8a26eb4..906eae2 100644
--- a/src/ORM/Query/AST/Functions/Random.php
+++ b/src/ORM/Query/AST/Functions/Random.php
@@ -5,9 +5,9 @@
 namespace Pfilsx\PostgreSQLDoctrine\ORM\Query\AST\Functions;
 
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 /**
  * Implementation of PostgreSql RANDOM() function.
@@ -20,9 +20,9 @@ final class Random extends FunctionNode
 {
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/Round.php b/src/ORM/Query/AST/Functions/Round.php
index 882d1c5..8d1254a 100644
--- a/src/ORM/Query/AST/Functions/Round.php
+++ b/src/ORM/Query/AST/Functions/Round.php
@@ -7,9 +7,9 @@
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 use Doctrine\ORM\Query\AST\Literal;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 /**
  * Implementation of PostgreSql ROUND() function.
@@ -26,17 +26,17 @@ final class Round extends FunctionNode
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
 
         $this->field = $parser->StringPrimary();
 
-        if ($parser->getLexer()->isNextToken(Lexer::T_COMMA)) {
-            $parser->match(Lexer::T_COMMA);
+        if ($parser->getLexer()->isNextToken(TokenType::T_COMMA)) {
+            $parser->match(TokenType::T_COMMA);
             $this->precision = $parser->Literal();
         }
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/StringAgg.php b/src/ORM/Query/AST/Functions/StringAgg.php
index dc21165..9d62c6d 100644
--- a/src/ORM/Query/AST/Functions/StringAgg.php
+++ b/src/ORM/Query/AST/Functions/StringAgg.php
@@ -5,9 +5,9 @@
 namespace Pfilsx\PostgreSQLDoctrine\ORM\Query\AST\Functions;
 
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 /**
  * Implementation of PostgreSql STRING_AGG() function.
@@ -25,20 +25,20 @@ final class StringAgg extends AbstractAggregateWithFilterFunction
 
     public function parseFunction(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
 
         $lexer = $parser->getLexer();
-        if ($lexer->isNextToken(Lexer::T_DISTINCT)) {
-            $parser->match(Lexer::T_DISTINCT);
+        if ($lexer->isNextToken(TokenType::T_DISTINCT)) {
+            $parser->match(TokenType::T_DISTINCT);
             $this->distinct = true;
         }
 
         $this->expr = $parser->StringPrimary();
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
         $this->delimiter = $parser->StringPrimary();
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getFunctionSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/TsHeadline.php b/src/ORM/Query/AST/Functions/TsHeadline.php
index 6df5bde..b95c9d3 100644
--- a/src/ORM/Query/AST/Functions/TsHeadline.php
+++ b/src/ORM/Query/AST/Functions/TsHeadline.php
@@ -6,9 +6,9 @@
 
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 /**
  * Implementation of PostgreSql TS_HEADLINE() function.
@@ -29,24 +29,24 @@ class TsHeadline extends FunctionNode
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
 
         $this->node1 = $parser->StringPrimary();
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
         $this->node2 = $parser->StringPrimary();
 
-        if ($parser->getLexer()->isNextToken(Lexer::T_COMMA)) {
-            $parser->match(Lexer::T_COMMA);
+        if ($parser->getLexer()->isNextToken(TokenType::T_COMMA)) {
+            $parser->match(TokenType::T_COMMA);
             $this->node3 = $parser->StringPrimary();
         }
 
-        if ($parser->getLexer()->isNextToken(Lexer::T_COMMA)) {
-            $parser->match(Lexer::T_COMMA);
+        if ($parser->getLexer()->isNextToken(TokenType::T_COMMA)) {
+            $parser->match(TokenType::T_COMMA);
             $this->node4 = $parser->StringPrimary();
         }
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/TsMatch.php b/src/ORM/Query/AST/Functions/TsMatch.php
index c586347..32587f3 100644
--- a/src/ORM/Query/AST/Functions/TsMatch.php
+++ b/src/ORM/Query/AST/Functions/TsMatch.php
@@ -6,9 +6,9 @@
 
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 /**
  * Implementation of PostgreSql text search matching operator ( @@ ).
@@ -25,12 +25,12 @@ class TsMatch extends FunctionNode
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
         $this->vector = $parser->StringPrimary();
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
         $this->query = $parser->StringPrimary();
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $sqlWalker): string
diff --git a/src/ORM/Query/AST/Functions/TsRank.php b/src/ORM/Query/AST/Functions/TsRank.php
index 1ccf014..fcdc739 100644
--- a/src/ORM/Query/AST/Functions/TsRank.php
+++ b/src/ORM/Query/AST/Functions/TsRank.php
@@ -6,9 +6,9 @@
 
 use Doctrine\ORM\Query\AST\Functions\FunctionNode;
 use Doctrine\ORM\Query\AST\Node;
-use Doctrine\ORM\Query\Lexer;
 use Doctrine\ORM\Query\Parser;
 use Doctrine\ORM\Query\SqlWalker;
+use Pfilsx\PostgreSQLDoctrine\Enum\TokenType;
 
 /**
  * Implementation of PostgreSql TS_RANK() function.
@@ -29,18 +29,18 @@ class TsRank extends FunctionNode
 
     public function parse(Parser $parser): void
     {
-        $parser->match(Lexer::T_IDENTIFIER);
-        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(TokenType::T_IDENTIFIER);
+        $parser->match(TokenType::T_OPEN_PARENTHESIS);
         $this->vector = $parser->StringPrimary();
-        $parser->match(Lexer::T_COMMA);
+        $parser->match(TokenType::T_COMMA);
         $this->query = $parser->StringPrimary();
 
-        if ($parser->getLexer()->isNextToken(Lexer::T_COMMA)) {
-            $parser->match(Lexer::T_COMMA);
+        if ($parser->getLexer()->isNextToken(TokenType::T_COMMA)) {
+            $parser->match(TokenType::T_COMMA);
             $this->normalization = $parser->ArithmeticPrimary();
         }
 
-        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        $parser->match(TokenType::T_CLOSE_PARENTHESIS);
     }
 
     public function getSql(SqlWalker $sqlWalker): string