Select.php 23.4 KB
Newer Older
1 2
<?php

3
namespace Drupal\Core\Database\Query;
4

5 6
use Drupal\Core\Database\Database;
use Drupal\Core\Database\Connection;
7 8 9

/**
 * Query builder for SELECT statements.
10 11
 *
 * @ingroup database
12 13 14
 */
class Select extends Query implements SelectInterface {

15 16
  use QueryConditionTrait;

17 18 19 20 21
  /**
   * The fields to SELECT.
   *
   * @var array
   */
22
  protected $fields = [];
23 24 25 26 27 28

  /**
   * The expressions to SELECT as virtual fields.
   *
   * @var array
   */
29
  protected $expressions = [];
30 31 32 33 34 35 36 37 38 39 40

  /**
   * The tables against which to JOIN.
   *
   * This property is a nested array. Each entry is an array representing
   * a single table against which to join. The structure of each entry is:
   *
   * array(
   *   'type' => $join_type (one of INNER, LEFT OUTER, RIGHT OUTER),
   *   'table' => $table,
   *   'alias' => $alias_of_the_table,
41
   *   'condition' => $join_condition (string or Condition object),
42 43 44 45 46
   *   'arguments' => $array_of_arguments_for_placeholders_in_the condition.
   *   'all_fields' => TRUE to SELECT $alias.*, FALSE or NULL otherwise.
   * )
   *
   * If $table is a string, it is taken as the name of a table. If it is
47
   * a Select query object, it is taken as a subquery.
48
   *
49 50 51 52
   * If $join_condition is a Condition object, any arguments should be
   * incorporated into the object; a separate array of arguments does not
   * need to be provided.
   *
53 54
   * @var array
   */
55
  protected $tables = [];
56 57 58 59 60 61 62 63 64

  /**
   * The fields by which to order this query.
   *
   * This is an associative array. The keys are the fields to order, and the value
   * is the direction to order, either ASC or DESC.
   *
   * @var array
   */
65
  protected $order = [];
66 67 68 69 70 71

  /**
   * The fields by which to group.
   *
   * @var array
   */
72
  protected $group = [];
73 74 75 76

  /**
   * The conditional object for the HAVING clause.
   *
77
   * @var \Drupal\Core\Database\Query\Condition
78 79 80 81 82 83
   */
  protected $having;

  /**
   * Whether or not this query should be DISTINCT
   *
84
   * @var bool
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
   */
  protected $distinct = FALSE;

  /**
   * The range limiters for this query.
   *
   * @var array
   */
  protected $range;

  /**
   * An array whose elements specify a query to UNION, and the UNION type. The
   * 'type' key may be '', 'ALL', or 'DISTINCT' to represent a 'UNION',
   * 'UNION ALL', or 'UNION DISTINCT' statement, respectively.
   *
   * All entries in this array will be applied from front to back, with the
   * first query to union on the right of the original query, the second union
   * to the right of the first, etc.
   *
   * @var array
   */
106
  protected $union = [];
107 108 109

  /**
   * Indicates if preExecute() has already been called.
110
   * @var bool
111 112 113 114 115
   */
  protected $prepared = FALSE;

