RetailCRM-Mirror/doctrine2
1
0
Fork 0
mirror of synced 2025-04-03 13:23:37 +03:00
Code Issues Projects Releases Wiki Activity

[2.0] Some docs and cleanups.

Browse source
This commit is contained in:
romanb 2009-03-23 19:02:16 +00:00
parent e6dbc733c5
commit 5ebaa6504c
1 changed files with 80 additions and 68 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

148
lib/Doctrine/ORM/Query/Parser.php
View file

@ -26,7 +26,7 @@ use Doctrine\ORM\Query\AST;
use Doctrine\ORM\Query\Exec; use Doctrine\ORM\Query\Exec;
/** /**
* An LL(*) parser for the context-free grammar of Doctrine Query Language. * An LL(*) parser for the context-free grammar of the Doctrine Query Language.
* Parses a DQL query, reports any errors in it, and generates an AST. * Parses a DQL query, reports any errors in it, and generates an AST.
* *
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
@ -159,17 +159,11 @@ class Parser
$this->_lexer->moveNext(); $this->_lexer->moveNext();
} }
public function isA($value, $token)
{
return $this->_lexer->isA($value, $token);
}
/** /**
* Free this parser enabling it to be reused * Free this parser enabling it to be reused
* *
* @param boolean $deep Whether to clean peek and reset errors * @param boolean $deep Whether to clean peek and reset errors
* @param integer $position Position to reset * @param integer $position Position to reset
* @return void
*/ */
public function free($deep = false, $position = 0) public function free($deep = false, $position = 0)
{ {
@ -197,14 +191,14 @@ class Parser
// Check for end of string // Check for end of string
if ($this->_lexer->lookahead !== null) { if ($this->_lexer->lookahead !== null) {
var_dump($this->_lexer->lookahead); //var_dump($this->_lexer->lookahead);
$this->syntaxError('end of string'); $this->syntaxError('end of string');
} }
// Create SqlWalker who creates the SQL from the AST // Create SqlWalker who creates the SQL from the AST
$sqlWalker = new SqlWalker($this->_em, $this->_parserResult); $sqlWalker = new SqlWalker($this->_em, $this->_parserResult);
// Assign the executor in parser result // Assign an SQL executor to the parser result
$this->_parserResult->setSqlExecutor(Exec\AbstractExecutor::create($AST, $sqlWalker)); $this->_parserResult->setSqlExecutor(Exec\AbstractExecutor::create($AST, $sqlWalker));
return $this->_parserResult; return $this->_parserResult;
@ -301,7 +295,7 @@ class Parser
} }
/** /**
* Checks if the next-next (after lookahead) token start a function. * Checks if the next-next (after lookahead) token starts a function.
* *
* @return boolean * @return boolean
*/ */
@ -347,7 +341,7 @@ class Parser
/** /**
* SelectStatement ::= SelectClause FromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause] * SelectStatement ::= SelectClause FromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
*/ */
private function _SelectStatement() public function _SelectStatement()
{ {
$this->_beginDeferredPathExpressionStack(); $this->_beginDeferredPathExpressionStack();
$selectClause = $this->_SelectClause(); $selectClause = $this->_SelectClause();
@ -440,7 +434,7 @@ class Parser
/** /**
* UpdateStatement ::= UpdateClause [WhereClause] * UpdateStatement ::= UpdateClause [WhereClause]
*/ */
private function _UpdateStatement() public function _UpdateStatement()
{ {
$updateStatement = new AST\UpdateStatement($this->_UpdateClause()); $updateStatement = new AST\UpdateStatement($this->_UpdateClause());
$updateStatement->setWhereClause( $updateStatement->setWhereClause(
@ -452,7 +446,7 @@ class Parser
/** /**
* UpdateClause ::= "UPDATE" AbstractSchemaName [["AS"] AliasIdentificationVariable] "SET" UpdateItem {"," UpdateItem}* * UpdateClause ::= "UPDATE" AbstractSchemaName [["AS"] AliasIdentificationVariable] "SET" UpdateItem {"," UpdateItem}*
*/ */
private function _UpdateClause() public function _UpdateClause()
{ {
$this->match(Lexer::T_UPDATE); $this->match(Lexer::T_UPDATE);
$abstractSchemaName = $this->_AbstractSchemaName(); $abstractSchemaName = $this->_AbstractSchemaName();
@ -495,7 +489,7 @@ class Parser
/** /**
* UpdateItem ::= [IdentificationVariable "."] {StateField | SingleValuedAssociationField} "=" NewValue * UpdateItem ::= [IdentificationVariable "."] {StateField | SingleValuedAssociationField} "=" NewValue
*/ */
private function _UpdateItem() public function _UpdateItem()
{ {
$peek = $this->_lexer->glimpse(); $peek = $this->_lexer->glimpse();
$identVariable = null; $identVariable = null;
@ -521,7 +515,7 @@ class Parser
* NewValue ::= SimpleArithmeticExpression | StringPrimary | DatetimePrimary | BooleanPrimary | * NewValue ::= SimpleArithmeticExpression | StringPrimary | DatetimePrimary | BooleanPrimary |
* EnumPrimary | SimpleEntityExpression | "NULL" * EnumPrimary | SimpleEntityExpression | "NULL"
*/ */
private function _NewValue() public function _NewValue()
{ {
if ($this->_lexer->isNextToken(Lexer::T_NULL)) { if ($this->_lexer->isNextToken(Lexer::T_NULL)) {
$this->match(Lexer::T_NULL); $this->match(Lexer::T_NULL);
@ -541,7 +535,7 @@ class Parser
/** /**
* DeleteStatement ::= DeleteClause [WhereClause] * DeleteStatement ::= DeleteClause [WhereClause]
*/ */
private function _DeleteStatement() public function _DeleteStatement()
{ {
$deleteStatement = new AST\DeleteStatement($this->_DeleteClause()); $deleteStatement = new AST\DeleteStatement($this->_DeleteClause());
$deleteStatement->setWhereClause( $deleteStatement->setWhereClause(
@ -553,7 +547,7 @@ class Parser
/** /**
* DeleteClause ::= "DELETE" ["FROM"] AbstractSchemaName [["AS"] AliasIdentificationVariable] * DeleteClause ::= "DELETE" ["FROM"] AbstractSchemaName [["AS"] AliasIdentificationVariable]
*/ */
private function _DeleteClause() public function _DeleteClause()
{ {
$this->match(Lexer::T_DELETE); $this->match(Lexer::T_DELETE);
if ($this->_lexer->isNextToken(Lexer::T_FROM)) { if ($this->_lexer->isNextToken(Lexer::T_FROM)) {
@ -588,7 +582,7 @@ class Parser
/** /**
* SelectClause ::= "SELECT" ["DISTINCT"] SelectExpression {"," SelectExpression} * SelectClause ::= "SELECT" ["DISTINCT"] SelectExpression {"," SelectExpression}
*/ */
private function _SelectClause() public function _SelectClause()
{ {
$isDistinct = false; $isDistinct = false;
$this->match(Lexer::T_SELECT); $this->match(Lexer::T_SELECT);
@ -613,7 +607,7 @@ class Parser
/** /**
* FromClause ::= "FROM" IdentificationVariableDeclaration {"," IdentificationVariableDeclaration} * FromClause ::= "FROM" IdentificationVariableDeclaration {"," IdentificationVariableDeclaration}
*/ */
private function _FromClause() public function _FromClause()
{ {
$this->match(Lexer::T_FROM); $this->match(Lexer::T_FROM);
$identificationVariableDeclarations = array(); $identificationVariableDeclarations = array();
@ -634,7 +628,7 @@ class Parser
* IdentificationVariable | StateFieldPathExpression | * IdentificationVariable | StateFieldPathExpression |
* (AggregateExpression | "(" Subselect ")") [["AS"] FieldAliasIdentificationVariable] * (AggregateExpression | "(" Subselect ")") [["AS"] FieldAliasIdentificationVariable]
*/ */
private function _SelectExpression() public function _SelectExpression()
{ {
$expression = null; $expression = null;
$fieldIdentificationVariable = null; $fieldIdentificationVariable = null;
@ -666,7 +660,7 @@ class Parser
/** /**
* IdentificationVariable ::= identifier * IdentificationVariable ::= identifier
*/ */
private function _IdentificationVariable() public function _IdentificationVariable()
{ {
$this->match(Lexer::T_IDENTIFIER); $this->match(Lexer::T_IDENTIFIER);
return $this->_lexer->token['value']; return $this->_lexer->token['value'];
@ -675,7 +669,7 @@ class Parser
/** /**
* IdentificationVariableDeclaration ::= RangeVariableDeclaration [IndexBy] {JoinVariableDeclaration}* * IdentificationVariableDeclaration ::= RangeVariableDeclaration [IndexBy] {JoinVariableDeclaration}*
*/ */
private function _IdentificationVariableDeclaration() public function _IdentificationVariableDeclaration()
{ {
$rangeVariableDeclaration = $this->_RangeVariableDeclaration(); $rangeVariableDeclaration = $this->_RangeVariableDeclaration();
$indexBy = $this->_lexer->isNextToken(Lexer::T_INDEX) ? $indexBy = $this->_lexer->isNextToken(Lexer::T_INDEX) ?
@ -697,7 +691,7 @@ class Parser
/** /**
* RangeVariableDeclaration ::= AbstractSchemaName ["AS"] AliasIdentificationVariable * RangeVariableDeclaration ::= AbstractSchemaName ["AS"] AliasIdentificationVariable
*/ */
private function _RangeVariableDeclaration() public function _RangeVariableDeclaration()
{ {
$abstractSchemaName = $this->_AbstractSchemaName(); $abstractSchemaName = $this->_AbstractSchemaName();
@ -725,7 +719,7 @@ class Parser
/** /**
* AbstractSchemaName ::= identifier * AbstractSchemaName ::= identifier
*/ */
private function _AbstractSchemaName() public function _AbstractSchemaName()
{ {
$this->match(Lexer::T_IDENTIFIER); $this->match(Lexer::T_IDENTIFIER);
return $this->_lexer->token['value']; return $this->_lexer->token['value'];
@ -734,7 +728,7 @@ class Parser
/** /**
* AliasIdentificationVariable = identifier * AliasIdentificationVariable = identifier
*/ */
private function _AliasIdentificationVariable() public function _AliasIdentificationVariable()
{ {
$this->match(Lexer::T_IDENTIFIER); $this->match(Lexer::T_IDENTIFIER);
return $this->_lexer->token['value']; return $this->_lexer->token['value'];
@ -743,7 +737,7 @@ class Parser
/** /**
* JoinVariableDeclaration ::= Join [IndexBy] * JoinVariableDeclaration ::= Join [IndexBy]
*/ */
private function _JoinVariableDeclaration() public function _JoinVariableDeclaration()
{ {
$join = $this->_Join(); $join = $this->_Join();
$indexBy = $this->_lexer->isNextToken(Lexer::T_INDEX) ? $indexBy = $this->_lexer->isNextToken(Lexer::T_INDEX) ?
@ -755,7 +749,7 @@ class Parser
* Join ::= ["LEFT" ["OUTER"] | "INNER"] "JOIN" JoinAssociationPathExpression * Join ::= ["LEFT" ["OUTER"] | "INNER"] "JOIN" JoinAssociationPathExpression
* ["AS"] AliasIdentificationVariable [("ON" | "WITH") ConditionalExpression] * ["AS"] AliasIdentificationVariable [("ON" | "WITH") ConditionalExpression]
*/ */
private function _Join() public function _Join()
{ {
// Check Join type // Check Join type
$joinType = AST\Join::JOIN_TYPE_INNER; $joinType = AST\Join::JOIN_TYPE_INNER;
@ -844,7 +838,7 @@ class Parser
/** /**
* JoinPathExpression ::= IdentificationVariable "." (CollectionValuedAssociationField | SingleValuedAssociationField) * JoinPathExpression ::= IdentificationVariable "." (CollectionValuedAssociationField | SingleValuedAssociationField)
*/ */
private function _JoinPathExpression() public function _JoinPathExpression()
{ {
$identificationVariable = $this->_IdentificationVariable(); $identificationVariable = $this->_IdentificationVariable();
$this->match('.'); $this->match('.');
@ -858,7 +852,7 @@ class Parser
/** /**
* IndexBy ::= "INDEX" "BY" SimpleStateFieldPathExpression * IndexBy ::= "INDEX" "BY" SimpleStateFieldPathExpression
*/ */
private function _IndexBy() public function _IndexBy()
{ {
$this->match(Lexer::T_INDEX); $this->match(Lexer::T_INDEX);
$this->match(Lexer::T_BY); $this->match(Lexer::T_BY);
@ -873,7 +867,7 @@ class Parser
/** /**
* SimpleStateFieldPathExpression ::= IdentificationVariable "." StateField * SimpleStateFieldPathExpression ::= IdentificationVariable "." StateField
*/ */
private function _SimpleStateFieldPathExpression() public function _SimpleStateFieldPathExpression()
{ {
$identificationVariable = $this->_IdentificationVariable(); $identificationVariable = $this->_IdentificationVariable();
$this->match('.'); $this->match('.');
@ -885,7 +879,7 @@ class Parser
/** /**
* StateFieldPathExpression ::= SimpleStateFieldPathExpression | SimpleStateFieldAssociationPathExpression * StateFieldPathExpression ::= SimpleStateFieldPathExpression | SimpleStateFieldAssociationPathExpression
*/ */
private function _StateFieldPathExpression() public function _StateFieldPathExpression()
{ {
if ( ! empty($this->_deferredPathExpressionStacks)) { if ( ! empty($this->_deferredPathExpressionStacks)) {
$exprStack = array_pop($this->_deferredPathExpressionStacks); $exprStack = array_pop($this->_deferredPathExpressionStacks);
@ -950,7 +944,7 @@ class Parser
/** /**
* NullComparisonExpression ::= (SingleValuedPathExpression | InputParameter) "IS" ["NOT"] "NULL" * NullComparisonExpression ::= (SingleValuedPathExpression | InputParameter) "IS" ["NOT"] "NULL"
*/ */
private function _NullComparisonExpression() public function _NullComparisonExpression()
{ {
if ($this->_lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) { if ($this->_lexer->isNextToken(Lexer::T_INPUT_PARAMETER)) {
$this->match(Lexer::T_INPUT_PARAMETER); $this->match(Lexer::T_INPUT_PARAMETER);
@ -974,7 +968,7 @@ class Parser
* ("AVG" | "MAX" | "MIN" | "SUM") "(" ["DISTINCT"] StateFieldPathExpression ")" | * ("AVG" | "MAX" | "MIN" | "SUM") "(" ["DISTINCT"] StateFieldPathExpression ")" |
* "COUNT" "(" ["DISTINCT"] (IdentificationVariable | SingleValuedAssociationPathExpression | StateFieldPathExpression) ")" * "COUNT" "(" ["DISTINCT"] (IdentificationVariable | SingleValuedAssociationPathExpression | StateFieldPathExpression) ")"
*/ */
private function _AggregateExpression() public function _AggregateExpression()
{ {
$isDistinct = false; $isDistinct = false;
$functionName = ''; $functionName = '';
@ -1013,7 +1007,7 @@ class Parser
* GroupByClause ::= "GROUP" "BY" GroupByItem {"," GroupByItem}* * GroupByClause ::= "GROUP" "BY" GroupByItem {"," GroupByItem}*
* GroupByItem ::= SingleValuedPathExpression * GroupByItem ::= SingleValuedPathExpression
*/ */
private function _GroupByClause() public function _GroupByClause()
{ {
$this->match(Lexer::T_GROUP); $this->match(Lexer::T_GROUP);
$this->match(Lexer::T_BY); $this->match(Lexer::T_BY);
@ -1029,7 +1023,7 @@ class Parser
/** /**
* HavingClause ::= "HAVING" ConditionalExpression * HavingClause ::= "HAVING" ConditionalExpression
*/ */
private function _HavingClause() public function _HavingClause()
{ {
$this->match(Lexer::T_HAVING); $this->match(Lexer::T_HAVING);
return new AST\HavingClause($this->_ConditionalExpression()); return new AST\HavingClause($this->_ConditionalExpression());
@ -1038,7 +1032,7 @@ class Parser
/** /**
* OrderByClause ::= "ORDER" "BY" OrderByItem {"," OrderByItem}* * OrderByClause ::= "ORDER" "BY" OrderByItem {"," OrderByItem}*
*/ */
private function _OrderByClause() public function _OrderByClause()
{ {
$this->match(Lexer::T_ORDER); $this->match(Lexer::T_ORDER);
$this->match(Lexer::T_BY); $this->match(Lexer::T_BY);
@ -1054,7 +1048,7 @@ class Parser
/** /**
* OrderByItem ::= StateFieldPathExpression ["ASC" | "DESC"] * OrderByItem ::= StateFieldPathExpression ["ASC" | "DESC"]
*/ */
private function _OrderByItem() public function _OrderByItem()
{ {
$item = new AST\OrderByItem($this->_StateFieldPathExpression()); $item = new AST\OrderByItem($this->_StateFieldPathExpression());
if ($this->_lexer->isNextToken(Lexer::T_ASC)) { if ($this->_lexer->isNextToken(Lexer::T_ASC)) {
@ -1072,7 +1066,7 @@ class Parser
/** /**
* WhereClause ::= "WHERE" ConditionalExpression * WhereClause ::= "WHERE" ConditionalExpression
*/ */
private function _WhereClause() public function _WhereClause()
{ {
$this->match(Lexer::T_WHERE); $this->match(Lexer::T_WHERE);
return new AST\WhereClause($this->_ConditionalExpression()); return new AST\WhereClause($this->_ConditionalExpression());
@ -1081,7 +1075,7 @@ class Parser
/** /**
* ConditionalExpression ::= ConditionalTerm {"OR" ConditionalTerm}* * ConditionalExpression ::= ConditionalTerm {"OR" ConditionalTerm}*
*/ */
private function _ConditionalExpression() public function _ConditionalExpression()
{ {
$conditionalTerms = array(); $conditionalTerms = array();
$conditionalTerms[] = $this->_ConditionalTerm(); $conditionalTerms[] = $this->_ConditionalTerm();
@ -1095,7 +1089,7 @@ class Parser
/** /**
* ConditionalTerm ::= ConditionalFactor {"AND" ConditionalFactor}* * ConditionalTerm ::= ConditionalFactor {"AND" ConditionalFactor}*
*/ */
private function _ConditionalTerm() public function _ConditionalTerm()
{ {
$conditionalFactors = array(); $conditionalFactors = array();
$conditionalFactors[] = $this->_ConditionalFactor(); $conditionalFactors[] = $this->_ConditionalFactor();
@ -1109,7 +1103,7 @@ class Parser
/** /**
* ConditionalFactor ::= ["NOT"] ConditionalPrimary * ConditionalFactor ::= ["NOT"] ConditionalPrimary
*/ */
private function _ConditionalFactor() public function _ConditionalFactor()
{ {
$not = false; $not = false;
if ($this->_lexer->isNextToken(Lexer::T_NOT)) { if ($this->_lexer->isNextToken(Lexer::T_NOT)) {
@ -1122,7 +1116,7 @@ class Parser
/** /**
* ConditionalPrimary ::= SimpleConditionalExpression | "(" ConditionalExpression ")" * ConditionalPrimary ::= SimpleConditionalExpression | "(" ConditionalExpression ")"
*/ */
private function _ConditionalPrimary() public function _ConditionalPrimary()
{ {
$condPrimary = new AST\ConditionalPrimary; $condPrimary = new AST\ConditionalPrimary;
if ($this->_lexer->isNextToken('(')) { if ($this->_lexer->isNextToken('(')) {
@ -1161,7 +1155,7 @@ class Parser
* InExpression | NullComparisonExpression | ExistsExpression | * InExpression | NullComparisonExpression | ExistsExpression |
* EmptyCollectionComparisonExpression | CollectionMemberExpression * EmptyCollectionComparisonExpression | CollectionMemberExpression
*/ */
private function _SimpleConditionalExpression() public function _SimpleConditionalExpression()
{ {
if ($this->_lexer->isNextToken(Lexer::T_NOT)) { if ($this->_lexer->isNextToken(Lexer::T_NOT)) {
$token = $this->_lexer->glimpse(); $token = $this->_lexer->glimpse();
@ -1231,7 +1225,7 @@ class Parser
* DatetimeExpression ComparisonOperator (DatetimeExpression | QuantifiedExpression) | * DatetimeExpression ComparisonOperator (DatetimeExpression | QuantifiedExpression) |
* EntityExpression ("=" | "<>") (EntityExpression | QuantifiedExpression) * EntityExpression ("=" | "<>") (EntityExpression | QuantifiedExpression)
*/ */
private function _ComparisonExpression() public function _ComparisonExpression()
{ {
$peek = $this->_lexer->glimpse(); $peek = $this->_lexer->glimpse();
@ -1322,17 +1316,17 @@ class Parser
return new AST\ComparisonExpression($leftExpr, $operator, $rightExpr); return new AST\ComparisonExpression($leftExpr, $operator, $rightExpr);
} }
private function _isStringFunction($funcName) public function _isStringFunction($funcName)
{ {
return isset(self::$_STRING_FUNCTIONS[strtolower($funcName)]); return isset(self::$_STRING_FUNCTIONS[strtolower($funcName)]);
} }
private function _isNumericFunction($funcName) public function _isNumericFunction($funcName)
{ {
return isset(self::$_NUMERIC_FUNCTIONS[strtolower($funcName)]); return isset(self::$_NUMERIC_FUNCTIONS[strtolower($funcName)]);
} }
private function _isDatetimeFunction($funcName) public function _isDatetimeFunction($funcName)
{ {
return isset(self::$_DATETIME_FUNCTIONS[strtolower($funcName)]); return isset(self::$_DATETIME_FUNCTIONS[strtolower($funcName)]);
} }
@ -1348,7 +1342,7 @@ class Parser
return $peek; return $peek;
} }
private function _isComparisonOperator($token) public function _isComparisonOperator($token)
{ {
$value = $token['value']; $value = $token['value'];
return $value == '=' || $value == '<' || $value == '<=' || $value == '<>' || return $value == '=' || $value == '<' || $value == '<=' || $value == '<>' ||
@ -1358,7 +1352,7 @@ class Parser
/** /**
* ArithmeticExpression ::= SimpleArithmeticExpression | "(" Subselect ")" * ArithmeticExpression ::= SimpleArithmeticExpression | "(" Subselect ")"
*/ */
private function _ArithmeticExpression() public function _ArithmeticExpression()
{ {
$expr = new AST\ArithmeticExpression; $expr = new AST\ArithmeticExpression;
if ($this->_lexer->lookahead['value'] === '(') { if ($this->_lexer->lookahead['value'] === '(') {
@ -1377,7 +1371,7 @@ class Parser
/** /**
* SimpleArithmeticExpression ::= ArithmeticTerm {("+" | "-") ArithmeticTerm}* * SimpleArithmeticExpression ::= ArithmeticTerm {("+" | "-") ArithmeticTerm}*
*/ */
private function _SimpleArithmeticExpression() public function _SimpleArithmeticExpression()
{ {
$terms = array(); $terms = array();
$terms[] = $this->_ArithmeticTerm(); $terms[] = $this->_ArithmeticTerm();
@ -1396,7 +1390,7 @@ class Parser
/** /**
* ArithmeticTerm ::= ArithmeticFactor {("*" | "/") ArithmeticFactor}* * ArithmeticTerm ::= ArithmeticFactor {("*" | "/") ArithmeticFactor}*
*/ */
private function _ArithmeticTerm() public function _ArithmeticTerm()
{ {
$factors = array(); $factors = array();
$factors[] = $this->_ArithmeticFactor(); $factors[] = $this->_ArithmeticFactor();
@ -1415,7 +1409,7 @@ class Parser
/** /**
* ArithmeticFactor ::= [("+" | "-")] ArithmeticPrimary * ArithmeticFactor ::= [("+" | "-")] ArithmeticPrimary
*/ */
private function _ArithmeticFactor() public function _ArithmeticFactor()
{ {
$pSign = $nSign = false; $pSign = $nSign = false;
if ($this->_lexer->lookahead['value'] == '+') { if ($this->_lexer->lookahead['value'] == '+') {
@ -1431,7 +1425,7 @@ class Parser
/** /**
* InExpression ::= StateFieldPathExpression ["NOT"] "IN" "(" (Literal {"," Literal}* | Subselect) ")" * InExpression ::= StateFieldPathExpression ["NOT"] "IN" "(" (Literal {"," Literal}* | Subselect) ")"
*/ */
private function _InExpression() public function _InExpression()
{ {
$inExpression = new AST\InExpression($this->_StateFieldPathExpression()); $inExpression = new AST\InExpression($this->_StateFieldPathExpression());
if ($this->_lexer->isNextToken(Lexer::T_NOT)) { if ($this->_lexer->isNextToken(Lexer::T_NOT)) {
@ -1459,7 +1453,7 @@ class Parser
/** /**
* ExistsExpression ::= ["NOT"] "EXISTS" "(" Subselect ")" * ExistsExpression ::= ["NOT"] "EXISTS" "(" Subselect ")"
*/ */
private function _ExistsExpression() public function _ExistsExpression()
{ {
$not = false; $not = false;
if ($this->_lexer->isNextToken(Lexer::T_NOT)) { if ($this->_lexer->isNextToken(Lexer::T_NOT)) {
@ -1477,7 +1471,7 @@ class Parser
/** /**
* Subselect ::= SimpleSelectClause SubselectFromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause] * Subselect ::= SimpleSelectClause SubselectFromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
*/ */
private function _Subselect() public function _Subselect()
{ {
$this->_beginDeferredPathExpressionStack(); $this->_beginDeferredPathExpressionStack();
$subselect = new AST\Subselect($this->_SimpleSelectClause(), $this->_SubselectFromClause()); $subselect = new AST\Subselect($this->_SimpleSelectClause(), $this->_SubselectFromClause());
@ -1505,7 +1499,7 @@ class Parser
/** /**
* SimpleSelectClause ::= "SELECT" ["DISTINCT"] SimpleSelectExpression * SimpleSelectClause ::= "SELECT" ["DISTINCT"] SimpleSelectExpression
*/ */
private function _SimpleSelectClause() public function _SimpleSelectClause()
{ {
$distinct = false; $distinct = false;
$this->match(Lexer::T_SELECT); $this->match(Lexer::T_SELECT);
@ -1521,7 +1515,7 @@ class Parser
/** /**
* SubselectFromClause ::= "FROM" SubselectIdentificationVariableDeclaration {"," SubselectIdentificationVariableDeclaration}* * SubselectFromClause ::= "FROM" SubselectIdentificationVariableDeclaration {"," SubselectIdentificationVariableDeclaration}*
*/ */
private function _SubselectFromClause() public function _SubselectFromClause()
{ {
$this->match(Lexer::T_FROM); $this->match(Lexer::T_FROM);
$identificationVariables = array(); $identificationVariables = array();
@ -1536,7 +1530,7 @@ class Parser
/** /**
* SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration | (AssociationPathExpression ["AS"] AliasIdentificationVariable) * SubselectIdentificationVariableDeclaration ::= IdentificationVariableDeclaration | (AssociationPathExpression ["AS"] AliasIdentificationVariable)
*/ */
private function _SubselectIdentificationVariableDeclaration() public function _SubselectIdentificationVariableDeclaration()
{ {
$peek = $this->_lexer->glimpse(); $peek = $this->_lexer->glimpse();
if ($peek['value'] == '.') { if ($peek['value'] == '.') {
@ -1554,7 +1548,7 @@ class Parser
/** /**
* SimpleSelectExpression ::= StateFieldPathExpression | IdentificationVariable | (AggregateExpression [["AS"] FieldAliasIdentificationVariable]) * SimpleSelectExpression ::= StateFieldPathExpression | IdentificationVariable | (AggregateExpression [["AS"] FieldAliasIdentificationVariable])
*/ */
private function _SimpleSelectExpression() public function _SimpleSelectExpression()
{ {
if ($this->_lexer->isNextToken(Lexer::T_IDENTIFIER)) { if ($this->_lexer->isNextToken(Lexer::T_IDENTIFIER)) {
// SingleValuedPathExpression | IdentificationVariable // SingleValuedPathExpression | IdentificationVariable
@ -1581,7 +1575,7 @@ class Parser
/** /**
* Literal ::= string | char | integer | float | boolean | InputParameter * Literal ::= string | char | integer | float | boolean | InputParameter
*/ */
private function _Literal() public function _Literal()
{ {
switch ($this->_lexer->lookahead['type']) { switch ($this->_lexer->lookahead['type']) {
case Lexer::T_INPUT_PARAMETER: case Lexer::T_INPUT_PARAMETER:
@ -1600,7 +1594,7 @@ class Parser
/** /**
* BetweenExpression ::= ArithmeticExpression ["NOT"] "BETWEEN" ArithmeticExpression "AND" ArithmeticExpression * BetweenExpression ::= ArithmeticExpression ["NOT"] "BETWEEN" ArithmeticExpression "AND" ArithmeticExpression
*/ */
private function _BetweenExpression() public function _BetweenExpression()
{ {
$not = false; $not = false;
$arithExpr1 = $this->_ArithmeticExpression(); $arithExpr1 = $this->_ArithmeticExpression();
@ -1622,7 +1616,7 @@ class Parser
/** /**
* ArithmeticPrimary ::= StateFieldPathExpression | Literal | "(" SimpleArithmeticExpression ")" | Function | AggregateExpression * ArithmeticPrimary ::= StateFieldPathExpression | Literal | "(" SimpleArithmeticExpression ")" | Function | AggregateExpression
*/ */
private function _ArithmeticPrimary() public function _ArithmeticPrimary()
{ {
if ($this->_lexer->lookahead['value'] === '(') { if ($this->_lexer->lookahead['value'] === '(') {
$this->match('('); $this->match('(');
@ -1669,7 +1663,7 @@ class Parser
* "LOWER" "(" StringPrimary ")" | * "LOWER" "(" StringPrimary ")" |
* "UPPER" "(" StringPrimary ")" * "UPPER" "(" StringPrimary ")"
*/ */
private function _FunctionsReturningStrings() public function _FunctionsReturningStrings()
{ {
$funcNameLower = strtolower($this->_lexer->lookahead['value']); $funcNameLower = strtolower($this->_lexer->lookahead['value']);
$funcClass = self::$_STRING_FUNCTIONS[$funcNameLower]; $funcClass = self::$_STRING_FUNCTIONS[$funcNameLower];
@ -1687,7 +1681,7 @@ class Parser
* "MOD" "(" SimpleArithmeticExpression "," SimpleArithmeticExpression ")" | * "MOD" "(" SimpleArithmeticExpression "," SimpleArithmeticExpression ")" |
* "SIZE" "(" CollectionValuedPathExpression ")" * "SIZE" "(" CollectionValuedPathExpression ")"
*/ */
private function _FunctionsReturningNumerics() public function _FunctionsReturningNumerics()
{ {
$funcNameLower = strtolower($this->_lexer->lookahead['value']); $funcNameLower = strtolower($this->_lexer->lookahead['value']);
$funcClass = self::$_NUMERIC_FUNCTIONS[$funcNameLower]; $funcClass = self::$_NUMERIC_FUNCTIONS[$funcNameLower];
@ -1711,7 +1705,7 @@ class Parser
/** /**
* Checks whether the given token type indicates an aggregate function. * Checks whether the given token type indicates an aggregate function.
*/ */
private function _isAggregateFunction($tokenType) public function _isAggregateFunction($tokenType)
{ {
return $tokenType == Lexer::T_AVG || $tokenType == Lexer::T_MIN || return $tokenType == Lexer::T_AVG || $tokenType == Lexer::T_MIN ||
$tokenType == Lexer::T_MAX || $tokenType == Lexer::T_SUM || $tokenType == Lexer::T_MAX || $tokenType == Lexer::T_SUM ||
@ -1721,7 +1715,7 @@ class Parser
/** /**
* ComparisonOperator ::= "=" | "<" | "<=" | "<>" | ">" | ">=" | "!=" * ComparisonOperator ::= "=" | "<" | "<=" | "<>" | ">" | ">=" | "!="
*/ */
private function _ComparisonOperator() public function _ComparisonOperator()
{ {
switch ($this->_lexer->lookahead['value']) { switch ($this->_lexer->lookahead['value']) {
case '=': case '=':
@ -1759,7 +1753,7 @@ class Parser
/** /**
* LikeExpression ::= StringExpression ["NOT"] "LIKE" (string | input_parameter) ["ESCAPE" char] * LikeExpression ::= StringExpression ["NOT"] "LIKE" (string | input_parameter) ["ESCAPE" char]
*/ */
private function _LikeExpression() public function _LikeExpression()
{ {
$stringExpr = $this->_StringExpression(); $stringExpr = $this->_StringExpression();
$isNot = false; $isNot = false;
@ -1787,7 +1781,7 @@ class Parser
/** /**
* StringExpression ::= StringPrimary | "(" Subselect ")" * StringExpression ::= StringPrimary | "(" Subselect ")"
*/ */
private function _StringExpression() public function _StringExpression()
{ {
if ($this->_lexer->lookahead['value'] === '(') { if ($this->_lexer->lookahead['value'] === '(') {
$peek = $this->_lexer->glimpse(); $peek = $this->_lexer->glimpse();
@ -1826,16 +1820,34 @@ class Parser
} }
} }
/**
* Registers a custom function that returns strings.
*
* @param string $name The function name.
* @param string $class The class name of the function implementation.
*/
public static function registerStringFunction($name, $class) public static function registerStringFunction($name, $class)
{ {
self::$_STRING_FUNCTIONS[$name] = $class; self::$_STRING_FUNCTIONS[$name] = $class;
} }
/**
* Registers a custom function that returns numerics.
*
* @param string $name The function name.
* @param string $class The class name of the function implementation.
*/
public static function registerNumericFunction($name, $class) public static function registerNumericFunction($name, $class)
{ {
self::$_NUMERIC_FUNCTIONS[$name] = $class; self::$_NUMERIC_FUNCTIONS[$name] = $class;
} }
/**
* Registers a custom function that returns date/time values.
*
* @param string $name The function name.
* @param string $class The class name of the function implementation.
*/
public static function registerDatetimeFunction($name, $class) public static function registerDatetimeFunction($name, $class)
{ {
self::$_DATETIME_FUNCTIONS[$name] = $class; self::$_DATETIME_FUNCTIONS[$name] = $class;