select.inc 23.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
<?php
// $Id$

/**
 * @ingroup database
 * @{
 */

/**
 * Query builder for SELECT statements.
 */
class SelectQuery extends Query implements QueryConditionInterface, QueryAlterableInterface {

  /**
   * The fields to SELECT.
   *
   * @var array
   */
  protected $fields = array();

  /**
   * The expressions to SELECT as virtual fields.
   *
   * @var array
   */
  protected $expressions = array();

  /**
   * The tables against which to JOIN.
   *
31 32
   * 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:
33 34 35
   *
   * array(
   *   'type' => $join_type (one of INNER, LEFT OUTER, RIGHT OUTER),
36
   *   'table' => $table,
37 38 39
   *   'alias' => $alias_of_the_table,
   *   'condition' => $condition_clause_on_which_to_join,
   *   'arguments' => $array_of_arguments_for_placeholders_in_the condition.
40
   *   'all_fields' => TRUE to SELECT $alias.*, FALSE or NULL otherwise.
41 42
   * )
   *
43
   * If $table is a string, it is taken as the name of a table. If it is
44 45
   * a SelectQuery object, it is taken as a subquery.
   *
46 47 48 49 50 51 52
   * @var array
   */
  protected $tables = array();

  /**
   * The fields by which to order this query.
   *
53
   * This is an associative array. The keys are the fields to order, and the value
54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101
   * is the direction to order, either ASC or DESC.
   *
   * @var array
   */
  protected $order = array();

  /**
   * The fields by which to group.
   *
   * @var array
   */
  protected $group = array();

  /**
   * The conditional object for the WHERE clause.
   *
   * @var DatabaseCondition
   */
  protected $where;

  /**
   * The conditional object for the HAVING clause.
   *
   * @var DatabaseCondition
   */
  protected $having;

  /**
   * Whether or not this query should be DISTINCT
   *
   * @var boolean
   */
  protected $distinct = FALSE;

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

  public function __construct($table, $alias = NULL, DatabaseConnection $connection, $options = array()) {
    $options['return'] = Database::RETURN_STATEMENT;
    parent::__construct($connection, $options);
    $this->where = new DatabaseCondition('AND');
    $this->having = new DatabaseCondition('AND');
    $this->addJoin(NULL, $table, $alias);
  }
102

103
  /* Implementations of QueryAlterableInterface. */
104

105 106 107
  public function addTag($tag) {
    $this->alterTags[$tag] = 1;
  }
108

109 110 111
  public function hasTag($tag) {
    return isset($this->alterTags[$tag]);
  }
112

113 114 115
  public function hasAllTags() {
    return !(boolean)array_diff(func_get_args(), array_keys($this->alterTags));
  }
116

117 118 119
  public function hasAnyTag() {
    return (boolean)array_intersect(func_get_args(), array_keys($this->alterTags));
  }
120

121 122 123
  public function addMetaData($key, $object) {
    $this->alterMetaData[$key] = $object;
  }
124

125 126 127
  public function getMetaData($key) {
    return isset($this->alterMetaData[$key]) ? $this->alterMetaData[$key] : NULL;
  }
128

129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150
  /* Implementations of QueryConditionInterface for the WHERE clause. */

  public function condition($field, $value = NULL, $operator = '=') {
    if (!isset($num_args)) {
      $num_args = func_num_args();
    }
    $this->where->condition($field, $value, $operator, $num_args);
    return $this;
  }

  public function &conditions() {
    return $this->where->conditions();
  }

  public function arguments() {
    return $this->where->arguments();
  }

  public function where($snippet, $args = array()) {
    $this->where->where($snippet, $args);
    return $this;
  }
151

152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
  public function compile(DatabaseConnection $connection) {
    return $this->where->compile($connection);
  }

  /* Implmeentations of QueryConditionInterface for the HAVING clause. */

  public function havingCondition($field, $value = NULL, $operator = '=') {
    if (!isset($num_args)) {
      $num_args = func_num_args();
    }
    $this->having->condition($field, $value, $operator, $num_args);
    return $this;
  }

  public function &havingConditions() {
    return $this->having->conditions();
  }

  public function havingArguments() {
    return $this->having->arguments();
  }

  public function having($snippet, $args = array()) {
    $this->having->where($snippet, $args);
    return $this;
  }
178

179 180 181 182 183
  public function havingCompile(DatabaseConnection $connection) {
    return $this->having->compile($connection);
  }

  /* Alter accessors to expose the query data to alter hooks. */
184

185 186 187 188
  /**
   * Returns a reference to the fields array for this query.
   *
   * Because this method returns by reference, alter hooks may edit the fields
189
   * array directly to make their changes. If just adding fields, however, the
190 191 192
   * use of addField() is preferred.
   *
   * Note that this method must be called by reference as well:
193
   *
194 195 196 197 198 199 200 201 202 203
   * @code
   * $fields =& $query->getFields();
   * @endcode
   *
   * @return
   *   A reference to the fields array structure.
   */
  public function &getFields() {
    return $this->fields;
  }
204

205 206 207 208
  /**
   * Returns a reference to the expressions array for this query.
   *
   * Because this method returns by reference, alter hooks may edit the expressions
209
   * array directly to make their changes. If just adding expressions, however, the
210 211 212
   * use of addExpression() is preferred.
   *
   * Note that this method must be called by reference as well:
213
   *
214 215 216
   * @code
   * $fields =& $query->getExpressions();
   * @endcode
217
   *
218 219 220 221 222 223
   * @return
   *   A reference to the expression array structure.
   */
  public function &getExpressions() {
    return $this->expressions;
  }
224

225 226 227 228
  /**
   * Returns a reference to the order by array for this query.
   *
   * Because this method returns by reference, alter hooks may edit the order-by
229
   * array directly to make their changes. If just adding additional ordering
230 231 232
   * fields, however, the use of orderBy() is preferred.
   *
   * Note that this method must be called by reference as well:
233
   *
234 235 236
   * @code
   * $fields =& $query->getOrderBy();
   * @endcode
237
   *
238 239 240 241 242 243
   * @return
   *   A reference to the expression array structure.
   */
  public function &getOrderBy() {
    return $this->order;
  }
244

245 246 247 248
  /**
   * Returns a reference to the tables array for this query.
   *
   * Because this method returns by reference, alter hooks may edit the tables
249
   * array directly to make their changes. If just adding tables, however, the
250 251 252
   * use of the join() methods is preferred.
   *
   * Note that this method must be called by reference as well:
253
   *
254 255 256
   * @code
   * $fields =& $query->getTables();
   * @endcode
257
   *
258 259 260 261 262 263 264 265 266 267
   * @return
   *   A reference to the tables array structure.
   */
  public function &getTables() {
    return $this->tables;
  }

  /**
   * Compiles and returns an associative array of the arguments for this prepared statement.
   *
268 269
   * @return
   *   An associative array of all placeholder arguments for this query.
270 271 272 273 274 275 276 277 278
   */
  public function getArguments() {
    $this->where->compile($this->connection);
    $this->having->compile($this->connection);
    $args = $this->where->arguments() + $this->having->arguments();
    foreach ($this->tables as $table) {
      if ($table['arguments']) {
        $args += $table['arguments'];
      }
279 280 281 282
      // If this table is a subquery, grab its arguments recursively.
      if ($table['table'] instanceof SelectQuery) {
        $args += $table['table']->getArguments();
      }
283 284 285 286 287 288
    }
    foreach ($this->expressions as $expression) {
      if ($expression['arguments']) {
        $args += $expression['arguments'];
      }
    }
289

290 291
    return $args;
  }
292

293
  public function execute() {
294
    // Modules may alter all queries or only those having a particular tag.
295
    drupal_alter('query', $this);
296 297 298 299 300
    if (isset($this->alterTags)) {
      foreach ($this->alterTags as $tag => $value) {
        drupal_alter("query_$tag", $this);
      }
    }
301

302
    $args = $this->getArguments();
303

304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
    if (!empty($this->range)) {
      return $this->connection->queryRange((string)$this, $args, $this->range['start'], $this->range['length'], $this->queryOptions);
    }
    return $this->connection->query((string)$this, $args, $this->queryOptions);
  }

  /**
   * Sets this query to be DISTINCT.
   *
   * @param $distinct
   *   TRUE to flag this query DISTINCT, FALSE to disable it.
   * @return
   *   The called object.
   */
  public function distinct($distinct = TRUE) {
    $this->distinct = $distinct;
    return $this;
  }

  /**
   * Adds a field to the list to be SELECTed.
   *
   * @param $table_alias
327
   *   The name of the table from which the field comes, as an alias. Generally
328 329 330 331 332
   *   you will want to use the return value of join() here to ensure that it is
   *   valid.
   * @param $field
   *   The name of the field.
   * @param $alias
333 334
   *   The alias for this field. If not specified, one will be generated
   *   automatically based on the $table_alias and $field. The alias will be
335 336 337 338 339 340
   *   checked for uniqueness, so the requested alias may not be the alias
   *   that is assigned in all cases.
   * @return
   *   The unique alias that was assigned for this field.
   */
  public function addField($table_alias, $field, $alias = NULL) {
341
    // If no alias is specified, first try the field name itself.
342
    if (empty($alias)) {
343 344 345 346 347
      $alias = $field;
    }

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

351
    // If that is already used, just add a counter until we find an unused alias.
352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
    $alias_candidate = $alias;
    $count = 2;
    while (!empty($this->tables[$alias_candidate])) {
      $alias_candidate = $alias . '_' . $count++;
    }
    $alias = $alias_candidate;

    $this->fields[$alias] = array(
      'field' => $field,
      'table' => $table_alias,
      'alias' => $alias,
    );

    return $alias;
  }

368 369 370
  /**
   * Add multiple fields from the same table to be SELECTed.
   *
371
   * This method does not return the aliases set for the passed fields. In the
372
   * majority of cases that is not a problem, as the alias will be the field
373 374
   * name. However, if you do need to know the alias you can call getFields()
   * and examine the result to determine what alias was created. Alternatively,
375 376 377 378
   * simply use addField() for the few fields you care about and this method for
   * the rest.
   *
   * @param $table_alias
379
   *   The name of the table from which the field comes, as an alias. Generally
380 381 382 383
   *   you will want to use the return value of join() here to ensure that it is
   *   valid.
   * @param $fields
   *   An indexed array of fields present in the specified table that should be
384
   *   included in this query. If not specified, $table_alias.* will be generated
385 386 387 388
   *   without any aliases.
   * @return
   *   The called object.
   */
389
  public function fields($table_alias, array $fields = array()) {
390 391 392 393 394 395 396 397 398 399 400 401 402 403 404

    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;
  }

405 406 407 408 409 410 411
  /**
   * Private list of aliases already attributed to expression fields.
   *
   * @var Array
   */
  private $expressionAliases = array();

412 413 414
  /**
   * Adds an expression to the list of "fields" to be SELECTed.
   *
415
   * An expression can be any arbitrary string that is valid SQL. That includes
416
   * various functions, which may in some cases be database-dependent. This
417 418 419
   * method makes no effort to correct for database-specific functions.
   *
   * @param $expression
420
   *   The expression string. May contain placeholders.
421
   * @param $alias
422 423
   *   The alias for this expression. If not specified, one will be generated
   *   automatically in the form "expression_#". The alias will be checked for
424
   *   uniqueness, so the requested alias may not be the alias that is assigned
425 426 427 428 429 430 431 432 433 434
   *   in all cases.
   * @param $arguments
   *   Any placeholder arguments needed for this expression.
   * @return
   *   The unique alias that was assigned for this expression.
   */
  public function addExpression($expression, $alias = NULL, $arguments = array()) {
    if (empty($alias)) {
      $alias = 'expression';
    }
435

436 437 438 439
    $alias_candidate = $alias;
    $count = 2;
    while (!empty($this->expressions[$alias_candidate])) {
      $alias_candidate = $alias . '_' . $count++;
440
    }
441
    $alias = $alias_candidate;
442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459

    $this->expressions[$alias] = array(
      'expression' => $expression,
      'alias' => $alias,
      'arguments' => $arguments,
    );

    return $alias;
  }

  /**
   * Default Join against another table in the database.
   *
   * This method is a convenience method for innerJoin().
   *
   * @param $table
   *   The table against which to join.
   * @param $alias
460
   *   The alias for the table. In most cases this should be the first letter
461 462
   *   of the table, or the first letter of each "word" in the table.
   * @param $condition
463
   *   The condition on which to join this table. If the join requires values,
464
   *   this clause should use a named placeholder and the value or values to
465
   *   insert should be passed in the 4th parameter. For the first table joined
466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482
   *   on a query, this value is ignored as the first table is taken as the base
   *   table.
   * @param $arguments
   *   An array of arguments to replace into the $condition of this join.
   * @return
   *   The unique alias that was assigned for this table.
   */
  public function join($table, $alias = NULL, $condition = NULL, $arguments = array()) {
    return $this->addJoin('INNER', $table, $alias, $condition, $arguments);
  }