  /**
   * The FOR UPDATE status
116 117
   *
   * @var bool
118 119 120
   */
  protected $forUpdate = FALSE;

121 122 123
  /**
   * Constructs a Select object.
   *
124 125
   * @param \Drupal\Core\Database\Connection $connection
   *   Database connection object.
126 127 128 129 130 131 132
   * @param string $table
   *   The name of the table that is being queried.
   * @param string $alias
   *   The alias for the table.
   * @param array $options
   *   Array of query options.
   */
133
  public function __construct(Connection $connection, $table, $alias = NULL, $options = []) {
134 135
    $options['return'] = Database::RETURN_STATEMENT;
    parent::__construct($connection, $options);
136
    $conjunction = isset($options['conjunction']) ? $options['conjunction'] : 'AND';
137 138
    $this->condition = $this->connection->condition($conjunction);
    $this->having = $this->connection->condition($conjunction);
139 140 141
    $this->addJoin(NULL, $table, $alias);
  }

142 143 144
  /**
   * {@inheritdoc}
   */
145 146 147 148 149
  public function addTag($tag) {
    $this->alterTags[$tag] = 1;
    return $this;
  }

150 151 152
  /**
   * {@inheritdoc}
   */
153 154 155 156
  public function hasTag($tag) {
    return isset($this->alterTags[$tag]);
  }

157 158 159
  /**
   * {@inheritdoc}
   */
160
  public function hasAllTags() {
161
    return !(boolean) array_diff(func_get_args(), array_keys($this->alterTags));
162 163
  }

164 165 166
  /**
   * {@inheritdoc}
   */
167
  public function hasAnyTag() {
168
    return (boolean) array_intersect(func_get_args(), array_keys($this->alterTags));
169 170
  }

171 172 173
  /**
   * {@inheritdoc}
   */
174 175 176 177 178
  public function addMetaData($key, $object) {
    $this->alterMetaData[$key] = $object;
    return $this;
  }

179 180 181
  /**
   * {@inheritdoc}
   */
182 183 184 185
  public function getMetaData($key) {
    return isset($this->alterMetaData[$key]) ? $this->alterMetaData[$key] : NULL;
  }

186 187 188
  /**
   * {@inheritdoc}
   */
189 190 191 192 193
  public function arguments() {
    if (!$this->compiled()) {
      return NULL;
    }

194
    $args = $this->condition->arguments() + $this->having->arguments();
195 196 197 198 199 200 201 202 203

    foreach ($this->tables as $table) {
      if ($table['arguments']) {
        $args += $table['arguments'];
      }
      // If this table is a subquery, grab its arguments recursively.
      if ($table['table'] instanceof SelectInterface) {
        $args += $table['table']->arguments();
      }
204 205 206 207
      // If the join condition is an object, grab its arguments recursively.
      if (!empty($table['condition']) && $table['condition'] instanceof ConditionInterface) {
        $args += $table['condition']->arguments();
      }
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
    }

    foreach ($this->expressions as $expression) {
      if ($expression['arguments']) {
        $args += $expression['arguments'];
      }
    }

    // If there are any dependent queries to UNION,
    // incorporate their arguments recursively.
    foreach ($this->union as $union) {
      $args += $union['query']->arguments();
    }

    return $args;
  }

225 226 227
  /**
   * {@inheritdoc}
   */
228
  public function compile(Connection $connection, PlaceholderInterface $queryPlaceholder) {
229
    $this->condition->compile($connection, $queryPlaceholder);
230 231 232 233 234 235 236
    $this->having->compile($connection, $queryPlaceholder);

    foreach ($this->tables as $table) {
      // If this table is a subquery, compile it recursively.
      if ($table['table'] instanceof SelectInterface) {
        $table['table']->compile($connection, $queryPlaceholder);
      }
237 238 239 240
      // Make sure join conditions are also compiled.
      if (!empty($table['condition']) && $table['condition'] instanceof ConditionInterface) {
        $table['condition']->compile($connection, $queryPlaceholder);
      }
241 242 243 244 245 246 247 248
    }

    // If there are any dependent queries to UNION, compile it recursively.
    foreach ($this->union as $union) {
      $union['query']->compile($connection, $queryPlaceholder);
    }
  }

249 250 251
  /**
   * {@inheritdoc}
   */
252
  public function compiled() {
253
    if (!$this->condition->compiled() || !$this->having->compiled()) {
254 255 256 257 258 259 260 261 262 263
      return FALSE;
    }

    foreach ($this->tables as $table) {
      // If this table is a subquery, check its status recursively.
      if ($table['table'] instanceof SelectInterface) {
        if (!$table['table']->compiled()) {
          return FALSE;
        }
      }
264 265 266 267 268
      if (!empty($table['condition']) && $table['condition'] instanceof ConditionInterface) {
        if (!$table['condition']->compiled()) {
          return FALSE;
        }
      }
269 270 271 272 273 274 275 276 277 278 279
    }

    foreach ($this->union as $union) {
      if (!$union['query']->compiled()) {
        return FALSE;
      }
    }

    return TRUE;
  }

280 281 282
  /**
   * {@inheritdoc}
   */
283 284 285 286 287
  public function havingCondition($field, $value = NULL, $operator = NULL) {
    $this->having->condition($field, $value, $operator);
    return $this;
  }

288
  /**
289
   * {@inheritdoc}
290
   */
291 292 293 294
  public function &havingConditions() {
    return $this->having->conditions();
  }

295
  /**
296
   * {@inheritdoc}
297
   */
298 299 300 301
  public function havingArguments() {
    return $this->having->arguments();
  }

302
  /**
303
   * {@inheritdoc}
304
   */
305
  public function having($snippet, $args = []) {
306 307 308 309
    $this->having->where($snippet, $args);
    return $this;
  }

310
  /**
311
   * {@inheritdoc}
312
   */
313
  public function havingCompile(Connection $connection) {
314
    $this->having->compile($connection, $this);
315 316
  }

317 318 319
  /**
   * {@inheritdoc}
   */
320 321 322 323 324 325 326 327
  public function extend($extender_name) {
    $override_class = $extender_name . '_' . $this->connection->driver();
    if (class_exists($override_class)) {
      $extender_name = $override_class;
    }
    return new $extender_name($this, $this->connection);
  }

328
  /**
329
   * {@inheritdoc}
330
   */
331 332 333 334 335
  public function havingIsNull($field) {
    $this->having->isNull($field);
    return $this;
  }

336
  /**
337
   * {@inheritdoc}
338
   */
339 340 341 342 343
  public function havingIsNotNull($field) {
    $this->having->isNotNull($field);
    return $this;
  }

344
  /**
345
   * {@inheritdoc}
346
   */
347 348 349 350 351
  public function havingExists(SelectInterface $select) {
    $this->having->exists($select);
    return $this;
  }

352
  /**
353
   * {@inheritdoc}
354
   */
355 356 357 358 359
  public function havingNotExists(SelectInterface $select) {
    $this->having->notExists($select);
    return $this;
  }

360 361 362
  /**
   * {@inheritdoc}
   */
363 364 365 366 367 368 369
  public function forUpdate($set = TRUE) {
    if (isset($set)) {
      $this->forUpdate = $set;
    }
    return $this;
  }

370 371 372
  /**
   * {@inheritdoc}
   */
373 374 375 376
  public function &getFields() {
    return $this->fields;
  }

377 378 379
  /**
   * {@inheritdoc}
   */
380 381 382 383
  public function &getExpressions() {
    return $this->expressions;
  }

384 385 386
  /**
   * {@inheritdoc}
   */
387 388 389 390
  public function &getOrderBy() {
    return $this->order;
  }

391 392 393
  /**
   * {@inheritdoc}
   */
394 395 396 397
  public function &getGroupBy() {
    return $this->group;
  }

398 399 400
  /**
   * {@inheritdoc}
   */
401 402 403 404
  public function &getTables() {
    return $this->tables;
  }

405 406 407
  /**
   * {@inheritdoc}
   */
408 409 410 411
  public function &getUnion() {
    return $this->union;
  }

412 413 414 415 416 417 418
  /**
   * {@inheritdoc}
   */
  public function escapeLike($string) {
    return $this->connection->escapeLike($string);
  }

419 420 421 422 423 424 425
  /**
   * {@inheritdoc}
   */
  public function escapeField($string) {
    return $this->connection->escapeField($string);
  }

426 427 428
  /**
   * {@inheritdoc}
   */
429 430 431 432 433 434 435 436 437
  public function getArguments(PlaceholderInterface $queryPlaceholder = NULL) {
    if (!isset($queryPlaceholder)) {
      $queryPlaceholder = $this;
    }
    $this->compile($this->connection, $queryPlaceholder);
    return $this->arguments();
  }

