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

   1 <?php
   2
   3 namespace Doctrine\Tests\ORM\Functional;
   4
   5 use Doctrine\Common\Collections\ArrayCollection;
   6
   7 use Doctrine\ORM\Query\ResultSetMapping;
   8 use Doctrine\ORM\Query\ResultSetMappingBuilder;
   9 use Doctrine\ORM\Query\Parameter;
  10
  11 use Doctrine\Tests\Models\CMS\CmsUser;
  12 use Doctrine\Tests\Models\CMS\CmsPhonenumber;
  13 use Doctrine\Tests\Models\CMS\CmsAddress;
  14 use Doctrine\Tests\Models\CMS\CmsEmail;
  15 use Doctrine\Tests\Models\CMS\CmsArticle;
  16 use Doctrine\Tests\Models\Company\CompanyFixContract;
  17 use Doctrine\Tests\Models\Company\CompanyEmployee;
  18 use Doctrine\Tests\Models\Company\CompanyPerson;
  19
  20 require_once __DIR__ . '/../../TestInit.php';
  21
  22 /**
  23  * NativeQueryTest
  24  *
  25  * @author robo
  26  */
  27 class NativeQueryTest extends \Doctrine\Tests\OrmFunctionalTestCase
  28 {
  29     private $platform = null;
  30
  31     protected function setUp() {
  32         $this->useModelSet('cms');
  33         $this->useModelSet('company');
  34         parent::setUp();
  35         $this->platform = $this->_em->getConnection()->getDatabasePlatform();
  36     }
  37
  38     public function testBasicNativeQuery()
  39     {
  40         $user = new CmsUser;
  41         $user->name = 'Roman';
  42         $user->username = 'romanb';
  43         $user->status = 'dev';
  44         $this->_em->persist($user);
  45         $this->_em->flush();
  46
  47         $this->_em->clear();
  48
  49         $rsm = new ResultSetMapping;
  50         $rsm->addEntityResult('Doctrine\Tests\Models\CMS\CmsUser', 'u');
  51         $rsm->addFieldResult('u', $this->platform->getSQLResultCasing('id'), 'id');
  52         $rsm->addFieldResult('u', $this->platform->getSQLResultCasing('name'), 'name');
  53
  54         $query = $this->_em->createNativeQuery('SELECT id, name FROM cms_users WHERE username = ?', $rsm);
  55         $query->setParameter(1, 'romanb');
  56
  57         $users = $query->getResult();
  58
  59         $this->assertEquals(1, count($users));
  60         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsUser', $users[0]);
  61         $this->assertEquals('Roman', $users[0]->name);
  62     }
  63
  64     public function testBasicNativeQueryWithMetaResult()
  65     {
  66         $user = new CmsUser;
  67         $user->name = 'Roman';
  68         $user->username = 'romanb';
  69         $user->status = 'dev';
  70
  71         $addr = new CmsAddress;
  72         $addr->country = 'germany';
  73         $addr->zip = 10827;
  74         $addr->city = 'Berlin';
  75
  76
  77         $user->setAddress($addr);
  78
  79         $this->_em->persist($user);
  80         $this->_em->flush();
  81
  82         $this->_em->clear();
  83
  84         $rsm = new ResultSetMapping;
  85         $rsm->addEntityResult('Doctrine\Tests\Models\CMS\CmsAddress', 'a');
  86         $rsm->addFieldResult('a', $this->platform->getSQLResultCasing('id'), 'id');
  87         $rsm->addFieldResult('a', $this->platform->getSQLResultCasing('country'), 'country');
  88         $rsm->addFieldResult('a', $this->platform->getSQLResultCasing('zip'), 'zip');
  89         $rsm->addFieldResult('a', $this->platform->getSQLResultCasing('city'), 'city');
  90         $rsm->addMetaResult('a', $this->platform->getSQLResultCasing('user_id'), 'user_id');
  91
  92         $query = $this->_em->createNativeQuery('SELECT a.id, a.country, a.zip, a.city, a.user_id FROM cms_addresses a WHERE a.id = ?', $rsm);
  93         $query->setParameter(1, $addr->id);
  94
  95         $addresses = $query->getResult();
  96
  97         $this->assertEquals(1, count($addresses));
  98         $this->assertTrue($addresses[0] instanceof CmsAddress);
  99         $this->assertEquals($addr->country, $addresses[0]->country);
 100         $this->assertEquals($addr->zip, $addresses[0]->zip);
 101         $this->assertEquals($addr->city, $addresses[0]->city);
 102         $this->assertEquals($addr->street, $addresses[0]->street);
 103         $this->assertTrue($addresses[0]->user instanceof CmsUser);
 104     }
 105
 106     public function testJoinedOneToManyNativeQuery()
 107     {
 108         $user = new CmsUser;
 109         $user->name = 'Roman';
 110         $user->username = 'romanb';
 111         $user->status = 'dev';
 112
 113         $phone = new CmsPhonenumber;
 114         $phone->phonenumber = 424242;
 115
 116         $user->addPhonenumber($phone);
 117
 118         $this->_em->persist($user);
 119         $this->_em->flush();
 120
 121         $this->_em->clear();
 122
 123         $rsm = new ResultSetMapping;
 124         $rsm->addEntityResult('Doctrine\Tests\Models\CMS\CmsUser', 'u');
 125         $rsm->addFieldResult('u', $this->platform->getSQLResultCasing('id'), 'id');
 126         $rsm->addFieldResult('u', $this->platform->getSQLResultCasing('name'), 'name');
 127         $rsm->addFieldResult('u', $this->platform->getSQLResultCasing('status'), 'status');
 128         $rsm->addJoinedEntityResult('Doctrine\Tests\Models\CMS\CmsPhonenumber', 'p', 'u', 'phonenumbers');
 129         $rsm->addFieldResult('p', $this->platform->getSQLResultCasing('phonenumber'), 'phonenumber');
 130
 131         $query = $this->_em->createNativeQuery('SELECT id, name, status, phonenumber FROM cms_users INNER JOIN cms_phonenumbers ON id = user_id WHERE username = ?', $rsm);
 132         $query->setParameter(1, 'romanb');
 133
 134         $users = $query->getResult();
 135         $this->assertEquals(1, count($users));
 136         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsUser', $users[0]);
 137         $this->assertEquals('Roman', $users[0]->name);
 138         $this->assertInstanceOf('Doctrine\ORM\PersistentCollection', $users[0]->getPhonenumbers());
 139         $this->assertTrue($users[0]->getPhonenumbers()->isInitialized());
 140         $this->assertEquals(1, count($users[0]->getPhonenumbers()));
 141         $phones = $users[0]->getPhonenumbers();
 142         $this->assertEquals(424242, $phones[0]->phonenumber);
 143         $this->assertTrue($phones[0]->getUser() === $users[0]);
 144
 145     }
 146
 147     public function testJoinedOneToOneNativeQuery()
 148     {
 149         $user = new CmsUser;
 150         $user->name = 'Roman';
 151         $user->username = 'romanb';
 152         $user->status = 'dev';
 153
 154         $addr = new CmsAddress;
 155         $addr->country = 'germany';
 156         $addr->zip = 10827;
 157         $addr->city = 'Berlin';
 158
 159
 160         $user->setAddress($addr);
 161
 162         $this->_em->persist($user);
 163         $this->_em->flush();
 164
 165         $this->_em->clear();
 166
 167
 168         $rsm = new ResultSetMapping;
 169         $rsm->addEntityResult('Doctrine\Tests\Models\CMS\CmsUser', 'u');
 170         $rsm->addFieldResult('u', $this->platform->getSQLResultCasing('id'), 'id');
 171         $rsm->addFieldResult('u', $this->platform->getSQLResultCasing('name'), 'name');
 172         $rsm->addFieldResult('u', $this->platform->getSQLResultCasing('status'), 'status');
 173         $rsm->addJoinedEntityResult('Doctrine\Tests\Models\CMS\CmsAddress', 'a', 'u', 'address');
 174         $rsm->addFieldResult('a', $this->platform->getSQLResultCasing('a_id'), 'id');
 175         $rsm->addFieldResult('a', $this->platform->getSQLResultCasing('country'), 'country');
 176         $rsm->addFieldResult('a', $this->platform->getSQLResultCasing('zip'), 'zip');
 177         $rsm->addFieldResult('a', $this->platform->getSQLResultCasing('city'), 'city');
 178
 179         $query = $this->_em->createNativeQuery('SELECT u.id, u.name, u.status, a.id AS a_id, a.country, a.zip, a.city FROM cms_users u INNER JOIN cms_addresses a ON u.id = a.user_id WHERE u.username = ?', $rsm);
 180         $query->setParameter(1, 'romanb');
 181
 182         $users = $query->getResult();
 183
 184         $this->assertEquals(1, count($users));
 185         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsUser', $users[0]);
 186         $this->assertEquals('Roman', $users[0]->name);
 187         $this->assertInstanceOf('Doctrine\ORM\PersistentCollection', $users[0]->getPhonenumbers());
 188         $this->assertFalse($users[0]->getPhonenumbers()->isInitialized());
 189         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsAddress', $users[0]->getAddress());
 190         $this->assertTrue($users[0]->getAddress()->getUser() == $users[0]);
 191         $this->assertEquals('germany', $users[0]->getAddress()->getCountry());
 192         $this->assertEquals(10827, $users[0]->getAddress()->getZipCode());
 193         $this->assertEquals('Berlin', $users[0]->getAddress()->getCity());
 194     }
 195
 196     public function testFluentInterface()
 197     {
 198         $parameters = new ArrayCollection;
 199         $parameters->add(new Parameter(1, 'foo'));
 200         $parameters->add(new Parameter(2, 'bar'));
 201
 202         $rsm = new ResultSetMapping;
 203
 204         $q = $this->_em->createNativeQuery('SELECT id, name, status, phonenumber FROM cms_users INNER JOIN cms_phonenumbers ON id = user_id WHERE username = ?', $rsm);
 205         $q2 = $q->setSql('foo', $rsm)
 206           ->setResultSetMapping($rsm)
 207           ->expireResultCache(true)
 208           ->setHint('foo', 'bar')
 209           ->setParameter(1, 'foo')
 210           ->setParameters($parameters)
 211           ->setResultCacheDriver(null)
 212           ->setResultCacheLifetime(3500);
 213
 214         $this->assertSame($q, $q2);
 215     }
 216
 217     public function testJoinedOneToManyNativeQueryWithRSMBuilder()
 218     {
 219         $user = new CmsUser;
 220         $user->name = 'Roman';
 221         $user->username = 'romanb';
 222         $user->status = 'dev';
 223
 224         $phone = new CmsPhonenumber;
 225         $phone->phonenumber = 424242;
 226
 227         $user->addPhonenumber($phone);
 228
 229         $this->_em->persist($user);
 230         $this->_em->flush();
 231
 232         $this->_em->clear();
 233
 234         $rsm = new ResultSetMappingBuilder($this->_em);
 235         $rsm->addRootEntityFromClassMetadata('Doctrine\Tests\Models\CMS\CmsUser', 'u');
 236         $rsm->addJoinedEntityFromClassMetadata('Doctrine\Tests\Models\CMS\CmsPhonenumber', 'p', 'u', 'phonenumbers');
 237         $query = $this->_em->createNativeQuery('SELECT u.*, p.* FROM cms_users u LEFT JOIN cms_phonenumbers p ON u.id = p.user_id WHERE username = ?', $rsm);
 238         $query->setParameter(1, 'romanb');
 239
 240         $users = $query->getResult();
 241         $this->assertEquals(1, count($users));
 242         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsUser', $users[0]);
 243         $this->assertEquals('Roman', $users[0]->name);
 244         $this->assertInstanceOf('Doctrine\ORM\PersistentCollection', $users[0]->getPhonenumbers());
 245         $this->assertTrue($users[0]->getPhonenumbers()->isInitialized());
 246         $this->assertEquals(1, count($users[0]->getPhonenumbers()));
 247         $phones = $users[0]->getPhonenumbers();
 248         $this->assertEquals(424242, $phones[0]->phonenumber);
 249         $this->assertTrue($phones[0]->getUser() === $users[0]);
 250
 251         $this->_em->clear();
 252
 253         $rsm = new ResultSetMappingBuilder($this->_em);
 254         $rsm->addRootEntityFromClassMetadata('Doctrine\Tests\Models\CMS\CmsPhonenumber', 'p');
 255         $query = $this->_em->createNativeQuery('SELECT p.* FROM cms_phonenumbers p WHERE p.phonenumber = ?', $rsm);
 256         $query->setParameter(1, $phone->phonenumber);
 257         $phone = $query->getSingleResult();
 258
 259         $this->assertNotNull($phone->getUser());
 260         $this->assertEquals($user->name, $phone->getUser()->getName());
 261     }
 262
 263     public function testJoinedOneToOneNativeQueryWithRSMBuilder()
 264     {
 265         $user = new CmsUser;
 266         $user->name = 'Roman';
 267         $user->username = 'romanb';
 268         $user->status = 'dev';
 269
 270         $addr = new CmsAddress;
 271         $addr->country = 'germany';
 272         $addr->zip = 10827;
 273         $addr->city = 'Berlin';
 274
 275
 276         $user->setAddress($addr);
 277
 278         $this->_em->persist($user);
 279         $this->_em->flush();
 280
 281         $this->_em->clear();
 282
 283
 284         $rsm = new ResultSetMappingBuilder($this->_em);
 285         $rsm->addRootEntityFromClassMetadata('Doctrine\Tests\Models\CMS\CmsUser', 'u');
 286         $rsm->addJoinedEntityFromClassMetadata('Doctrine\Tests\Models\CMS\CmsAddress', 'a', 'u', 'address', array('id' => 'a_id'));
 287
 288         $query = $this->_em->createNativeQuery('SELECT u.*, a.*, a.id AS a_id FROM cms_users u INNER JOIN cms_addresses a ON u.id = a.user_id WHERE u.username = ?', $rsm);
 289         $query->setParameter(1, 'romanb');
 290
 291         $users = $query->getResult();
 292
 293         $this->assertEquals(1, count($users));
 294         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsUser', $users[0]);
 295         $this->assertEquals('Roman', $users[0]->name);
 296         $this->assertInstanceOf('Doctrine\ORM\PersistentCollection', $users[0]->getPhonenumbers());
 297         $this->assertFalse($users[0]->getPhonenumbers()->isInitialized());
 298         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsAddress', $users[0]->getAddress());
 299         $this->assertTrue($users[0]->getAddress()->getUser() == $users[0]);
 300         $this->assertEquals('germany', $users[0]->getAddress()->getCountry());
 301         $this->assertEquals(10827, $users[0]->getAddress()->getZipCode());
 302         $this->assertEquals('Berlin', $users[0]->getAddress()->getCity());
 303
 304         $this->_em->clear();
 305
 306         $rsm = new ResultSetMappingBuilder($this->_em);
 307         $rsm->addRootEntityFromClassMetadata('Doctrine\Tests\Models\CMS\CmsAddress', 'a');
 308         $query = $this->_em->createNativeQuery('SELECT a.* FROM cms_addresses a WHERE a.id = ?', $rsm);
 309         $query->setParameter(1, $addr->getId());
 310         $address = $query->getSingleResult();
 311
 312         $this->assertNotNull($address->getUser());
 313         $this->assertEquals($user->name, $address->getUser()->getName());
 314     }
 315
 316     /**
 317      * @expectedException \InvalidArgumentException
 318      */
 319     public function testRSMBuilderThrowsExceptionOnColumnConflict()
 320     {
 321         $rsm = new ResultSetMappingBuilder($this->_em);
 322         $rsm->addRootEntityFromClassMetadata('Doctrine\Tests\Models\CMS\CmsUser', 'u');
 323         $rsm->addJoinedEntityFromClassMetadata('Doctrine\Tests\Models\CMS\CmsAddress', 'a', 'u', 'address');
 324     }
 325
 326     /**
 327      * @group PR-39
 328      */
 329     public function testUnknownParentAliasThrowsException()
 330     {
 331         $rsm = new ResultSetMappingBuilder($this->_em);
 332         $rsm->addRootEntityFromClassMetadata('Doctrine\Tests\Models\CMS\CmsUser', 'u');
 333         $rsm->addJoinedEntityFromClassMetadata('Doctrine\Tests\Models\CMS\CmsAddress', 'a', 'un', 'address', array('id' => 'a_id'));
 334
 335         $query = $this->_em->createNativeQuery('SELECT u.*, a.*, a.id AS a_id FROM cms_users u INNER JOIN cms_addresses a ON u.id = a.user_id WHERE u.username = ?', $rsm);
 336         $query->setParameter(1, 'romanb');
 337
 338         $this->setExpectedException(
 339             "Doctrine\ORM\Internal\Hydration\HydrationException",
 340             "The parent object of entity result with alias 'a' was not found. The parent alias is 'un'."
 341         );
 342         $users = $query->getResult();
 343     }
 344
 345
 346     /**
 347      * @group DDC-1663
 348      */
 349     public function testBasicNativeNamedQueryWithSqlResultSetMapping()
 350     {
 351         $user           = new CmsUser;
 352         $user->name     = 'Fabio B. Silva';
 353         $user->username = 'FabioBatSilva';
 354         $user->status   = 'dev';
 355
 356         $addr           = new CmsAddress;
 357         $addr->country  = 'Brazil';
 358         $addr->zip      = 10827;
 359         $addr->city     = 'São Paulo';
 360
 361         $user->setAddress($addr);
 362
 363         $this->_em->clear();
 364         $this->_em->persist($user);
 365         $this->_em->flush();
 366
 367         $this->_em->clear();
 368
 369
 370         $repository = $this->_em->getRepository('Doctrine\Tests\Models\CMS\CmsAddress');
 371         $query      = $repository->createNativeNamedQuery('find-all');
 372         $result     = $query->getResult();
 373
 374         $this->assertCount(1, $result);
 375         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsAddress', $result[0]);
 376         $this->assertEquals($addr->id,  $result[0]->id);
 377         $this->assertEquals($addr->city,  $result[0]->city);
 378         $this->assertEquals($addr->country, $result[0]->country);
 379     }
 380
 381     /**
 382      * @group DDC-1663
 383      */
 384     public function testBasicNativeNamedQueryWithResultClass()
 385     {
 386         $user           = new CmsUser;
 387         $user->name     = 'Fabio B. Silva';
 388         $user->username = 'FabioBatSilva';
 389         $user->status   = 'dev';
 390
 391         $email          = new CmsEmail();
 392         $email->email   = 'fabio.bat.silva@gmail.com';
 393
 394         $user->setEmail($email);
 395
 396         $this->_em->clear();
 397         $this->_em->persist($user);
 398         $this->_em->flush();
 399
 400         $this->_em->clear();
 401
 402         $repository = $this->_em->getRepository('Doctrine\Tests\Models\CMS\CmsUser');
 403
 404
 405         $result = $repository->createNativeNamedQuery('fetchIdAndUsernameWithResultClass')
 406                         ->setParameter(1, 'FabioBatSilva')->getResult();
 407
 408         $this->assertEquals(1, count($result));
 409         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsUser', $result[0]);
 410         $this->assertNull($result[0]->name);
 411         $this->assertNull($result[0]->email);
 412         $this->assertEquals($user->id, $result[0]->id);
 413         $this->assertEquals('FabioBatSilva', $result[0]->username);
 414
 415         $this->_em->clear();
 416
 417
 418         $result = $repository->createNativeNamedQuery('fetchAllColumns')
 419                         ->setParameter(1, 'FabioBatSilva')->getResult();
 420
 421         $this->assertEquals(1, count($result));
 422         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsUser', $result[0]);
 423         $this->assertEquals($user->id, $result[0]->id);
 424         $this->assertEquals('Fabio B. Silva', $result[0]->name);
 425         $this->assertEquals('FabioBatSilva', $result[0]->username);
 426         $this->assertEquals('dev', $result[0]->status);
 427         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsEmail', $result[0]->email);
 428     }
 429
 430
 431     /**
 432      * @group DDC-1663
 433      */
 434     public function testJoinedOneToOneNativeNamedQueryWithResultSetMapping()
 435     {
 436         $user           = new CmsUser;
 437         $user->name     = 'Fabio B. Silva';
 438         $user->username = 'FabioBatSilva';
 439         $user->status   = 'dev';
 440
 441         $addr           = new CmsAddress;
 442         $addr->country  = 'Brazil';
 443         $addr->zip      = 10827;
 444         $addr->city     = 'São Paulo';
 445
 446
 447         $user->setAddress($addr);
 448
 449         $this->_em->persist($user);
 450         $this->_em->flush();
 451
 452         $this->_em->clear();
 453
 454         $repository = $this->_em->getRepository('Doctrine\Tests\Models\CMS\CmsUser');
 455
 456
 457         $result = $repository->createNativeNamedQuery('fetchJoinedAddress')
 458                         ->setParameter(1, 'FabioBatSilva')->getResult();
 459
 460         $this->assertEquals(1, count($result));
 461         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsUser', $result[0]);
 462         $this->assertEquals('Fabio B. Silva', $result[0]->name);
 463         $this->assertInstanceOf('Doctrine\ORM\PersistentCollection', $result[0]->getPhonenumbers());
 464         $this->assertFalse($result[0]->getPhonenumbers()->isInitialized());
 465         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsAddress', $result[0]->getAddress());
 466         $this->assertTrue($result[0]->getAddress()->getUser() == $result[0]);
 467         $this->assertEquals('Brazil', $result[0]->getAddress()->getCountry());
 468         $this->assertEquals(10827, $result[0]->getAddress()->getZipCode());
 469         $this->assertEquals('São Paulo', $result[0]->getAddress()->getCity());
 470     }
 471
 472     /**
 473      * @group DDC-1663
 474      */
 475     public function testJoinedOneToManyNativeNamedQueryWithResultSetMapping()
 476     {
 477         $user               = new CmsUser;
 478         $user->name         = 'Fabio B. Silva';
 479         $user->username     = 'FabioBatSilva';
 480         $user->status       = 'dev';
 481
 482         $phone              = new CmsPhonenumber;
 483         $phone->phonenumber = 424242;
 484
 485         $user->addPhonenumber($phone);
 486
 487         $this->_em->persist($user);
 488         $this->_em->flush();
 489
 490         $this->_em->clear();
 491
 492         $repository = $this->_em->getRepository('Doctrine\Tests\Models\CMS\CmsUser');
 493
 494         $result = $repository->createNativeNamedQuery('fetchJoinedPhonenumber')
 495                         ->setParameter(1, 'FabioBatSilva')->getResult();
 496
 497         $this->assertEquals(1, count($result));
 498         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsUser', $result[0]);
 499         $this->assertEquals('Fabio B. Silva', $result[0]->name);
 500         $this->assertInstanceOf('Doctrine\ORM\PersistentCollection', $result[0]->getPhonenumbers());
 501         $this->assertTrue($result[0]->getPhonenumbers()->isInitialized());
 502         $this->assertEquals(1, count($result[0]->getPhonenumbers()));
 503         $phones = $result[0]->getPhonenumbers();
 504         $this->assertEquals(424242, $phones[0]->phonenumber);
 505         $this->assertTrue($phones[0]->getUser() === $result[0]);
 506     }
 507
 508     /**
 509      * @group DDC-1663
 510      */
 511     public function testMixedNativeNamedQueryNormalJoin()
 512     {
 513         $user1                  = new CmsUser;
 514         $user1->name            = 'Fabio B. Silva';
 515         $user1->username        = 'FabioBatSilva';
 516         $user1->status          = 'dev';
 517
 518         $user2                  = new CmsUser;
 519         $user2->name            = 'test tester';
 520         $user2->username        = 'test';
 521         $user2->status          = 'tester';
 522
 523         $phone1                 = new CmsPhonenumber;
 524         $phone2                 = new CmsPhonenumber;
 525         $phone3                 = new CmsPhonenumber;
 526         $phone1->phonenumber    = 11111111;
 527         $phone2->phonenumber    = 22222222;
 528         $phone3->phonenumber    = 33333333;
 529
 530         $user1->addPhonenumber($phone1);
 531         $user1->addPhonenumber($phone2);
 532         $user2->addPhonenumber($phone3);
 533
 534         $this->_em->persist($user1);
 535         $this->_em->persist($user2);
 536         $this->_em->flush();
 537
 538         $this->_em->clear();
 539
 540         $repository = $this->_em->getRepository('Doctrine\Tests\Models\CMS\CmsUser');
 541
 542         $result = $repository->createNativeNamedQuery('fetchUserPhonenumberCount')
 543                         ->setParameter(1, array('test','FabioBatSilva'))->getResult();
 544
 545         $this->assertEquals(2, count($result));
 546         $this->assertTrue(is_array($result[0]));
 547         $this->assertTrue(is_array($result[1]));
 548
 549         // first user => 2 phonenumbers
 550         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsUser', $result[0][0]);
 551         $this->assertEquals('Fabio B. Silva', $result[0][0]->name);
 552         $this->assertEquals(2, $result[0]['numphones']);
 553
 554         // second user => 1 phonenumbers
 555         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsUser', $result[1][0]);
 556         $this->assertEquals('test tester', $result[1][0]->name);
 557         $this->assertEquals(1, $result[1]['numphones']);
 558     }
 559
 560     /**
 561      * @group DDC-1663
 562      */
 563     public function testNativeNamedQueryInheritance()
 564     {
 565         $person = new CompanyPerson;
 566         $person->setName('Fabio B. Silva');
 567
 568         $employee = new CompanyEmployee;
 569         $employee->setName('Fabio Silva');
 570         $employee->setSalary(100000);
 571         $employee->setDepartment('IT');
 572
 573         $this->_em->persist($person);
 574         $this->_em->persist($employee);
 575
 576         $this->_em->flush();
 577         $this->_em->clear();
 578
 579         $repository = $this->_em->getRepository('Doctrine\Tests\Models\Company\CompanyPerson');
 580
 581         $result = $repository->createNativeNamedQuery('fetchAllWithSqlResultSetMapping')
 582                         ->getResult();
 583
 584         $this->assertEquals(2, count($result));
 585         $this->assertInstanceOf('Doctrine\Tests\Models\Company\CompanyPerson', $result[0]);
 586         $this->assertInstanceOf('Doctrine\Tests\Models\Company\CompanyEmployee', $result[1]);
 587         $this->assertTrue(is_numeric($result[0]->getId()));
 588         $this->assertTrue(is_numeric($result[1]->getId()));
 589         $this->assertEquals('Fabio B. Silva', $result[0]->getName());
 590         $this->assertEquals('Fabio Silva', $result[1]->getName());
 591
 592
 593         $this->_em->clear();
 594
 595
 596         $result = $repository->createNativeNamedQuery('fetchAllWithResultClass')
 597                         ->getResult();
 598
 599         $this->assertEquals(2, count($result));
 600         $this->assertInstanceOf('Doctrine\Tests\Models\Company\CompanyPerson', $result[0]);
 601         $this->assertInstanceOf('Doctrine\Tests\Models\Company\CompanyEmployee', $result[1]);
 602         $this->assertTrue(is_numeric($result[0]->getId()));
 603         $this->assertTrue(is_numeric($result[1]->getId()));
 604         $this->assertEquals('Fabio B. Silva', $result[0]->getName());
 605         $this->assertEquals('Fabio Silva', $result[1]->getName());
 606     }
 607
 608     /**
 609      * @group DDC-1663
 610      * DQL : SELECT u, a, COUNT(p) AS numphones FROM Doctrine\Tests\Models\CMS\CmsUser u JOIN u.address a JOIN u.phonenumbers p
 611      */
 612     public function testMultipleEntityResults()
 613     {
 614
 615         $user               = new CmsUser;
 616         $user->name         = 'Fabio B. Silva';
 617         $user->username     = 'FabioBatSilva';
 618         $user->status       = 'dev';
 619
 620         $addr               = new CmsAddress;
 621         $addr->country      = 'Brazil';
 622         $addr->zip          = 10827;
 623         $addr->city         = 'São Paulo';
 624
 625         $phone              = new CmsPhonenumber;
 626         $phone->phonenumber = 424242;
 627
 628
 629         $user->setAddress($addr);
 630         $user->addPhonenumber($phone);
 631
 632
 633         $this->_em->clear();
 634         $this->_em->persist($user);
 635         $this->_em->flush();
 636
 637         $this->_em->clear();
 638
 639
 640         $repository = $this->_em->getRepository('Doctrine\Tests\Models\CMS\CmsUser');
 641         $query      = $repository->createNativeNamedQuery('fetchMultipleJoinsEntityResults');
 642         $result     = $query->getResult();
 643
 644
 645         $this->assertEquals(1, count($result));
 646         $this->assertTrue(is_array($result[0]));
 647
 648         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsUser', $result[0][0]);
 649         $this->assertEquals('Fabio B. Silva', $result[0][0]->name);
 650         $this->assertInstanceOf('Doctrine\Tests\Models\CMS\CmsAddress', $result[0][0]->getAddress());
 651         $this->assertTrue($result[0][0]->getAddress()->getUser() == $result[0][0]);
 652         $this->assertEquals('Brazil', $result[0][0]->getAddress()->getCountry());
 653         $this->assertEquals(10827, $result[0][0]->getAddress()->getZipCode());
 654
 655         $this->assertEquals(1, $result[0]['numphones']);
 656
 657     }
 658
 659     /**
 660      * @group DDC-1663
 661      */
 662     public function testNamedNativeQueryInheritance()
 663     {
 664         $contractMetadata   = $this->_em->getClassMetadata('Doctrine\Tests\Models\Company\CompanyContract');
 665         $flexMetadata       = $this->_em->getClassMetadata('Doctrine\Tests\Models\Company\CompanyFlexContract');
 666
 667         $contractQueries    = $contractMetadata->getNamedNativeQueries();
 668         $flexQueries        = $flexMetadata->getNamedNativeQueries();
 669
 670         $contractMappings   = $contractMetadata->getSqlResultSetMappings();
 671         $flexMappings       = $flexMetadata->getSqlResultSetMappings();
 672
 673
 674         // contract queries
 675         $this->assertEquals('all-contracts', $contractQueries['all-contracts']['name']);
 676         $this->assertEquals('Doctrine\Tests\Models\Company\CompanyContract', $contractQueries['all-contracts']['resultClass']);
 677
 678         $this->assertEquals('all', $contractQueries['all']['name']);
 679         $this->assertEquals('Doctrine\Tests\Models\Company\CompanyContract', $contractQueries['all']['resultClass']);
 680
 681
 682         // flex contract queries
 683         $this->assertEquals('all-contracts', $flexQueries['all-contracts']['name']);
 684         $this->assertEquals('Doctrine\Tests\Models\Company\CompanyFlexContract', $flexQueries['all-contracts']['resultClass']);
 685
 686         $this->assertEquals('all-flex', $flexQueries['all-flex']['name']);
 687         $this->assertEquals('Doctrine\Tests\Models\Company\CompanyFlexContract', $flexQueries['all-flex']['resultClass']);
 688
 689         $this->assertEquals('all', $flexQueries['all']['name']);
 690         $this->assertEquals('Doctrine\Tests\Models\Company\CompanyFlexContract', $flexQueries['all']['resultClass']);
 691
 692
 693         // contract result mapping
 694         $this->assertEquals('mapping-all-contracts', $contractMappings['mapping-all-contracts']['name']);
 695         $this->assertEquals('Doctrine\Tests\Models\Company\CompanyContract', $contractMappings['mapping-all-contracts']['entities'][0]['entityClass']);
 696
 697         $this->assertEquals('mapping-all', $contractMappings['mapping-all']['name']);
 698         $this->assertEquals('Doctrine\Tests\Models\Company\CompanyContract', $contractMappings['mapping-all-contracts']['entities'][0]['entityClass']);
 699
 700         // flex contract result mapping
 701         $this->assertEquals('mapping-all-contracts', $flexMappings['mapping-all-contracts']['name']);
 702         $this->assertEquals('Doctrine\Tests\Models\Company\CompanyFlexContract', $flexMappings['mapping-all-contracts']['entities'][0]['entityClass']);
 703
 704         $this->assertEquals('mapping-all', $flexMappings['mapping-all']['name']);
 705         $this->assertEquals('Doctrine\Tests\Models\Company\CompanyFlexContract', $flexMappings['mapping-all']['entities'][0]['entityClass']);
 706
 707         $this->assertEquals('mapping-all-flex', $flexMappings['mapping-all-flex']['name']);
 708         $this->assertEquals('Doctrine\Tests\Models\Company\CompanyFlexContract', $flexMappings['mapping-all-flex']['entities'][0]['entityClass']);
 709
 710     }
 711
 712 }