vendor/doctrine/orm/tests/Doctrine/Tests/ORM/QueryBuilderTest.php

   1 <?php
   2 /*
   3  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   4  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   5  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   6  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   7  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   8  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   9  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  10  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  11  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  12  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  13  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14  *
  15  * This software consists of voluntary contributions made by many individuals
  16  * and is licensed under the LGPL. For more information, see
  17  * <http://www.doctrine-project.org>.
  18  */
  19
  20 namespace Doctrine\Tests\ORM;
  21
  22 use Doctrine\Common\Collections\ArrayCollection;
  23
  24 use Doctrine\ORM\QueryBuilder,
  25     Doctrine\ORM\Query\Expr,
  26     Doctrine\ORM\Query\Parameter,
  27     Doctrine\ORM\Query\ParameterTypeInferer;
  28
  29 require_once __DIR__ . '/../TestInit.php';
  30
  31 /**
  32  * Test case for the QueryBuilder class used to build DQL query string in a
  33  * object oriented way.
  34  *
  35  * @author      Jonathan H. Wage <jonwage@gmail.com>
  36  * @author      Roman Borschel <roman@code-factory.org
  37  * @since       2.0
  38  */
  39 class QueryBuilderTest extends \Doctrine\Tests\OrmTestCase
  40 {
  41     private $_em;
  42
  43     protected function setUp()
  44     {
  45         $this->_em = $this->_getTestEntityManager();
  46     }
  47
  48     protected function assertValidQueryBuilder(QueryBuilder $qb, $expectedDql)
  49     {
  50         $dql = $qb->getDql();
  51         $q = $qb->getQuery();
  52
  53         $this->assertEquals($expectedDql, $dql);
  54     }
  55
  56     public function testSelectSetsType()
  57     {
  58         $qb = $this->_em->createQueryBuilder()
  59             ->delete('Doctrine\Tests\Models\CMS\CmsUser', 'u')
  60             ->select('u.id', 'u.username');
  61
  62         $this->assertEquals($qb->getType(), QueryBuilder::SELECT);
  63     }
  64
  65     public function testEmptySelectSetsType()
  66     {
  67         $qb = $this->_em->createQueryBuilder()
  68             ->delete('Doctrine\Tests\Models\CMS\CmsUser', 'u')
  69             ->select();
  70
  71         $this->assertEquals($qb->getType(), QueryBuilder::SELECT);
  72     }
  73
  74     public function testDeleteSetsType()
  75     {
  76         $qb = $this->_em->createQueryBuilder()
  77             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
  78             ->delete();
  79
  80         $this->assertEquals($qb->getType(), QueryBuilder::DELETE);
  81     }
  82
  83     public function testUpdateSetsType()
  84     {
  85         $qb = $this->_em->createQueryBuilder()
  86             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
  87             ->update();
  88
  89         $this->assertEquals($qb->getType(), QueryBuilder::UPDATE);
  90     }
  91
  92     public function testSimpleSelect()
  93     {
  94         $qb = $this->_em->createQueryBuilder()
  95             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
  96             ->select('u.id', 'u.username');
  97
  98         $this->assertValidQueryBuilder($qb, 'SELECT u.id, u.username FROM Doctrine\Tests\Models\CMS\CmsUser u');
  99     }
 100
 101     public function testSimpleDelete()
 102     {
 103         $qb = $this->_em->createQueryBuilder()
 104             ->delete('Doctrine\Tests\Models\CMS\CmsUser', 'u');
 105
 106         $this->assertValidQueryBuilder($qb, 'DELETE Doctrine\Tests\Models\CMS\CmsUser u');
 107     }
 108
 109     public function testSimpleUpdate()
 110     {
 111         $qb = $this->_em->createQueryBuilder()
 112             ->update('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 113             ->set('u.username', ':username');
 114
 115         $this->assertValidQueryBuilder($qb, 'UPDATE Doctrine\Tests\Models\CMS\CmsUser u SET u.username = :username');
 116     }
 117
 118     public function testInnerJoin()
 119     {
 120         $qb = $this->_em->createQueryBuilder()
 121             ->select('u', 'a')
 122             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 123             ->innerJoin('u.articles', 'a');
 124
 125         $this->assertValidQueryBuilder($qb, 'SELECT u, a FROM Doctrine\Tests\Models\CMS\CmsUser u INNER JOIN u.articles a');
 126     }
 127
 128     public function testComplexInnerJoin()
 129     {
 130         $qb = $this->_em->createQueryBuilder()
 131             ->select('u', 'a')
 132             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 133             ->innerJoin('u.articles', 'a', 'ON', 'u.id = a.author_id');
 134
 135         $this->assertValidQueryBuilder(
 136             $qb,
 137             'SELECT u, a FROM Doctrine\Tests\Models\CMS\CmsUser u INNER JOIN u.articles a ON u.id = a.author_id'
 138         );
 139     }
 140
 141     public function testLeftJoin()
 142     {
 143         $qb = $this->_em->createQueryBuilder()
 144             ->select('u', 'a')
 145             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 146             ->leftJoin('u.articles', 'a');
 147
 148         $this->assertValidQueryBuilder($qb, 'SELECT u, a FROM Doctrine\Tests\Models\CMS\CmsUser u LEFT JOIN u.articles a');
 149     }
 150
 151     public function testLeftJoinWithIndexBy()
 152     {
 153         $qb = $this->_em->createQueryBuilder()
 154             ->select('u', 'a')
 155             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 156             ->leftJoin('u.articles', 'a', null, null, 'a.name');
 157
 158         $this->assertValidQueryBuilder($qb, 'SELECT u, a FROM Doctrine\Tests\Models\CMS\CmsUser u LEFT JOIN u.articles a INDEX BY a.name');
 159     }
 160
 161     public function testMultipleFrom()
 162     {
 163         $qb = $this->_em->createQueryBuilder()
 164             ->select('u', 'g')
 165             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 166             ->from('Doctrine\Tests\Models\CMS\CmsGroup', 'g');
 167
 168         $this->assertValidQueryBuilder($qb, 'SELECT u, g FROM Doctrine\Tests\Models\CMS\CmsUser u, Doctrine\Tests\Models\CMS\CmsGroup g');
 169     }
 170
 171     public function testMultipleFromWithJoin()
 172     {
 173         $qb = $this->_em->createQueryBuilder()
 174             ->select('u', 'g')
 175             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 176             ->from('Doctrine\Tests\Models\CMS\CmsGroup', 'g')
 177             ->innerJoin('u.articles', 'a', 'ON', 'u.id = a.author_id');
 178
 179         $this->assertValidQueryBuilder($qb, 'SELECT u, g FROM Doctrine\Tests\Models\CMS\CmsUser u INNER JOIN u.articles a ON u.id = a.author_id, Doctrine\Tests\Models\CMS\CmsGroup g');
 180     }
 181
 182     public function testMultipleFromWithMultipleJoin()
 183     {
 184         $qb = $this->_em->createQueryBuilder()
 185             ->select('u', 'g')
 186             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 187             ->from('Doctrine\Tests\Models\CMS\CmsArticle', 'a')
 188             ->innerJoin('u.groups', 'g')
 189             ->leftJoin('u.address', 'ad')
 190             ->innerJoin('a.comments', 'c');
 191
 192         $this->assertValidQueryBuilder($qb, 'SELECT u, g FROM Doctrine\Tests\Models\CMS\CmsUser u INNER JOIN u.groups g LEFT JOIN u.address ad, Doctrine\Tests\Models\CMS\CmsArticle a INNER JOIN a.comments c');
 193     }
 194
 195     public function testWhere()
 196     {
 197         $qb = $this->_em->createQueryBuilder()
 198             ->select('u')
 199             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 200             ->where('u.id = :uid');
 201
 202         $this->assertValidQueryBuilder($qb, 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id = :uid');
 203     }
 204
 205     public function testComplexAndWhere()
 206     {
 207         $qb = $this->_em->createQueryBuilder()
 208             ->select('u')
 209             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 210             ->where('u.id = :uid OR u.id = :uid2 OR u.id = :uid3')
 211             ->andWhere('u.name = :name');
 212
 213         $this->assertValidQueryBuilder($qb, 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE (u.id = :uid OR u.id = :uid2 OR u.id = :uid3) AND u.name = :name');
 214     }
 215
 216     public function testAndWhere()
 217     {
 218         $qb = $this->_em->createQueryBuilder()
 219             ->select('u')
 220             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 221             ->where('u.id = :uid')
 222             ->andWhere('u.id = :uid2');
 223
 224         $this->assertValidQueryBuilder($qb, 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id = :uid AND u.id = :uid2');
 225     }
 226
 227     public function testOrWhere()
 228     {
 229         $qb = $this->_em->createQueryBuilder()
 230             ->select('u')
 231             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 232             ->where('u.id = :uid')
 233             ->orWhere('u.id = :uid2');
 234
 235         $this->assertValidQueryBuilder($qb, 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id = :uid OR u.id = :uid2');
 236     }
 237
 238     public function testComplexAndWhereOrWhereNesting()
 239     {
 240         $qb = $this->_em->createQueryBuilder();
 241         $qb->select('u')
 242            ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 243            ->where('u.id = :uid')
 244            ->orWhere('u.id = :uid2')
 245            ->andWhere('u.id = :uid3')
 246            ->orWhere('u.name = :name1', 'u.name = :name2')
 247            ->andWhere('u.name <> :noname');
 248
 249         $this->assertValidQueryBuilder($qb, 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE (((u.id = :uid OR u.id = :uid2) AND u.id = :uid3) OR u.name = :name1 OR u.name = :name2) AND u.name <> :noname');
 250     }
 251
 252     public function testAndWhereIn()
 253     {
 254         $qb = $this->_em->createQueryBuilder();
 255         $qb->select('u')
 256            ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 257            ->where('u.id = :uid')
 258            ->andWhere($qb->expr()->in('u.id', array(1, 2, 3)));
 259
 260         $this->assertValidQueryBuilder($qb, 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id = :uid AND u.id IN(1, 2, 3)');
 261     }
 262
 263     public function testOrWhereIn()
 264     {
 265         $qb = $this->_em->createQueryBuilder();
 266         $qb->select('u')
 267            ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 268            ->where('u.id = :uid')
 269            ->orWhere($qb->expr()->in('u.id', array(1, 2, 3)));
 270
 271         $this->assertValidQueryBuilder($qb, 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id = :uid OR u.id IN(1, 2, 3)');
 272     }
 273
 274     public function testAndWhereNotIn()
 275     {
 276         $qb = $this->_em->createQueryBuilder();
 277         $qb->select('u')
 278            ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 279            ->where('u.id = :uid')
 280            ->andWhere($qb->expr()->notIn('u.id', array(1, 2, 3)));
 281
 282         $this->assertValidQueryBuilder($qb, 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id = :uid AND u.id NOT IN(1, 2, 3)');
 283     }
 284
 285     public function testOrWhereNotIn()
 286     {
 287         $qb = $this->_em->createQueryBuilder();
 288         $qb->select('u')
 289            ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 290            ->where('u.id = :uid')
 291            ->orWhere($qb->expr()->notIn('u.id', array(1, 2, 3)));
 292
 293         $this->assertValidQueryBuilder($qb, 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id = :uid OR u.id NOT IN(1, 2, 3)');
 294     }
 295
 296     public function testGroupBy()
 297     {
 298         $qb = $this->_em->createQueryBuilder()
 299             ->select('u')
 300             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 301             ->groupBy('u.id')
 302             ->addGroupBy('u.username');
 303
 304         $this->assertValidQueryBuilder($qb, 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u GROUP BY u.id, u.username');
 305     }
 306
 307     public function testHaving()
 308     {
 309         $qb = $this->_em->createQueryBuilder()
 310             ->select('u')
 311             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 312             ->groupBy('u.id')
 313             ->having('COUNT(u.id) > 1');
 314
 315         $this->assertValidQueryBuilder($qb, 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u GROUP BY u.id HAVING COUNT(u.id) > 1');
 316     }
 317
 318     public function testAndHaving()
 319     {
 320         $qb = $this->_em->createQueryBuilder()
 321             ->select('u')
 322             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 323             ->groupBy('u.id')
 324             ->having('COUNT(u.id) > 1')
 325             ->andHaving('COUNT(u.id) < 1');
 326
 327         $this->assertValidQueryBuilder($qb, 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u GROUP BY u.id HAVING COUNT(u.id) > 1 AND COUNT(u.id) < 1');
 328     }
 329
 330     public function testOrHaving()
 331     {
 332         $qb = $this->_em->createQueryBuilder()
 333             ->select('u')
 334             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 335             ->groupBy('u.id')
 336             ->having('COUNT(u.id) > 1')
 337             ->andHaving('COUNT(u.id) < 1')
 338             ->orHaving('COUNT(u.id) > 1');
 339
 340         $this->assertValidQueryBuilder($qb, 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u GROUP BY u.id HAVING (COUNT(u.id) > 1 AND COUNT(u.id) < 1) OR COUNT(u.id) > 1');
 341     }
 342
 343     public function testOrderBy()
 344     {
 345         $qb = $this->_em->createQueryBuilder()
 346             ->select('u')
 347             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 348             ->orderBy('u.username', 'ASC');
 349
 350         $this->assertValidQueryBuilder($qb, 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u ORDER BY u.username ASC');
 351     }
 352
 353     public function testOrderByWithExpression()
 354     {
 355         $qb = $this->_em->createQueryBuilder();
 356         $qb->select('u')
 357             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 358             ->orderBy($qb->expr()->asc('u.username'));
 359
 360         $this->assertValidQueryBuilder($qb, 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u ORDER BY u.username ASC');
 361     }
 362
 363     public function testAddOrderBy()
 364     {
 365         $qb = $this->_em->createQueryBuilder()
 366             ->select('u')
 367             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 368             ->orderBy('u.username', 'ASC')
 369             ->addOrderBy('u.username', 'DESC');
 370
 371         $this->assertValidQueryBuilder($qb, 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u ORDER BY u.username ASC, u.username DESC');
 372     }
 373
 374     public function testGetQuery()
 375     {
 376         $qb = $this->_em->createQueryBuilder()
 377             ->select('u')
 378             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u');
 379         $q = $qb->getQuery();
 380
 381         $this->assertEquals('Doctrine\ORM\Query', get_class($q));
 382     }
 383
 384     public function testSetParameter()
 385     {
 386         $qb = $this->_em->createQueryBuilder()
 387             ->select('u')
 388             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 389             ->where('u.id = :id')
 390             ->setParameter('id', 1);
 391
 392         $parameter = new Parameter('id', 1, ParameterTypeInferer::inferType(1));
 393
 394         $this->assertEquals($parameter, $qb->getParameter('id'));
 395     }
 396
 397     public function testSetParameters()
 398     {
 399         $qb = $this->_em->createQueryBuilder();
 400         $qb->select('u')
 401            ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 402            ->where($qb->expr()->orx('u.username = :username', 'u.username = :username2'));
 403
 404         $parameters = new ArrayCollection();
 405         $parameters->add(new Parameter('username', 'jwage'));
 406         $parameters->add(new Parameter('username2', 'jonwage'));
 407
 408         $qb->setParameters($parameters);
 409
 410         $this->assertEquals($parameters, $qb->getQuery()->getParameters());
 411     }
 412
 413
 414     public function testGetParameters()
 415     {
 416         $qb = $this->_em->createQueryBuilder();
 417         $qb->select('u')
 418            ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 419            ->where('u.id = :id');
 420
 421         $parameters = new ArrayCollection();
 422         $parameters->add(new Parameter('id', 1));
 423
 424         $qb->setParameters($parameters);
 425
 426         $this->assertEquals($parameters, $qb->getParameters());
 427     }
 428
 429     public function testGetParameter()
 430     {
 431         $qb = $this->_em->createQueryBuilder()
 432             ->select('u')
 433             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 434             ->where('u.id = :id');
 435
 436         $parameters = new ArrayCollection();
 437         $parameters->add(new Parameter('id', 1));
 438
 439         $qb->setParameters($parameters);
 440
 441         $this->assertEquals($parameters->first(), $qb->getParameter('id'));
 442     }
 443
 444     public function testMultipleWhere()
 445     {
 446         $qb = $this->_em->createQueryBuilder()
 447             ->select('u')
 448             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 449             ->where('u.id = :uid', 'u.id = :uid2');
 450
 451         $this->assertValidQueryBuilder($qb, 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id = :uid AND u.id = :uid2');
 452     }
 453
 454     public function testMultipleAndWhere()
 455     {
 456         $qb = $this->_em->createQueryBuilder()
 457             ->select('u')
 458             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 459             ->andWhere('u.id = :uid', 'u.id = :uid2');
 460
 461         $this->assertValidQueryBuilder($qb, 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id = :uid AND u.id = :uid2');
 462     }
 463
 464     public function testMultipleOrWhere()
 465     {
 466         $qb = $this->_em->createQueryBuilder();
 467         $qb->select('u')
 468            ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 469            ->orWhere('u.id = :uid', $qb->expr()->eq('u.id', ':uid2'));
 470
 471         $this->assertValidQueryBuilder($qb, 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id = :uid OR u.id = :uid2');
 472     }
 473
 474     public function testComplexWhere()
 475     {
 476         $qb = $this->_em->createQueryBuilder();
 477         $orExpr = $qb->expr()->orX();
 478         $orExpr->add($qb->expr()->eq('u.id', ':uid3'));
 479         $orExpr->add($qb->expr()->in('u.id', array(1)));
 480
 481         $qb->select('u')
 482            ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 483            ->where($orExpr);
 484
 485         $this->assertValidQueryBuilder($qb, 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id = :uid3 OR u.id IN(1)');
 486     }
 487
 488     public function testWhereInWithStringLiterals()
 489     {
 490         $qb = $this->_em->createQueryBuilder();
 491         $qb->select('u')
 492            ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 493            ->where($qb->expr()->in('u.name', array('one', 'two', 'three')));
 494
 495         $this->assertValidQueryBuilder($qb, "SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.name IN('one', 'two', 'three')");
 496
 497         $qb->where($qb->expr()->in('u.name', array("O'Reilly", "O'Neil", 'Smith')));
 498
 499         $this->assertValidQueryBuilder($qb, "SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.name IN('O''Reilly', 'O''Neil', 'Smith')");
 500     }
 501
 502     public function testWhereInWithObjectLiterals()
 503     {
 504         $qb = $this->_em->createQueryBuilder();
 505         $expr = $this->_em->getExpressionBuilder();
 506         $qb->select('u')
 507            ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 508            ->where($expr->in('u.name', array($expr->literal('one'), $expr->literal('two'), $expr->literal('three'))));
 509
 510         $this->assertValidQueryBuilder($qb, "SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.name IN('one', 'two', 'three')");
 511
 512         $qb->where($expr->in('u.name', array($expr->literal("O'Reilly"), $expr->literal("O'Neil"), $expr->literal('Smith'))));
 513
 514         $this->assertValidQueryBuilder($qb, "SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.name IN('O''Reilly', 'O''Neil', 'Smith')");
 515     }
 516
 517     public function testNegation()
 518     {
 519         $expr = $this->_em->getExpressionBuilder();
 520         $orExpr = $expr->orX();
 521         $orExpr->add($expr->eq('u.id', ':uid3'));
 522         $orExpr->add($expr->not($expr->in('u.id', array(1))));
 523
 524         $qb = $this->_em->createQueryBuilder();
 525         $qb->select('u')
 526            ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 527            ->where($orExpr);
 528
 529         $this->assertValidQueryBuilder($qb, 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id = :uid3 OR NOT(u.id IN(1))');
 530     }
 531
 532     public function testSomeAllAny()
 533     {
 534         $qb = $this->_em->createQueryBuilder();
 535         $expr = $this->_em->getExpressionBuilder();
 536
 537         //$subquery = $qb->subquery('Doctrine\Tests\Models\CMS\CmsArticle', 'a')->select('a.id');
 538
 539         $qb->select('u')
 540            ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 541            ->where($expr->gt('u.id', $expr->all('select a.id from Doctrine\Tests\Models\CMS\CmsArticle a')));
 542
 543         $this->assertValidQueryBuilder($qb, 'SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id > ALL(select a.id from Doctrine\Tests\Models\CMS\CmsArticle a)');
 544
 545     }
 546
 547     public function testMultipleIsolatedQueryConstruction()
 548     {
 549         $qb = $this->_em->createQueryBuilder();
 550         $expr = $this->_em->getExpressionBuilder();
 551
 552         $qb->select('u')->from('Doctrine\Tests\Models\CMS\CmsUser', 'u');
 553         $qb->where($expr->eq('u.name', ':name'));
 554         $qb->setParameter('name', 'romanb');
 555
 556         $q1 = $qb->getQuery();
 557
 558         $this->assertEquals('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.name = :name', $q1->getDql());
 559         $this->assertEquals(1, count($q1->getParameters()));
 560
 561         // add another condition and construct a second query
 562         $qb->andWhere($expr->eq('u.id', ':id'));
 563         $qb->setParameter('id', 42);
 564
 565         $q2 = $qb->getQuery();
 566
 567         $this->assertEquals('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.name = :name AND u.id = :id', $q2->getDql());
 568         $this->assertTrue($q1 !== $q2); // two different, independent queries
 569         $this->assertEquals(2, count($q2->getParameters()));
 570         $this->assertEquals(1, count($q1->getParameters())); // $q1 unaffected
 571     }
 572
 573     public function testGetEntityManager()
 574     {
 575         $qb = $this->_em->createQueryBuilder();
 576         $this->assertEquals($this->_em, $qb->getEntityManager());
 577     }
 578
 579     public function testInitialStateIsClean()
 580     {
 581         $qb = $this->_em->createQueryBuilder();
 582         $this->assertEquals(QueryBuilder::STATE_CLEAN, $qb->getState());
 583     }
 584
 585     public function testAlteringQueryChangesStateToDirty()
 586     {
 587         $qb = $this->_em->createQueryBuilder()
 588             ->select('u')
 589             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u');
 590
 591         $this->assertEquals(QueryBuilder::STATE_DIRTY, $qb->getState());
 592     }
 593
 594     public function testSelectWithFuncExpression()
 595     {
 596         $qb = $this->_em->createQueryBuilder();
 597         $expr = $qb->expr();
 598         $qb->select($expr->count('e.id'));
 599
 600         $this->assertValidQueryBuilder($qb, 'SELECT COUNT(e.id)');
 601     }
 602
 603     public function testResetDQLPart()
 604     {
 605         $qb = $this->_em->createQueryBuilder()
 606             ->select('u')
 607             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 608             ->where('u.username = ?1')->orderBy('u.username');
 609
 610         $this->assertEquals('u.username = ?1', (string)$qb->getDQLPart('where'));
 611         $this->assertEquals(1, count($qb->getDQLPart('orderBy')));
 612
 613         $qb->resetDqlPart('where')->resetDqlPart('orderBy');
 614
 615         $this->assertNull($qb->getDQLPart('where'));
 616         $this->assertEquals(0, count($qb->getDQLPart('orderBy')));
 617     }
 618
 619     public function testResetDQLParts()
 620     {
 621         $qb = $this->_em->createQueryBuilder()
 622             ->select('u')
 623             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 624             ->where('u.username = ?1')->orderBy('u.username');
 625
 626         $qb->resetDQLParts(array('where', 'orderBy'));
 627
 628         $this->assertEquals(1, count($qb->getDQLPart('select')));
 629         $this->assertNull($qb->getDQLPart('where'));
 630         $this->assertEquals(0, count($qb->getDQLPart('orderBy')));
 631     }
 632
 633     public function testResetAllDQLParts()
 634     {
 635         $qb = $this->_em->createQueryBuilder()
 636             ->select('u')
 637             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 638             ->where('u.username = ?1')->orderBy('u.username');
 639
 640         $qb->resetDQLParts();
 641
 642         $this->assertEquals(0, count($qb->getDQLPart('select')));
 643         $this->assertNull($qb->getDQLPart('where'));
 644         $this->assertEquals(0, count($qb->getDQLPart('orderBy')));
 645     }
 646
 647     /**
 648      * @group DDC-867
 649      */
 650     public function testDeepClone()
 651     {
 652         $qb = $this->_em->createQueryBuilder()
 653             ->select('u')
 654             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 655             ->andWhere('u.username = ?1')
 656             ->andWhere('u.status = ?2');
 657
 658         $expr = $qb->getDQLPart('where');
 659         $this->assertEquals(2, $expr->count(), "Modifying the second query should affect the first one.");
 660
 661         $qb2 = clone $qb;
 662         $qb2->andWhere('u.name = ?3');
 663
 664         $this->assertEquals(2, $expr->count(), "Modifying the second query should affect the first one.");
 665     }
 666
 667     /**
 668      * @group DDC-1933
 669      */
 670     public function testParametersAreCloned()
 671     {
 672         $originalQb = new QueryBuilder($this->_em);
 673
 674         $originalQb->setParameter('parameter1', 'value1');
 675
 676         $copy = clone $originalQb;
 677         $copy->setParameter('parameter2', 'value2');
 678
 679         $this->assertCount(1, $originalQb->getParameters());
 680         $this->assertSame('value1', $copy->getParameter('parameter1')->getValue());
 681         $this->assertSame('value2', $copy->getParameter('parameter2')->getValue());
 682     }
 683
 684     public function testGetRootAlias()
 685     {
 686         $qb = $this->_em->createQueryBuilder()
 687             ->select('u')
 688             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u');
 689
 690         $this->assertEquals('u', $qb->getRootAlias());
 691     }
 692
 693     public function testGetRootAliases()
 694     {
 695         $qb = $this->_em->createQueryBuilder()
 696             ->select('u')
 697             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u');
 698
 699         $this->assertEquals(array('u'), $qb->getRootAliases());
 700     }
 701
 702     public function testGetRootEntities()
 703     {
 704         $qb = $this->_em->createQueryBuilder()
 705             ->select('u')
 706             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u');
 707
 708         $this->assertEquals(array('Doctrine\Tests\Models\CMS\CmsUser'), $qb->getRootEntities());
 709     }
 710
 711     public function testGetSeveralRootAliases()
 712     {
 713         $qb = $this->_em->createQueryBuilder()
 714             ->select('u')
 715             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 716             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u2');
 717
 718         $this->assertEquals(array('u', 'u2'), $qb->getRootAliases());
 719         $this->assertEquals('u', $qb->getRootAlias());
 720     }
 721
 722     public function testBCAddJoinWithoutRootAlias()
 723     {
 724         $qb = $this->_em->createQueryBuilder()
 725             ->select('u')
 726             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 727             ->add('join', array('INNER JOIN u.groups g'), true);
 728
 729         $this->assertEquals('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u INNER JOIN u.groups g', $qb->getDQL());
 730     }
 731
 732     /**
 733      * @group DDC-1211
 734      */
 735     public function testEmptyStringLiteral()
 736     {
 737         $expr = $this->_em->getExpressionBuilder();
 738         $qb = $this->_em->createQueryBuilder()
 739             ->select('u')
 740             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 741             ->where($expr->eq('u.username', $expr->literal("")));
 742
 743         $this->assertEquals("SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.username = ''", $qb->getDQL());
 744     }
 745
 746     /**
 747      * @group DDC-1211
 748      */
 749     public function testEmptyNumericLiteral()
 750     {
 751         $expr = $this->_em->getExpressionBuilder();
 752         $qb = $this->_em->createQueryBuilder()
 753             ->select('u')
 754             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 755             ->where($expr->eq('u.username', $expr->literal(0)));
 756
 757         $this->assertEquals('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.username = 0', $qb->getDQL());
 758     }
 759
 760     /**
 761      * @group DDC-1227
 762      */
 763     public function testAddFromString()
 764     {
 765         $qb = $this->_em->createQueryBuilder()
 766             ->add('select', 'u')
 767             ->add('from', 'Doctrine\Tests\Models\CMS\CmsUser u');
 768
 769         $this->assertEquals('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u', $qb->getDQL());
 770     }
 771
 772     /**
 773      * @group DDC-1619
 774      */
 775     public function testAddDistinct()
 776     {
 777         $qb = $this->_em->createQueryBuilder()
 778             ->select('u')
 779             ->distinct()
 780             ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u');
 781
 782         $this->assertEquals('SELECT DISTINCT u FROM Doctrine\Tests\Models\CMS\CmsUser u', $qb->getDQL());
 783     }
 784 }