vendor/doctrine/orm/tests/Doctrine/Tests/ORM/Query/LanguageRecognitionTest.php

   1 <?php
   2 namespace Doctrine\Tests\ORM\Query;
   3
   4 use Doctrine\ORM\Query,
   5     Doctrine\ORM\Query\QueryException;
   6
   7 require_once __DIR__ . '/../../TestInit.php';
   8
   9 class LanguageRecognitionTest extends \Doctrine\Tests\OrmTestCase
  10 {
  11     private $_em;
  12
  13     protected function setUp()
  14     {
  15         $this->_em = $this->_getTestEntityManager();
  16     }
  17
  18     public function assertValidDQL($dql, $debug = false)
  19     {
  20         try {
  21             $parserResult = $this->parseDql($dql);
  22         } catch (QueryException $e) {
  23             if ($debug) {
  24                 echo $e->getTraceAsString() . PHP_EOL;
  25             }
  26
  27             $this->fail($e->getMessage());
  28         }
  29     }
  30
  31     public function assertInvalidDQL($dql, $debug = false)
  32     {
  33         try {
  34             $parserResult = $this->parseDql($dql);
  35
  36             $this->fail('No syntax errors were detected, when syntax errors were expected');
  37         } catch (QueryException $e) {
  38             if ($debug) {
  39                 echo $e->getMessage() . PHP_EOL;
  40                 echo $e->getTraceAsString() . PHP_EOL;
  41             }
  42         }
  43     }
  44
  45     public function parseDql($dql, $hints = array())
  46     {
  47         $query = $this->_em->createQuery($dql);
  48         $query->setHint(Query::HINT_FORCE_PARTIAL_LOAD, true);
  49         $query->setDql($dql);
  50
  51         foreach ($hints as $key => $value) {
  52                 $query->setHint($key, $value);
  53         }
  54
  55         $parser = new \Doctrine\ORM\Query\Parser($query);
  56
  57         // We do NOT test SQL output here. That only unnecessarily slows down the tests!
  58         $parser->setCustomOutputTreeWalker('Doctrine\Tests\Mocks\MockTreeWalker');
  59
  60         return $parser->parse();
  61     }
  62
  63     public function testEmptyQueryString()
  64     {
  65         $this->assertInvalidDQL('');
  66     }
  67
  68     public function testPlainFromClauseWithAlias()
  69     {
  70         $this->assertValidDQL('SELECT u.id FROM Doctrine\Tests\Models\CMS\CmsUser u');
  71     }
  72
  73     public function testSelectSingleComponentWithAsterisk()
  74     {
  75         $this->assertValidDQL('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u');
  76     }
  77
  78     public function testSelectSingleComponentWithMultipleColumns()
  79     {
  80         $this->assertValidDQL('SELECT u.name, u.username FROM Doctrine\Tests\Models\CMS\CmsUser u');
  81     }
  82
  83     public function testSelectMultipleComponentsUsingMultipleFrom()
  84     {
  85         $this->assertValidDQL('SELECT u, p FROM Doctrine\Tests\Models\CMS\CmsUser u, Doctrine\Tests\Models\CMS\CmsPhonenumber p WHERE u = p.user');
  86     }
  87
  88     public function testSelectMultipleComponentsWithAsterisk()
  89     {
  90         $this->assertValidDQL('SELECT u, p FROM Doctrine\Tests\Models\CMS\CmsUser u JOIN u.phonenumbers p');
  91     }
  92
  93     public function testSelectDistinctIsSupported()
  94     {
  95         $this->assertValidDQL('SELECT DISTINCT u.name FROM Doctrine\Tests\Models\CMS\CmsUser u');
  96     }
  97
  98     public function testAggregateFunctionInSelect()
  99     {
 100         $this->assertValidDQL('SELECT COUNT(u.id) FROM Doctrine\Tests\Models\CMS\CmsUser u');
 101     }
 102
 103     public function testDuplicatedAliasInAggregateFunction()
 104     {
 105         $this->assertInvalidDQL('SELECT COUNT(u.id) AS num, SUM(u.id) AS num FROM Doctrine\Tests\Models\CMS\CmsUser u');
 106     }
 107
 108     public function testAggregateFunctionWithDistinctInSelect()
 109     {
 110         $this->assertValidDQL('SELECT COUNT(DISTINCT u.name) FROM Doctrine\Tests\Models\CMS\CmsUser u');
 111     }
 112
 113     public function testFunctionalExpressionsSupportedInWherePart()
 114     {
 115         $this->assertValidDQL("SELECT u.name FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE TRIM(u.name) = 'someone'");
 116     }
 117
 118     public function testArithmeticExpressionsSupportedInWherePart()
 119     {
 120         $this->assertValidDQL('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE ((u.id + 5000) * u.id + 3) < 10000000');
 121     }
 122
 123     public function testInExpressionSupportedInWherePart()
 124     {
 125         $this->assertValidDQL('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id IN (1, 2)');
 126     }
 127
 128     public function testInExpressionWithoutSpacesSupportedInWherePart()
 129     {
 130         $this->assertValidDQL('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id IN (1,2,3)');
 131     }
 132
 133     public function testNotInExpressionSupportedInWherePart()
 134     {
 135         $this->assertValidDQL('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id NOT IN (1)');
 136     }
 137
 138     public function testInExpressionWithSingleValuedAssociationPathExpression()
 139     {
 140         $this->assertValidDQL("SELECT u FROM Doctrine\Tests\Models\Forum\ForumUser u WHERE u.avatar IN (?1, ?2)");
 141     }
 142
 143     public function testInvalidInExpressionWithCollectionValuedAssociationPathExpression()
 144     {
 145         $this->assertInvalidDQL("SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.phonenumbers IN (?1, ?2)");
 146     }
 147
 148     public function testInstanceOfExpressionSupportedInWherePart()
 149     {
 150         $this->assertValidDQL('SELECT u FROM Doctrine\Tests\Models\Company\CompanyPerson u WHERE u INSTANCE OF Doctrine\Tests\Models\Company\CompanyEmployee');
 151     }
 152
 153     public function testInstanceOfExpressionWithInputParamSupportedInWherePart()
 154     {
 155         $this->assertValidDQL('SELECT u FROM Doctrine\Tests\Models\Company\CompanyPerson u WHERE u INSTANCE OF ?1');
 156     }
 157
 158     public function testNotInstanceOfExpressionSupportedInWherePart()
 159     {
 160         $this->assertValidDQL('SELECT u FROM Doctrine\Tests\Models\Company\CompanyPerson u WHERE u NOT INSTANCE OF ?1');
 161     }
 162
 163     public function testExistsExpressionSupportedInWherePart()
 164     {
 165         $this->assertValidDQL('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE EXISTS (SELECT p.phonenumber FROM Doctrine\Tests\Models\CMS\CmsPhonenumber p WHERE p.phonenumber = 1234)');
 166     }
 167
 168     public function testNotExistsExpressionSupportedInWherePart()
 169     {
 170         $this->assertValidDQL('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE NOT EXISTS (SELECT p.phonenumber FROM Doctrine\Tests\Models\CMS\CmsPhonenumber p WHERE p.phonenumber = 1234)');
 171     }
 172
 173     public function testAggregateFunctionInHavingClause()
 174     {
 175         $this->assertValidDQL('SELECT u.name FROM Doctrine\Tests\Models\CMS\CmsUser u LEFT JOIN u.phonenumbers p HAVING COUNT(p.phonenumber) > 2');
 176         $this->assertValidDQL("SELECT u.name FROM Doctrine\Tests\Models\CMS\CmsUser u LEFT JOIN u.phonenumbers p HAVING MAX(u.name) = 'romanb'");
 177     }
 178
 179     public function testLeftJoin()
 180     {
 181         $this->assertValidDQL('SELECT u, p FROM Doctrine\Tests\Models\CMS\CmsUser u LEFT JOIN u.phonenumbers p');
 182     }
 183
 184     public function testJoin()
 185     {
 186         $this->assertValidDQL('SELECT u,p FROM Doctrine\Tests\Models\CMS\CmsUser u JOIN u.phonenumbers p');
 187     }
 188
 189     public function testInnerJoin()
 190     {
 191         $this->assertValidDQL('SELECT u, p FROM Doctrine\Tests\Models\CMS\CmsUser u INNER JOIN u.phonenumbers p');
 192     }
 193
 194     public function testMultipleLeftJoin()
 195     {
 196         $this->assertValidDQL('SELECT u, a, p FROM Doctrine\Tests\Models\CMS\CmsUser u LEFT JOIN u.articles a LEFT JOIN u.phonenumbers p');
 197     }
 198
 199     public function testMultipleInnerJoin()
 200     {
 201         $this->assertValidDQL('SELECT u.name FROM Doctrine\Tests\Models\CMS\CmsUser u INNER JOIN u.articles a INNER JOIN u.phonenumbers p');
 202     }
 203
 204     public function testMixingOfJoins()
 205     {
 206         $this->assertValidDQL('SELECT u.name, a.topic, p.phonenumber FROM Doctrine\Tests\Models\CMS\CmsUser u INNER JOIN u.articles a LEFT JOIN u.phonenumbers p');
 207     }
 208
 209     public function testJoinClassPath()
 210     {
 211         $this->assertValidDQL('SELECT u.name FROM Doctrine\Tests\Models\CMS\CmsUser u JOIN Doctrine\Tests\Models\CMS\CmsArticle a WITH a.user = u.id');
 212     }
 213
 214     public function testOrderBySingleColumn()
 215     {
 216         $this->assertValidDQL('SELECT u.name FROM Doctrine\Tests\Models\CMS\CmsUser u ORDER BY u.name');
 217     }
 218
 219     public function testOrderBySingleColumnAscending()
 220     {
 221         $this->assertValidDQL('SELECT u.name FROM Doctrine\Tests\Models\CMS\CmsUser u ORDER BY u.name ASC');
 222     }
 223
 224     public function testOrderBySingleColumnDescending()
 225     {
 226         $this->assertValidDQL('SELECT u.name FROM Doctrine\Tests\Models\CMS\CmsUser u ORDER BY u.name DESC');
 227     }
 228
 229     public function testOrderByMultipleColumns()
 230     {
 231         $this->assertValidDQL('SELECT u.name, u.username FROM Doctrine\Tests\Models\CMS\CmsUser u ORDER BY u.username DESC, u.name DESC');
 232     }
 233
 234     public function testSubselectInInExpression()
 235     {
 236         $this->assertValidDQL("SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id NOT IN (SELECT u2.id FROM Doctrine\Tests\Models\CMS\CmsUser u2 WHERE u2.name = 'zYne')");
 237     }
 238
 239     public function testSubselectInSelectPart()
 240     {
 241         $this->assertValidDQL("SELECT u.name, (SELECT COUNT(p.phonenumber) FROM Doctrine\Tests\Models\CMS\CmsPhonenumber p WHERE p.phonenumber = 1234) pcount FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.name = 'jon'");
 242     }
 243
 244     public function testArithmeticExpressionInSelectPart()
 245     {
 246         $this->assertValidDQL("SELECT SUM(u.id) / COUNT(u.id) FROM Doctrine\Tests\Models\CMS\CmsUser u");
 247     }
 248
 249     public function testArithmeticExpressionInSubselectPart()
 250     {
 251         $this->assertValidDQL("SELECT (SELECT SUM(u.id) / COUNT(u.id) FROM Doctrine\Tests\Models\CMS\CmsUser u2) value FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.name = 'jon'");
 252     }
 253
 254     public function testArithmeticExpressionWithParenthesisInSubselectPart()
 255     {
 256         $this->assertValidDQL("SELECT (SELECT (SUM(u.id) / COUNT(u.id)) FROM Doctrine\Tests\Models\CMS\CmsUser u2) value FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.name = 'jon'");
 257     }
 258
 259     /**
 260      * @group DDC-1079
 261      */
 262     public function testSelectLiteralInSubselect()
 263     {
 264         $this->assertValidDQL('SELECT (SELECT 1 FROM Doctrine\Tests\Models\CMS\CmsUser u2) value FROM Doctrine\Tests\Models\CMS\CmsUser u');
 265         $this->assertValidDQL('SELECT (SELECT 0 FROM Doctrine\Tests\Models\CMS\CmsUser u2) value FROM Doctrine\Tests\Models\CMS\CmsUser u');
 266     }
 267
 268     /**
 269      * @group DDC-1077
 270      */
 271     public function testConstantValueInSelect()
 272     {
 273         $this->assertValidDQL("SELECT u.name, 'foo' AS bar FROM Doctrine\Tests\Models\CMS\CmsUser u", true);
 274     }
 275
 276     public function testDuplicateAliasInSubselectPart()
 277     {
 278         $this->assertInvalidDQL("SELECT (SELECT SUM(u.id) / COUNT(u.id) AS foo FROM Doctrine\Tests\Models\CMS\CmsUser u2) foo FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.name = 'jon'");
 279     }
 280
 281     public function testPositionalInputParameter()
 282     {
 283         $this->assertValidDQL('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id = ?1');
 284     }
 285
 286     public function testNamedInputParameter()
 287     {
 288         $this->assertValidDQL('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id = :id');
 289     }
 290
 291     public function testJoinConditionOverrideNotSupported()
 292     {
 293         $this->assertInvalidDQL("SELECT u.name, p FROM Doctrine\Tests\Models\CMS\CmsUser u LEFT JOIN u.phonenumbers p ON p.phonenumber = '123 123'");
 294     }
 295
 296     public function testIndexByClauseWithOneComponent()
 297     {
 298         $this->assertValidDQL('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u INDEX BY u.id');
 299     }
 300
 301     public function testIndexBySupportsJoins()
 302     {
 303         $this->assertValidDQL('SELECT u, a FROM Doctrine\Tests\Models\CMS\CmsUser u LEFT JOIN u.articles a INDEX BY a.id'); // INDEX BY is now referring to articles
 304     }
 305
 306     public function testIndexBySupportsJoins2()
 307     {
 308         $this->assertValidDQL('SELECT u, p FROM Doctrine\Tests\Models\CMS\CmsUser u INDEX BY u.id LEFT JOIN u.phonenumbers p INDEX BY p.phonenumber');
 309     }
 310
 311     public function testBetweenExpressionSupported()
 312     {
 313         $this->assertValidDQL("SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.name BETWEEN 'jepso' AND 'zYne'");
 314     }
 315
 316     public function testNotBetweenExpressionSupported()
 317     {
 318         $this->assertValidDQL("SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.name NOT BETWEEN 'jepso' AND 'zYne'");
 319     }
 320
 321     public function testLikeExpression()
 322     {
 323         $this->assertValidDQL("SELECT u.id FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.name LIKE 'z%'");
 324     }
 325
 326     public function testNotLikeExpression()
 327     {
 328         $this->assertValidDQL("SELECT u.id FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.name NOT LIKE 'z%'");
 329     }
 330
 331     public function testLikeExpressionWithCustomEscapeCharacter()
 332     {
 333         $this->assertValidDQL("SELECT u.id FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.name LIKE 'z|%' ESCAPE '|'");
 334     }
 335
 336     public function testFieldComparisonWithoutAlias()
 337     {
 338         $this->assertInvalidDQL("SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE id = 1");
 339     }
 340
 341     public function testDuplicatedAliasDeclaration()
 342     {
 343         $this->assertInvalidDQL("SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u INNER JOIN u.articles u WHERE u.id = 1");
 344     }
 345
 346     public function testImplicitJoinInWhereOnSingleValuedAssociationPathExpression()
 347     {
 348         // This should be allowed because avatar is a single-value association.
 349         // SQL: SELECT ... FROM forum_user fu INNER JOIN forum_avatar fa ON fu.avatar_id = fa.id WHERE fa.id = ?
 350         $this->assertValidDQL("SELECT u FROM Doctrine\Tests\Models\Forum\ForumUser u JOIN u.avatar a WHERE a.id = ?1");
 351     }
 352
 353     public function testImplicitJoinInWhereOnCollectionValuedPathExpression()
 354     {
 355         // This should be forbidden, because articles is a collection
 356         $this->assertInvalidDQL("SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u JOIN u.articles a WHERE a.title = ?");
 357     }
 358
 359     public function testInvalidSyntaxIsRejected()
 360     {
 361         $this->assertInvalidDQL("FOOBAR CmsUser");
 362         $this->assertInvalidDQL("DELETE FROM Doctrine\Tests\Models\CMS\CmsUser.articles");
 363         $this->assertInvalidDQL("SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u JOIN u.articles.comments");
 364
 365         // Currently UNDEFINED OFFSET error
 366         $this->assertInvalidDQL("SELECT c FROM CmsUser.articles.comments c");
 367     }
 368
 369     public function testUpdateWorksWithOneField()
 370     {
 371         $this->assertValidDQL("UPDATE Doctrine\Tests\Models\CMS\CmsUser u SET u.name = 'someone'");
 372     }
 373
 374     public function testUpdateWorksWithMultipleFields()
 375     {
 376         $this->assertValidDQL("UPDATE Doctrine\Tests\Models\CMS\CmsUser u SET u.name = 'someone', u.username = 'some'");
 377     }
 378
 379     public function testUpdateSupportsConditions()
 380     {
 381         $this->assertValidDQL("UPDATE Doctrine\Tests\Models\CMS\CmsUser u SET u.name = 'someone' WHERE u.id = 5");
 382     }
 383
 384     public function testDeleteAll()
 385     {
 386         $this->assertValidDQL('DELETE FROM Doctrine\Tests\Models\CMS\CmsUser u');
 387     }
 388
 389     public function testDeleteWithCondition()
 390     {
 391         $this->assertValidDQL('DELETE FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id = 3');
 392     }
 393
 394     /**
 395      * The main use case for this generalized style of join is when a join condition
 396      * does not involve a foreign key relationship that is mapped to an entity relationship.
 397      */
 398     public function testImplicitJoinWithCartesianProductAndConditionInWhere()
 399     {
 400         $this->assertValidDQL("SELECT u, a FROM Doctrine\Tests\Models\CMS\CmsUser u, Doctrine\Tests\Models\CMS\CmsArticle a WHERE u.name = a.topic");
 401     }
 402
 403     public function testAllExpressionWithCorrelatedSubquery()
 404     {
 405         $this->assertValidDQL('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id > ALL (SELECT u2.id FROM Doctrine\Tests\Models\CMS\CmsUser u2 WHERE u2.name = u.name)');
 406     }
 407
 408     public function testCustomJoinsAndWithKeywordSupported()
 409     {
 410         $this->assertValidDQL('SELECT u, p FROM Doctrine\Tests\Models\CMS\CmsUser u INNER JOIN u.phonenumbers p WITH p.phonenumber = 123 WHERE u.id = 1');
 411     }
 412
 413     public function testAnyExpressionWithCorrelatedSubquery()
 414     {
 415         $this->assertValidDQL('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id > ANY (SELECT u2.id FROM Doctrine\Tests\Models\CMS\CmsUser u2 WHERE u2.name = u.name)');
 416     }
 417
 418     public function testSomeExpressionWithCorrelatedSubquery()
 419     {
 420         $this->assertValidDQL('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id > SOME (SELECT u2.id FROM Doctrine\Tests\Models\CMS\CmsUser u2 WHERE u2.name = u.name)');
 421     }
 422
 423     public function testArithmeticExpressionWithoutParenthesisInWhereClause()
 424     {
 425         $this->assertValidDQL('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE SIZE(u.phonenumbers) + 1 > 10');
 426     }
 427
 428     public function testMemberOfExpression()
 429     {
 430         $this->assertValidDQL('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE :param MEMBER OF u.phonenumbers');
 431         //$this->assertValidDQL("SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE 'Joe' MEMBER OF u.nicknames");
 432     }
 433
 434     public function testSizeFunction()
 435     {
 436         $this->assertValidDQL('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE SIZE(u.phonenumbers) > 1');
 437     }
 438
 439     public function testEmptyCollectionComparisonExpression()
 440     {
 441         $this->assertValidDQL('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.phonenumbers IS EMPTY');
 442     }
 443
 444     public function testSingleValuedAssociationFieldInWhere()
 445     {
 446         $this->assertValidDQL('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.address = ?1');
 447         $this->assertValidDQL('SELECT p FROM Doctrine\Tests\Models\CMS\CmsPhonenumber p WHERE p.user = ?1');
 448     }
 449
 450     public function testBooleanLiteralInWhere()
 451     {
 452         $this->assertValidDQL('SELECT b FROM Doctrine\Tests\Models\Generic\BooleanModel b WHERE b.booleanField = true');
 453     }
 454
 455     public function testSubqueryInSelectExpression()
 456     {
 457         $this->assertValidDQL('select u, (select max(p.phonenumber) from Doctrine\Tests\Models\CMS\CmsPhonenumber p) maxId from Doctrine\Tests\Models\CMS\CmsUser u');
 458     }
 459
 460     public function testUsageOfQComponentOutsideSubquery()
 461     {
 462         $this->assertInvalidDQL('select u, (select max(p.phonenumber) from Doctrine\Tests\Models\CMS\CmsPhonenumber p) maxId from Doctrine\Tests\Models\CMS\CmsUser u WHERE p.user = ?1');
 463     }
 464
 465     public function testUnknownAbstractSchemaName()
 466     {
 467         $this->assertInvalidDQL('SELECT u FROM UnknownClassName u');
 468     }
 469
 470     public function testCorrectPartialObjectLoad()
 471     {
 472         $this->assertValidDQL('SELECT PARTIAL u.{id,name} FROM Doctrine\Tests\Models\CMS\CmsUser u');
 473     }
 474
 475     public function testIncorrectPartialObjectLoadBecauseOfMissingIdentifier()
 476     {
 477         $this->assertInvalidDQL('SELECT PARTIAL u.{name} FROM Doctrine\Tests\Models\CMS\CmsUser u');
 478     }
 479
 480     public function testScalarExpressionInSelect()
 481     {
 482         $this->assertValidDQL('SELECT u, 42 + u.id AS someNumber FROM Doctrine\Tests\Models\CMS\CmsUser u');
 483     }
 484
 485     public function testInputParameterInSelect()
 486     {
 487         $this->assertValidDQL('SELECT u, u.id + ?1 AS someNumber FROM Doctrine\Tests\Models\CMS\CmsUser u');
 488     }
 489
 490     /**
 491      * @group DDC-1091
 492      */
 493     public function testCustomFunctionsReturningStringInStringPrimary()
 494     {
 495         $this->_em->getConfiguration()->addCustomStringFunction('CC', 'Doctrine\ORM\Query\AST\Functions\ConcatFunction');
 496
 497         $this->assertValidDQL("SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE CC('%', u.name) LIKE '%foo%'", true);
 498     }
 499
 500     /**
 501      * @group DDC-505
 502      */
 503     public function testDQLKeywordInJoinIsAllowed()
 504     {
 505         $this->assertValidDQL('SELECT u FROM ' . __NAMESPACE__ . '\DQLKeywordsModelUser u JOIN u.group g');
 506     }
 507
 508     /**
 509      * @group DDC-505
 510      */
 511     public function testDQLKeywordInConditionIsAllowed()
 512     {
 513         $this->assertValidDQL('SELECT g FROM ' . __NAMESPACE__ . '\DQLKeywordsModelGroup g WHERE g.from=0');
 514     }
 515
 516     /* The exception is currently thrown in the SQLWalker, not earlier.
 517     public function testInverseSideSingleValuedAssociationPathNotAllowed()
 518     {
 519         $this->assertInvalidDQL('SELECT u.id FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.address = ?1');
 520     }
 521     */
 522
 523     /**
 524      * @group DDC-617
 525      */
 526     public function testSelectOnlyNonRootEntityAlias()
 527     {
 528         $this->assertInvalidDQL('SELECT g FROM Doctrine\Tests\Models\CMS\CmsUser u JOIN u.groups g');
 529     }
 530
 531     /**
 532      * @group DDC-1108
 533      */
 534     public function testInputParameterSingleChar()
 535     {
 536         $this->assertValidDQL('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.name = :q');
 537     }
 538
 539     /**
 540      * @group DDC-1053
 541      */
 542     public function testGroupBy()
 543     {
 544         $this->assertValidDQL('SELECT g.id, count(u.id) FROM Doctrine\Tests\Models\CMS\CmsGroup g JOIN g.users u GROUP BY g.id');
 545     }
 546
 547     /**
 548      * @group DDC-1053
 549      */
 550     public function testGroupByIdentificationVariable()
 551     {
 552         $this->assertValidDQL('SELECT g, count(u.id) FROM Doctrine\Tests\Models\CMS\CmsGroup g JOIN g.users u GROUP BY g');
 553     }
 554
 555     /**
 556      * @group DDC-1053
 557      */
 558     public function testGroupByUnknownIdentificationVariable()
 559     {
 560         $this->assertInvalidDQL('SELECT g, count(u.id) FROM Doctrine\Tests\Models\CMS\CmsGroup g JOIN g.users u GROUP BY m');
 561     }
 562
 563     /**
 564      * @group DDC-117
 565      */
 566     public function testSizeOfForeignKeyOneToManyPrimaryKeyEntity()
 567     {
 568         $this->assertValidDQL("SELECT a, t FROM Doctrine\Tests\Models\DDC117\DDC117Article a JOIN a.translations t WHERE SIZE(a.translations) > 0");
 569     }
 570
 571     /**
 572      * @group DDC-117
 573      */
 574     public function testSizeOfForeignKeyManyToManyPrimaryKeyEntity()
 575     {
 576         $this->assertValidDQL("SELECT e, t FROM Doctrine\Tests\Models\DDC117\DDC117Editor e JOIN e.reviewingTranslations t WHERE SIZE(e.reviewingTranslations) > 0");
 577     }
 578
 579     public function testCaseSupportContainingNullIfExpression()
 580     {
 581         $this->assertValidDQL("SELECT u.id, NULLIF(u.name, u.name) AS shouldBeNull FROM Doctrine\Tests\Models\CMS\CmsUser u");
 582     }
 583
 584     public function testCaseSupportContainingCoalesceExpression()
 585     {
 586         $this->assertValidDQL("select COALESCE(NULLIF(u.name, ''), u.username) as Display FROM Doctrine\Tests\Models\CMS\CmsUser u");
 587     }
 588 }
 589
 590 /** @Entity */
 591 class DQLKeywordsModelUser
 592 {
 593     /** @Id @Column(type="integer") @GeneratedValue */
 594     private $id;
 595     /** @OneToOne(targetEntity="DQLKeywordsModelGroup") */
 596     private $group;
 597 }
 598
 599 /** @Entity */
 600 class DQLKeywordsModelGroup
 601 {
 602     /** @Id @Column(type="integer") @GeneratedValue */
 603     private $id;
 604     /** @Column */
 605     private $from;
 606 }