  /**
438
   * {@inheritdoc}
439 440 441 442 443 444
   */
  public function isPrepared() {
    return $this->prepared;
  }

  /**
445
   * {@inheritdoc}
446 447 448 449 450 451 452 453 454 455 456 457 458 459
   */
  public function preExecute(SelectInterface $query = NULL) {
    // If no query object is passed in, use $this.
    if (!isset($query)) {
      $query = $this;
    }

    // Only execute this once.
    if ($query->isPrepared()) {
      return TRUE;
    }

    // Modules may alter all queries or only those having a particular tag.
    if (isset($this->alterTags)) {
460 461 462 463 464 465 466 467 468 469 470 471
      // Many contrib modules as well as Entity Reference in core assume that
      // query tags used for access-checking purposes follow the pattern
      // $entity_type . '_access'. But this is not the case for taxonomy terms,
      // since the core Taxonomy module used to add term_access instead of
      // taxonomy_term_access to its queries. Provide backwards compatibility
      // by adding both tags here instead of attempting to fix all contrib
      // modules in a coordinated effort.
      // TODO:
      // - Extract this mechanism into a hook as part of a public (non-security)
      //   issue.
      // - Emit E_USER_DEPRECATED if term_access is used.
      //   https://www.drupal.org/node/2575081
472
      $term_access_tags = ['term_access' => 1, 'taxonomy_term_access' => 1];
473 474 475
      if (array_intersect_key($this->alterTags, $term_access_tags)) {
        $this->alterTags += $term_access_tags;
      }
476
      $hooks = ['query'];
477 478 479
      foreach ($this->alterTags as $tag => $value) {
        $hooks[] = 'query_' . $tag;
      }
480
      \Drupal::moduleHandler()->alter($hooks, $query);
481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498
    }

    $this->prepared = TRUE;

    // Now also prepare any sub-queries.
    foreach ($this->tables as $table) {
      if ($table['table'] instanceof SelectInterface) {
        $table['table']->preExecute();
      }
    }

    foreach ($this->union as $union) {
      $union['query']->preExecute();
    }

    return $this->prepared;
  }

499 500 501
  /**
   * {@inheritdoc}
   */
502 503 504 505 506 507 508 509 510 511 512
  public function execute() {
    // If validation fails, simply return NULL.
    // Note that validation routines in preExecute() may throw exceptions instead.
    if (!$this->preExecute()) {
      return NULL;
    }

    $args = $this->getArguments();
    return $this->connection->query((string) $this, $args, $this->queryOptions);
  }

513 514 515
  /**
   * {@inheritdoc}
   */
516 517 518 519 520
  public function distinct($distinct = TRUE) {
    $this->distinct = $distinct;
    return $this;
  }

521 522 523
  /**
   * {@inheritdoc}
   */
524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542
  public function addField($table_alias, $field, $alias = NULL) {
    // If no alias is specified, first try the field name itself.
    if (empty($alias)) {
      $alias = $field;
    }

    // If that's already in use, try the table name and field name.
    if (!empty($this->fields[$alias])) {
      $alias = $table_alias . '_' . $field;
    }

    // If that is already used, just add a counter until we find an unused alias.
    $alias_candidate = $alias;
    $count = 2;
    while (!empty($this->fields[$alias_candidate])) {
      $alias_candidate = $alias . '_' . $count++;
    }
    $alias = $alias_candidate;

543
    $this->fields[$alias] = [
544 545 546
      'field' => $field,
      'table' => $table_alias,
      'alias' => $alias,
547
    ];
548 549 550 551

    return $alias;
  }

552 553 554
  /**
   * {@inheritdoc}
   */
555
  public function fields($table_alias, array $fields = []) {
556 557 558 559 560 561 562 563 564 565 566 567 568 569
    if ($fields) {
      foreach ($fields as $field) {
        // We don't care what alias was assigned.
        $this->addField($table_alias, $field);
      }
    }
    else {
      // We want all fields from this table.
      $this->tables[$table_alias]['all_fields'] = TRUE;
    }

    return $this;
  }

570 571 572
  /**
   * {@inheritdoc}
   */
573
  public function addExpression($expression, $alias = NULL, $arguments = []) {
574 575 576 577 578 579 580 581 582 583 584
    if (empty($alias)) {
      $alias = 'expression';
    }

    $alias_candidate = $alias;
    $count = 2;
    while (!empty($this->expressions[$alias_candidate])) {
      $alias_candidate = $alias . '_' . $count++;
    }
    $alias = $alias_candidate;

585
    $this->expressions[$alias] = [
586 587 588
      'expression' => $expression,
      'alias' => $alias,
      'arguments' => $arguments,
589
    ];
590 591 592 593

    return $alias;
  }

594 595 596
  /**
   * {@inheritdoc}
   */
597
  public function join($table, $alias = NULL, $condition = NULL, $arguments = []) {
598 599 600
    return $this->addJoin('INNER', $table, $alias, $condition, $arguments);
  }

601 602 603
  /**
   * {@inheritdoc}
   */
604
  public function innerJoin($table, $alias = NULL, $condition = NULL, $arguments = []) {
605 606 607
    return $this->addJoin('INNER', $table, $alias, $condition, $arguments);
  }

608 609 610
  /**
   * {@inheritdoc}
   */
611
  public function leftJoin($table, $alias = NULL, $condition = NULL, $arguments = []) {
612 613 614
    return $this->addJoin('LEFT OUTER', $table, $alias, $condition, $arguments);
  }

615 616 617
  /**
   * {@inheritdoc}
   */
618
  public function addJoin($type, $table, $alias = NULL, $condition = NULL, $arguments = []) {
619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638
    if (empty($alias)) {
      if ($table instanceof SelectInterface) {
        $alias = 'subquery';
      }
      else {
        $alias = $table;
      }
    }

    $alias_candidate = $alias;
    $count = 2;
    while (!empty($this->tables[$alias_candidate])) {
      $alias_candidate = $alias . '_' . $count++;
    }
    $alias = $alias_candidate;

    if (is_string($condition)) {
      $condition = str_replace('%alias', $alias, $condition);
    }

639
    $this->tables[$alias] = [
640 641 642 643 644
      'join type' => $type,
      'table' => $table,
      'alias' => $alias,
      'condition' => $condition,
      'arguments' => $arguments,
645
    ];
646 647 648 649

    return $alias;
  }

650 651 652
  /**
   * {@inheritdoc}
   */
653
  public function orderBy($field, $direction = 'ASC') {
654 655
    // Only allow ASC and DESC, default to ASC.
    $direction = strtoupper($direction) == 'DESC' ? 'DESC' : 'ASC';
656 657 658 659
    $this->order[$field] = $direction;
    return $this;
  }

660 661 662
  /**
   * {@inheritdoc}
   */
663 664 665 666 667 668
  public function orderRandom() {
    $alias = $this->addExpression('RAND()', 'random_field');
    $this->orderBy($alias);
    return $this;
  }

669 670 671
  /**
   * {@inheritdoc}
   */
672
  public function range($start = NULL, $length = NULL) {
673
    $this->range = $start !== NULL ? ['start' => $start, 'length' => $length] : [];
674 675 676
    return $this;
  }

677 678 679
  /**
   * {@inheritdoc}
   */
680 681 682 683 684 685 686 687 688 689 690 691 692 693
  public function union(SelectInterface $query, $type = '') {
    // Handle UNION aliasing.
    switch ($type) {
      // Fold UNION DISTINCT to UNION for better cross database support.
      case 'DISTINCT':
      case '':
        $type = 'UNION';
        break;

      case 'ALL':
        $type = 'UNION ALL';
      default:
    }

694
    $this->union[] = [
695 696
      'type' => $type,
      'query' => $query,
697
    ];
698 699 700 701

    return $this;
  }

702 703 704
  /**
   * {@inheritdoc}
   */
705 706 707 708 709
  public function groupBy($field) {
    $this->group[$field] = $field;
    return $this;
  }

710
  /**
711
   * {@inheritdoc}
712
   */
713
  public function countQuery() {
714 715
    $count = $this->prepareCountQuery();

716
    $query = $this->connection->select($count, NULL, $this->queryOptions);
717 718 719 720 721 722 723 724
    $query->addExpression('COUNT(*)');

    return $query;
  }