  /**
   * Inner Join against another table in the database.
   *
   * @param $table
   *   The table against which to join.
   * @param $alias
483
   *   The alias for the table. In most cases this should be the first letter
484 485
   *   of the table, or the first letter of each "word" in the table.
   * @param $condition
486
   *   The condition on which to join this table. If the join requires values,
487
   *   this clause should use a named placeholder and the value or values to
488
   *   insert should be passed in the 4th parameter. For the first table joined
489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505
   *   on a query, this value is ignored as the first table is taken as the base
   *   table.
   * @param $arguments
   *   An array of arguments to replace into the $condition of this join.
   * @return
   *   The unique alias that was assigned for this table.
   */
  public function innerJoin($table, $alias = NULL, $condition = NULL, $arguments = array()) {
    return $this->addJoin('INNER', $table, $alias, $condition, $arguments);
  }

  /**
   * Left Outer Join against another table in the database.
   *
   * @param $table
   *   The table against which to join.
   * @param $alias
506
   *   The alias for the table. In most cases this should be the first letter
507 508
   *   of the table, or the first letter of each "word" in the table.
   * @param $condition
509
   *   The condition on which to join this table. If the join requires values,
510
   *   this clause should use a named placeholder and the value or values to
511
   *   insert should be passed in the 4th parameter. For the first table joined
512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528
   *   on a query, this value is ignored as the first table is taken as the base
   *   table.
   * @param $arguments
   *   An array of arguments to replace into the $condition of this join.
   * @return
   *   The unique alias that was assigned for this table.
   */
  public function leftJoin($table, $alias = NULL, $condition = NULL, $arguments = array()) {
    return $this->addJoin('LEFT OUTER', $table, $alias, $condition, $arguments);
  }

  /**
   * Right Outer Join against another table in the database.
   *
   * @param $table
   *   The table against which to join.
   * @param $alias
529
   *   The alias for the table. In most cases this should be the first letter
530 531
   *   of the table, or the first letter of each "word" in the table.
   * @param $condition
532
   *   The condition on which to join this table. If the join requires values,
533
   *   this clause should use a named placeholder and the value or values to
534
   *   insert should be passed in the 4th parameter. For the first table joined
535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552
   *   on a query, this value is ignored as the first table is taken as the base
   *   table.
   * @param $arguments
   *   An array of arguments to replace into the $condition of this join.
   * @return
   *   The unique alias that was assigned for this table.
   */
  public function rightJoin($table, $alias = NULL, $condition = NULL, $arguments = array()) {
    return $this->addJoin('RIGHT OUTER', $table, $alias, $condition, $arguments);
  }

  /**
   * Join against another table in the database.
   *
   * This method does the "hard" work of queuing up a table to be joined against.
   * In some cases, that may include dipping into the Schema API to find the necessary
   * fields on which to join.
   *
553
   * @param $type
554
   *   The type of join. Typically one one of INNER, LEFT OUTER, and RIGHT OUTER.
555
   * @param $table
556 557
   *   The table against which to join. May be a string or another SelectQuery
   *   object. If a query object is passed, it will be used as a subselect.
558
   * @param $alias
559 560
   *   The alias for the table. In most cases this should be the first letter
   *   of the table, or the first letter of each "word" in the table. If omitted,
561 562
   *   one will be dynamically generated.
   * @param $condition
563
   *   The condition on which to join this table. If the join requires values,
564
   *   this clause should use a named placeholder and the value or values to
565
   *   insert should be passed in the 4th parameter. For the first table joined
566 567
   *   on a query, this value is ignored as the first table is taken as the base
   *   table.
568
   * @param $arguments
569 570 571 572 573 574 575
   *   An array of arguments to replace into the $condition of this join.
   * @return
   *   The unique alias that was assigned for this table.
   */
  public function addJoin($type, $table, $alias = NULL, $condition = NULL, $arguments = array()) {

    if (empty($alias)) {
576 577 578 579 580 581
      if ($table instanceof SelectQuery) {
        $alias = 'subquery';
      }
      else {
        $alias = $table;
      }
582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610
    }

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

    $this->tables[$alias] = array(
      'join type' => $type,
      'table' => $table,
      'alias' => $alias,
      'condition' => $condition,
      'arguments' => $arguments,
    );

    return $alias;
  }

  /**
   * Orders the result set by a given field.
   *
   * If called multiple times, the query will order by each specified field in the
   * order this method is called.
   *
   * @param $field
   *   The field on which to order.
   * @param $direction
611
   *   The direction to sort. Legal values are "ASC" and "DESC".
612 613 614 615 616 617 618 619 620 621 622 623 624 625 626
   * @return
   *   The called object.
   */
  public function orderBy($field, $direction = 'ASC') {
    $this->order[$field] = $direction;
    return $this;
  }

  /**
   * Restricts a query to a given range in the result set.
   *
   * If this method is called with no parameters, will remove any range
   * directives that have been set.
   *
   * @param $start
627
   *   The first record from the result set to return. If NULL, removes any
628 629 630 631 632 633 634 635 636 637 638 639 640 641 642
   *   range directives that are set.
   * @param $limit
   *   The number of records to return from the result set.
   * @return
   *   The called object.
   */
  public function range($start = NULL, $length = NULL) {
    $this->range = func_num_args() ? array('start' => $start, 'length' => $length) : array();
    return $this;
  }

  /**
   * Groups the result set by the specified field.
   *
   * @param $field
643
   *   The field on which to group. This should be the field as aliased.
644 645 646 647 648 649
   * @return
   *   The called object.
   */
  public function groupBy($field) {
    $this->group[] = $field;
  }
650

651 652 653 654 655 656 657
  /**
   * Get the equivalent COUNT query of this query as a new query object.
   *
   * @return
   *   A new SelectQuery object with no fields or expressions besides COUNT(*).
   */
  public function countQuery() {
658
    // Shallow-clone this query. We don't want to duplicate any of the
659 660
    // referenced objects, so a shallow query is all we need.
    $count = clone($this);
661

662 663 664 665 666
    // Zero-out existing fields and expressions.
    $fields =& $count->getFields();
    $fields = array();
    $expressions =& $count->getExpressions();
    $expressions = array();
667

668 669 670 671
    // Ordering a count query is a waste of cycles, and breaks on some
    // databases anyway.
    $orders = &$count->getOrderBy();
    $orders = array();
672

673 674
    // COUNT() is an expression, so we add that back in.
    $count->addExpression('COUNT(*)');
675

676 677
    return $count;
  }
678

679 680 681 682 683 684 685 686 687 688 689
  public function __toString() {

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

    // FIELDS and EXPRESSIONS
    $fields = array();
    foreach ($this->fields as $alias => $field) {
690 691
      // Always use the AS keyword for field aliases, as some
      // databases require it (e.g., PostgreSQL).
692 693 694 695 696
      $fields[] = (isset($field['table']) ? $field['table'] . '.' : '') . $field['field'] . ' AS ' . $field['alias'];
    }
    foreach ($this->expressions as $alias => $expression) {
      $fields[] = $expression['expression'] . ' AS ' . $expression['alias'];
    }
697 698 699 700 701
    foreach ($this->tables as $alias => $table) {
      if (!empty($table['all_fields'])) {
        $fields[] = $alias . '.*';
      }
    }
702 703
    $query .= implode(', ', $fields);

704

705 706 707 708 709 710 711
    // FROM - We presume all queries have a FROM, as any query that doesn't won't need the query builder anyway.
    $query .= "\nFROM ";
    foreach ($this->tables as $alias => $table) {
      $query .= "\n";
      if (isset($table['join type'])) {
        $query .= $table['join type'] . ' JOIN ';
      }
712 713 714 715 716 717 718 719 720

      // If the table is a subquery, compile it and integrate it into this query.
      if ($table['table'] instanceof SelectQuery) {
        $table_string = '(' . (string)$table['table'] .')';
      }
      else {
        $table_string = '{' . $this->connection->escapeTable($table['table']) . '}';
      }

721 722
      // Don't use the AS keyword for table aliases, as some
      // databases don't support it (e.g., Oracle).
723 724
      $query .=  $table_string . ' ' . $table['alias'];

725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751
      if (!empty($table['condition'])) {
        $query .= ' ON ' . $table['condition'];
      }
    }

    // WHERE
    if (count($this->where)) {
      $this->where->compile($this->connection);
      // There is an implicit string cast on $this->condition.
      $query .= "\nWHERE " . $this->where;
    }

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

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

    // ORDER BY
    if ($this->order) {
      $query .= "\nORDER BY ";
752
      $fields = array();
753
      foreach ($this->order as $field => $direction) {
754
        $fields[] = $field . ' ' . $direction;
755
      }
756
      $query .= implode(', ', $fields);
757 758 759 760 761 762
    }

    // RANGE is database specific, so we can't do it here.

    return $query;
  }
763

764
  public function __clone() {
765
    // On cloning, also clone the conditional objects. However, we do not
766 767
    // want to clone the database connection object as that would duplicate the
    // connection itself.
768

769 770 771 772 773 774 775 776
    $this->where = clone($this->where);
    $this->having = clone($this->having);
  }
}

/**
 * @} End of "ingroup database".
 */