Subida del módulo y tema de PrestaShop

vendor/beberlei/doctrineextensions/LICENSE

@@ -0,0 +1,28 @@
+Copyright (c) 2010-2020, Benjamin Eberlei <kontakt@beberlei.de> and individual
+contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+
+    3. Neither the name of DoctrineExtensions nor the names of its contributors may be used
+       to endorse or promote products derived from this software without
+       specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/beberlei/doctrineextensions/config/mysql.yml

@@ -0,0 +1,124 @@
+doctrine:
+     orm:
+         dql:
+             datetime_functions:
+                 addtime: DoctrineExtensions\Query\Mysql\AddTime
+                 convert_tz: DoctrineExtensions\Query\Mysql\ConvertTz
+                 date: DoctrineExtensions\Query\Mysql\Date
+                 date_format: DoctrineExtensions\Query\Mysql\DateFormat
+                 dateadd: DoctrineExtensions\Query\Mysql\DateAdd
+                 datesub: DoctrineExtensions\Query\Mysql\DateSub
+                 datediff: DoctrineExtensions\Query\Mysql\DateDiff
+                 day: DoctrineExtensions\Query\Mysql\Day
+                 dayname: DoctrineExtensions\Query\Mysql\DayName
+                 dayofweek: DoctrineExtensions\Query\Mysql\DayOfWeek
+                 dayofyear: DoctrineExtensions\Query\Mysql\DayOfYear
+                 div: DoctrineExtensions\Query\Mysql\Div
+                 from_unixtime: DoctrineExtensions\Query\Mysql\FromUnixtime
+                 hour: DoctrineExtensions\Query\Mysql\Hour
+                 last_day: DoctrineExtensions\Query\Mysql\LastDay
+                 makedate: DoctrineExtensions\Query\Mysql\MakeDate
+                 minute: DoctrineExtensions\Query\Mysql\Minute
+                 now: DoctrineExtensions\Query\Mysql\Now
+                 month: DoctrineExtensions\Query\Mysql\Month
+                 monthname: DoctrineExtensions\Query\Mysql\MonthName
+                 period_diff: DoctrineExtensions\Query\Mysql\PeriodDiff
+                 second: DoctrineExtensions\Query\Mysql\Second
+                 sectotime: DoctrineExtensions\Query\Mysql\SecToTime
+                 strtodate: DoctrineExtensions\Query\Mysql\StrToDate
+                 time: DoctrineExtensions\Query\Mysql\Time
+                 timediff: DoctrineExtensions\Query\Mysql\TimeDiff
+                 timestampadd: DoctrineExtensions\Query\Mysql\TimestampAdd
+                 timestampdiff: DoctrineExtensions\Query\Mysql\TimestampDiff
+                 timetosec: DoctrineExtensions\Query\Mysql\TimeToSec
+                 truncate: DoctrineExtensions\Query\Mysql\Truncate
+                 week: DoctrineExtensions\Query\Mysql\Week
+                 weekday: DoctrineExtensions\Query\Mysql\WeekDay
+                 year: DoctrineExtensions\Query\Mysql\Year
+                 yearmonth: DoctrineExtensions\Query\Mysql\YearMonth
+                 yearweek: DoctrineExtensions\Query\Mysql\YearWeek
+                 unix_timestamp: DoctrineExtensions\Query\Mysql\UnixTimestamp
+                 utc_timestamp: DoctrineExtensions\Query\Mysql\UtcTimestamp
+                 extract: DoctrineExtensions\Query\Mysql\Extract
+
+             numeric_functions:
+                 acos: DoctrineExtensions\Query\Mysql\Acos
+                 asin: DoctrineExtensions\Query\Mysql\Asin
+                 atan2: DoctrineExtensions\Query\Mysql\Atan2
+                 atan: DoctrineExtensions\Query\Mysql\Atan
+                 bit_count: DoctrineExtensions\Query\Mysql\BitCount
+                 bit_xor: DoctrineExtensions\Query\Mysql\BitXor
+                 ceil: DoctrineExtensions\Query\Mysql\Ceil
+                 cos: DoctrineExtensions\Query\Mysql\Cos
+                 cot: DoctrineExtensions\Query\Mysql\Cot
+                 degrees: DoctrineExtensions\Query\Mysql\Degrees
+                 exp: DoctrineExtensions\Query\Mysql\Exp
+                 floor: DoctrineExtensions\Query\Mysql\Floor
+                 json_contains: DoctrineExtensions\Query\Mysql\JsonContains
+                 json_depth: DoctrineExtensions\Query\Mysql\JsonDepth
+                 json_length: DoctrineExtensions\Query\Mysql\JsonLength
+                 log: DoctrineExtensions\Query\Mysql\Log
+                 log10: DoctrineExtensions\Query\Mysql\Log10
+                 log2: DoctrineExtensions\Query\Mysql\Log2
+                 pi: DoctrineExtensions\Query\Mysql\Pi
+                 power: DoctrineExtensions\Query\Mysql\Power
+                 quarter: DoctrineExtensions\Query\Mysql\Quarter
+                 radians: DoctrineExtensions\Query\Mysql\Radians
+                 rand: DoctrineExtensions\Query\Mysql\Rand
+                 round: DoctrineExtensions\Query\Mysql\Round
+                 stddev: DoctrineExtensions\Query\Mysql\StdDev
+                 sin: DoctrineExtensions\Query\Mysql\Sin
+                 std: DoctrineExtensions\Query\Mysql\Std
+                 tan: DoctrineExtensions\Query\Mysql\Tan
+                 variance: DoctrineExtensions\Query\Mysql\Variance
+
+             string_functions:
+                 aes_decrypt: DoctrineExtensions\Query\Mysql\AesDecrypt
+                 aes_encrypt: DoctrineExtensions\Query\Mysql\AesEncrypt
+                 any_value: DoctrineExtensions\Query\Mysql\AnyValue
+                 ascii: DoctrineExtensions\Query\Mysql\Ascii
+                 binary: DoctrineExtensions\Query\Mysql\Binary
+                 cast: DoctrineExtensions\Query\Mysql\Cast
+                 char_length: DoctrineExtensions\Query\Mysql\CharLength
+                 collate: DoctrineExtensions\Query\Mysql\Collate
+                 concat_ws: DoctrineExtensions\Query\Mysql\ConcatWs
+                 countif: DoctrineExtensions\Query\Mysql\CountIf
+                 crc32: DoctrineExtensions\Query\Mysql\Crc32
+                 degrees: DoctrineExtensions\Query\Mysql\Degrees
+                 field: DoctrineExtensions\Query\Mysql\Field
+                 find_in_set: DoctrineExtensions\Query\Mysql\FindInSet
+                 format: DoctrineExtensions\Query\Mysql\Format
+                 from_base64: DoctrineExtensions\Query\Mysql\FromBase64
+                 greatest: DoctrineExtensions\Query\Mysql\Greatest
+                 group_concat: DoctrineExtensions\Query\Mysql\GroupConcat
+                 hex: DoctrineExtensions\Query\Mysql\Hex
+                 ifelse: DoctrineExtensions\Query\Mysql\IfElse
+                 ifnull: DoctrineExtensions\Query\Mysql\IfNull
+                 inet_aton: DoctrineExtensions\Query\Mysql\InetAton
+                 inet_ntoa: DoctrineExtensions\Query\Mysql\InetNtoa
+                 inet6_aton: DoctrineExtensions\Query\Mysql\Inet6Aton
+                 inet6_ntoa: DoctrineExtensions\Query\Mysql\Inet6Ntoa
+                 instr: DoctrineExtensions\Query\Mysql\Instr
+                 is_ipv4: DoctrineExtensions\Query\Mysql\IsIpv4
+                 is_ipv4_compat: DoctrineExtensions\Query\Mysql\IsIpv4Compat
+                 is_ipv4_mapped: DoctrineExtensions\Query\Mysql\IsIpv4Mapped
+                 is_ipv6: DoctrineExtensions\Query\Mysql\IsIpv6
+                 lag: DoctrineExtensions\Query\Mysql\Lag
+                 lead: DoctrineExtensions\Query\Mysql\Lead
+                 least: DoctrineExtensions\Query\Mysql\Least
+                 lpad: DoctrineExtensions\Query\Mysql\Lpad
+                 match: DoctrineExtensions\Query\Mysql\MatchAgainst
+                 md5: DoctrineExtensions\Query\Mysql\Md5
+                 nullif: DoctrineExtensions\Query\Mysql\NullIf
+                 over: DoctrineExtensions\Query\Mysql\Over
+                 radians: DoctrineExtensions\Query\Mysql\Radians
+                 regexp: DoctrineExtensions\Query\Mysql\Regexp
+                 replace: DoctrineExtensions\Query\Mysql\Replace
+                 rpad: DoctrineExtensions\Query\Mysql\Rpad
+                 sha1: DoctrineExtensions\Query\Mysql\Sha1
+                 sha2: DoctrineExtensions\Query\Mysql\Sha2
+                 soundex: DoctrineExtensions\Query\Mysql\Soundex
+                 str_to_date: DoctrineExtensions\Query\Mysql\StrToDate
+                 substring_index: DoctrineExtensions\Query\Mysql\SubstringIndex
+                 unhex: DoctrineExtensions\Query\Mysql\Unhex
+                 uuid_short: DoctrineExtensions\Query\Mysql\UuidShort

vendor/beberlei/doctrineextensions/config/oracle.yml

