Initial commit

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/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,83 @@
+<?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://www.doctrine-project.org/projects/doctrine-orm/en/2.6/cookbook/dql-user-defined-functions.html#conclusion
+ * @link    https://dev.mysql.com/doc/refman/5.6/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,59 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * "COLLATE"
+ * override the default collation
+ * More info:
+ * https://dev.mysql.com/doc/refman/5.7/en/charset-collate.html
+ *
+ * @category    DoctrineExtensions
+ * @package     DoctrineExtensions\Query\Mysql
+ * @author      Peter Tanath <peter.tanath@gmail.com>
+ * @license     MIT License
+ */
+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,55 @@
+<?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;
+
+/**
+ * Converts timezones.
+ *
+ * Allows Doctrine 2 Query Language to execute a MySQL CONVERT_TZ function.
+ *
+ * @link http://dev.mysql.com/doc/refman/5.5/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@stevelacey.net>
+ */
+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@stevelacey.net>
+ */
+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,33 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\QueryException;
+
+/**
+ * Class DateSub
+ * @package DoctrineExtensions\Query\Mysql
+ *
+ * @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@stevelacey.net>
+ */
+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,53 @@
+<?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;
+
+/**
+ * Performs an integer division. This is a MySQL operator, implemented as a Doctrine function.
+ *
+ * @see http://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/FromUnixtime.php

@@ -0,0 +1,29 @@
+<?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 $time;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'FROM_UNIXTIME(' . $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/Greatest.php

@@ -0,0 +1,66 @@
+<?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 Greatest
+ * @package DoctrineExtensions\Query\Mysql
+ *
+ * @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,46 @@
+<?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
+ * @package DoctrineExtensions\Query\Mysql
+ * @author Jan H <jan@pmconnect.co.uk>
+ */
+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/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/Least.php

@@ -0,0 +1,65 @@
+<?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 Least
+ * @package DoctrineExtensions\Query\Mysql
+ *
+ * @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/MatchAgainst.php

@@ -0,0 +1,77 @@
+<?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;
+        }
+
+        if (strtolower($lexer->lookahead['value']) === 'expand') {
+            $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@stevelacey.net>
+ */
+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/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,53 @@
+<?php
+
+/**
+ * DoctrineExtensions Mysql Function Pack
+ * LICENSE
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to kontakt@beberlei.de so I can send you a copy immediately.
+ */
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * "SEC_TO_TIME" "(" SimpleArithmeticExpression ")".
+ * Modified from DoctrineExtensions\Query\Mysql\TimeToSec
+ * More info:
+ * https://dev.mysql.com/doc/refman/5.5/en/date-and-time-functions.html
+ *
+ * @category    DoctrineExtensions
+ * @package     DoctrineExtensions\Query\Mysql
+ * @author      Clemens Bastian <clemens.bastian@gmail.com>
+ * @license     MIT License
+ */
+class SecToTime extends FunctionNode
+{
+    public $time;
+
+    /**
+     * @override
+     */
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'SEC_TO_TIME('.$sqlWalker->walkArithmeticPrimary($this->time).')';
+    }
+
+    /**
+     * @override
+     */
+    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) .
+        ')';
+    }
+}

vendor/beberlei/DoctrineExtensions/src/Query/Mysql/SubstringIndex.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 SubstringIndex
+ * @package DoctrineExtensions\Query\Mysql
+ * @author Vas N <phpvas@gmail.com>
+ */
+class SubstringIndex extends FunctionNode
+{
+    public $string = null;
+
+    public $delimiter = null;
+
+    public $count = null;
+
+    /**
+     * @param \Doctrine\ORM\Query\Parser $parser
+     */
+    public function parse(Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+        $this->string = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_COMMA);
+        $this->delimiter = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_COMMA);
+        $this->count = $parser->ArithmeticFactor();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    /**
+     * @param \Doctrine\ORM\Query\SqlWalker $sqlWalker
+     * @return string
+     */
+    public function getSql(SqlWalker $sqlWalker)
+    {
+        return sprintf(
+            'SUBSTRING_INDEX(%s, %s, %s)',
+            $this->string->dispatch($sqlWalker),
+            $this->delimiter->dispatch($sqlWalker),
+            $this->count->dispatch($sqlWalker)
+        );
+    }
+}

vendor/beberlei/DoctrineExtensions/src/Query/Mysql/Tan.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Tan extends FunctionNode
+{
+    public $arithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'TAN(' . $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/Time.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Steve Lacey <steve@stevelacey.net>
+ * @author James Rohacik <rohacik.james@gmail.com>
+ */
+class Time extends FunctionNode
+{
+    public $time;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return '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/TimeDiff.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class TimeDiff 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 sprintf(
+            'TIMEDIFF(%s, %s)',
+            $this->firstDateExpression->dispatch($sqlWalker),
+            $this->secondDateExpression->dispatch($sqlWalker)
+        );
+    }
+}

vendor/beberlei/DoctrineExtensions/src/Query/Mysql/TimeToSec.php

@@ -0,0 +1,53 @@
+<?php
+
+/**
+ * DoctrineExtensions Mysql Function Pack
+ * LICENSE
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to kontakt@beberlei.de so I can send you a copy immediately.
+ */
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * "TIME_TO_SEC" "(" SimpleArithmeticExpression ")".
+ * Modified from DoctrineExtensions\Query\Mysql\Hour
+ * More info:
+ * https://dev.mysql.com/doc/refman/5.5/en/date-and-time-functions.html
+ *
+ * @category    DoctrineExtensions
+ * @package     DoctrineExtensions\Query\Mysql
+ * @author      Pawel Stasicki <p.stasicki@gmail.com>
+ * @license     MIT License
+ */
+class TimeToSec extends FunctionNode
+{
+    public $time;
+
+    /**
+     * @override
+     */
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'TIME_TO_SEC('.$sqlWalker->walkArithmeticPrimary($this->time).')';
+    }
+
+    /**
+     * @override
+     */
+    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/TimestampAdd.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Alessandro Tagliapietra <tagliapietra.alessandro@gmail.com>
+ */
+class TimestampAdd extends FunctionNode
+{
+    public $firstDatetimeExpression = null;
+
+    public $secondDatetimeExpression = 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_COMMA);
+        $this->firstDatetimeExpression = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_COMMA);
+        $this->secondDatetimeExpression = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sql_walker)
+    {
+        return sprintf(
+          'TIMESTAMPADD(%s, %s, %s)',
+          $this->unit,
+          $this->firstDatetimeExpression->dispatch($sql_walker),
+          $this->secondDatetimeExpression->dispatch($sql_walker)
+      );
+    }
+}

vendor/beberlei/DoctrineExtensions/src/Query/Mysql/TimestampDiff.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Przemek Sobstel <przemek@sobstel.org>
+ */
+class TimestampDiff extends FunctionNode
+{
+    public $firstDatetimeExpression = null;
+
+    public $secondDatetimeExpression = 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_COMMA);
+        $this->firstDatetimeExpression = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_COMMA);
+        $this->secondDatetimeExpression = $parser->ArithmeticPrimary();
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sql_walker)
+    {
+        return sprintf(
+          'TIMESTAMPDIFF(%s, %s, %s)',
+          $this->unit,
+          $this->firstDatetimeExpression->dispatch($sql_walker),
+          $this->secondDatetimeExpression->dispatch($sql_walker)
+      );
+    }
+}

vendor/beberlei/DoctrineExtensions/src/Query/Mysql/Unhex.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class Unhex extends FunctionNode
+{
+    public $arithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'UNHEX(' . $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/UnixTimestamp.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author      Rafael Kassner <kassner@gmail.com>
+ * @author      Oleg Khussainov <getmequick@gmail.com>
+ */
+class UnixTimestamp extends FunctionNode
+{
+    public $date;
+
+    /**
+     * @override
+     */
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return sprintf(
+            'UNIX_TIMESTAMP(%s)',
+            $this->date ? $sqlWalker->walkArithmeticPrimary($this->date) : ''
+        );
+    }
+
+    /**
+     * @override
+     */
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        if (!$parser->getLexer()->isNextToken(Lexer::T_CLOSE_PARENTHESIS)) {
+            $this->date = $parser->ArithmeticPrimary();
+        }
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/DoctrineExtensions/src/Query/Mysql/UtcTimestamp.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author      Marius Krämer <marius@marius-kraemer.de>
+ */
+class UtcTimestamp extends FunctionNode
+{
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'UTC_TIMESTAMP()';
+    }
+
+    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/UuidShort.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+class UuidShort extends FunctionNode
+{
+    public $arithmeticExpression;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'UUID_SHORT()';
+    }
+
+    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/Variance.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+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 Variance extends FunctionNode
+{
+    /** @var SimpleArithmeticExpression */
+    protected $arithmeticExpression;
+
+    public function parse(Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->arithmeticExpression = $parser->SimpleArithmeticExpression();
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+
+    public function getSql(SqlWalker $sqlWalker)
+    {
+        return sprintf('VARIANCE(%s)', $sqlWalker->walkSimpleArithmeticExpression($this->arithmeticExpression));
+    }
+}

vendor/beberlei/DoctrineExtensions/src/Query/Mysql/Week.php

@@ -0,0 +1,44 @@
+<?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>
+ * @author Łukasz Nowicki <lukasz.mnowicki@gmail.com>
+ */
+class Week extends FunctionNode
+{
+    public $date;
+
+    public $mode;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        $sql = 'WEEK(' . $sqlWalker->walkArithmeticPrimary($this->date);
+        if ($this->mode != null) {
+            $sql .= ', ' . $sqlWalker->walkLiteral($this->mode);
+        }
+        $sql .= ')';
+
+        return $sql;
+    }
+
+    public function parse(\Doctrine\ORM\Query\Parser $parser)
+    {
+        $parser->match(Lexer::T_IDENTIFIER);
+        $parser->match(Lexer::T_OPEN_PARENTHESIS);
+
+        $this->date = $parser->ArithmeticPrimary();
+
+        if (Lexer::T_COMMA === $parser->getLexer()->lookahead['type']) {
+            $parser->match(Lexer::T_COMMA);
+            $this->mode = $parser->Literal();
+        }
+
+        $parser->match(Lexer::T_CLOSE_PARENTHESIS);
+    }
+}

vendor/beberlei/DoctrineExtensions/src/Query/Mysql/WeekDay.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Pavlo Cherniavskyi <ionafan2@gmail.com>
+ */
+class WeekDay extends FunctionNode
+{
+    private $date;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'WEEKDAY(' . $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/Year.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace DoctrineExtensions\Query\Mysql;
+
+use Doctrine\ORM\Query\AST\Functions\FunctionNode;
+use Doctrine\ORM\Query\Lexer;
+
+/**
+ * @author Rafael Kassner <kassner@gmail.com>
+ */
+class Year extends FunctionNode
+{
+    public $date;
+
+    public function getSql(\Doctrine\ORM\Query\SqlWalker $sqlWalker)
+    {
+        return 'YEAR(' . $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);
+    }
+}