  /**
   * Prepares a count query from the current query object.
   *
725
   * @return \Drupal\Core\Database\Query\Select
726 727 728
   *   A new query object ready to have COUNT(*) performed on it.
   */
  protected function prepareCountQuery() {
729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755
    // Create our new query object that we will mutate into a count query.
    $count = clone($this);

    $group_by = $count->getGroupBy();
    $having = $count->havingConditions();

    if (!$count->distinct && !isset($having[0])) {
      // When not executing a distinct query, we can zero-out existing fields
      // and expressions that are not used by a GROUP BY or HAVING. Fields
      // listed in a GROUP BY or HAVING clause need to be present in the
      // query.
      $fields =& $count->getFields();
      foreach (array_keys($fields) as $field) {
        if (empty($group_by[$field])) {
          unset($fields[$field]);
        }
      }

      $expressions =& $count->getExpressions();
      foreach (array_keys($expressions) as $field) {
        if (empty($group_by[$field])) {
          unset($expressions[$field]);
        }
      }

      // Also remove 'all_fields' statements, which are expanded into tablename.*
      // when the query is executed.
756
      foreach ($count->tables as &$table) {
757 758 759 760 761 762 763 764 765 766 767
        unset($table['all_fields']);
      }
    }

    // If we've just removed all fields from the query, make sure there is at
    // least one so that the query still runs.
    $count->addExpression('1');

    // Ordering a count query is a waste of cycles, and breaks on some
    // databases anyway.
    $orders = &$count->getOrderBy();
768
    $orders = [];
769 770 771 772 773 774 775

    if ($count->distinct && !empty($group_by)) {
      // If the query is distinct and contains a GROUP BY, we need to remove the
      // distinct because SQL99 does not support counting on distinct multiple fields.
      $count->distinct = FALSE;
    }

776 777 778 779 780
    // If there are any dependent queries to UNION, prepare each of those for
    // the count query also.
    foreach ($count->union as &$union) {
      $union['query'] = $union['query']->prepareCountQuery();
    }
781

782
    return $count;
783 784
  }

785 786 787
  /**
   * {@inheritdoc}
   */
788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806
  public function __toString() {
    // For convenience, we compile the query ourselves if the caller forgot
    // to do it. This allows constructs like "(string) $query" to work. When
    // the query will be executed, it will be recompiled using the proper
    // placeholder generator anyway.
    if (!$this->compiled()) {
      $this->compile($this->connection, $this);
    }

    // Create a sanitized comment string to prepend to the query.
    $comments = $this->connection->makeComment($this->comments);

    // SELECT
    $query = $comments . 'SELECT ';
    if ($this->distinct) {
      $query .= 'DISTINCT ';
    }

    // FIELDS and EXPRESSIONS
807
    $fields = [];
808 809 810 811 812
    foreach ($this->tables as $alias => $table) {
      if (!empty($table['all_fields'])) {
        $fields[] = $this->connection->escapeTable($alias) . '.*';
      }
    }
813
    foreach ($this->fields as $field) {
814 815
      // Always use the AS keyword for field aliases, as some
      // databases require it (e.g., PostgreSQL).
816 817
      $table = isset($field['table']) ? $field['table'] . '.' : '';
      $fields[] = $this->connection->escapeField($table . $field['field']) . ' AS ' . $this->connection->escapeAlias($field['alias']);
818
    }
819
    foreach ($this->expressions as $expression) {
820 821 822 823 824
      $fields[] = $expression['expression'] . ' AS ' . $this->connection->escapeAlias($expression['alias']);
    }
    $query .= implode(', ', $fields);

    // FROM - We presume all queries have a FROM, as any query that doesn't won't need the query builder anyway.
825
    $query .= "\nFROM";
826
    foreach ($this->tables as $table) {
827 828 829 830 831 832 833 834 835 836 837 838 839
      $query .= "\n";
      if (isset($table['join type'])) {
        $query .= $table['join type'] . ' JOIN ';
      }

      // If the table is a subquery, compile it and integrate it into this query.
      if ($table['table'] instanceof SelectInterface) {
        // Run preparation steps on this sub-query before converting to string.
        $subquery = $table['table'];
        $subquery->preExecute();
        $table_string = '(' . (string) $subquery . ')';
      }
      else {
840 841 842 843 844
        $table_string = $this->connection->escapeTable($table['table']);
        // Do not attempt prefixing cross database / schema queries.
        if (strpos($table_string, '.') === FALSE) {
          $table_string = '{' . $table_string . '}';
        }
845 846 847 848
      }

      // Don't use the AS keyword for table aliases, as some
      // databases don't support it (e.g., Oracle).
849
      $query .= $table_string . ' ' . $this->connection->escapeAlias($table['alias']);
850 851

      if (!empty($table['condition'])) {
852
        $query .= ' ON ' . (string) $table['condition'];
853 854 855 856
      }
    }

    // WHERE
857
    if (count($this->condition)) {
858
      // There is an implicit string cast on $this->condition.
859
      $query .= "\nWHERE " . $this->condition;
860 861 862 863 864 865 866 867 868 869 870 871 872
    }

    // GROUP BY
    if ($this->group) {
      $query .= "\nGROUP BY " . implode(', ', $this->group);
    }

    // HAVING
    if (count($this->having)) {
      // There is an implicit string cast on $this->having.
      $query .= "\nHAVING " . $this->having;
    }

873 874 875 876 877 878 879 880
    // UNION is a little odd, as the select queries to combine are passed into
    // this query, but syntactically they all end up on the same level.
    if ($this->union) {
      foreach ($this->union as $union) {
        $query .= ' ' . $union['type'] . ' ' . (string) $union['query'];
      }
    }

881 882 883
    // ORDER BY
    if ($this->order) {
      $query .= "\nORDER BY ";
884
      $fields = [];
885
      foreach ($this->order as $field => $direction) {
886
        $fields[] = $this->connection->escapeField($field) . ' ' . $direction;
887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906
      }
      $query .= implode(', ', $fields);
    }

    // RANGE
    // There is no universal SQL standard for handling range or limit clauses.
    // Fortunately, all core-supported databases use the same range syntax.
    // Databases that need a different syntax can override this method and
    // do whatever alternate logic they need to.
    if (!empty($this->range)) {
      $query .= "\nLIMIT " . (int) $this->range['length'] . " OFFSET " . (int) $this->range['start'];
    }

    if ($this->forUpdate) {
      $query .= ' FOR UPDATE';
    }

    return $query;
  }

907 908 909
  /**
   * {@inheritdoc}
   */
910
  public function __clone() {
911 912
    parent::__clone();

913 914 915 916
    // On cloning, also clone the dependent objects. However, we do not
    // want to clone the database connection object as that would duplicate the
    // connection itself.

917
    $this->condition = clone($this->condition);
918 919 920 921
    $this->having = clone($this->having);
    foreach ($this->union as $key => $aggregate) {
      $this->union[$key]['query'] = clone($aggregate['query']);
    }
922 923 924 925 926
    foreach ($this->tables as $alias => $table) {
      if ($table['table'] instanceof SelectInterface) {
        $this->tables[$alias]['table'] = clone $table['table'];
      }
    }
927
  }
928

929
}