PHP Doctrine\ORM\Query Parser::StringPrimary Examples

StringPrimary() public method

StringPrimary ::= StateFieldPathExpression | string | InputParameter | FunctionsReturningStrings | AggregateExpression

public StringPrimary ( )

Example #1

File: GroupConcat.php Project: Maksold/platform

 /**
  * @param Parser $parser
  * @throws QueryException
  */
 public function parse(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;
     }
     $this->pathExpressions[] = $parser->SingleValuedPathExpression();
     while ($lexer->isNextToken(Lexer::T_COMMA)) {
         $parser->match(Lexer::T_COMMA);
         $this->pathExpressions[] = $parser->StringPrimary();
     }
     if ($lexer->isNextToken(Lexer::T_ORDER)) {
         $this->orderBy = $parser->OrderByClause();
     }
     if ($lexer->isNextToken(Lexer::T_IDENTIFIER)) {
         if (strtolower($lexer->lookahead['value']) !== self::T_SEPARATOR) {
             $parser->syntaxError(self::T_SEPARATOR);
         }
         $parser->match(Lexer::T_IDENTIFIER);
         $this->separator = $parser->StringPrimary();
     }
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #2

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

 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 = array();
     $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);
 }

Example #3

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

 /**
  * @url http://sysmagazine.com/posts/181666/
  *
  * {@inheritdoc}
  */
 public function parse(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->parameters[self::DISTINCT_KEY] = true;
     }
     // first Path Expression is mandatory
     $this->parameters[self::PARAMETER_KEY] = array();
     $this->parameters[self::PARAMETER_KEY][] = $parser->SingleValuedPathExpression();
     while ($lexer->isNextToken(Lexer::T_COMMA)) {
         $parser->match(Lexer::T_COMMA);
         $this->parameters[self::PARAMETER_KEY][] = $parser->StringPrimary();
     }
     if ($lexer->isNextToken(Lexer::T_ORDER)) {
         $this->parameters[self::ORDER_KEY] = $parser->OrderByClause();
     }
     if ($lexer->isNextToken(Lexer::T_IDENTIFIER)) {
         if (strtolower($lexer->lookahead['value']) !== 'separator') {
             $parser->syntaxError('separator');
         }
         $parser->match(Lexer::T_IDENTIFIER);
         $this->parameters[self::SEPARATOR_KEY] = $parser->StringPrimary();
     }
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #4

