/**
* SimpleConditionalExpression ::=
* ComparisonExpression | BetweenExpression | LikeExpression |
* InExpression | NullComparisonExpression | ExistsExpression |
* EmptyCollectionComparisonExpression | CollectionMemberExpression |
* InstanceOfExpression
*/
public function SimpleConditionalExpression()
{
$token = $this->_lexer->lookahead;
if ($this->_lexer->isNextToken(Lexer::T_NOT)) {
$token = $this->_lexer->glimpse();
}
if ($token['type'] === Lexer::T_EXISTS) {
return $this->ExistsExpression();
}
$peek = $this->_lexer->glimpse();
if ($token['type'] === Lexer::T_IDENTIFIER || $token['type'] === Lexer::T_INPUT_PARAMETER) {
if ($peek['value'] == '(') {
// Peek beyond the matching closing paranthesis ')'
$this->_lexer->peek();
$token = $this->_peekBeyondClosingParenthesis(false);
if ($token['type'] === Lexer::T_NOT) {
$token = $this->_lexer->peek();
}
$this->_lexer->resetPeek();
} else {
// Peek beyond the PathExpression (or InputParameter)
$peek = $this->_lexer->peek();
while ($peek['value'] === '.') {
$this->_lexer->peek();
$peek = $this->_lexer->peek();
}
// Also peek beyond a NOT if there is one
if ($peek['type'] === Lexer::T_NOT) {
$peek = $this->_lexer->peek();
}
$token = $peek;
// We need to go even further in case of IS (differenciate between NULL and EMPTY)
$lookahead = $this->_lexer->peek();
// Also peek beyond a NOT if there is one
if ($lookahead['type'] === Lexer::T_NOT) {
$lookahead = $this->_lexer->peek();
}
$this->_lexer->resetPeek();
}
}
switch ($token['type']) {
case Lexer::T_BETWEEN:
return $this->BetweenExpression();
case Lexer::T_LIKE:
return $this->LikeExpression();
case Lexer::T_IN:
return $this->InExpression();
case Lexer::T_INSTANCE:
return $this->InstanceOfExpression();
case Lexer::T_IS:
if ($lookahead['type'] == Lexer::T_NULL) {
return $this->NullComparisonExpression();
}
return $this->EmptyCollectionComparisonExpression();
case Lexer::T_MEMBER:
return $this->CollectionMemberExpression();
default:
return $this->ComparisonExpression();
}
}
/**
* OrderByItem ::= (
* SimpleArithmeticExpression | SingleValuedPathExpression |
* ScalarExpression | ResultVariable | FunctionDeclaration
* ) ["ASC" | "DESC"]
*
* @return \Doctrine\ORM\Query\AST\OrderByItem
*/
public function OrderByItem()
{
$this->lexer->peek();
// lookahead => '.'
$this->lexer->peek();
// lookahead => token after '.'
$peek = $this->lexer->peek();
// lookahead => token after the token after the '.'
$this->lexer->resetPeek();
$glimpse = $this->lexer->glimpse();
switch (true) {
case $this->isFunction($peek):
$expr = $this->FunctionDeclaration();
break;
case $this->isMathOperator($peek):
$expr = $this->SimpleArithmeticExpression();
break;
case $glimpse['type'] === Lexer::T_DOT:
$expr = $this->SingleValuedPathExpression();
break;
case $this->lexer->peek() && $this->isMathOperator($this->peekBeyondClosingParenthesis()):
$expr = $this->ScalarExpression();
break;
default:
$expr = $this->ResultVariable();
break;
}
$type = 'ASC';
$item = new AST\OrderByItem($expr);
switch (true) {
case $this->lexer->isNextToken(Lexer::T_DESC):
$this->match(Lexer::T_DESC);
$type = 'DESC';
break;
case $this->lexer->isNextToken(Lexer::T_ASC):
$this->match(Lexer::T_ASC);
break;
default:
// Do nothing
}
$item->type = $type;
return $item;
}
/**
* SimpleConditionalExpression ::=
* ComparisonExpression | BetweenExpression | LikeExpression |
* InExpression | NullComparisonExpression | ExistsExpression |
* EmptyCollectionComparisonExpression | CollectionMemberExpression |
* InstanceOfExpression
*/
public function SimpleConditionalExpression()
{
if ($this->lexer->isNextToken(Lexer::T_EXISTS)) {
return $this->ExistsExpression();
}
$token = $this->lexer->lookahead;
$peek = $this->lexer->glimpse();
$lookahead = $token;
if ($this->lexer->isNextToken(Lexer::T_NOT)) {
$token = $this->lexer->glimpse();
}
if ($token['type'] === Lexer::T_IDENTIFIER || $token['type'] === Lexer::T_INPUT_PARAMETER || $this->isFunction()) {
// Peek beyond the matching closing parenthesis.
$beyond = $this->lexer->peek();
switch ($peek['value']) {
case '(':
// Peeks beyond the matched closing parenthesis.
$token = $this->peekBeyondClosingParenthesis(false);
if ($token['type'] === Lexer::T_NOT) {
$token = $this->lexer->peek();
}
if ($token['type'] === Lexer::T_IS) {
$lookahead = $this->lexer->peek();
}
break;
default:
// Peek beyond the PathExpression or InputParameter.
$token = $beyond;
while ($token['value'] === '.') {
$this->lexer->peek();
$token = $this->lexer->peek();
}
// Also peek beyond a NOT if there is one.
if ($token['type'] === Lexer::T_NOT) {
$token = $this->lexer->peek();
}
// We need to go even further in case of IS (differentiate between NULL and EMPTY)
$lookahead = $this->lexer->peek();
}
// Also peek beyond a NOT if there is one.
if ($lookahead['type'] === Lexer::T_NOT) {
$lookahead = $this->lexer->peek();
}
$this->lexer->resetPeek();
}
if ($token['type'] === Lexer::T_BETWEEN) {
return $this->BetweenExpression();
}
if ($token['type'] === Lexer::T_LIKE) {
return $this->LikeExpression();
}
if ($token['type'] === Lexer::T_IN) {
return $this->InExpression();
}
if ($token['type'] === Lexer::T_INSTANCE) {
return $this->InstanceOfExpression();
}
if ($token['type'] === Lexer::T_MEMBER) {
return $this->CollectionMemberExpression();
}
if ($token['type'] === Lexer::T_IS && $lookahead['type'] === Lexer::T_NULL) {
return $this->NullComparisonExpression();
}
if ($token['type'] === Lexer::T_IS && $lookahead['type'] === Lexer::T_EMPTY) {
return $this->EmptyCollectionComparisonExpression();
}
return $this->ComparisonExpression();
}