@@ -0,0 +1,21 @@
+doctrine:
+    orm:
+        dql:
+            datetime_functions:
+                second: DoctrineExtensions\Query\Oracle\Second
+                minute: DoctrineExtensions\Query\Oracle\Minute
+                hour: DoctrineExtensions\Query\Oracle\Hour
+                day: DoctrineExtensions\Query\Oracle\Day
+                month: DoctrineExtensions\Query\Oracle\Month
+                year: DoctrineExtensions\Query\Oracle\Year
+                to_char: DoctrineExtensions\Query\Oracle\ToChar
+                trunc: DoctrineExtensions\Query\Oracle\Trunc
+
+            string_functions:
+                nvl: DoctrineExtensions\Query\Oracle\Nvl
+                listagg: DoctrineExtensions\Query\Oracle\Listagg
+                to_date: DoctrineExtensions\Query\Oracle\ToDate
+
+            numeric_functions:
+                ceil: DoctrineExtensions\Query\Oracle\Ceil
+                floor: DoctrineExtensions\Query\Oracle\Floor

vendor/beberlei/doctrineextensions/config/postgres.yml

@@ -0,0 +1,24 @@
+doctrine:
+    orm:
+        dql:
+            datetime_functions:
+                second: DoctrineExtensions\Query\Postgresql\Second
+                minute: DoctrineExtensions\Query\Postgresql\Minute
+                hour: DoctrineExtensions\Query\Postgresql\Hour
+                day: DoctrineExtensions\Query\Postgresql\Day
+                month: DoctrineExtensions\Query\Postgresql\Month
+                year: DoctrineExtensions\Query\Postgresql\Year
+                date_format: DoctrineExtensions\Query\Postgresql\DateFormat
+                at_time_zone: DoctrineExtensions\Query\Postgresql\AtTimeZoneFunction
+                date_part: DoctrineExtensions\Query\Postgresql\DatePart
+                extract: DoctrineExtensions\Query\Postgresql\ExtractFunction
+                date_trunc: DoctrineExtensions\Query\Postgresql\DateTrunc
+                date: DoctrineExtensions\Query\Postgresql\Date
+
+            string_functions:
+                str_to_date: DoctrineExtensions\Query\Postgresql\StrToDate
+                count_filter: DoctrineExtensions\Query\Postgresql\CountFilterFunction
+                string_agg: DoctrineExtensions\Query\Postgresql\StringAgg
+                greatest: DoctrineExtensions\Query\Postgresql\Greatest
+                least: DoctrineExtensions\Query\Postgresql\Least
+                regexp_replace: DoctrineExtensions\Query\Postgresql\RegexpReplace

vendor/beberlei/doctrineextensions/config/sqlite.yml

@@ -0,0 +1,53 @@
+doctrine:
+     orm:
+         dql:
+             datetime_functions:
+                 second: DoctrineExtensions\Query\Sqlite\Second
+                 minute: DoctrineExtensions\Query\Sqlite\Minute
+                 hour: DoctrineExtensions\Query\Sqlite\Hour
+                 day: DoctrineExtensions\Query\Sqlite\Day
+                 dayname: DoctrineExtensions\Query\Sqlite\DayName
+                 #monthname: DoctrineExtensions\Query\Sqlite\MonthName
+                 month:  DoctrineExtensions\Query\Sqlite\Month
+                 week: DoctrineExtensions\Query\Sqlite\Week
+                 weekday: DoctrineExtensions\Query\Sqlite\WeekDay
+                 year: DoctrineExtensions\Query\Sqlite\Year
+                 date: DoctrineExtensions\Query\Sqlite\Date
+                 date_format: DoctrineExtensions\Query\Sqlite\DateFormat
+                 #dateadd: DoctrineExtensions\Query\Sqlite\DateAdd
+                 #datediff: DoctrineExtensions\Query\Sqlite\DateDiff
+                 julianday: DoctrineExtensions\Query\Sqlite\JulianDay
+                 strftime:  DoctrineExtensions\Query\Sqlite\StrfTime
+                 #strtodate: DoctrineExtensions\Query\Sqlite\StrToDate
+                 #time: DoctrineExtensions\Query\Sqlite\Time
+                 #timestampadd: DoctrineExtensions\Query\Sqlite\TimestampAdd
+                 #timestampdiff: DoctrineExtensions\Query\Sqlite\TimestampDiff
+
+             string_functions:
+#                 binary: DoctrineExtensions\Query\Sqlite\Binary
+#                 char_length: DoctrineExtensions\Query\Sqlite\CharLength
+                 concat_ws: DoctrineExtensions\Query\Sqlite\ConcatWs
+#                 countif: DoctrineExtensions\Query\Sqlite\CountIf
+#                 crc32: DoctrineExtensions\Query\Sqlite\Crc32
+#                 degrees: DoctrineExtensions\Query\Sqlite\Degrees
+#                 field: DoctrineExtensions\Query\Sqlite\Field
+#                 find_in_set: DoctrineExtensions\Query\Sqlite\FindInSet
+#                 group_concat: DoctrineExtensions\Query\Sqlite\GroupConcat
+                 greatest: DoctrineExtensions\Query\Sqlite\Greatest
+                 ifelse: DoctrineExtensions\Query\Sqlite\IfElse
+                 ifnull: DoctrineExtensions\Query\Sqlite\IfNull
+                 least: DoctrineExtensions\Query\Sqlite\Least
+#                 match: DoctrineExtensions\Query\Sqlite\MatchAgainst
+#                 md5: DoctrineExtensions\Query\Sqlite\Md5
+#                 nullif: DoctrineExtensions\Query\Sqlite\NullIf
+#                 radians: DoctrineExtensions\Query\Sqlite\Radians
+                 random: DoctrineExtensions\Query\Sqlite\Random
+#                 regexp: DoctrineExtensions\Query\Sqlite\Regexp
+                 replace: DoctrineExtensions\Query\Sqlite\Replace
+#                 sha1: DoctrineExtensions\Query\Sqlite\Sha1
+#                 sha2: DoctrineExtensions\Query\Sqlite\Sha2
+#                 soundex: DoctrineExtensions\Query\Sqlite\Soundex
+#                 uuid_short: DoctrineExtensions\Query\Sqlite\UuidShort
+
+             numeric_functions:
+                 round: DoctrineExtensions\Query\Sqlite\Round