File: TSFunction.php Project: jbinfo/DoctrineFullTextPostrgres

 public function parse(Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->ftsField = $parser->StringPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->queryString = $parser->StringPrimary();
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #5

File: DefinedFunction.php Project: molaux/hstore-bundle

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

Example #6

File: ConcatFunction.php Project: nemekzg/doctrine2

 /**
  * @override
  */
 public function parse(\Doctrine\ORM\Query\Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->firstStringPrimary = $parser->StringPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->secondStringPrimary = $parser->StringPrimary();
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #7

File: PlainToTsquery.php Project: samuvack/admin

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

Example #8

File: Replace.php Project: GerDner/luck-docker

 /**
  * Define the parser
  *
  * @param Parser $parser
  */
 public function parse(Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->subjectExpression = $parser->StringExpression();
     $parser->match(Lexer::T_COMMA);
     $this->findExpression = $parser->StringPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->replaceExpression = $parser->StringPrimary();
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #9

File: CountIf.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);
     $this->column = $parser->StringPrimary()->value;
     $parser->match(Lexer::T_COMMA);
     $this->cond = $parser->StringPrimary()->value;
     $parser->match(Lexer::T_COMMA);
     $this->value = $parser->StringExpression()->value;
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #10

File: ConvertTz.php Project: beberlei/doctrineextensions

 /**
  * {@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);
 }

Example #11

File: ConcatWs.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::SEPARATOR_KEY] = $parser->StringPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->parameters[self::STRINGS_KEY][] = $parser->StringPrimary();
     while ($parser->getLexer()->isNextToken(Lexer::T_COMMA)) {
         $parser->match(Lexer::T_COMMA);
         $this->parameters[self::STRINGS_KEY][] = $parser->StringPrimary();
     }
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #12

File: PlainToTsqueryFunction.php Project: slkxmail/postgres-search-bundle

 public function parse(\Doctrine\ORM\Query\Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->fieldName = $parser->StringPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->queryString = $parser->StringPrimary();
     if ($parser->getLexer()->lookahead['type'] == Lexer::T_COMMA) {
         $parser->match(Lexer::T_COMMA);
         $this->regconfig = $parser->StringPrimary();
     }
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #13

File: ConcatWs.php Project: m3uzz/onionfw

 /**
  * {@inheritdoc}
  */
 public function parse(\Doctrine\ORM\Query\Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->parameters['separator'] = $parser->StringPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->parameters['strings'][] = $parser->StringPrimary();
     while ($parser->getLexer()->isNextToken(Lexer::T_COMMA)) {
         $parser->match(Lexer::T_COMMA);
         $this->parameters['strings'][] = $parser->StringPrimary();
     }
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #14

File: GeoDistanceByPostalCode.php Project: marc-f/CraueGeoBundle

 public function parse(Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->countryOrigin = $parser->StringPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->postalCodeOrigin = $parser->StringPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->countryDestination = $parser->StringPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->postalCodeDestination = $parser->StringPrimary();
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #15

File: TsqueryFunction.php Project: styleflashernewmedia/PostgreSearchBundle

 public function parse(\Doctrine\ORM\Query\Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->fieldName = $parser->StringPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->queryString = $parser->StringPrimary();
     $lexer = $parser->getLexer();
     if ($lexer->isNextToken(Lexer::T_COMMA)) {
         $parser->match(Lexer::T_COMMA);
         $this->configuration = $parser->StringPrimary();
     }
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #16

File: TsConcat.php Project: opsway/doctrine-dbal-postgresql

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

Example #17

File: LocateFunction.php Project: krishcdbry/z-zangura

 /**
  * @override
  */
 public function parse(\Doctrine\ORM\Query\Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->firstStringPrimary = $parser->StringPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->secondStringPrimary = $parser->StringPrimary();
     $lexer = $parser->getLexer();
     if ($lexer->isNextToken(Lexer::T_COMMA)) {
         $parser->match(Lexer::T_COMMA);
         $this->simpleArithmeticExpression = $parser->SimpleArithmeticExpression();
     }
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #18

File: Regexp.php Project: MagmaDigitalLtd/ZucchiDoctrine

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

Example #19

File: ReplaceFunction.php Project: defan-marunchak/eurotax

 public function parse(\Doctrine\ORM\Query\Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     // REPLACE
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->stringStr = $parser->StringPrimary();
     // str
     $parser->match(Lexer::T_COMMA);
     $this->stringFromStr = $parser->StringPrimary();
     // from_str
     $parser->match(Lexer::T_COMMA);
     $this->stringToStr = $parser->StringPrimary();
     // to_str
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #20

File: ConcatFunction.php Project: alfredocoj/blogzf2tutorial

 /**
  * @override
  */
 public function parse(\Doctrine\ORM\Query\Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->firstStringPrimary = $parser->StringPrimary();
     $this->concatExpressions[] = $this->firstStringPrimary;
     $parser->match(Lexer::T_COMMA);
     $this->secondStringPrimary = $parser->StringPrimary();
     $this->concatExpressions[] = $this->secondStringPrimary;
     while ($parser->getLexer()->isNextToken(Lexer::T_COMMA)) {
         $parser->match(Lexer::T_COMMA);
         $this->concatExpressions[] = $parser->StringPrimary();
     }
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #21

File: MatchAgainstFunction.php Project: Avazanga1/Sylius

 /**
  * @param Parser $parser
  */
 public function parse(Parser $parser)
 {
     // match
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     // first Path Expression is mandatory
     $this->pathExp = array();
     $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);
 }

Example #22

File: SortByKlassenstufe.php Project: baurat/Schulapp

 public function parse(Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->firstDateExpression = $parser->StringPrimary();
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #23

File: MatchAgainstFunction.php Project: brick/brick

 /**
  * @inheritdoc
  */
 public function parse(Parser $parser)
 {
     $this->match = [];
     $this->mode = null;
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $lexer = $parser->getLexer();
     for (;;) {
         $this->match[] = $parser->StateFieldPathExpression();
         if (!$lexer->isNextToken(Lexer::T_COMMA)) {
             break;
         }
         $parser->match(Lexer::T_COMMA);
     }
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
     if (strtoupper($lexer->lookahead['value']) !== 'AGAINST') {
         $parser->syntaxError('AGAINST');
     }
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->against = $parser->StringPrimary();
     if ($lexer->isNextToken(Lexer::T_STRING)) {
         $parser->match(Lexer::T_STRING);
         $this->mode = $lexer->token['value'];
     }
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #24

File: DateIntervalFunction.php Project: kamilkrzywda/php-doctrine-dateinterval

 /**
  * @override
  */
 public function parse(Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->intervalSpec = $parser->StringPrimary();
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #25

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

 /**
  * @override
  */
 public function parse(\Doctrine\ORM\Query\Parser $parser)
 {
     $lexer = $parser->getLexer();
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->stringPrimary = $parser->StringPrimary();
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #26

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

 public function parse(Parser $parser)
 {
     $lexer = $parser->getLexer();
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->strings[] = $parser->StringPrimary();
     // Separator
     $parser->match(Lexer::T_COMMA);
     $this->strings[] = $parser->StringPrimary();
     $parser->match(Lexer::T_COMMA);
     $this->strings[] = $parser->StringPrimary();
     while ($lexer->isNextToken(Lexer::T_COMMA)) {
         $parser->match(Lexer::T_COMMA);
         $this->strings[] = $parser->StringPrimary();
     }
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #27

File: DateFormat.php Project: liverbool/dos-resource-bundle

 /**
  * parse - allows DQL to breakdown the DQL string into a processable structure.
  *
  * @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->dateExpression = $parser->ArithmeticExpression();
     $parser->match(Lexer::T_COMMA);
     $this->formatChar = $parser->StringPrimary();
     $parser->match(Lexer::T_CLOSE_PARENTHESIS);
 }

Example #28

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

 public function parse(\Doctrine\ORM\Query\Parser $parser)
 {
     $lexer = $parser->getLexer();
     $parser->match(\Doctrine\ORM\Query\Lexer::T_IDENTIFIER);
     $parser->match(\Doctrine\ORM\Query\Lexer::T_OPEN_PARENTHESIS);
     $this->expression = $parser->ArithmeticPrimary();
     $parser->match(\Doctrine\ORM\Query\Lexer::T_COMMA);
     $this->format = $parser->StringPrimary();
     $parser->match(\Doctrine\ORM\Query\Lexer::T_CLOSE_PARENTHESIS);
 }

Example #29

File: Collate.php Project: blitzik/vycetky-doctrine

 public function parse(\Doctrine\ORM\Query\Parser $parser)
 {
     $parser->match(Lexer::T_IDENTIFIER);
     $parser->match(Lexer::T_OPEN_PARENTHESIS);
     $this->expressionToCollate = $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);
 }

Example #30

File: DateAddFunction.php Project: Dren-x/mobit

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