vendor/doctrine/dbal/tests/Doctrine/Tests/DBAL/Query/QueryBuilderTest.php

   1 <?php
   2
   3 namespace Doctrine\Tests\DBAL\Query;
   4
   5 use Doctrine\DBAL\Query\Expression\ExpressionBuilder,
   6     Doctrine\DBAL\Query\QueryBuilder;
   7
   8 require_once __DIR__ . '/../../TestInit.php';
   9
  10 /**
  11  * @group DBAL-12
  12  */
  13 class QueryBuilderTest extends \Doctrine\Tests\DbalTestCase
  14 {
  15     protected $conn;
  16
  17     public function setUp()
  18     {
  19         $this->conn = $this->getMock('Doctrine\DBAL\Connection', array(), array(), '', false);
  20
  21         $expressionBuilder = new ExpressionBuilder($this->conn);
  22
  23         $this->conn->expects($this->any())
  24                    ->method('getExpressionBuilder')
  25                    ->will($this->returnValue($expressionBuilder));
  26     }
  27
  28     public function testSimpleSelect()
  29     {
  30         $qb = new QueryBuilder($this->conn);
  31
  32         $qb->select('u.id')
  33            ->from('users', 'u');
  34
  35         $this->assertEquals('SELECT u.id FROM users u', (string) $qb);
  36     }
  37
  38     public function testSelectWithSimpleWhere()
  39     {
  40         $qb   = new QueryBuilder($this->conn);
  41         $expr = $qb->expr();
  42
  43         $qb->select('u.id')
  44            ->from('users', 'u')
  45            ->where($expr->andX($expr->eq('u.nickname', '?')));
  46
  47         $this->assertEquals("SELECT u.id FROM users u WHERE u.nickname = ?", (string) $qb);
  48     }
  49
  50     public function testSelectWithLeftJoin()
  51     {
  52         $qb   = new QueryBuilder($this->conn);
  53         $expr = $qb->expr();
  54
  55         $qb->select('u.*', 'p.*')
  56            ->from('users', 'u')
  57            ->leftJoin('u', 'phones', 'p', $expr->eq('p.user_id', 'u.id'));
  58
  59         $this->assertEquals('SELECT u.*, p.* FROM users u LEFT JOIN phones p ON p.user_id = u.id', (string) $qb);
  60     }
  61
  62     public function testSelectWithJoin()
  63     {
  64         $qb   = new QueryBuilder($this->conn);
  65         $expr = $qb->expr();
  66
  67         $qb->select('u.*', 'p.*')
  68            ->from('users', 'u')
  69            ->Join('u', 'phones', 'p', $expr->eq('p.user_id', 'u.id'));
  70
  71         $this->assertEquals('SELECT u.*, p.* FROM users u INNER JOIN phones p ON p.user_id = u.id', (string) $qb);
  72     }
  73
  74     public function testSelectWithInnerJoin()
  75     {
  76         $qb   = new QueryBuilder($this->conn);
  77         $expr = $qb->expr();
  78
  79         $qb->select('u.*', 'p.*')
  80            ->from('users', 'u')
  81            ->innerJoin('u', 'phones', 'p', $expr->eq('p.user_id', 'u.id'));
  82
  83         $this->assertEquals('SELECT u.*, p.* FROM users u INNER JOIN phones p ON p.user_id = u.id', (string) $qb);
  84     }
  85
  86     public function testSelectWithRightJoin()
  87     {
  88         $qb   = new QueryBuilder($this->conn);
  89         $expr = $qb->expr();
  90
  91         $qb->select('u.*', 'p.*')
  92            ->from('users', 'u')
  93            ->rightJoin('u', 'phones', 'p', $expr->eq('p.user_id', 'u.id'));
  94
  95         $this->assertEquals('SELECT u.*, p.* FROM users u RIGHT JOIN phones p ON p.user_id = u.id', (string) $qb);
  96     }
  97
  98     public function testSelectWithAndWhereConditions()
  99     {
 100         $qb   = new QueryBuilder($this->conn);
 101         $expr = $qb->expr();
 102
 103         $qb->select('u.*', 'p.*')
 104            ->from('users', 'u')
 105            ->where('u.username = ?')
 106            ->andWhere('u.name = ?');
 107
 108         $this->assertEquals('SELECT u.*, p.* FROM users u WHERE (u.username = ?) AND (u.name = ?)', (string) $qb);
 109     }
 110
 111     public function testSelectWithOrWhereConditions()
 112     {
 113         $qb   = new QueryBuilder($this->conn);
 114         $expr = $qb->expr();
 115
 116         $qb->select('u.*', 'p.*')
 117            ->from('users', 'u')
 118            ->where('u.username = ?')
 119            ->orWhere('u.name = ?');
 120
 121         $this->assertEquals('SELECT u.*, p.* FROM users u WHERE (u.username = ?) OR (u.name = ?)', (string) $qb);
 122     }
 123
 124     public function testSelectWithOrOrWhereConditions()
 125     {
 126         $qb   = new QueryBuilder($this->conn);
 127         $expr = $qb->expr();
 128
 129         $qb->select('u.*', 'p.*')
 130            ->from('users', 'u')
 131            ->orWhere('u.username = ?')
 132            ->orWhere('u.name = ?');
 133
 134         $this->assertEquals('SELECT u.*, p.* FROM users u WHERE (u.username = ?) OR (u.name = ?)', (string) $qb);
 135     }
 136
 137     public function testSelectWithAndOrWhereConditions()
 138     {
 139         $qb   = new QueryBuilder($this->conn);
 140         $expr = $qb->expr();
 141
 142         $qb->select('u.*', 'p.*')
 143            ->from('users', 'u')
 144            ->where('u.username = ?')
 145            ->andWhere('u.username = ?')
 146            ->orWhere('u.name = ?')
 147            ->andWhere('u.name = ?');
 148
 149         $this->assertEquals('SELECT u.*, p.* FROM users u WHERE (((u.username = ?) AND (u.username = ?)) OR (u.name = ?)) AND (u.name = ?)', (string) $qb);
 150     }
 151
 152     public function testSelectGroupBy()
 153     {
 154         $qb   = new QueryBuilder($this->conn);
 155         $expr = $qb->expr();
 156
 157         $qb->select('u.*', 'p.*')
 158            ->from('users', 'u')
 159            ->groupBy('u.id');
 160
 161         $this->assertEquals('SELECT u.*, p.* FROM users u GROUP BY u.id', (string) $qb);
 162     }
 163
 164     public function testSelectEmptyGroupBy()
 165     {
 166         $qb   = new QueryBuilder($this->conn);
 167         $expr = $qb->expr();
 168
 169         $qb->select('u.*', 'p.*')
 170            ->groupBy(array())
 171            ->from('users', 'u');
 172
 173         $this->assertEquals('SELECT u.*, p.* FROM users u', (string) $qb);
 174     }
 175
 176     public function testSelectEmptyAddGroupBy()
 177     {
 178         $qb   = new QueryBuilder($this->conn);
 179         $expr = $qb->expr();
 180
 181         $qb->select('u.*', 'p.*')
 182            ->addGroupBy(array())
 183            ->from('users', 'u');
 184
 185         $this->assertEquals('SELECT u.*, p.* FROM users u', (string) $qb);
 186     }
 187
 188     public function testSelectAddGroupBy()
 189     {
 190         $qb   = new QueryBuilder($this->conn);
 191         $expr = $qb->expr();
 192
 193         $qb->select('u.*', 'p.*')
 194            ->from('users', 'u')
 195            ->groupBy('u.id')
 196            ->addGroupBy('u.foo');
 197
 198         $this->assertEquals('SELECT u.*, p.* FROM users u GROUP BY u.id, u.foo', (string) $qb);
 199     }
 200
 201     public function testSelectAddGroupBys()
 202     {
 203         $qb   = new QueryBuilder($this->conn);
 204         $expr = $qb->expr();
 205
 206         $qb->select('u.*', 'p.*')
 207            ->from('users', 'u')
 208            ->groupBy('u.id')
 209            ->addGroupBy('u.foo', 'u.bar');
 210
 211         $this->assertEquals('SELECT u.*, p.* FROM users u GROUP BY u.id, u.foo, u.bar', (string) $qb);
 212     }
 213
 214     public function testSelectHaving()
 215     {
 216         $qb   = new QueryBuilder($this->conn);
 217         $expr = $qb->expr();
 218
 219         $qb->select('u.*', 'p.*')
 220            ->from('users', 'u')
 221            ->groupBy('u.id')
 222            ->having('u.name = ?');
 223
 224         $this->assertEquals('SELECT u.*, p.* FROM users u GROUP BY u.id HAVING u.name = ?', (string) $qb);
 225     }
 226
 227     public function testSelectAndHaving()
 228     {
 229         $qb   = new QueryBuilder($this->conn);
 230         $expr = $qb->expr();
 231
 232         $qb->select('u.*', 'p.*')
 233            ->from('users', 'u')
 234            ->groupBy('u.id')
 235            ->andHaving('u.name = ?');
 236
 237         $this->assertEquals('SELECT u.*, p.* FROM users u GROUP BY u.id HAVING u.name = ?', (string) $qb);
 238     }
 239
 240     public function testSelectHavingAndHaving()
 241     {
 242         $qb   = new QueryBuilder($this->conn);
 243         $expr = $qb->expr();
 244
 245         $qb->select('u.*', 'p.*')
 246            ->from('users', 'u')
 247            ->groupBy('u.id')
 248            ->having('u.name = ?')
 249            ->andHaving('u.username = ?');
 250
 251         $this->assertEquals('SELECT u.*, p.* FROM users u GROUP BY u.id HAVING (u.name = ?) AND (u.username = ?)', (string) $qb);
 252     }
 253
 254     public function testSelectHavingOrHaving()
 255     {
 256         $qb   = new QueryBuilder($this->conn);
 257         $expr = $qb->expr();
 258
 259         $qb->select('u.*', 'p.*')
 260            ->from('users', 'u')
 261            ->groupBy('u.id')
 262            ->having('u.name = ?')
 263            ->orHaving('u.username = ?');
 264
 265         $this->assertEquals('SELECT u.*, p.* FROM users u GROUP BY u.id HAVING (u.name = ?) OR (u.username = ?)', (string) $qb);
 266     }
 267
 268     public function testSelectOrHavingOrHaving()
 269     {
 270         $qb   = new QueryBuilder($this->conn);
 271         $expr = $qb->expr();
 272
 273         $qb->select('u.*', 'p.*')
 274            ->from('users', 'u')
 275            ->groupBy('u.id')
 276            ->orHaving('u.name = ?')
 277            ->orHaving('u.username = ?');
 278
 279         $this->assertEquals('SELECT u.*, p.* FROM users u GROUP BY u.id HAVING (u.name = ?) OR (u.username = ?)', (string) $qb);
 280     }
 281
 282     public function testSelectHavingAndOrHaving()
 283     {
 284         $qb   = new QueryBuilder($this->conn);
 285         $expr = $qb->expr();
 286
 287         $qb->select('u.*', 'p.*')
 288            ->from('users', 'u')
 289            ->groupBy('u.id')
 290            ->having('u.name = ?')
 291            ->orHaving('u.username = ?')
 292            ->andHaving('u.username = ?');
 293
 294         $this->assertEquals('SELECT u.*, p.* FROM users u GROUP BY u.id HAVING ((u.name = ?) OR (u.username = ?)) AND (u.username = ?)', (string) $qb);
 295     }
 296
 297     public function testSelectOrderBy()
 298     {
 299         $qb   = new QueryBuilder($this->conn);
 300         $expr = $qb->expr();
 301
 302         $qb->select('u.*', 'p.*')
 303            ->from('users', 'u')
 304            ->orderBy('u.name');
 305
 306         $this->assertEquals('SELECT u.*, p.* FROM users u ORDER BY u.name ASC', (string) $qb);
 307     }
 308
 309     public function testSelectAddOrderBy()
 310     {
 311         $qb   = new QueryBuilder($this->conn);
 312         $expr = $qb->expr();
 313
 314         $qb->select('u.*', 'p.*')
 315            ->from('users', 'u')
 316            ->orderBy('u.name')
 317            ->addOrderBy('u.username', 'DESC');
 318
 319         $this->assertEquals('SELECT u.*, p.* FROM users u ORDER BY u.name ASC, u.username DESC', (string) $qb);
 320     }
 321
 322     public function testSelectAddAddOrderBy()
 323     {
 324         $qb   = new QueryBuilder($this->conn);
 325         $expr = $qb->expr();
 326
 327         $qb->select('u.*', 'p.*')
 328            ->from('users', 'u')
 329            ->addOrderBy('u.name')
 330            ->addOrderBy('u.username', 'DESC');
 331
 332         $this->assertEquals('SELECT u.*, p.* FROM users u ORDER BY u.name ASC, u.username DESC', (string) $qb);
 333     }
 334
 335     public function testEmptySelect()
 336     {
 337         $qb   = new QueryBuilder($this->conn);
 338         $qb2 = $qb->select();
 339
 340         $this->assertSame($qb, $qb2);
 341         $this->assertEquals(QueryBuilder::SELECT, $qb->getType());
 342     }
 343
 344     public function testSelectAddSelect()
 345     {
 346         $qb   = new QueryBuilder($this->conn);
 347         $expr = $qb->expr();
 348
 349         $qb->select('u.*')
 350            ->addSelect('p.*')
 351            ->from('users', 'u');
 352
 353         $this->assertEquals('SELECT u.*, p.* FROM users u', (string) $qb);
 354     }
 355
 356     public function testEmptyAddSelect()
 357     {
 358         $qb   = new QueryBuilder($this->conn);
 359         $qb2 = $qb->addSelect();
 360
 361         $this->assertSame($qb, $qb2);
 362         $this->assertEquals(QueryBuilder::SELECT, $qb->getType());
 363     }
 364
 365     public function testSelectMultipleFrom()
 366     {
 367         $qb   = new QueryBuilder($this->conn);
 368         $expr = $qb->expr();
 369
 370         $qb->select('u.*')
 371            ->addSelect('p.*')
 372            ->from('users', 'u')
 373            ->from('phonenumbers', 'p');
 374
 375         $this->assertEquals('SELECT u.*, p.* FROM users u, phonenumbers p', (string) $qb);
 376     }
 377
 378     public function testUpdate()
 379     {
 380         $qb   = new QueryBuilder($this->conn);
 381         $qb->update('users', 'u')
 382            ->set('u.foo', '?')
 383            ->set('u.bar', '?');
 384
 385         $this->assertEquals(QueryBuilder::UPDATE, $qb->getType());
 386         $this->assertEquals('UPDATE users u SET u.foo = ?, u.bar = ?', (string) $qb);
 387     }
 388
 389     public function testUpdateWithoutAlias()
 390     {
 391         $qb   = new QueryBuilder($this->conn);
 392         $qb->update('users')
 393            ->set('foo', '?')
 394            ->set('bar', '?');
 395
 396         $this->assertEquals('UPDATE users SET foo = ?, bar = ?', (string) $qb);
 397     }
 398
 399     public function testUpdateWhere()
 400     {
 401         $qb   = new QueryBuilder($this->conn);
 402         $qb->update('users', 'u')
 403            ->set('u.foo', '?')
 404            ->where('u.foo = ?');
 405
 406         $this->assertEquals('UPDATE users u SET u.foo = ? WHERE u.foo = ?', (string) $qb);
 407     }
 408
 409     public function testEmptyUpdate()
 410     {
 411         $qb   = new QueryBuilder($this->conn);
 412         $qb2 = $qb->update();
 413
 414         $this->assertEquals(QueryBuilder::UPDATE, $qb->getType());
 415         $this->assertSame($qb2, $qb);
 416     }
 417
 418     public function testDelete()
 419     {
 420         $qb   = new QueryBuilder($this->conn);
 421         $qb->delete('users', 'u');
 422
 423         $this->assertEquals(QueryBuilder::DELETE, $qb->getType());
 424         $this->assertEquals('DELETE FROM users u', (string) $qb);
 425     }
 426
 427     public function testDeleteWithoutAlias()
 428     {
 429         $qb   = new QueryBuilder($this->conn);
 430         $qb->delete('users');
 431
 432         $this->assertEquals(QueryBuilder::DELETE, $qb->getType());
 433         $this->assertEquals('DELETE FROM users', (string) $qb);
 434     }
 435
 436     public function testDeleteWhere()
 437     {
 438         $qb   = new QueryBuilder($this->conn);
 439         $qb->delete('users', 'u')
 440            ->where('u.foo = ?');
 441
 442         $this->assertEquals('DELETE FROM users u WHERE u.foo = ?', (string) $qb);
 443     }
 444
 445     public function testEmptyDelete()
 446     {
 447         $qb   = new QueryBuilder($this->conn);
 448         $qb2 = $qb->delete();
 449
 450         $this->assertEquals(QueryBuilder::DELETE, $qb->getType());
 451         $this->assertSame($qb2, $qb);
 452     }
 453
 454     public function testGetConnection()
 455     {
 456         $qb   = new QueryBuilder($this->conn);
 457         $this->assertSame($this->conn, $qb->getConnection());
 458     }
 459
 460     public function testGetState()
 461     {
 462         $qb   = new QueryBuilder($this->conn);
 463
 464         $this->assertEquals(QueryBuilder::STATE_CLEAN, $qb->getState());
 465
 466         $qb->select('u.*')->from('users', 'u');
 467
 468         $this->assertEquals(QueryBuilder::STATE_DIRTY, $qb->getState());
 469
 470         $sql1 = $qb->getSQL();
 471
 472         $this->assertEquals(QueryBuilder::STATE_CLEAN, $qb->getState());
 473         $this->assertEquals($sql1, $qb->getSQL());
 474     }
 475
 476     public function testSetMaxResults()
 477     {
 478         $qb   = new QueryBuilder($this->conn);
 479         $qb->setMaxResults(10);
 480
 481         $this->assertEquals(QueryBuilder::STATE_DIRTY, $qb->getState());
 482         $this->assertEQuals(10, $qb->getMaxResults());
 483     }
 484
 485     public function testSetFirstResult()
 486     {
 487         $qb   = new QueryBuilder($this->conn);
 488         $qb->setFirstResult(10);
 489
 490         $this->assertEquals(QueryBuilder::STATE_DIRTY, $qb->getState());
 491         $this->assertEQuals(10, $qb->getFirstResult());
 492     }
 493
 494     public function testResetQueryPart()
 495     {
 496         $qb   = new QueryBuilder($this->conn);
 497
 498         $qb->select('u.*')->from('users', 'u')->where('u.name = ?');
 499
 500         $this->assertEquals('SELECT u.* FROM users u WHERE u.name = ?', (string)$qb);
 501         $qb->resetQueryPart('where');
 502         $this->assertEquals('SELECT u.* FROM users u', (string)$qb);
 503     }
 504
 505     public function testResetQueryParts()
 506     {
 507         $qb   = new QueryBuilder($this->conn);
 508
 509         $qb->select('u.*')->from('users', 'u')->where('u.name = ?')->orderBy('u.name');
 510
 511         $this->assertEquals('SELECT u.* FROM users u WHERE u.name = ? ORDER BY u.name ASC', (string)$qb);
 512         $qb->resetQueryParts(array('where', 'orderBy'));
 513         $this->assertEquals('SELECT u.* FROM users u', (string)$qb);
 514     }
 515
 516     public function testCreateNamedParameter()
 517     {
 518         $qb   = new QueryBuilder($this->conn);
 519
 520         $qb->select('u.*')->from('users', 'u')->where(
 521             $qb->expr()->eq('u.name', $qb->createNamedParameter(10, \PDO::PARAM_INT))
 522         );
 523
 524         $this->assertEquals('SELECT u.* FROM users u WHERE u.name = :dcValue1', (string)$qb);
 525         $this->assertEquals(10, $qb->getParameter('dcValue1'));
 526     }
 527
 528     public function testCreateNamedParameterCustomPlaceholder()
 529     {
 530         $qb   = new QueryBuilder($this->conn);
 531
 532         $qb->select('u.*')->from('users', 'u')->where(
 533             $qb->expr()->eq('u.name', $qb->createNamedParameter(10, \PDO::PARAM_INT, ':test'))
 534         );
 535
 536         $this->assertEquals('SELECT u.* FROM users u WHERE u.name = :test', (string)$qb);
 537         $this->assertEquals(10, $qb->getParameter('test'));
 538     }
 539
 540     public function testCreatePositionalParameter()
 541     {
 542         $qb   = new QueryBuilder($this->conn);
 543
 544         $qb->select('u.*')->from('users', 'u')->where(
 545             $qb->expr()->eq('u.name', $qb->createPositionalParameter(10, \PDO::PARAM_INT))
 546         );
 547
 548         $this->assertEquals('SELECT u.* FROM users u WHERE u.name = ?', (string)$qb);
 549         $this->assertEquals(10, $qb->getParameter(1));
 550     }
 551
 552     /**
 553      * @group DBAL-172
 554      */
 555     public function testReferenceJoinFromJoin()
 556     {
 557         $qb = new QueryBuilder($this->conn);
 558
 559         $qb->select("l.id", "mdsh.xcode", "mdso.xcode")
 560                 ->from("location_tree", "l")
 561                 ->join("l", "location_tree_pos", "p", "l.id = p.tree_id")
 562                 ->rightJoin("l", "hotel", "h", "h.location_id = l.id")
 563                 ->leftJoin("l", "offer_location", "ol", "l.id=ol.location_id")
 564                 ->leftJoin("ol", "mds_offer", "mdso", "ol.offer_id = mdso.offer_id")
 565                 ->leftJoin("h", "mds_hotel", "mdsh", "h.id = mdsh.hotel_id")
 566                 ->where("p.parent_id IN (:ids)")
 567                 ->andWhere("(mdso.xcode IS NOT NULL OR mdsh.xcode IS NOT NULL)");
 568
 569         $this->setExpectedException('Doctrine\DBAL\Query\QueryException', "The given alias 'ol' is not part of any FROM clause table. The currently registered FROM-clause aliases are: l");
 570         $this->assertEquals('', $qb->getSQL());
 571     }
 572 }