vendor/beberlei/doctrineextensions/src/Query/Mysql/Acos.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Acos extends FunctionNode
+{
+    public $arithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'ACOS(' . $sqlWalker->walkSimpleArithmeticExpression(
+            $this->arithmeticExpression
+        ) . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->arithmeticExpression = $parser->SimpleArithmeticExpression();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/AddTime.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Pascal Wacker <hello@pascalwacker.ch>
+ */
+class AddTime extends FunctionNode
+{
+    public $date;
+
+    public $time;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'ADDTIME(' . $sqlWalker->walkArithmeticPrimary($this->date) . ', ' . $sqlWalker->walkArithmeticPrimary($this->time) . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->date = $parser->ArithmeticPrimary();
+
+        $parser->match(Lexer::T_COMMA);
+
+        $this->time = $parser->ArithmeticPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/AesDecrypt.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class AesDecrypt extends FunctionNode
+{
+    public $field = '';
+
+    public $key = '';
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->field = $parser->StringExpression();
+        $parser->match(Lexer::T_COMMA);
+        $this->key = $parser->StringExpression();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return sprintf(
+            'AES_DECRYPT(%s, %s)',
+            $this->field->dispatch($sqlWalker),
+            $this->key->dispatch($sqlWalker)
+        );
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/AesEncrypt.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class AesEncrypt extends FunctionNode
+{
+    public $field = '';
+
+    public $key = '';
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->field = $parser->StringExpression();
+        $parser->match(Lexer::T_COMMA);
+        $this->key = $parser->StringExpression();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return sprintf(
+            'AES_ENCRYPT(%s, %s)',
+            $this->field->dispatch($sqlWalker),
+            $this->key->dispatch($sqlWalker)
+        );
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/AnyValue.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class AnyValue extends FunctionNode
+{
+    public $value;
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->value = $parser->StringPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return sprintf(
+            'ANY_VALUE(%s)',
+            $this->value->dispatch($sqlWalker)
+        );
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Ascii.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Ascii extends FunctionNode
+{
+    private $string;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'ASCII('.$sqlWalker->walkArithmeticPrimary($this->string).')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->string = $parser->ArithmeticExpression();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Asin.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Asin extends FunctionNode
+{
+    public $arithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'ASIN(' . $sqlWalker->walkSimpleArithmeticExpression(
+            $this->arithmeticExpression
+        ) . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->arithmeticExpression = $parser->SimpleArithmeticExpression();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Atan.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+use Doctrine\ORM\Query\QueryException;
+
+class Atan extends FunctionNode
+{
+    public $arithmeticExpression;
+
+    public $optionalSecondExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        $secondArgument = '';
+
+        if ($this->optionalSecondExpression) {
+            $secondArgument = $sqlWalker->walkSimpleArithmeticExpression(
+                $this->optionalSecondExpression
+            );
+        }
+
+        return 'ATAN(' . $sqlWalker->walkSimpleArithmeticExpression(
+            $this->arithmeticExpression
+        ) . (($secondArgument) ? ', ' . $secondArgument : '')
+        . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->arithmeticExpression = $parser->SimpleArithmeticExpression();
+
+        try {
+            $parser->match(Lexer::T_COMMA);
+
+            $this->optionalSecondExpression = $parser->SimpleArithmeticExpression();
+
+            $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        } catch (QueryException $e) {
+            $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+        }
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Atan2.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Atan2 extends FunctionNode
+{
+    public $firstExpression;
+
+    public $secondExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        $firstArgument = $sqlWalker->walkSimpleArithmeticExpression(
+            $this->firstExpression
+        );
+
+        $secondArgument = $sqlWalker->walkSimpleArithmeticExpression(
+            $this->secondExpression
+        );
+
+        return 'ATAN2(' . $firstArgument . ', ' . $secondArgument . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->firstExpression = $parser->SimpleArithmeticExpression();
+
+        $parser->match(Lexer::T_COMMA);
+
+        $this->secondExpression = $parser->SimpleArithmeticExpression();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Binary.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Sarjono Mukti Aji <me@simukti.net>
+ */
+class Binary extends FunctionNode
+{
+    private $stringPrimary;
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->stringPrimary = $parser->StringPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'BINARY('.$sqlWalker->walkSimpleArithmeticExpression($this->stringPrimary).')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/BitCount.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class BitCount extends FunctionNode
+{
+    public $arithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'BIT_COUNT(' . $sqlWalker->walkSimpleArithmeticExpression(
+            $this->arithmeticExpression
+        )
+        . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->arithmeticExpression = $parser->SimpleArithmeticExpression();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/BitXor.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * "BIT_XOR" "(" ArithmeticPrimary "," ArithmeticPrimary ")"
+ */
+class BitXor extends FunctionNode
+{
+    public $firstArithmetic;
+
+    public $secondArithmetic;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return $this->firstArithmetic->dispatch($sqlWalker)
+            . ' ^ '
+            . $this->secondArithmetic->dispatch($sqlWalker);
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->firstArithmetic = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_COMMA);
+        $this->secondArithmetic = $parser->ArithmeticPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Cast.php

@@ -0,0 +1,81 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+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\QueryException;
+use Doctrine\ORM\Query\SqlWalker;
+
+/**
+ * "CAST" "(" "$fieldIdentifierExpression" "AS" "$castingTypeExpression" ")"
+ *
+ * @example SELECT CAST(foo.bar AS SIGNED) FROM dual;
+ *
+ * @link https://dev.mysql.com/doc/refman/en/cast-functions.html#function_cast
+ */
+class Cast extends FunctionNode
+{
+    /** @var Node */
+    protected $fieldIdentifierExpression;
+
+    /** @var string */
+    protected $castingTypeExpression;
+
+    /**
+     * @param Parser $parser
+     *
+     * @throws QueryException
+     */
+    public function parse(Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->fieldIdentifierExpression = $parser->SimpleArithmeticExpression();
+
+        $parser->match(Lexer::T_AS);
+        $parser->match(Lexer::T_IDENTIFIER);
+
+        $type = $parser->getLexer()->token['value'];
+
+        if ($parser->getLexer()->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
+            $parser->match(Lexer::T_OPEN_PARENTHESIS);
+            /** @var Literal $parameter */
+            $parameter = $parser->Literal();
+            $parameters = [$parameter->value];
+
+            if ($parser->getLexer()->isNextToken(Lexer::T_COMMA)) {
+                while ($parser->getLexer()->isNextToken(Lexer::T_COMMA)) {
+                    $parser->match(Lexer::T_COMMA);
+                    $parameter = $parser->Literal();
+                    $parameters[] = $parameter->value;
+                }
+            }
+
+            $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+            $type .= '('.implode(', ', $parameters).')';
+        }
+
+        $this->castingTypeExpression = $type;
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    /**
+     * @param SqlWalker $sqlWalker
+     *
+     * @return string
+     */
+    public function getSql(SqlWalker $sqlWalker)
+    {
+        return sprintf(
+            'CAST(%s AS %s)',
+            $sqlWalker->walkSimpleArithmeticExpression($this->fieldIdentifierExpression),
+            $this->castingTypeExpression
+        );
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Ceil.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Ceil extends FunctionNode
+{
+    private $arithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'CEIL(' . $sqlWalker->walkSimpleArithmeticExpression($this->arithmeticExpression) . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->arithmeticExpression = $parser->SimpleArithmeticExpression();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/CharLength.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Metod <metod@simpel.si>
+ */
+class CharLength extends FunctionNode
+{
+    private $expr;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'CHAR_LENGTH('.$sqlWalker->walkArithmeticPrimary($this->expr1).')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->expr1 = $parser->ArithmeticExpression();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Collate.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @link https://dev.mysql.com/doc/refman/en/charset-collate.html
+ * @author Peter Tanath <peter.tanath@gmail.com>
+ */
+class Collate extends FunctionNode
+{
+    /**
+     * @var null
+     */
+    public $stringPrimary = null;
+
+    /**
+     * @var null
+     */
+    public $collation = null;
+
+    /**
+     * @param \Doctrine\ORM\Query\Parser $parser
+     */
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->stringPrimary = $parser->StringPrimary();
+
+        $parser->match(Lexer::T_COMMA);
+        $parser->match(Lexer::T_IDENTIFIER);
+
+        $lexer = $parser->getLexer();
+
+        $this->collation = $lexer->token['value'];
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    /**
+     * @param \Doctrine\ORM\Query\SqlWalker $sqlWalker
+     * @return string
+     */
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return sprintf('%s COLLATE %s', $sqlWalker->walkStringPrimary($this->stringPrimary), $this->collation);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/ConcatWs.php

@@ -0,0 +1,84 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Andrew Mackrodt <andrew@ajmm.org>
+ */
+class ConcatWs extends FunctionNode
+{
+    private $values = [];
+
+    private $notEmpty = false;
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        // Add the concat separator to the values array.
+        $this->values[] = $parser->ArithmeticExpression();
+
+        // Add the rest of the strings to the values array. CONCAT_WS must
+        // be used with at least 2 strings not including the separator.
+
+        $lexer = $parser->getLexer();
+
+        while (count($this->values) < 3 || $lexer->lookahead['type'] == Lexer::T_COMMA) {
+            $parser->match(Lexer::T_COMMA);
+            $peek = $lexer->glimpse();
+
+            $this->values[] = $peek['value'] == '('
+                    ? $parser->FunctionDeclaration()
+                    : $parser->ArithmeticExpression();
+        }
+
+        while ($lexer->lookahead['type'] == Lexer::T_IDENTIFIER) {
+            switch (strtolower($lexer->lookahead['value'])) {
+                case 'notempty':
+                    $parser->match(Lexer::T_IDENTIFIER);
+                    $this->notEmpty = true;
+
+                break;
+                default: // Identifier not recognized (causes exception).
+                    $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+
+                break;
+            }
+        }
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        // Create an array to hold the query elements.
+        $queryBuilder = ['CONCAT_WS('];
+
+        // Iterate over the captured expressions and add them to the query.
+        for ($i = 0; $i < count($this->values); $i++) {
+            if ($i > 0) {
+                $queryBuilder[] = ', ';
+            }
+
+            // Dispatch the walker on the current node.
+            $nodeSql = $sqlWalker->walkArithmeticPrimary($this->values[$i]);
+
+            if ($this->notEmpty) {
+                // Exclude empty strings from the concatenation.
+                $nodeSql = sprintf("NULLIF(%s, '')", $nodeSql);
+            }
+
+            $queryBuilder[] = $nodeSql;
+        }
+
+        // Close the query.
+        $queryBuilder[] = ')';
+
+        // Return the joined query.
+        return implode('', $queryBuilder);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/ConvertTz.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+use Doctrine\ORM\Query\Parser;
+use Doctrine\ORM\Query\SqlWalker;
+
+/**
+ * @link https://dev.mysql.com/doc/refman/en/date-and-time-functions.html#function_convert-tz
+ */
+class ConvertTz extends FunctionNode
+{
+    protected $dateExpression;
+
+    protected $fromTz;
+
+    protected $toTz;
+
+    /**
+     * @inheritdoc
+     */
+    public function getSql(SqlWalker $sqlWalker)
+    {
+        return sprintf(
+            'CONVERT_TZ(%s, %s, %s)',
+            $sqlWalker->walkArithmeticExpression($this->dateExpression),
+            $sqlWalker->walkStringPrimary($this->fromTz),
+            $sqlWalker->walkStringPrimary($this->toTz)
+        );
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function parse(Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->dateExpression = $parser->ArithmeticExpression();
+        $parser->match(Lexer::T_COMMA);
+
+        $this->fromTz = $parser->StringPrimary();
+        $parser->match(Lexer::T_COMMA);
+
+        $this->toTz = $parser->StringPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Cos.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Cos extends FunctionNode
+{
+    public $arithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'COS(' . $sqlWalker->walkSimpleArithmeticExpression(
+            $this->arithmeticExpression
+        ) . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->arithmeticExpression = $parser->SimpleArithmeticExpression();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Cot.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Cot extends FunctionNode
+{
+    public $arithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'COT(' . $sqlWalker->walkSimpleArithmeticExpression(
+            $this->arithmeticExpression
+        ) . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->arithmeticExpression = $parser->SimpleArithmeticExpression();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/CountIf.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Andrew Mackrodt <andrew@ajmm.org>
+ */
+class CountIf extends FunctionNode
+{
+    private $expr1;
+
+    private $expr2;
+
+    private $inverse = false;
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->expr1 = $parser->ArithmeticExpression();
+        $parser->match(Lexer::T_COMMA);
+        $this->expr2 = $parser->ArithmeticExpression();
+
+        $lexer = $parser->getLexer();
+
+        while ($lexer->lookahead['type'] == Lexer::T_IDENTIFIER) {
+            switch (strtolower($lexer->lookahead['value'])) {
+                case 'inverse':
+                    $parser->match(Lexer::T_IDENTIFIER);
+                    $this->inverse = true;
+
+                break;
+                default: // Identifier not recognized (causes exception).
+                    $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+
+                break;
+            }
+        }
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return sprintf(
+            'COUNT(CASE %s WHEN %s THEN %s END)',
+            $sqlWalker->walkArithmeticPrimary($this->expr1),
+            $sqlWalker->walkArithmeticPrimary($this->expr2),
+            !$this->inverse ? '1 ELSE NULL' : 'NULL ELSE 1'
+        );
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Crc32.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Igor Timoshenko <igor.timoshenko@i.ua>
+ */
+class Crc32 extends FunctionNode
+{
+    public $stringPrimary;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'CRC32(' .
+            $sqlWalker->walkStringPrimary($this->stringPrimary) .
+        ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->stringPrimary = $parser->StringPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Date.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Steve Lacey <steve@steve.ly>
+ */
+class Date extends FunctionNode
+{
+    public $date;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'DATE(' . $sqlWalker->walkArithmeticPrimary($this->date) . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->date = $parser->ArithmeticPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/DateAdd.php

@@ -0,0 +1,69 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+use Doctrine\ORM\Query\QueryException;
+
+class DateAdd extends FunctionNode
+{
+    public $firstDateExpression = null;
+
+    public $intervalExpression = null;
+
+    public $unit = null;
+
+    protected static $allowedUnits = [
+        'MICROSECOND',
+        'SECOND',
+        'MINUTE',
+        'HOUR',
+        'DAY',
+        'WEEK',
+        'MONTH',
+        'QUARTER',
+        'YEAR',
+        'SECOND_MICROSECOND',
+        'MINUTE_MICROSECOND',
+        'MINUTE_SECOND',
+        'HOUR_MICROSECOND',
+        'HOUR_SECOND',
+        'HOUR_MINUTE',
+        'DAY_MICROSECOND',
+        'DAY_SECOND',
+        'DAY_MINUTE',
+        'DAY_HOUR',
+        'YEAR_MONTH',
+    ];
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->firstDateExpression = $parser->ArithmeticFactor();
+
+        $parser->match(Lexer::T_COMMA);
+        $this->intervalExpression = $parser->ArithmeticFactor();
+
+        $parser->match(Lexer::T_COMMA);
+        $this->unit = $parser->StringPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        $unit = strtoupper(is_string($this->unit) ? $this->unit : $this->unit->value);
+
+        if (!in_array($unit, self::$allowedUnits)) {
+            throw QueryException::semanticalError('DATE_ADD() does not support unit "' . $unit . '".');
+        }
+
+        return 'DATE_ADD(' .
+            $sqlWalker->walkArithmeticTerm($this->firstDateExpression) . ', INTERVAL ' .
+            $sqlWalker->walkArithmeticTerm($this->intervalExpression) . ' ' . $unit .
+        ')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/DateDiff.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class DateDiff extends FunctionNode
+{
+    public $firstDateExpression = null;
+
+    public $secondDateExpression = null;
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->firstDateExpression = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_COMMA);
+        $this->secondDateExpression = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'DATEDIFF(' .
+            $sqlWalker->walkArithmeticTerm($this->firstDateExpression) . ', ' .
+            $sqlWalker->walkArithmeticTerm($this->secondDateExpression) .
+        ')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/DateFormat.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Steve Lacey <steve@steve.ly>
+ */
+class DateFormat extends FunctionNode
+{
+    public $dateExpression = null;
+
+    public $patternExpression = null;
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->dateExpression = $parser->ArithmeticExpression();
+        $parser->match(Lexer::T_COMMA);
+        $this->patternExpression = $parser->StringPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'DATE_FORMAT(' .
+            $this->dateExpression->dispatch($sqlWalker) . ', ' .
+            $this->patternExpression->dispatch($sqlWalker) .
+        ')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/DateSub.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\QueryException;
+
+/**
+ * @author Vas N <phpvas@gmail.com>
+ */
+class DateSub extends DateAdd
+{
+    /**
+     * @param \Doctrine\ORM\Query\SqlWalker $sqlWalker
+     * @throws QueryException
+     * @return string
+     */
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        $unit = strtoupper(is_string($this->unit) ? $this->unit : $this->unit->value);
+
+        if (!in_array($unit, self::$allowedUnits)) {
+            throw QueryException::semanticalError('DATE_SUB() does not support unit "' . $unit . '".');
+        }
+
+        return 'DATE_SUB(' .
+            $this->firstDateExpression->dispatch($sqlWalker) . ', INTERVAL ' .
+            $this->intervalExpression->dispatch($sqlWalker) . ' ' . $unit .
+        ')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Day.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Rafael Kassner <kassner@gmail.com>
+ * @author Sarjono Mukti Aji <me@simukti.net>
+ */
+class Day extends FunctionNode
+{
+    public $date;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'DAY(' . $sqlWalker->walkArithmeticPrimary($this->date) . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->date = $parser->ArithmeticPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/DayName.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Steve Lacey <steve@steve.ly>
+ */
+class DayName extends FunctionNode
+{
+    public $date;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'DAYNAME(' . $sqlWalker->walkArithmeticPrimary($this->date) . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->date = $parser->ArithmeticPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/DayOfWeek.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class DayOfWeek extends FunctionNode
+{
+    public $date;
+    
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'DAYOFWEEK(' . $sqlWalker->walkArithmeticPrimary($this->date) . ')';
+    }
+    
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        
+        $this->date = $parser->ArithmeticPrimary();
+        
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/DayOfYear.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+use Doctrine\ORM\Query\Parser;
+use Doctrine\ORM\Query\SqlWalker;
+
+class DayOfYear extends FunctionNode
+{
+    /**
+     * @var \Doctrine\ORM\Query\AST\Node
+     */
+    public $date;
+
+    /**
+     * @inheritdoc
+     */
+    public function getSql(SqlWalker $sqlWalker)
+    {
+        return 'DAYOFYEAR(' . $sqlWalker->walkArithmeticPrimary($this->date) . ')';
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function parse(Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->date = $parser->ArithmeticPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Degrees.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Degrees extends FunctionNode
+{
+    public $arithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'DEGREES(' .
+            $sqlWalker->walkSimpleArithmeticExpression(
+                $this->arithmeticExpression
+            ) .
+        ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->arithmeticExpression = $parser->SimpleArithmeticExpression();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Div.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+use Doctrine\ORM\Query\Parser;
+use Doctrine\ORM\Query\SqlWalker;
+
+/**
+ * @link https://dev.mysql.com/doc/refman/en/arithmetic-functions.html#operator_div
+ */
+class Div extends FunctionNode
+{
+    /**
+     * @var \Doctrine\ORM\Query\AST\Node
+     */
+    private $dividend;
+
+    /**
+     * @var \Doctrine\ORM\Query\AST\Node
+     */
+    private $divisor;
+
+    /**
+     * @inheritdoc
+     */
+    public function getSql(SqlWalker $sqlWalker)
+    {
+        return
+            $sqlWalker->walkArithmeticPrimary($this->dividend) . ' DIV ' .
+            $sqlWalker->walkArithmeticPrimary($this->divisor);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function parse(Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->dividend = $parser->ArithmeticPrimary();
+
+        $parser->match(Lexer::T_COMMA);
+
+        $this->divisor = $parser->ArithmeticPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Exp.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Exp extends FunctionNode
+{
+    public $arithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'EXP(' . $sqlWalker->walkSimpleArithmeticExpression(
+            $this->arithmeticExpression
+        ) . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->arithmeticExpression = $parser->SimpleArithmeticExpression();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Extract.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\Lexer;
+use Doctrine\ORM\Query\QueryException;
+
+/**
+ * @author Ahwalian Masykur <ahwalian@gmail.com>
+ */
+class Extract extends DateAdd
+{
+    public $date = null;
+
+    public $unit = null;
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $parser->match(Lexer::T_IDENTIFIER);
+        $lexer = $parser->getLexer();
+        $this->unit = $lexer->token['value'];
+
+        $parser->match(Lexer::T_IDENTIFIER);
+        $this->date = $parser->ArithmeticPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        $unit = strtoupper($this->unit);
+        if (!in_array($unit, self::$allowedUnits)) {
+            throw QueryException::semanticalError('EXTRACT() does not support unit "' . $unit . '".');
+        }
+
+        return 'EXTRACT(' . $unit . ' FROM '. $this->date->dispatch($sqlWalker) . ')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Field.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Jeremy Hicks <jeremy.hicks@gmail.com>
+ */
+class Field extends FunctionNode
+{
+    private $field = null;
+
+    private $values = [];
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        // Do the field.
+        $this->field = $parser->ArithmeticPrimary();
+
+        // Add the strings to the values array. FIELD must
+        // be used with at least 1 string not including the field.
+
+        $lexer = $parser->getLexer();
+
+        while (count($this->values) < 1 ||
+            $lexer->lookahead['type'] != Lexer::T_CLOSE_PARENTHESIS) {
+            $parser->match(Lexer::T_COMMA);
+            $this->values[] = $parser->ArithmeticPrimary();
+        }
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        $query = 'FIELD(';
+
+        $query .= $this->field->dispatch($sqlWalker);
+
+        $query .= ', ';
+
+        for ($i = 0; $i < count($this->values); $i++) {
+            if ($i > 0) {
+                $query .= ', ';
+            }
+
+            $query .= $this->values[$i]->dispatch($sqlWalker);
+        }
+
+        $query .= ')';
+
+        return $query;
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/FindInSet.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class FindInSet extends FunctionNode
+{
+    public $needle = null;
+
+    public $haystack = null;
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->needle = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_COMMA);
+        $this->haystack = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'FIND_IN_SET(' .
+            $this->needle->dispatch($sqlWalker) . ', ' .
+            $this->haystack->dispatch($sqlWalker) .
+        ')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Floor.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Floor extends FunctionNode
+{
+    private $arithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'FLOOR(' . $sqlWalker->walkSimpleArithmeticExpression($this->arithmeticExpression) . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->arithmeticExpression = $parser->SimpleArithmeticExpression();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Format.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Wally Noveno <wally.noveno@gmail.com>
+ */
+class Format extends FunctionNode
+{
+    public $numberExpression = null;
+
+    public $patternExpression = null;
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->numberExpression = $parser->SimpleArithmeticExpression();
+        $parser->match(Lexer::T_COMMA);
+        $this->patternExpression = $parser->SimpleArithmeticExpression();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'FORMAT(' .
+            $this->numberExpression->dispatch($sqlWalker) . ', ' .
+            $this->patternExpression->dispatch($sqlWalker) .
+        ')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/FromBase64.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+use Doctrine\ORM\Query\Parser;
+use Doctrine\ORM\Query\SqlWalker;
+
+/**
+ * "FROM_BASE64" "(" "$fieldIdentifierExpression" ")"
+ *
+ * @example SELECT FROM_BASE64(foo) FROM dual;
+ *
+ * @link https://dev.mysql.com/doc/refman/en/string-functions.html#function_from-base64
+ */
+class FromBase64 extends FunctionNode
+{
+    public $field = null;
+
+    public function parse(Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->field = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(SqlWalker $sqlWalker)
+    {
+        return 'FROM_BASE64(' . $this->field->dispatch($sqlWalker) . ')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/FromUnixtime.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Nima S <nimasdj@yahoo.com>
+ */
+class FromUnixtime extends FunctionNode
+{
+    public $firstExpression = null;
+
+    public $secondExpression = null;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        if (null !== $this->secondExpression) {
+            return 'FROM_UNIXTIME('
+                . $this->firstExpression->dispatch($sqlWalker)
+                . ','
+                . $this->secondExpression->dispatch($sqlWalker)
+                . ')';
+        }
+
+        return 'FROM_UNIXTIME(' . $this->firstExpression->dispatch($sqlWalker) . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $lexer = $parser->getLexer();
+
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->firstExpression = $parser->ArithmeticPrimary();
+
+        // parse second parameter if available
+        if (Lexer::T_COMMA === $lexer->lookahead['type']) {
+            $parser->match(Lexer::T_COMMA);
+            $this->secondExpression = $parser->ArithmeticPrimary();
+        }
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Greatest.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+use Doctrine\ORM\Query\Parser;
+use Doctrine\ORM\Query\SqlWalker;
+
+/**
+ * @author Vas N <phpvas@gmail.com>
+ * @author Guven Atbakan <guven@atbakan.com>
+ */
+class Greatest extends FunctionNode
+{
+    private $field = null;
+
+    private $values = [];
+
+    /**
+     * @param Parser $parser
+     */
+    public function parse(Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->field = $parser->ArithmeticExpression();
+        $lexer = $parser->getLexer();
+
+        while (count($this->values) < 1 ||
+            $lexer->lookahead['type'] != Lexer::T_CLOSE_PARENTHESIS) {
+            $parser->match(Lexer::T_COMMA);
+            $this->values[] = $parser->ArithmeticExpression();
+        }
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    /**
+     * @param SqlWalker $sqlWalker
+     * @return string
+     */
+    public function getSql(SqlWalker $sqlWalker)
+    {
+        $query = 'GREATEST(';
+
+        $query .= $this->field->dispatch($sqlWalker);
+
+        $query .= ', ';
+
+        for ($i = 0; $i < count($this->values); $i++) {
+            if ($i > 0) {
+                $query .= ', ';
+            }
+
+            $query .= $this->values[$i]->dispatch($sqlWalker);
+        }
+
+        $query .= ')';
+
+        return $query;
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/GroupConcat.php

@@ -0,0 +1,82 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class GroupConcat extends FunctionNode
+{
+    public $isDistinct = false;
+
+    public $pathExp = null;
+
+    public $separator = null;
+
+    public $orderBy = null;
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $lexer = $parser->getLexer();
+        if ($lexer->isNextToken(Lexer::T_DISTINCT)) {
+            $parser->match(Lexer::T_DISTINCT);
+
+            $this->isDistinct = true;
+        }
+
+        // first Path Expression is mandatory
+        $this->pathExp = [];
+        if ($lexer->isNextToken(Lexer::T_IDENTIFIER)) {
+            $this->pathExp[] = $parser->StringExpression();
+        } else {
+            $this->pathExp[] = $parser->SingleValuedPathExpression();
+        }
+
+        while ($lexer->isNextToken(Lexer::T_COMMA)) {
+            $parser->match(Lexer::T_COMMA);
+            $this->pathExp[] = $parser->StringPrimary();
+        }
+
+        if ($lexer->isNextToken(Lexer::T_ORDER)) {
+            $this->orderBy = $parser->OrderByClause();
+        }
+
+        if ($lexer->isNextToken(Lexer::T_IDENTIFIER)) {
+            if (strtolower($lexer->lookahead['value']) !== 'separator') {
+                $parser->syntaxError('separator');
+            }
+            $parser->match(Lexer::T_IDENTIFIER);
+
+            $this->separator = $parser->StringPrimary();
+        }
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        $result = 'GROUP_CONCAT(' . ($this->isDistinct ? 'DISTINCT ' : '');
+
+        $fields = [];
+        foreach ($this->pathExp as $pathExp) {
+            $fields[] = $pathExp->dispatch($sqlWalker);
+        }
+
+        $result .= sprintf('%s', implode(', ', $fields));
+
+        if ($this->orderBy) {
+            $result .= ' '.$sqlWalker->walkOrderByClause($this->orderBy);
+        }
+
+        if ($this->separator) {
+            $result .= ' SEPARATOR '.$sqlWalker->walkStringPrimary($this->separator);
+        }
+
+        $result .= ')';
+
+        return $result;
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Hex.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Hex extends FunctionNode
+{
+    public $arithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'HEX(' . $sqlWalker->walkSimpleArithmeticExpression($this->arithmeticExpression) . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->arithmeticExpression = $parser->SimpleArithmeticExpression();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Hour.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Dawid Nowak <macdada@mmg.pl>
+ */
+class Hour extends FunctionNode
+{
+    public $date;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'HOUR('.$sqlWalker->walkArithmeticPrimary($this->date).')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->date = $parser->ArithmeticPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/IfElse.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Andrew Mackrodt <andrew@ajmm.org>
+ */
+class IfElse extends FunctionNode
+{
+    private $expr = [];
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->expr[] = $parser->ConditionalExpression();
+
+        $parser->match(Lexer::T_COMMA);
+        if ($parser->getLexer()->isNextToken(Lexer::T_NULL)) {
+            $parser->match(Lexer::T_NULL);
+            $this->expr[] = null;
+        } else {
+            $this->expr[] = $parser->ArithmeticExpression();
+        }
+        $parser->match(Lexer::T_COMMA);
+        if ($parser->getLexer()->isNextToken(Lexer::T_NULL)) {
+            $parser->match(Lexer::T_NULL);
+            $this->expr[] = null;
+        } else {
+            $this->expr[] = $parser->ArithmeticExpression();
+        }
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return sprintf(
+            'IF(%s, %s, %s)',
+            $sqlWalker->walkConditionalExpression($this->expr[0]),
+            $this->expr[1] !== null ? $sqlWalker->walkArithmeticPrimary($this->expr[1]) : 'NULL',
+            $this->expr[2] !== null ? $sqlWalker->walkArithmeticPrimary($this->expr[2]) : 'NULL'
+        );
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/IfNull.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Andrew Mackrodt <andrew@ajmm.org>
+ */
+class IfNull extends FunctionNode
+{
+    private $expr1;
+
+    private $expr2;
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->expr1 = $parser->ArithmeticExpression();
+        $parser->match(Lexer::T_COMMA);
+        $this->expr2 = $parser->ArithmeticExpression();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'IFNULL('
+            .$sqlWalker->walkArithmeticPrimary($this->expr1). ', '
+            .$sqlWalker->walkArithmeticPrimary($this->expr2).')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Inet6Aton.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+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\QueryException;
+use Doctrine\ORM\Query\SqlWalker;
+
+class Inet6Aton extends FunctionNode
+{
+    public $valueExpression = null;
+
+    /**
+     * @param Parser $parser
+     *
+     * @throws QueryException
+     */
+    public function parse(Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->valueExpression = $parser->StringPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    /**
+     * @param SqlWalker $sqlWalker
+     *
+     * @return string
+     */
+    public function getSql(SqlWalker $sqlWalker)
+    {
+        return 'INET6_ATON('
+            . (
+                $this->valueExpression instanceof Node
+                ? $this->valueExpression->dispatch($sqlWalker)
+                : "'" . $this->valueExpression . "'"
+            )
+            .')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Inet6Ntoa.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+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\QueryException;
+use Doctrine\ORM\Query\SqlWalker;
+
+class Inet6Ntoa extends FunctionNode
+{
+    public $valueExpression = null;
+
+    /**
+     * @param Parser $parser
+     *
+     * @throws QueryException
+     */
+    public function parse(Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->valueExpression = $parser->StringPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    /**
+     * @param SqlWalker $sqlWalker
+     *
+     * @return string
+     */
+    public function getSql(SqlWalker $sqlWalker)
+    {
+        return 'INET6_NTOA('
+            . (
+                $this->valueExpression instanceof Node
+                ? $this->valueExpression->dispatch($sqlWalker)
+                : "'" . $this->valueExpression . "'"
+            )
+            .')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/InetAton.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+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\QueryException;
+use Doctrine\ORM\Query\SqlWalker;
+
+class InetAton extends FunctionNode
+{
+    public $valueExpression = null;
+
+    /**
+     * @param Parser $parser
+     *
+     * @throws QueryException
+     */
+    public function parse(Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->valueExpression = $parser->StringPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    /**
+     * @param SqlWalker $sqlWalker
+     *
+     * @return string
+     */
+    public function getSql(SqlWalker $sqlWalker)
+    {
+        return 'INET_ATON('
+            . (
+                $this->valueExpression instanceof Node
+                ? $this->valueExpression->dispatch($sqlWalker)
+                : "'" . $this->valueExpression . "'"
+            )
+            .')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/InetNtoa.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+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\QueryException;
+use Doctrine\ORM\Query\SqlWalker;
+
+class InetNtoa extends FunctionNode
+{
+    public $valueExpression = null;
+
+    /**
+     * @param Parser $parser
+     *
+     * @throws QueryException
+     */
+    public function parse(Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->valueExpression = $parser->StringPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    /**
+     * @param SqlWalker $sqlWalker
+     *
+     * @return string
+     */
+    public function getSql(SqlWalker $sqlWalker)
+    {
+        return 'INET_NTOA('
+            . (
+                $this->valueExpression instanceof Node
+                ? $this->valueExpression->dispatch($sqlWalker)
+                : "'" . $this->valueExpression . "'"
+            )
+            .')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Instr.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use  Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use  Doctrine\ORM\Query\Lexer;
+use  Doctrine\ORM\Query\Parser;
+use  Doctrine\ORM\Query\SqlWalker;
+
+class Instr extends FunctionNode
+{
+    public $originalString = null;
+
+    public $subString = null;
+
+    /**
+     * @param \Doctrine\ORM\Query\Parser $parser
+     */
+    public function parse(Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->originalString = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_COMMA);
+        $this->subString = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    /**
+     * @param \Doctrine\ORM\Query\SqlWalker $sqlWalker
+     * @return string
+     */
+    public function getSql(SqlWalker $sqlWalker)
+    {
+        return sprintf(
+            'INSTR(%s, %s)',
+            $this->originalString->dispatch($sqlWalker),
+            $this->subString->dispatch($sqlWalker)
+        );
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/IsIpv4.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+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\QueryException;
+use Doctrine\ORM\Query\SqlWalker;
+
+class IsIpv4 extends FunctionNode
+{
+    public $valueExpression = null;
+
+    /**
+     * @param Parser $parser
+     *
+     * @throws QueryException
+     */
+    public function parse(Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->valueExpression = $parser->StringPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    /**
+     * @param SqlWalker $sqlWalker
+     *
+     * @return string
+     */
+    public function getSql(SqlWalker $sqlWalker)
+    {
+        return 'IS_IPV4('
+            . (
+                $this->valueExpression instanceof Node
+                ? $this->valueExpression->dispatch($sqlWalker)
+                : "'" . $this->valueExpression . "'"
+            )
+            .')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/IsIpv4Compat.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+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\QueryException;
+use Doctrine\ORM\Query\SqlWalker;
+
+class IsIpv4Compat extends FunctionNode
+{
+    public $valueExpression = null;
+
+    /**
+     * @param Parser $parser
+     *
+     * @throws QueryException
+     */
+    public function parse(Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->valueExpression = $parser->StringPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    /**
+     * @param SqlWalker $sqlWalker
+     *
+     * @return string
+     */
+    public function getSql(SqlWalker $sqlWalker)
+    {
+        return 'IS_IPV4_COMPAT('
+            . (
+                $this->valueExpression instanceof Node
+                ? $this->valueExpression->dispatch($sqlWalker)
+                : "'" . $this->valueExpression . "'"
+            )
+            .')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/IsIpv4Mapped.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+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\QueryException;
+use Doctrine\ORM\Query\SqlWalker;
+
+class IsIpv4Mapped extends FunctionNode
+{
+    public $valueExpression = null;
+
+    /**
+     * @param Parser $parser
+     *
+     * @throws QueryException
+     */
+    public function parse(Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->valueExpression = $parser->StringPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    /**
+     * @param SqlWalker $sqlWalker
+     *
+     * @return string
+     */
+    public function getSql(SqlWalker $sqlWalker)
+    {
+        return 'IS_IPV4_MAPPED('
+            . (
+                $this->valueExpression instanceof Node
+                ? $this->valueExpression->dispatch($sqlWalker)
+                : "'" . $this->valueExpression . "'"
+            )
+            .')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/IsIpv6.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+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\QueryException;
+use Doctrine\ORM\Query\SqlWalker;
+
+class IsIpv6 extends FunctionNode
+{
+    public $valueExpression = null;
+
+    /**
+     * @param Parser $parser
+     *
+     * @throws QueryException
+     */
+    public function parse(Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->valueExpression = $parser->StringPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    /**
+     * @param SqlWalker $sqlWalker
+     *
+     * @return string
+     */
+    public function getSql(SqlWalker $sqlWalker)
+    {
+        return 'IS_IPV6('
+            . (
+                $this->valueExpression instanceof Node
+                ? $this->valueExpression->dispatch($sqlWalker)
+                : "'" . $this->valueExpression . "'"
+            )
+            .')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/JsonContains.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+use Doctrine\ORM\Query\Parser;
+use Doctrine\ORM\Query\SqlWalker;
+
+class JsonContains extends FunctionNode
+{
+    protected $target;
+
+    protected $candidate;
+
+    protected $path;
+
+    public function parse(Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->target = $parser->StringPrimary();
+
+        $parser->match(Lexer::T_COMMA);
+
+        $this->candidate = $parser->StringPrimary();
+
+        if ($parser->getLexer()->isNextToken(Lexer::T_COMMA)) {
+            $parser->match(Lexer::T_COMMA);
+
+            $this->path = $parser->StringPrimary();
+        }
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(SqlWalker $sqlWalker)
+    {
+        $target = $sqlWalker->walkStringPrimary($this->target);
+        $candidate = $sqlWalker->walkStringPrimary($this->candidate);
+
+        if ($this->path !== null) {
+            $path = $sqlWalker->walkStringPrimary($this->path);
+
+            return sprintf('JSON_CONTAINS(%s, %s, %s)', $target, $candidate, $path);
+        }
+
+        return sprintf('JSON_CONTAINS(%s, %s)', $target, $candidate);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/JsonDepth.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+use Doctrine\ORM\Query\Parser;
+use Doctrine\ORM\Query\SqlWalker;
+
+class JsonDepth extends FunctionNode
+{
+    protected $target;
+
+    public function parse(Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->target = $parser->StringPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(SqlWalker $sqlWalker)
+    {
+        return sprintf('JSON_DEPTH(%s)', $sqlWalker->walkStringPrimary($this->target));
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/JsonLength.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+use Doctrine\ORM\Query\Parser;
+use Doctrine\ORM\Query\SqlWalker;
+
+class JsonLength extends FunctionNode
+{
+    protected $target;
+
+    protected $path;
+
+    public function parse(Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->target = $parser->StringPrimary();
+
+        if ($parser->getLexer()->isNextToken(Lexer::T_COMMA)) {
+            $parser->match(Lexer::T_COMMA);
+
+            $this->path = $parser->StringPrimary();
+        }
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(SqlWalker $sqlWalker)
+    {
+        $target = $sqlWalker->walkStringPrimary($this->target);
+
+        if ($this->path !== null) {
+            $path = $sqlWalker->walkStringPrimary($this->path);
+
+            return sprintf('JSON_LENGTH(%s, %s)', $target, $path);
+        }
+
+        return sprintf('JSON_LENGTH(%s)', $target);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Lag.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\AggregateExpression;
+use Doctrine\ORM\Query\AST\ArithmeticExpression;
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\AST\SimpleArithmeticExpression;
+use Doctrine\ORM\Query\Lexer;
+use Doctrine\ORM\Query\Parser;
+use Doctrine\ORM\Query\SqlWalker;
+
+class Lag extends FunctionNode
+{
+    /** @var AggregateExpression */
+    private $aggregateExpression;
+
+    /** @var ArithmeticExpression */
+    private $offset;
+
+    /** @var SimpleArithmeticExpression */
+    private $defaultValue;
+
+    public function getSql(SqlWalker $sqlWalker): string
+    {
+        if (isset($this->offset, $this->defaultValue)) {
+            return 'LAG(' . $sqlWalker->walkAggregateExpression($this->aggregateExpression) . ', ' . $sqlWalker->walkArithmeticPrimary($this->offset) . ', ' . $sqlWalker->walkSimpleArithmeticExpression($this->defaultValue) . ')';
+        }
+        if (isset($this->offset)) {
+            return 'LAG(' . $sqlWalker->walkAggregateExpression($this->aggregateExpression) . ', ' . $sqlWalker->walkArithmeticPrimary($this->offset) . ')';
+        }
+
+        return 'LAG(' . $sqlWalker->walkAggregateExpression($this->aggregateExpression) . ')';
+    }
+
+    public function parse(Parser $parser): void
+    {
+        $lexer = $parser->getLexer();
+
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->aggregateExpression = $parser->StringExpression();
+        if (!$lexer->isNextToken(Lexer::T_CLOSE_PARENTHESIS)) {
+            $parser->match(Lexer::T_COMMA);
+            $this->offset = $parser->ArithmeticPrimary();
+        }
+        if (!$lexer->isNextToken(Lexer::T_CLOSE_PARENTHESIS)) {
+            $parser->match(Lexer::T_COMMA);
+            $this->defaultValue = $parser->SimpleArithmeticExpression();
+        }
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/LastDay.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Rafael Kassner <kassner@gmail.com>
+ * @author Sarjono Mukti Aji <me@simukti.net>
+ */
+class LastDay extends FunctionNode
+{
+    public $date;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'LAST_DAY(' . $sqlWalker->walkArithmeticPrimary($this->date) . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->date = $parser->ArithmeticPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Lead.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\AggregateExpression;
+use Doctrine\ORM\Query\AST\ArithmeticExpression;
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\AST\SimpleArithmeticExpression;
+use Doctrine\ORM\Query\Lexer;
+use Doctrine\ORM\Query\Parser;
+use Doctrine\ORM\Query\SqlWalker;
+
+class Lead extends FunctionNode
+{
+    /** @var AggregateExpression */
+    private $aggregateExpression;
+
+    /** @var ArithmeticExpression */
+    private $offset;
+
+    /** @var SimpleArithmeticExpression */
+    private $defaultValue;
+
+    public function getSql(SqlWalker $sqlWalker): string
+    {
+        if (isset($this->offset, $this->defaultValue)) {
+            return 'LEAD(' . $sqlWalker->walkAggregateExpression($this->aggregateExpression) . ', ' . $sqlWalker->walkArithmeticPrimary($this->offset) . ', ' . $sqlWalker->walkSimpleArithmeticExpression($this->defaultValue) . ')';
+        }
+        if (isset($this->offset)) {
+            return 'LEAD(' . $sqlWalker->walkAggregateExpression($this->aggregateExpression) . ', ' . $sqlWalker->walkArithmeticPrimary($this->offset) . ')';
+        }
+
+        return 'LEAD(' . $sqlWalker->walkAggregateExpression($this->aggregateExpression) . ')';
+    }
+
+    public function parse(Parser $parser): void
+    {
+        $lexer = $parser->getLexer();
+
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->aggregateExpression = $parser->StringExpression();
+        if (!$lexer->isNextToken(Lexer::T_CLOSE_PARENTHESIS)) {
+            $parser->match(Lexer::T_COMMA);
+            $this->offset = $parser->ArithmeticPrimary();
+        }
+        if (!$lexer->isNextToken(Lexer::T_CLOSE_PARENTHESIS)) {
+            $parser->match(Lexer::T_COMMA);
+            $this->defaultValue = $parser->SimpleArithmeticExpression();
+        }
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Least.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+use Doctrine\ORM\Query\Parser;
+use Doctrine\ORM\Query\SqlWalker;
+
+/**
+ * @author Vas N <phpvas@gmail.com>
+ */
+class Least extends FunctionNode
+{
+    private $field = null;
+
+    private $values = [];
+
+    /**
+     * @param Parser $parser
+     */
+    public function parse(Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->field = $parser->ArithmeticExpression();
+        $lexer = $parser->getLexer();
+
+        while (count($this->values) < 1 ||
+            $lexer->lookahead['type'] != Lexer::T_CLOSE_PARENTHESIS) {
+            $parser->match(Lexer::T_COMMA);
+            $this->values[] = $parser->ArithmeticExpression();
+        }
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    /**
+     * @param SqlWalker $sqlWalker
+     * @return string
+     */
+    public function getSql(SqlWalker $sqlWalker)
+    {
+        $query = 'LEAST(';
+
+        $query .= $this->field->dispatch($sqlWalker);
+
+        $query .= ', ';
+
+        for ($i = 0; $i < count($this->values); $i++) {
+            if ($i > 0) {
+                $query .= ', ';
+            }
+
+            $query .= $this->values[$i]->dispatch($sqlWalker);
+        }
+
+        $query .= ')';
+
+        return $query;
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Log.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Log extends FunctionNode
+{
+    public $arithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'LOG(' . $sqlWalker->walkSimpleArithmeticExpression(
+            $this->arithmeticExpression
+        ) . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->arithmeticExpression = $parser->SimpleArithmeticExpression();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Log10.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Log10 extends FunctionNode
+{
+    public $arithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'LOG10(' . $sqlWalker->walkSimpleArithmeticExpression(
+            $this->arithmeticExpression
+        ) . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->arithmeticExpression = $parser->SimpleArithmeticExpression();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Log2.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Log2 extends FunctionNode
+{
+    public $arithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'LOG2(' . $sqlWalker->walkSimpleArithmeticExpression(
+            $this->arithmeticExpression
+        ) . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->arithmeticExpression = $parser->SimpleArithmeticExpression();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Lpad.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Giulia Santoiemma <giuliaries@gmail.com>
+ */
+class Lpad extends FunctionNode
+{
+    public $string = null;
+
+    public $length = null;
+
+    public $padstring = null;
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->string = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_COMMA);
+        $this->length = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_COMMA);
+        $this->padstring = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'LPAD(' .
+        $this->string->dispatch($sqlWalker) . ', ' .
+        $this->length->dispatch($sqlWalker) . ', ' .
+        $this->padstring->dispatch($sqlWalker) .
+        ')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/MakeDate.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class MakeDate extends FunctionNode
+{
+    public $year      = null;
+
+    public $dayOfYear = null;
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->year = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_COMMA);
+        $this->dayOfYear = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'MAKEDATE('.
+            $sqlWalker->walkArithmeticPrimary($this->year).', '.
+            $sqlWalker->walkArithmeticPrimary($this->dayOfYear).
+            ')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/MatchAgainst.php

@@ -0,0 +1,105 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class MatchAgainst extends FunctionNode
+{
+    /** @var array list of \Doctrine\ORM\Query\AST\PathExpression */
+    protected $pathExp = null;
+
+    /** @var string */
+    protected $against = null;
+
+    /** @var bool */
+    protected $booleanMode = false;
+
+    /** @var bool */
+    protected $queryExpansion = false;
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        // match
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        // first Path Expression is mandatory
+        $this->pathExp = [];
+        $this->pathExp[] = $parser->StateFieldPathExpression();
+
+        // Subsequent Path Expressions are optional
+        $lexer = $parser->getLexer();
+        while ($lexer->isNextToken(Lexer::T_COMMA)) {
+            $parser->match(Lexer::T_COMMA);
+            $this->pathExp[] = $parser->StateFieldPathExpression();
+        }
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+
+        // against
+        if (strtolower($lexer->lookahead['value']) !== 'against') {
+            $parser->syntaxError('against');
+        }
+
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->against = $parser->StringPrimary();
+
+        if (strtolower($lexer->lookahead['value']) === 'boolean') {
+            $parser->match(Lexer::T_IDENTIFIER);
+            $this->booleanMode = true;
+        } elseif (strtolower($lexer->lookahead['value']) === 'in') {
+            $parser->match(Lexer::T_IDENTIFIER);
+
+            if (strtolower($lexer->lookahead['value']) !== 'boolean') {
+                $parser->syntaxError('boolean');
+            }
+            $parser->match(Lexer::T_IDENTIFIER);
+
+            if (strtolower($lexer->lookahead['value']) !== 'mode') {
+                $parser->syntaxError('mode');
+            }
+            $parser->match(Lexer::T_IDENTIFIER);
+
+            $this->booleanMode = true;
+        }
+
+        if (strtolower($lexer->lookahead['value']) === 'expand') {
+            $parser->match(Lexer::T_IDENTIFIER);
+            $this->queryExpansion = true;
+        } elseif (strtolower($lexer->lookahead['value']) === 'with') {
+            $parser->match(Lexer::T_IDENTIFIER);
+
+            if (strtolower($lexer->lookahead['value']) !== 'query') {
+                $parser->syntaxError('query');
+            }
+            $parser->match(Lexer::T_IDENTIFIER);
+
+            if (strtolower($lexer->lookahead['value']) !== 'expansion') {
+                $parser->syntaxError('expansion');
+            }
+            $parser->match(Lexer::T_IDENTIFIER);
+
+            $this->queryExpansion = true;
+        }
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $walker)
+    {
+        $fields = [];
+
+        foreach ($this->pathExp as $pathExp) {
+            $fields[] = $pathExp->dispatch($walker);
+        }
+
+        $against = $walker->walkStringPrimary($this->against)
+        . ($this->booleanMode ? ' IN BOOLEAN MODE' : '')
+        . ($this->queryExpansion ? ' WITH QUERY EXPANSION' : '');
+
+        return sprintf('MATCH (%s) AGAINST (%s)', implode(', ', $fields), $against);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Md5.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Andreas Gallien <gallien@seleos.de>
+ */
+class Md5 extends FunctionNode
+{
+    public $stringPrimary;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return $sqlWalker->getConnection()->getDatabasePlatform()->getMd5Expression(
+            $sqlWalker->walkStringPrimary($this->stringPrimary)
+        );
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->stringPrimary = $parser->StringPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Minute.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Martin Štekl <martin.stekl@gmail.com>
+ */
+class Minute extends FunctionNode
+{
+    public $date;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'MINUTE('.$sqlWalker->walkArithmeticPrimary($this->date).')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->date = $parser->ArithmeticPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Month.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Rafael Kassner <kassner@gmail.com>
+ * @author Sarjono Mukti Aji <me@simukti.net>
+ */
+class Month extends FunctionNode
+{
+    public $date;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'MONTH(' . $sqlWalker->walkArithmeticPrimary($this->date) . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->date = $parser->ArithmeticPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/MonthName.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Steve Lacey <steve@steve.ly>
+ */
+class MonthName extends FunctionNode
+{
+    public $date;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'MONTHNAME(' . $sqlWalker->walkArithmeticPrimary($this->date) . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->date = $parser->ArithmeticPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Now.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Now extends FunctionNode
+{
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'NOW()';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/NullIf.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Andrew Mackrodt <andrew@ajmm.org>
+ */
+class NullIf extends FunctionNode
+{
+    private $expr1;
+
+    private $expr2;
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->expr1 = $parser->ArithmeticExpression();
+        $parser->match(Lexer::T_COMMA);
+        $this->expr2 = $parser->ArithmeticExpression();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return sprintf(
+            'NULLIF(%s, %s)',
+            $sqlWalker->walkArithmeticPrimary($this->expr1),
+            $sqlWalker->walkArithmeticPrimary($this->expr2)
+        );
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Over.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\ArithmeticExpression;
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\AST\OrderByClause;
+use Doctrine\ORM\Query\Lexer;
+use Doctrine\ORM\Query\Parser;
+use Doctrine\ORM\Query\SqlWalker;
+
+class Over extends FunctionNode
+{
+    /** @var ArithmeticExpression */
+    private $arithmeticExpression;
+
+    /** @var OrderByClause|null */
+    private $orderByClause;
+
+    public function getSql(SqlWalker $sqlWalker): string
+    {
+        return isset($this->orderByClause) && count($this->orderByClause->orderByItems) > 0
+            ? $sqlWalker->walkArithmeticExpression($this->arithmeticExpression) . ' OVER (' . trim($sqlWalker->walkOrderByClause($this->orderByClause)) . ')'
+            : $sqlWalker->walkArithmeticExpression($this->arithmeticExpression) . ' OVER ()';
+    }
+
+    public function parse(Parser $parser): void
+    {
+        $lexer = $parser->getLexer();
+
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->arithmeticExpression = $parser->ArithmeticExpression();
+        if (!$lexer->isNextToken(Lexer::T_CLOSE_PARENTHESIS)) {
+            $parser->match(Lexer::T_COMMA);
+            $this->orderByClause = $parser->OrderByClause();
+        }
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/PeriodDiff.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class PeriodDiff extends FunctionNode
+{
+    public $firstDateExpression = null;
+
+    public $secondDateExpression = null;
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->firstDateExpression = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_COMMA);
+        $this->secondDateExpression = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'PERIOD_DIFF(' .
+            $sqlWalker->walkArithmeticTerm($this->firstDateExpression) . ', ' .
+            $sqlWalker->walkArithmeticTerm($this->secondDateExpression) .
+        ')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Pi.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Pi extends FunctionNode
+{
+    public $arithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'PI()';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Power.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Power extends FunctionNode
+{
+    public $arithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'POWER(' . $this->arithmeticExpression->dispatch($sqlWalker) . ', '
+         . $this->power->dispatch($sqlWalker) . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->arithmeticExpression = $parser->SimpleArithmeticExpression();
+        $parser->match(Lexer::T_COMMA);
+        $this->power = $parser->ArithmeticExpression();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Quarter.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Martin Štekl <martin.stekl@gmail.com>
+ */
+class Quarter extends FunctionNode
+{
+    public $date;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'QUARTER('.$sqlWalker->walkArithmeticPrimary($this->date).')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->date = $parser->ArithmeticPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Radians.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Radians extends FunctionNode
+{
+    public $arithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'RADIANS(' .
+            $sqlWalker->walkSimpleArithmeticExpression(
+                $this->arithmeticExpression
+            ) .
+        ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->arithmeticExpression = $parser->SimpleArithmeticExpression();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Rand.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\AST\SimpleArithmeticExpression;
+use Doctrine\ORM\Query\Lexer;
+
+class Rand extends FunctionNode
+{
+    /**
+     * @var SimpleArithmeticExpression
+     */
+    private $expression = null;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        if ($this->expression) {
+            return 'RAND(' . $this->expression->dispatch($sqlWalker) . ')';
+        }
+
+        return 'RAND()';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $lexer = $parser->getLexer();
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        if (Lexer::T_CLOSE_PARENTHESIS !== $lexer->lookahead['type']) {
+            $this->expression = $parser->SimpleArithmeticExpression();
+        }
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Regexp.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Regexp extends FunctionNode
+{
+    public $value = null;
+
+    public $regexp = null;
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->value = $parser->StringPrimary();
+        $parser->match(Lexer::T_COMMA);
+        $this->regexp = $parser->StringExpression();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return '(' . $this->value->dispatch($sqlWalker) . ' REGEXP ' . $this->regexp->dispatch($sqlWalker) . ')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Replace.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Jarek Kostrz <jkostrz@gmail.com>
+ */
+class Replace extends FunctionNode
+{
+    public $search = null;
+
+    public $replace = null;
+
+    public $subject = null;
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->subject = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_COMMA);
+        $this->search = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_COMMA);
+        $this->replace = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'REPLACE(' .
+            $this->subject->dispatch($sqlWalker) . ', ' .
+            $this->search->dispatch($sqlWalker) . ', ' .
+            $this->replace->dispatch($sqlWalker) .
+        ')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Round.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Round extends FunctionNode
+{
+    private $firstExpression = null;
+
+    private $secondExpression = null;
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $lexer = $parser->getLexer();
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->firstExpression = $parser->SimpleArithmeticExpression();
+
+        // parse second parameter if available
+        if (Lexer::T_COMMA === $lexer->lookahead['type']) {
+            $parser->match(Lexer::T_COMMA);
+            $this->secondExpression = $parser->ArithmeticPrimary();
+        }
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        // use second parameter if parsed
+        if (null !== $this->secondExpression) {
+            return 'ROUND('
+                . $this->firstExpression->dispatch($sqlWalker)
+                . ', '
+                . $this->secondExpression->dispatch($sqlWalker)
+                . ')';
+        }
+
+        return 'ROUND(' . $this->firstExpression->dispatch($sqlWalker) . ')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Rpad.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Giulia Santoiemma <giuliaries@gmail.com>
+ */
+class Rpad extends FunctionNode
+{
+    public $string = null;
+
+    public $length = null;
+
+    public $padstring = null;
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->string = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_COMMA);
+        $this->length = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_COMMA);
+        $this->padstring = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'RPAD(' .
+        $this->string->dispatch($sqlWalker) . ', ' .
+        $this->length->dispatch($sqlWalker) . ', ' .
+        $this->padstring->dispatch($sqlWalker) .
+        ')';
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/SecToTime.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @example SELECT SEC_TO_TIME(2378);
+ * @link https://dev.mysql.com/doc/refman/en/date-and-time-functions.html#function_sec-to-time
+ * @author Clemens Bastian <clemens.bastian@gmail.com>
+ */
+class SecToTime extends FunctionNode
+{
+    public $time;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'SEC_TO_TIME('.$sqlWalker->walkArithmeticPrimary($this->time).')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->time = $parser->ArithmeticPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Second.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Martin Štekl <martin.stekl@gmail.com>
+ */
+class Second extends FunctionNode
+{
+    public $date;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'SECOND('.$sqlWalker->walkArithmeticPrimary($this->date).')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->date = $parser->ArithmeticPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Sha1.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Andreas Gallien <gallien@seleos.de>
+ */
+class Sha1 extends FunctionNode
+{
+    public $stringPrimary;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'SHA1(' .
+            $sqlWalker->walkStringPrimary($this->stringPrimary) .
+        ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->stringPrimary = $parser->StringPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Sha2.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Andreas Gallien <gallien@seleos.de>
+ */
+class Sha2 extends FunctionNode
+{
+    public $stringPrimary;
+
+    public $simpleArithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'SHA2(' .
+            $sqlWalker->walkStringPrimary($this->stringPrimary) .
+            ',' .
+            $sqlWalker->walkSimpleArithmeticExpression($this->simpleArithmeticExpression) .
+        ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->stringPrimary = $parser->StringPrimary();
+        $parser->match(Lexer::T_COMMA);
+        $this->simpleArithmeticExpression = $parser->SimpleArithmeticExpression();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Sin.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Sin extends FunctionNode
+{
+    public $arithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'SIN(' . $sqlWalker->walkSimpleArithmeticExpression(
+            $this->arithmeticExpression
+        ) . ')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->arithmeticExpression = $parser->SimpleArithmeticExpression();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Soundex.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Steve Tauber <taubers@gmail.com>
+ */
+class Soundex extends FunctionNode
+{
+    public $stringPrimary;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'SOUNDEX('.$sqlWalker->walkStringPrimary($this->stringPrimary).')';
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->stringPrimary = $parser->StringPrimary();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/Std.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Toni Uebernickel <tuebernickel@gmail.com>
+ */
+class Std extends FunctionNode
+{
+    public $arithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return sprintf('STD(%s)', $sqlWalker->walkSimpleArithmeticExpression($this->arithmeticExpression));
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->arithmeticExpression = $parser->SimpleArithmeticExpression();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/StdDev.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Joachim Schirrmacher <j.schirrmacher@dilab.co>
+ */
+class StdDev extends FunctionNode
+{
+    public $arithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return sprintf('STDDEV(%s)', $sqlWalker->walkSimpleArithmeticExpression($this->arithmeticExpression));
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->arithmeticExpression = $parser->SimpleArithmeticExpression();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/doctrineextensions/src/Query/Mysql/StrToDate.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class StrToDate extends FunctionNode
+{
+    public $dateString = null;
+
+    public $dateFormat = null;
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->dateString = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_COMMA);
+        $this->dateFormat = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'STR_TO_DATE(' .
+            $this->dateString->dispatch($sqlWalker) . ', ' .
+            $this->dateFormat->dispatch($sqlWalker) .
+        ')';
+    }
+}