vendor/doctrine/orm/tests/Doctrine/Tests/ORM/Functional/QueryTest.php

   1 <?php
   2
   3 namespace Doctrine\Tests\ORM\Functional;
   4
   5 use Doctrine\Common\Collections\ArrayCollection;
   6
   7 use Doctrine\DBAL\Connection;
   8 use Doctrine\Tests\Models\CMS\CmsUser,
   9     Doctrine\Tests\Models\CMS\CmsArticle,
  10     Doctrine\Tests\Models\CMS\CmsPhonenumber;
  11 use Doctrine\ORM\Mapping\ClassMetadata;
  12 use Doctrine\ORM\Query;
  13 use Doctrine\ORM\Query\Parameter;
  14
  15 require_once __DIR__ . '/../../TestInit.php';
  16
  17 /**
  18  * Functional Query tests.
  19  *
  20  * @author robo
  21  */
  22 class QueryTest extends \Doctrine\Tests\OrmFunctionalTestCase
  23 {
  24     protected function setUp()
  25     {
  26         $this->useModelSet('cms');
  27         parent::setUp();
  28     }
  29
  30     public function testSimpleQueries()
  31     {
  32         $user = new CmsUser;
  33         $user->name = 'Guilherme';
  34         $user->username = 'gblanco';
  35         $user->status = 'developer';
  36         $this->_em->persist($user);
  37         $this->_em->flush();
  38         $this->_em->clear();
  39
  40         $query = $this->_em->createQuery("select u, upper(u.name) from Doctrine\Tests\Models\CMS\CmsUser u where u.username = 'gblanco'");
  41
  42         $result = $query->getResult();
  43
  44         $this->assertEquals(1, count($result));
  45         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsUser', $result[0][0]);
  46         $this->assertEquals('Guilherme', $result[0][0]->name);
  47         $this->assertEquals('gblanco', $result[0][0]->username);
  48         $this->assertEquals('developer', $result[0][0]->status);
  49         $this->assertEquals('GUILHERME', $result[0][1]);
  50
  51         $resultArray = $query->getArrayResult();
  52         $this->assertEquals(1, count($resultArray));
  53         $this->assertTrue(is_array($resultArray[0][0]));
  54         $this->assertEquals('Guilherme', $resultArray[0][0]['name']);
  55         $this->assertEquals('gblanco', $resultArray[0][0]['username']);
  56         $this->assertEquals('developer', $resultArray[0][0]['status']);
  57         $this->assertEquals('GUILHERME', $resultArray[0][1]);
  58
  59         $scalarResult = $query->getScalarResult();
  60         $this->assertEquals(1, count($scalarResult));
  61         $this->assertEquals('Guilherme', $scalarResult[0]['u_name']);
  62         $this->assertEquals('gblanco', $scalarResult[0]['u_username']);
  63         $this->assertEquals('developer', $scalarResult[0]['u_status']);
  64         $this->assertEquals('GUILHERME', $scalarResult[0][1]);
  65
  66         $query = $this->_em->createQuery("select upper(u.name) from Doctrine\Tests\Models\CMS\CmsUser u where u.username = 'gblanco'");
  67         $this->assertEquals('GUILHERME', $query->getSingleScalarResult());
  68     }
  69
  70     public function testJoinQueries()
  71     {
  72         $user = new CmsUser;
  73         $user->name = 'Guilherme';
  74         $user->username = 'gblanco';
  75         $user->status = 'developer';
  76
  77         $article1 = new CmsArticle;
  78         $article1->topic = "Doctrine 2";
  79         $article1->text = "This is an introduction to Doctrine 2.";
  80         $user->addArticle($article1);
  81
  82         $article2 = new CmsArticle;
  83         $article2->topic = "Symfony 2";
  84         $article2->text = "This is an introduction to Symfony 2.";
  85         $user->addArticle($article2);
  86
  87         $this->_em->persist($user);
  88         $this->_em->persist($article1);
  89         $this->_em->persist($article2);
  90
  91         $this->_em->flush();
  92         $this->_em->clear();
  93
  94         $query = $this->_em->createQuery("select u, a from Doctrine\Tests\Models\CMS\CmsUser u join u.articles a ORDER BY a.topic");
  95         $users = $query->getResult();
  96         $this->assertEquals(1, count($users));
  97         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsUser', $users[0]);
  98         $this->assertEquals(2, count($users[0]->articles));
  99         $this->assertEquals('Doctrine 2', $users[0]->articles[0]->topic);
 100         $this->assertEquals('Symfony 2', $users[0]->articles[1]->topic);
 101     }
 102
 103     public function testUsingZeroBasedQueryParameterShouldWork()
 104     {
 105         $user = new CmsUser;
 106         $user->name = 'Jonathan';
 107         $user->username = 'jwage';
 108         $user->status = 'developer';
 109         $this->_em->persist($user);
 110         $this->_em->flush();
 111         $this->_em->clear();
 112
 113         $q = $this->_em->createQuery('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.username = ?0');
 114         $q->setParameter(0, 'jwage');
 115         $user = $q->getSingleResult();
 116
 117         $this->assertNotNull($user);
 118     }
 119
 120     public function testUsingUnknownQueryParameterShouldThrowException()
 121     {
 122         $this->setExpectedException(
 123             "Doctrine\ORM\Query\QueryException",
 124             "Invalid parameter: token 2 is not defined in the query."
 125         );
 126
 127         $q = $this->_em->createQuery('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.name = ?1');
 128         $q->setParameter(2, 'jwage');
 129         $user = $q->getSingleResult();
 130     }
 131
 132     public function testMismatchingParamExpectedParamCount()
 133     {
 134         $this->setExpectedException(
 135             "Doctrine\ORM\Query\QueryException",
 136             "Invalid parameter number: number of bound variables does not match number of tokens"
 137         );
 138
 139         $q = $this->_em->createQuery('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.name = ?1');
 140         $q->setParameter(1, 'jwage');
 141         $q->setParameter(2, 'jwage');
 142
 143         $user = $q->getSingleResult();
 144     }
 145
 146     public function testInvalidInputParameterThrowsException()
 147     {
 148         $this->setExpectedException("Doctrine\ORM\Query\QueryException");
 149
 150         $q = $this->_em->createQuery('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.name = ?');
 151         $q->setParameter(1, 'jwage');
 152         $user = $q->getSingleResult();
 153     }
 154
 155     public function testSetParameters()
 156     {
 157         $q = $this->_em->createQuery('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.name = ?1 AND u.status = ?2');
 158
 159         $parameters = new ArrayCollection();
 160         $parameters->add(new Parameter(1, 'jwage'));
 161         $parameters->add(new Parameter(2, 'active'));
 162
 163         $q->setParameters($parameters);
 164         $users = $q->getResult();
 165     }
 166
 167     public function testSetParametersBackwardsCompatible()
 168     {
 169         $q = $this->_em->createQuery('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.name = ?1 AND u.status = ?2');
 170         $q->setParameters(array(1 => 'jwage', 2 => 'active'));
 171
 172         $users = $q->getResult();
 173     }
 174
 175     /**
 176      * @group DDC-1070
 177      */
 178     public function testIterateResultAsArrayAndParams()
 179     {
 180         $article1 = new CmsArticle;
 181         $article1->topic = "Doctrine 2";
 182         $article1->text = "This is an introduction to Doctrine 2.";
 183
 184         $article2 = new CmsArticle;
 185         $article2->topic = "Symfony 2";
 186         $article2->text = "This is an introduction to Symfony 2.";
 187
 188         $this->_em->persist($article1);
 189         $this->_em->persist($article2);
 190
 191         $this->_em->flush();
 192         $this->_em->clear();
 193         $articleId = $article1->id;
 194
 195         $query = $this->_em->createQuery("select a from Doctrine\Tests\Models\CMS\CmsArticle a WHERE a.topic = ?1");
 196         $articles = $query->iterate(new ArrayCollection(array(new Parameter(1, 'Doctrine 2'))), Query::HYDRATE_ARRAY);
 197
 198         $found = array();
 199         foreach ($articles AS $article) {
 200             $found[] = $article;
 201         }
 202         $this->assertEquals(1, count($found));
 203         $this->assertEquals(array(
 204             array(array('id' => $articleId, 'topic' => 'Doctrine 2', 'text' => 'This is an introduction to Doctrine 2.', 'version' => 1))
 205         ), $found);
 206     }
 207
 208     public function testIterateResult_IterativelyBuildUpUnitOfWork()
 209     {
 210         $article1 = new CmsArticle;
 211         $article1->topic = "Doctrine 2";
 212         $article1->text = "This is an introduction to Doctrine 2.";
 213
 214         $article2 = new CmsArticle;
 215         $article2->topic = "Symfony 2";
 216         $article2->text = "This is an introduction to Symfony 2.";
 217
 218         $this->_em->persist($article1);
 219         $this->_em->persist($article2);
 220
 221         $this->_em->flush();
 222         $this->_em->clear();
 223
 224         $query = $this->_em->createQuery("select a from Doctrine\Tests\Models\CMS\CmsArticle a");
 225         $articles = $query->iterate();
 226
 227         $iteratedCount = 0;
 228         $topics = array();
 229         foreach($articles AS $row) {
 230             $article = $row[0];
 231             $topics[] = $article->topic;
 232
 233             $identityMap = $this->_em->getUnitOfWork()->getIdentityMap();
 234             $identityMapCount = count($identityMap['Doctrine\Tests\Models\CMS\CmsArticle']);
 235             $this->assertTrue($identityMapCount>$iteratedCount);
 236
 237             $iteratedCount++;
 238         }
 239
 240         $this->assertEquals(array("Doctrine 2", "Symfony 2"), $topics);
 241         $this->assertEquals(2, $iteratedCount);
 242
 243         $this->_em->flush();
 244         $this->_em->clear();
 245     }
 246
 247     public function testIterateResultClearEveryCycle()
 248     {
 249         $article1 = new CmsArticle;
 250         $article1->topic = "Doctrine 2";
 251         $article1->text = "This is an introduction to Doctrine 2.";
 252
 253         $article2 = new CmsArticle;
 254         $article2->topic = "Symfony 2";
 255         $article2->text = "This is an introduction to Symfony 2.";
 256
 257         $this->_em->persist($article1);
 258         $this->_em->persist($article2);
 259
 260         $this->_em->flush();
 261         $this->_em->clear();
 262
 263         $query    = $this->_em->createQuery("select a from Doctrine\Tests\Models\CMS\CmsArticle a");
 264         $articles = $query->iterate();
 265
 266         $iteratedCount = 0;
 267         $topics = array();
 268         foreach($articles AS $row) {
 269             $article  = $row[0];
 270             $topics[] = $article->topic;
 271
 272             $this->_em->clear();
 273
 274             $iteratedCount++;
 275         }
 276
 277         $this->assertEquals(array("Doctrine 2", "Symfony 2"), $topics);
 278         $this->assertEquals(2, $iteratedCount);
 279
 280         $this->_em->flush();
 281     }
 282
 283     /**
 284      * @expectedException \Doctrine\ORM\Query\QueryException
 285      */
 286     public function testIterateResult_FetchJoinedCollection_ThrowsException()
 287     {
 288         $query = $this->_em->createQuery("SELECT u, a FROM Doctrine\Tests\Models\CMS\CmsUser u JOIN u.articles a");
 289         $articles = $query->iterate();
 290     }
 291
 292     /**
 293      * @expectedException Doctrine\ORM\NoResultException
 294      */
 295     public function testGetSingleResultThrowsExceptionOnNoResult()
 296     {
 297         $this->_em->createQuery("select a from Doctrine\Tests\Models\CMS\CmsArticle a")
 298              ->getSingleResult();
 299     }
 300
 301     /**
 302      * @expectedException Doctrine\ORM\NoResultException
 303      */
 304     public function testGetSingleScalarResultThrowsExceptionOnNoResult()
 305     {
 306         $this->_em->createQuery("select a from Doctrine\Tests\Models\CMS\CmsArticle a")
 307              ->getSingleScalarResult();
 308     }
 309
 310     /**
 311      * @expectedException Doctrine\ORM\NonUniqueResultException
 312      */
 313     public function testGetSingleScalarResultThrowsExceptionOnNonUniqueResult()
 314     {
 315         $user = new CmsUser;
 316         $user->name = 'Guilherme';
 317         $user->username = 'gblanco';
 318         $user->status = 'developer';
 319
 320         $article1 = new CmsArticle;
 321         $article1->topic = "Doctrine 2";
 322         $article1->text = "This is an introduction to Doctrine 2.";
 323         $user->addArticle($article1);
 324
 325         $article2 = new CmsArticle;
 326         $article2->topic = "Symfony 2";
 327         $article2->text = "This is an introduction to Symfony 2.";
 328         $user->addArticle($article2);
 329
 330         $this->_em->persist($user);
 331         $this->_em->persist($article1);
 332         $this->_em->persist($article2);
 333
 334         $this->_em->flush();
 335         $this->_em->clear();
 336
 337         $this->_em->createQuery("select a from Doctrine\Tests\Models\CMS\CmsArticle a")
 338              ->getSingleScalarResult();
 339     }
 340
 341     public function testModifiedLimitQuery()
 342     {
 343         for ($i = 0; $i < 5; $i++) {
 344             $user = new CmsUser;
 345             $user->name = 'Guilherme' . $i;
 346             $user->username = 'gblanco' . $i;
 347             $user->status = 'developer';
 348             $this->_em->persist($user);
 349         }
 350
 351         $this->_em->flush();
 352         $this->_em->clear();
 353
 354         $data = $this->_em->createQuery('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u')
 355                   ->setFirstResult(1)
 356                   ->setMaxResults(2)
 357                   ->getResult();
 358
 359         $this->assertEquals(2, count($data));
 360         $this->assertEquals('gblanco1', $data[0]->username);
 361         $this->assertEquals('gblanco2', $data[1]->username);
 362
 363         $data = $this->_em->createQuery('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u')
 364                   ->setFirstResult(3)
 365                   ->setMaxResults(2)
 366                   ->getResult();
 367
 368         $this->assertEquals(2, count($data));
 369         $this->assertEquals('gblanco3', $data[0]->username);
 370         $this->assertEquals('gblanco4', $data[1]->username);
 371
 372         $data = $this->_em->createQuery('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u')
 373                   ->setFirstResult(3)
 374                   ->setMaxResults(2)
 375                   ->getScalarResult();
 376     }
 377
 378     public function testSupportsQueriesWithEntityNamespaces()
 379     {
 380         $this->_em->getConfiguration()->addEntityNamespace('CMS', 'Doctrine\Tests\Models\CMS');
 381
 382         try {
 383             $query = $this->_em->createQuery('UPDATE CMS:CmsUser u SET u.name = ?1');
 384             $this->assertEquals('UPDATE cms_users SET name = ?', $query->getSql());
 385             $query->free();
 386         } catch (\Exception $e) {
 387             $this->fail($e->getMessage());
 388         }
 389
 390         $this->_em->getConfiguration()->setEntityNamespaces(array());
 391     }
 392
 393     /**
 394      * @group DDC-604
 395      */
 396     public function testEntityParameters()
 397     {
 398         $article = new CmsArticle;
 399         $article->topic = "dr. dolittle";
 400         $article->text = "Once upon a time ...";
 401         $author = new CmsUser;
 402         $author->name = "anonymous";
 403         $author->username = "anon";
 404         $author->status = "here";
 405         $article->user = $author;
 406         $this->_em->persist($author);
 407         $this->_em->persist($article);
 408         $this->_em->flush();
 409         $this->_em->clear();
 410         //$this->_em->getConnection()->getConfiguration()->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger);
 411         $q = $this->_em->createQuery("select a from Doctrine\Tests\Models\CMS\CmsArticle a where a.topic = :topic and a.user = :user")
 412                 ->setParameter("user", $this->_em->getReference('Doctrine\Tests\Models\CMS\CmsUser', $author->id))
 413                 ->setParameter("topic", "dr. dolittle");
 414
 415         $result = $q->getResult();
 416         $this->assertEquals(1, count($result));
 417         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsArticle', $result[0]);
 418         $this->assertEquals("dr. dolittle", $result[0]->topic);
 419         $this->assertInstanceOf('Doctrine\ORM\Proxy\Proxy', $result[0]->user);
 420         $this->assertFalse($result[0]->user->__isInitialized__);
 421     }
 422
 423     /**
 424      * @group DDC-952
 425      */
 426     public function testEnableFetchEagerMode()
 427     {
 428         for ($i = 0; $i < 10; $i++) {
 429             $article = new CmsArticle;
 430             $article->topic = "dr. dolittle";
 431             $article->text = "Once upon a time ...";
 432             $author = new CmsUser;
 433             $author->name = "anonymous";
 434             $author->username = "anon".$i;
 435             $author->status = "here";
 436             $article->user = $author;
 437             $this->_em->persist($author);
 438             $this->_em->persist($article);
 439         }
 440         $this->_em->flush();
 441         $this->_em->clear();
 442
 443         $articles = $this->_em->createQuery('select a from Doctrine\Tests\Models\CMS\CmsArticle a')
 444                          ->setFetchMode('Doctrine\Tests\Models\CMS\CmsArticle', 'user', ClassMetadata::FETCH_EAGER)
 445                          ->getResult();
 446
 447         $this->assertEquals(10, count($articles));
 448         foreach ($articles AS $article) {
 449             $this->assertNotInstanceOf('Doctrine\ORM\Proxy\Proxy', $article);
 450         }
 451     }
 452
 453     /**
 454      * @group DDC-991
 455      */
 456     public function testgetOneOrNullResult()
 457     {
 458         $user = new CmsUser;
 459         $user->name = 'Guilherme';
 460         $user->username = 'gblanco';
 461         $user->status = 'developer';
 462         $this->_em->persist($user);
 463         $this->_em->flush();
 464         $this->_em->clear();
 465
 466         $query = $this->_em->createQuery("select u from Doctrine\Tests\Models\CMS\CmsUser u where u.username = 'gblanco'");
 467
 468         $fetchedUser = $query->getOneOrNullResult();
 469         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsUser', $fetchedUser);
 470         $this->assertEquals('gblanco', $fetchedUser->username);
 471
 472         $query = $this->_em->createQuery("select u.username from Doctrine\Tests\Models\CMS\CmsUser u where u.username = 'gblanco'");
 473         $fetchedUsername = $query->getOneOrNullResult(Query::HYDRATE_SINGLE_SCALAR);
 474         $this->assertEquals('gblanco', $fetchedUsername);
 475     }
 476
 477     /**
 478      * @group DDC-991
 479      */
 480     public function testgetOneOrNullResultSeveralRows()
 481     {
 482         $user = new CmsUser;
 483         $user->name = 'Guilherme';
 484         $user->username = 'gblanco';
 485         $user->status = 'developer';
 486         $this->_em->persist($user);
 487         $user = new CmsUser;
 488         $user->name = 'Roman';
 489         $user->username = 'romanb';
 490         $user->status = 'developer';
 491         $this->_em->persist($user);
 492         $this->_em->flush();
 493         $this->_em->clear();
 494
 495         $query = $this->_em->createQuery("select u from Doctrine\Tests\Models\CMS\CmsUser u");
 496
 497         $this->setExpectedException('Doctrine\ORM\NonUniqueResultException');
 498         $fetchedUser = $query->getOneOrNullResult();
 499     }
 500
 501     /**
 502      * @group DDC-991
 503      */
 504     public function testgetOneOrNullResultNoRows()
 505     {
 506         $query = $this->_em->createQuery("select u from Doctrine\Tests\Models\CMS\CmsUser u");
 507         $this->assertNull($query->getOneOrNullResult());
 508
 509         $query = $this->_em->createQuery("select u.username from Doctrine\Tests\Models\CMS\CmsUser u where u.username = 'gblanco'");
 510         $this->assertNull($query->getOneOrNullResult(Query::HYDRATE_SCALAR));
 511     }
 512
 513     /**
 514      * @group DBAL-171
 515      */
 516     public function testParameterOrder()
 517     {
 518         $user1 = new CmsUser;
 519         $user1->name = 'Benjamin';
 520         $user1->username = 'beberlei';
 521         $user1->status = 'developer';
 522         $this->_em->persist($user1);
 523
 524         $user2 = new CmsUser;
 525         $user2->name = 'Roman';
 526         $user2->username = 'romanb';
 527         $user2->status = 'developer';
 528         $this->_em->persist($user2);
 529
 530         $user3 = new CmsUser;
 531         $user3->name = 'Jonathan';
 532         $user3->username = 'jwage';
 533         $user3->status = 'developer';
 534         $this->_em->persist($user3);
 535
 536         $this->_em->flush();
 537         $this->_em->clear();
 538
 539         $query = $this->_em->createQuery("SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.status = :a AND u.id IN (:b)");
 540         $query->setParameters(new ArrayCollection(array(
 541             new Parameter('b', array($user1->id, $user2->id, $user3->id)),
 542             new Parameter('a', 'developer')
 543         )));
 544         $result = $query->getResult();
 545
 546         $this->assertEquals(3, count($result));
 547     }
 548
 549     public function testDqlWithAutoInferOfParameters()
 550     {
 551         $user = new CmsUser;
 552         $user->name = 'Benjamin';
 553         $user->username = 'beberlei';
 554         $user->status = 'developer';
 555         $this->_em->persist($user);
 556
 557         $user = new CmsUser;
 558         $user->name = 'Roman';
 559         $user->username = 'romanb';
 560         $user->status = 'developer';
 561         $this->_em->persist($user);
 562
 563         $user = new CmsUser;
 564         $user->name = 'Jonathan';
 565         $user->username = 'jwage';
 566         $user->status = 'developer';
 567         $this->_em->persist($user);
 568
 569         $this->_em->flush();
 570         $this->_em->clear();
 571
 572         $query = $this->_em->createQuery("SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u.username IN (?0)");
 573         $query->setParameter(0, array('beberlei', 'jwage'));
 574
 575         $users = $query->execute();
 576
 577         $this->assertEquals(2, count($users));
 578     }
 579
 580     public function testQueryBuilderWithStringWhereClauseContainingOrAndConditionalPrimary()
 581     {
 582         $qb = $this->_em->createQueryBuilder();
 583         $qb->select('u')
 584            ->from('Doctrine\Tests\Models\CMS\CmsUser', 'u')
 585            ->innerJoin('u.articles', 'a')
 586            ->where('(u.id = 0) OR (u.id IS NULL)');
 587
 588         $query = $qb->getQuery();
 589         $users = $query->execute();
 590
 591         $this->assertEquals(0, count($users));
 592     }
 593
 594     public function testQueryWithArrayOfEntitiesAsParameter()
 595     {
 596         $userA = new CmsUser;
 597         $userA->name = 'Benjamin';
 598         $userA->username = 'beberlei';
 599         $userA->status = 'developer';
 600         $this->_em->persist($userA);
 601
 602         $userB = new CmsUser;
 603         $userB->name = 'Roman';
 604         $userB->username = 'romanb';
 605         $userB->status = 'developer';
 606         $this->_em->persist($userB);
 607
 608         $userC = new CmsUser;
 609         $userC->name = 'Jonathan';
 610         $userC->username = 'jwage';
 611         $userC->status = 'developer';
 612         $this->_em->persist($userC);
 613
 614         $this->_em->flush();
 615         $this->_em->clear();
 616
 617         $query = $this->_em->createQuery("SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u WHERE u IN (?0) OR u.username = ?1");
 618         $query->setParameter(0, array($userA, $userC));
 619         $query->setParameter(1, 'beberlei');
 620
 621         $users = $query->execute();
 622
 623         $this->assertEquals(2, count($users));
 624     }
 625
 626     public function testQueryWithHiddenAsSelectExpression()
 627     {
 628         $userA = new CmsUser;
 629         $userA->name = 'Benjamin';
 630         $userA->username = 'beberlei';
 631         $userA->status = 'developer';
 632         $this->_em->persist($userA);
 633
 634         $userB = new CmsUser;
 635         $userB->name = 'Roman';
 636         $userB->username = 'romanb';
 637         $userB->status = 'developer';
 638         $this->_em->persist($userB);
 639
 640         $userC = new CmsUser;
 641         $userC->name = 'Jonathan';
 642         $userC->username = 'jwage';
 643         $userC->status = 'developer';
 644         $this->_em->persist($userC);
 645
 646         $this->_em->flush();
 647         $this->_em->clear();
 648
 649         $query = $this->_em->createQuery("SELECT u, (SELECT COUNT(u2.id) FROM Doctrine\Tests\Models\CMS\CmsUser u2) AS HIDDEN total FROM Doctrine\Tests\Models\CMS\CmsUser u");
 650         $users = $query->execute();
 651
 652         $this->assertEquals(3, count($users));
 653         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsUser', $users[0]);
 654     }
 655
 656     /**
 657      * @group DDC-1651
 658      */
 659     public function testSetParameterBindingSingleIdentifierObject()
 660     {
 661         $userC = new CmsUser;
 662         $userC->name = 'Jonathan';
 663         $userC->username = 'jwage';
 664         $userC->status = 'developer';
 665         $this->_em->persist($userC);
 666
 667         $this->_em->flush();
 668         $this->_em->clear();
 669
 670         $q = $this->_em->createQuery("SELECT DISTINCT u from Doctrine\Tests\Models\CMS\CmsUser u WHERE u.id = ?1");
 671         $q->setParameter(1, $userC);
 672
 673         $this->assertEquals($userC, $q->getParameter(1)->getValue());
 674
 675         // Parameter is not converted before, but it should be converted during execution. Test should not fail here
 676         $q->getResult();
 677     }
 678
 679
 680     /**
 681      * @group DDC-1822
 682      */
 683     public function testUnexpectedResultException()
 684     {
 685         $dql            = "SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u";
 686         $u1             = new CmsUser;
 687         $u2             = new CmsUser;
 688         $u1->name       = 'Fabio B. Silva';
 689         $u1->username   = 'FabioBatSilva';
 690         $u1->status     = 'developer';
 691         $u2->name       = 'Test';
 692         $u2->username   = 'test';
 693         $u2->status     = 'tester';
 694
 695         try {
 696             $this->_em->createQuery($dql)->getSingleResult();
 697             $this->fail('Expected exception "\Doctrine\ORM\NoResultException".');
 698         } catch (\Doctrine\ORM\UnexpectedResultException $exc) {
 699             $this->assertInstanceOf('\Doctrine\ORM\NoResultException', $exc);
 700         }
 701
 702
 703         $this->_em->persist($u1);
 704         $this->_em->persist($u2);
 705         $this->_em->flush();
 706         $this->_em->clear();
 707
 708         try {
 709             $this->_em->createQuery($dql)->getSingleResult();
 710             $this->fail('Expected exception "\Doctrine\ORM\NonUniqueResultException".');
 711         } catch (\Doctrine\ORM\UnexpectedResultException $exc) {
 712             $this->assertInstanceOf('\Doctrine\ORM\NonUniqueResultException', $exc);
 713         }
 714     }
 715
 716     public function testMultipleJoinComponentsUsingInnerJoin()
 717     {
 718         $userA = new CmsUser;
 719         $userA->name = 'Benjamin';
 720         $userA->username = 'beberlei';
 721         $userA->status = 'developer';
 722
 723         $phonenumberA = new CmsPhonenumber;
 724         $phonenumberA->phonenumber = '111111';
 725         $userA->addPhonenumber($phonenumberA);
 726
 727         $userB = new CmsUser;
 728         $userB->name = 'Alexander';
 729         $userB->username = 'asm89';
 730         $userB->status = 'developer';
 731
 732         $this->_em->persist($userA);
 733         $this->_em->persist($userB);
 734         $this->_em->flush();
 735         $this->_em->clear();
 736
 737         $query = $this->_em->createQuery("
 738             SELECT u, p
 739               FROM Doctrine\Tests\Models\CMS\CmsUser u
 740              INNER JOIN Doctrine\Tests\Models\CMS\CmsPhonenumber p WITH u = p.user
 741         ");
 742         $users = $query->execute();
 743
 744         $this->assertEquals(2, count($users));
 745         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsUser', $users[0]);
 746         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsPhonenumber', $users[1]);
 747     }
 748
 749     public function testMultipleJoinComponentsUsingLeftJoin()
 750     {
 751         $userA = new CmsUser;
 752         $userA->name = 'Benjamin';
 753         $userA->username = 'beberlei';
 754         $userA->status = 'developer';
 755
 756         $phonenumberA = new CmsPhonenumber;
 757         $phonenumberA->phonenumber = '111111';
 758         $userA->addPhonenumber($phonenumberA);
 759
 760         $userB = new CmsUser;
 761         $userB->name = 'Alexander';
 762         $userB->username = 'asm89';
 763         $userB->status = 'developer';
 764
 765         $this->_em->persist($userA);
 766         $this->_em->persist($userB);
 767         $this->_em->flush();
 768         $this->_em->clear();
 769
 770         $query = $this->_em->createQuery("
 771             SELECT u, p
 772               FROM Doctrine\Tests\Models\CMS\CmsUser u
 773               LEFT JOIN Doctrine\Tests\Models\CMS\CmsPhonenumber p WITH u = p.user
 774         ");
 775         $users = $query->execute();
 776
 777         $this->assertEquals(4, count($users));
 778         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsUser', $users[0]);
 779         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsPhonenumber', $users[1]);
 780         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsUser', $users[2]);
 781         $this->assertNull($users[3]);
 782     }
 783 }