PHP Doctrine\ORM\Query Parser::ArithmeticPrimary Examples

ArithmeticPrimary() public method

ArithmeticPrimary ::= SingleValuedPathExpression | Literal | "(" SimpleArithmeticExpression ")" | FunctionsReturningNumerics | AggregateExpression | FunctionsReturningStrings | FunctionsReturningDatetime | IdentificationVariable

public ArithmeticPrimary ( )

Example #1

File: StringAgg.php Project: wagnertw/mapasculturais

 public function parse(Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->expression = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->delimiter = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #2

File: TimeDiff.php Project: amohammad/ZeDoctrineExtensions

 /**
  * {@inheritDoc}
  */
 public function parse(\Doctrine\ORM\Query\Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->firstTimeExpression = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->secondTimeExpression = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #3

File: TimeDiff.php Project: interactive-solutions/zf-stdlib

 public function parse(Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->dateTime1 = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->dateTime2 = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #4

File: FindInSet.php Project: harentius/widgets-bundle

 /**
  * @param Parser $parser
  */
 public function parse(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);
 }

Example #5

File: LevenshteinRatioFunction.php Project: glanchow/doctrine-fuzzy

 public function parse(\Doctrine\ORM\Query\Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->expr1 = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->expr2 = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #6

File: DateDiff.php Project: imikay/doctrine-functions

 public function parse(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);
 }

Example #7

File: LevenshteinFunction.php Project: fza/mysql-doctrine-levenshtein-function

 public function parse(Parser $parser)
 {
     // levenshtein(str1, str2)
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->firstStringExpression = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->secondStringExpression = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #8

File: Substr.php Project: morontt/doctrine-functions

 /**
  * @param Parser $parser
  */
 public function parse(Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->string = $parser->StringPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->from = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->count = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #9

File: DistanceFunction.php Project: adampiotrowski/DoctrineBehaviors

 /**
  * Parses DQL function.
  *
  * @param Parser $parser
  */
 public function parse(Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->entityLocation = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->latitude = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->longitude = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #10

File: Replace.php Project: guiwoda/DoctrineExtensions

 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);
 }

Example #11

File: ConvertTz.php Project: Hikariii/doctrine-extensions

 /**
  * {@inheritdoc}
  */
 public function parse(Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->parameters[self::VALUE_KEY] = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->parameters[self::FROM_TZ_KEY] = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->parameters[self::TO_TZ_KEY] = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #12

File: DateAdd.php Project: digvijaymohite/e-tender

 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->intervalExpression = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->unit = $parser->StringPrimary();
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #13

File: LpadFunction.php Project: b4nan/doctrine

 /**
  * @param Parser $parser
  */
 public function parse(Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->stringExpression = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->lengthExpression = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->padStringExpression = $parser->StringPrimary();
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #14

File: Greatest.php Project: johnnoel/fansubebooks.chaostangent.com

 public function parse(Parser $parser)
 {
     $lexer = $parser->getLexer();
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->values[] = $parser->ArithmeticPrimary();
     while (Lexer::T_COMMA === $lexer->lookahead['type']) {
         $parser->match(Lexer::T_COMMA);
         $this->values[] = $parser->ArithmeticPrimary();
     }
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #15

File: Field.php Project: jacksleight/coast-doctrine

 public function parse(\Doctrine\ORM\Query\Parser $parser)
 {
     $parser->match(\Doctrine\ORM\Query\Lexer::T_IDENTIFIER);
     $parser->match(\Doctrine\ORM\Query\Lexer::T_OPEN_PARENTHESIS);
     $this->field = $parser->ArithmeticPrimary();
     $lexer = $parser->getLexer();
     while (count($this->values) < 1 || $lexer->lookahead['type'] != \Doctrine\ORM\Query\Lexer::T_CLOSE_PARENTHESIS) {
         $parser->match(\Doctrine\ORM\Query\Lexer::T_COMMA);
         $this->values[] = $parser->ArithmeticPrimary();
     }
     $parser->match(\Doctrine\ORM\Query\Lexer::T_CLOSE_PARENTHESIS);
 }

Example #16

File: AbstractVariableGeometryDQLFunction.php Project: raketman/doctrine2-spatial

 /**
  * @param Parser $parser
  */
 public function parse(Parser $parser)
 {
     $lexer = $parser->getLexer();
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->firstGeomExpression = $parser->ArithmeticPrimary();
     while (count($this->geomExpressions) < 1 || $lexer->lookahead['type'] != Lexer::T_CLOSE_PARENTHESIS) {
         $parser->match(Lexer::T_COMMA);
         $this->geomExpressions[] = $parser->ArithmeticPrimary();
     }
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #17

File: AbstractSpatialDQLFunction.php Project: dragosprotung/doctrine2-spatial

 /**
  * @param Parser $parser
  */
 public function parse(Parser $parser)
 {
     $lexer = $parser->getLexer();
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->geomExpr[] = $parser->ArithmeticPrimary();
     while (count($this->geomExpr) < $this->minGeomExpr || ($this->maxGeomExpr === null || count($this->geomExpr) < $this->maxGeomExpr) && $lexer->lookahead['type'] != Lexer::T_CLOSE_PARENTHESIS) {
         $parser->match(Lexer::T_COMMA);
         $this->geomExpr[] = $parser->ArithmeticPrimary();
     }
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #18

File: Round.php Project: uppaljs/pakistan-vlmis-v2

 public function parse(\Doctrine\ORM\Query\Parser $parser)
 {
     $lexer = $parser->getLexer();
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->firstExpression = $parser->ArithmeticPrimary();
     // parse second parameter if available
     if (Lexer::T_COMMA === $lexer->lookahead['type']) {
         $parser->match(Lexer::T_COMMA);
         $this->secondExpression = $parser->ArithmeticPrimary();
     }
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #19

File: TimestampDiff.php Project: matiasraies/Symfony2Inta

 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);
 }

Example #20

File: GeoDistance.php Project: msingi/msingi

 /**
  * @param \Doctrine\ORM\Query\Parser $parser
  *
  * @return void
  */
 public function parse(\Doctrine\ORM\Query\Parser $parser)
 {
     $lexer = $parser->getLexer();
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->from_lat = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->from_lon = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->to_lat = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->to_lon = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #21

File: AbstractDualGeometryOptionalParameterDQLFunction.php Project: raketman/doctrine2-spatial

 /**
  * @param Parser $parser
  */
 public function parse(Parser $parser)
 {
     $lexer = $parser->getLexer();
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->firstGeomExpression = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->secondGeomExpression = $parser->ArithmeticPrimary();
     if ($lexer->lookahead['type'] == Lexer::T_COMMA) {
         $parser->match(Lexer::T_COMMA);
         $this->optionalExpression = $parser->ArithmeticPrimary();
     }
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #22

File: MysqlDateSub.php Project: fxlacroix/component

 /**
  * Parse the DQL
  *
  * @param \Doctrine\ORM\Query\Parser $parser
  */
 public function parse(Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->firstDateExpression = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_COMMA);
     $parser->match(Lexer::T_IDENTIFIER);
     $this->intervalExpression = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_IDENTIFIER);
     /* @var $lexer Lexer */
     $lexer = $parser->getLexer();
     $this->unit = $lexer->token['value'];
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #23

File: Greatest.php Project: bares43/bachelor-thesis-survey

 /**
  * @param Parser $parser
  */
 public function parse(Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     // 2 arguments minimum
     $this->greatestArgs[] = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->greatestArgs[] = $parser->ArithmeticPrimary();
     while ($parser->getLexer()->isNextToken(Lexer::T_COMMA)) {
         $parser->match(Lexer::T_COMMA);
         $this->greatestArgs[] = $parser->ArithmeticPrimary();
     }
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #24

File: BitwiseAnd.php Project: leapt/core-bundle

 /**
  * @param \Doctrine\ORM\Query\Parser $parser
  */
 public function parse(Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     // (2)
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     // (3)
     $this->firstValue = $parser->ArithmeticPrimary();
     // (4)
     $parser->match(Lexer::T_COMMA);
     // (5)
     $this->secondValue = $parser->ArithmeticPrimary();
     // (6)
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
     // (3)
 }

Example #25

File: Field.php Project: rYsvelain/FunkylabBundle

 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);
 }

Example #26

File: DateDiff.php Project: janmarek/Neuron

 public function parse(\Doctrine\ORM\Query\Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     // (2)
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     // (3)
     $this->firstDateExpression = $parser->ArithmeticPrimary();
     // (4)
     $parser->match(Lexer::T_COMMA);
     // (5)
     $this->secondDateExpression = $parser->ArithmeticPrimary();
     // (6)
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
     // (3)
 }

Example #27

File: GroupConcat.php Project: gaedelprete/MysqlDoctrineFunctions

 public function parse(\Doctrine\ORM\Query\Parser $parser)
 {
     $lexer = $parser->getLexer();
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     if ($lexer->lookahead['type'] === Lexer::T_DISTINCT) {
         $parser->match(Lexer::T_DISTINCT);
         $this->distinct = true;
     }
     $this->field = $parser->ArithmeticPrimary();
     if ($lexer->lookahead['type'] === Lexer::T_IDENTIFIER) {
         $parser->match(Lexer::T_IDENTIFIER);
         $this->separator = $parser->ArithmeticPrimary();
     }
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #28

File: SimpleFunction.php Project: Hikariii/doctrine-extensions

 /**
  * {@inheritdoc}
  */
 public function parse(Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->parameters[self::PARAMETER_KEY] = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #29

File: DateFunction.php Project: mesour/filter

 public function parse(Query\Parser $parser)
 {
     $parser->match(Query\Lexer::T_IDENTIFIER);
     $parser->match(Query\Lexer::T_OPEN_PARENTHESIS);
     $this->arg = $parser->ArithmeticPrimary();
     $parser->match(Query\Lexer::T_CLOSE_PARENTHESIS);
 }

Example #30

File: Cast.php Project: sblmasta/doctrine-extensions

 /**
  * {@inheritdoc}
  */
 public function parse(Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->parameters[self::PARAMETER_KEY] = $parser->ArithmeticPrimary();
     $parser->match(Lexer::T_AS);
     $parser->match(Lexer::T_IDENTIFIER);
     $lexer = $parser->getLexer();
     $type = $lexer->token['value'];
     if ($lexer->isNextToken(Lexer::T_OPEN_PARENTHESIS)) {
         $parser->match(Lexer::T_OPEN_PARENTHESIS);
         /** @var Literal $parameter */
         $parameter = $parser->Literal();
         $parameters = array($parameter->value);
         if ($lexer->isNextToken(Lexer::T_COMMA)) {
             while ($lexer->isNextToken(Lexer::T_COMMA)) {
                 $parser->match(Lexer::T_COMMA);
                 $parameter = $parser->Literal();
                 $parameters[] = $parameter->value;
             }
         }
         $parser->match(Lexer::T_CLOSE_PARENTHESIS);
         $type .= '(' . implode(', ', $parameters) . ')';
     }
     if (!$this->checkType($type)) {
         $parser->syntaxError(sprintf('Type unsupported. Supported types are: "%s"', implode(', ', $this->supportedTypes)), $lexer->token);
     }
     $this->parameters[self::TYPE_KEY] = $type;
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }