function views_query::query in Views (for Drupal 7) 6.2

Generate a query and a countquery from all of the information supplied to the object.

Parameters

$get_count: Provide a countquery if this is true, otherwise provide a normal query.

File

includes/query.inc, line 893

query.inc Defines the query object which is the underlying layer in a View.

Class

views_query

Object used to create a SELECT query.

Code

function query($get_count = FALSE) {

  // Check query distinct value.
  if (empty($this->no_distinct) && $this->distinct && !empty($this->fields)) {
    if (!empty($this->fields[$this->base_field])) {
      $this->fields[$this->base_field]['distinct'] = TRUE;
      $this
        ->add_groupby($this->base_field);
    }
  }

  /**
   * An optimized count query includes just the base field instead of all the fields.
   * Determine of this query qualifies by checking for a groupby or distinct.
   */
  $fields_array = $this->fields;
  if ($get_count && !$this->groupby) {
    foreach ($fields_array as $field) {
      if (!empty($field['distinct'])) {
        $get_count_optimized = FALSE;
        break;
      }
    }
  }
  else {
    $get_count_optimized = FALSE;
  }
  if (!isset($get_count_optimized)) {
    $get_count_optimized = TRUE;
  }
  $joins = $fields = $where = $having = $orderby = $groupby = '';

  // Add all the tables to the query via joins. We assume all LEFT joins.
  foreach ($this->table_queue as $table) {
    if (is_object($table['join'])) {
      $joins .= $table['join']
        ->join($table, $this) . "\n";
    }
  }
  $has_aggregate = FALSE;
  $non_aggregates = array();
  foreach ($fields_array as $field) {
    if ($fields) {
      $fields .= ",\n   ";
    }
    $string = '';
    if (!empty($field['table'])) {
      $string .= $field['table'] . '.';
    }
    $string .= $field['field'];

    // store for use with non-aggregates below
    $fieldname = !empty($field['alias']) ? $field['alias'] : $string;
    if (!empty($field['distinct'])) {
      $string = "DISTINCT({$string})";
    }
    if (!empty($field['count'])) {
      $string = "COUNT({$string})";
      $has_aggregate = TRUE;
    }
    else {
      if (!empty($field['aggregate'])) {
        $has_aggregate = TRUE;
      }
      elseif ($this->distinct && !in_array($fieldname, $this->groupby)) {
        $string = $GLOBALS['db_type'] == 'pgsql' ? "FIRST({$string})" : $string;
      }
      else {
        $non_aggregates[] = $fieldname;
      }
    }
    if ($field['alias']) {
      $string .= " AS {$field['alias']}";
    }
    $fields .= $string;
    if ($get_count_optimized) {

      // We only want the first field in this case.
      break;
    }
  }
  if ($has_aggregate || $this->groupby) {
    $groupby = "GROUP BY " . implode(', ', array_unique(array_merge($this->groupby, $non_aggregates))) . "\n";
    if ($this->having) {
      $having = $this
        ->condition_sql('having');
    }
  }
  if (!$get_count_optimized) {

    // we only add the groupby if we're not counting.
    if ($this->orderby) {
      $orderby = "ORDER BY " . implode(', ', $this->orderby) . "\n";
    }
  }
  $where = $this
    ->condition_sql();
  $query = "SELECT {$fields}\n FROM {" . $this->base_table . "} {$this->base_table} \n{$joins} {$where} {$groupby} {$having} {$orderby}";
  $replace = array(
    '>' => '>',
    '&lt;' => '<',
  );
  $query = strtr($query, $replace);
  return $query;
}