manuelcillero/suitedesk
manuelcillero/suitedesk
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
This repository has been archived on 2025-06-21. You can view files and clone it, but you cannot make any changes to it's state, such as pushing and creating new issues, pull requests or comments.
suitedesk/modules/views/includes/query.inc

1011 lines
32 KiB
PHP
Raw Blame History

<?php
/**
* @file query.inc
* Defines the query object which is the underlying layer in a View.
*/
/**
* Object used to create a SELECT query.
*/
class views_query {
/**
* A list of tables in the order they should be added, keyed by alias.
*/
var $table_queue = array();
/**
* Holds an array of tables and counts added so that we can create aliases
*/
var $tables = array();
/**
* Holds an array of relationships, which are aliases of the primary
* table that represent different ways to join the same table in.
*/
var $relationships = array();
/**
* An array of sections of the WHERE query. Each section is in itself
* an array of pieces and a flag as to whether or not it should be AND
* or OR.
*/
var $where = array();
/**
* An array of sections of the HAVING query. Each section is in itself
* an array of pieces and a flag as to whether or not it should be AND
* or OR.
*/
var $having = array();
/**
* The default operator to use when connecting the WHERE groups. May be
* AND or OR.
*/
var $group_operator = 'AND';
/**
* A simple array of order by clauses.
*/
var $orderby = array();
/**
* A simple array of group by clauses.
*/
var $groupby = array();
/**
* The table header to use for tablesort. This matters because tablesort
* needs to modify the query and needs the header.
*/
var $header = array();
/**
* A flag as to whether or not to make the primary field distinct.
*/
var $distinct = FALSE;
/**
* Constructor; Create the basic query object and fill with default values.
*/
function views_query($base_table = 'node', $base_field = 'nid') {
$this->base_table = $base_table; // Predefine these above, for clarity.
$this->base_field = $base_field;
$this->relationships[$base_table] = array(
'link' => NULL,
'table' => $base_table,
'alias' => $base_table,
'base' => $base_table
);
// init the table queue with our primary table.
$this->table_queue[$base_table] = array(
'alias' => $base_table,
'table' => $base_table,
'relationship' => $base_table,
'join' => NULL,
);
// init the tables with our primary table
$this->tables[$base_table][$base_table] = array(
'count' => 1,
'alias' => $base_table,
);
if ($base_field) {
$this->fields[$base_field] = array(
'table' => $base_table,
'field' => $base_field,
'alias' => $base_field,
);
}
$this->count_field = array(
'table' => $base_table,
'field' => $base_field,
'alias' => $base_field,
'count' => TRUE,
);
}
// ----------------------------------------------------------------
// Utility methods to set flags and data.
/**
* Set the base field to be distinct.
*/
function set_distinct($value = TRUE) {
if (!(isset($this->no_distinct) && $value)) {
$this->distinct = $value;
}
}
/**
* Set what field the query will count() on for paging.
*/
function set_count_field($table, $field, $alias = NULL) {
if (empty($alias)) {
$alias = $table . '_' . $field;
}
$this->count_field = array(
'table' => $table,
'field' => $field,
'alias' => $alias,
'count' => TRUE,
);
}
/**
* Set the table header; used for click-sorting because it's needed
* info to modify the ORDER BY clause.
*/
function set_header($header) {
$this->header = $header;
}
// ----------------------------------------------------------------
// Table/join adding
/**
* A relationship is an alternative endpoint to a series of table
* joins. Relationships must be aliases of the primary table and
* they must join either to the primary table or to a pre-existing
* relationship.
*
* An example of a relationship would be a nodereference table.
* If you have a nodereference named 'book_parent' which links to a
* parent node, you could set up a relationship 'node_book_parent'
* to 'node'. Then, anything that links to 'node' can link to
* 'node_book_parent' instead, thus allowing all properties of
* both nodes to be available in the query.
*
* @param $alias
* What this relationship will be called, and is also the alias
* for the table.
* @param $join
* A views_join object (or derived object) to join the alias in.
* @param $base
* The name of the 'base' table this relationship represents; this
* tells the join search which path to attempt to use when finding
* the path to this relationship.
* @param $link_point
* If this relationship links to something other than the primary
* table, specify that table here. For example, a 'track' node
* might have a relationship to an 'album' node, which might
* have a relationship to an 'artist' node.
*/
function add_relationship($alias, $join, $base, $link_point = NULL) {
if (empty($link_point)) {
$link_point = $this->base_table;
}
else if (!array_key_exists($link_point, $this->relationships)) {
return FALSE;
}
// Make sure $alias isn't already used; if it, start adding stuff.
$alias_base = $alias;
$count = 1;
while (!empty($this->relationships[$alias])) {
$alias = $alias_base . '_' . $count++;
}
// Make sure this join is adjusted for our relationship.
if ($link_point && isset($this->relationships[$link_point])) {
$join = $this->adjust_join($join, $link_point);
}
// Add the table directly to the queue to avoid accidentally marking
// it.
$this->table_queue[$alias] = array(
'table' => $join->table,
'num' => 1,
'alias' => $alias,
'join' => $join,
'relationship' => $link_point,
);
$this->relationships[$alias] = array(
'link' => $link_point,
'table' => $join->table,
'base' => $base,
);
$this->tables[$this->base_table][$alias] = array(
'count' => 1,
'alias' => $alias,
);
return $alias;
}
/**
* Add a table to the query, ensuring the path exists.
*
* This function will test to ensure that the path back to the primary
* table is valid and exists; if you do not wish for this testing to
* occur, use $query->queue_table() instead.
*
* @param $table
* The name of the table to add. It needs to exist in the global table
* array.
* @param $relationship
* An alias of a table; if this is set, the path back to this table will
* be tested prior to adding the table, making sure that all intermediary
* tables exist and are properly aliased. If set to NULL the path to
* the primary table will be ensured. If the path cannot be made, the
* table will NOT be added.
* @param $join
* In some join configurations this table may actually join back through
* a different method; this is most likely to be used when tracing
* a hierarchy path. (node->parent->parent2->parent3). This parameter
* will specify how this table joins if it is not the default.
* @param $alias
* A specific alias to use, rather than the default alias.
*
* @return $alias
* The alias of the table; this alias can be used to access information
* about the table and should always be used to refer to the table when
* adding parts to the query. Or FALSE if the table was not able to be
* added.
*/
function add_table($table, $relationship = NULL, $join = NULL, $alias = NULL) {
if (!$this->ensure_path($table, $relationship, $join)) {
return FALSE;
}
if ($join && $relationship) {
$join = $this->adjust_join($join, $relationship);
}
return $this->queue_table($table, $relationship, $join, $alias);
}
/**
* Add a table to the query without ensuring the path.
*
* This is a pretty internal function to Views and add_table() or
* ensure_table() should be used instead of this one, unless you are
* absolutely sure this is what you want.
*
* @param $table
* The name of the table to add. It needs to exist in the global table
* array.
* @param $relationship
* The primary table alias this table is related to. If not set, the
* primary table will be used.
* @param $join
* In some join configurations this table may actually join back through
* a different method; this is most likely to be used when tracing
* a hierarchy path. (node->parent->parent2->parent3). This parameter
* will specify how this table joins if it is not the default.
* @param $alias
* A specific alias to use, rather than the default alias.
*
* @return $alias
* The alias of the table; this alias can be used to access information
* about the table and should always be used to refer to the table when
* adding parts to the query. Or FALSE if the table was not able to be
* added.
*/
function queue_table($table, $relationship = NULL, $join = NULL, $alias = NULL) {
// If the alias is set, make sure it doesn't already exist.
if (isset($this->table_queue[$alias])) {
return $alias;
}
if (empty($relationship)) {
$relationship = $this->base_table;
}
if (!array_key_exists($relationship, $this->relationships)) {
return FALSE;
}
if (!$alias && $join && $relationship && !empty($join->adjusted) && $table != $join->table) {
if ($relationship == $this->base_table) {
$alias = $table;
}
else {
$alias = $relationship . '_' . $table;
}
}
// Check this again to make sure we don't blow up existing aliases for already
// adjusted joins.
if (isset($this->table_queue[$alias])) {
return $alias;
}
$alias = $this->mark_table($table, $relationship, $alias);
// If no alias is specified, give it the default.
if (!isset($alias)) {
$alias = $this->tables[$relationship][$table]['alias'] . $this->tables[$relationship][$table]['count'];
}
// If this is a relationship based table, add a marker with
// the relationship as a primary table for the alias.
if ($table != $alias) {
$this->mark_table($alias, $this->base_table, $alias);
}
// If no join is specified, pull it from the table data.
if (!isset($join)) {
$join = $this->get_join_data($table, $this->relationships[$relationship]['base']);
if (empty($join)) {
return FALSE;
}
$join = $this->adjust_join($join, $relationship);
}
$this->table_queue[$alias] = array(
'table' => $table,
'num' => $this->tables[$relationship][$table]['count'],
'alias' => $alias,
'join' => $join,
'relationship' => $relationship,
);
return $alias;
}
function mark_table($table, $relationship, $alias) {
// Mark that this table has been added.
if (empty($this->tables[$relationship][$table])) {
if (!isset($alias)) {
$alias = '';
if ($relationship != $this->base_table) {
// double underscore will help prevent accidental name
// space collisions.
$alias = $relationship . '__';
}
$alias .= $table;
}
$this->tables[$relationship][$table] = array(
'count' => 1,
'alias' => $alias,
);
}
else {
$this->tables[$relationship][$table]['count']++;
}
return $alias;
}
/**
* Ensure a table exists in the queue; if it already exists it won't
* do anything, but if it doesn't it will add the table queue. It will ensure
* a path leads back to the relationship table.
*
* @param $table
* The unaliased name of the table to ensure.
* @param $relationship
* The relationship to ensure the table links to. Each relationship will
* get a unique instance of the table being added. If not specified,
* will be the primary table.
* @param $join
* A views_join object (or derived object) to join the alias in.
*
* @return
* The alias used to refer to this specific table, or NULL if the table
* cannot be ensured.
*/
function ensure_table($table, $relationship = NULL, $join = NULL) {
// ensure a relationship
if (empty($relationship)) {
$relationship = $this->base_table;
}
// If the relationship is the primary table, this actually be a relationship
// link back from an alias. We store all aliases along with the primary table
// to detect this state, because eventually it'll hit a table we already
// have and that's when we want to stop.
if ($relationship == $this->base_table && !empty($this->tables[$relationship][$table])) {
return $this->tables[$relationship][$table]['alias'];
}
if (!array_key_exists($relationship, $this->relationships)) {
return FALSE;
}
if ($table == $this->relationships[$relationship]['base']) {
return $relationship;
}
// If we do not have join info, fetch it.
if (!isset($join)) {
$join = $this->get_join_data($table, $this->relationships[$relationship]['base']);
}
// If it can't be fetched, this won't work.
if (empty($join)) {
return;
}
// Adjust this join for the relationship, which will ensure that the 'base'
// table it links to is correct. Tables adjoined to a relationship
// join to a link point, not the base table.
$join = $this->adjust_join($join, $relationship);
if ($this->ensure_path($table, $relationship, $join)) {
// Attempt to eliminate redundant joins. If this table's
// relationship and join exactly matches an existing table's
// relationship and join, we do not have to join to it again;
// just return the existing table's alias. See
// http://groups.drupal.org/node/11288 for details.
//
// This can be done safely here but not lower down in
// queue_table(), because queue_table() is also used by
// add_table() which requires the ability to intentionally add
// the same table with the same join multiple times. For
// example, a view that filters on 3 taxonomy terms using AND
// needs to join term_data 3 times with the same join.
// scan through the table queue to see if a matching join and
// relationship exists. If so, use it instead of this join.
// TODO: Scanning through $this->table_queue results in an
// O(N^2) algorithm, and this code runs every time the view is
// instantiated (Views 2 does not currently cache queries).
// There are a couple possible "improvements" but we should do
// some performance testing before picking one.
foreach ($this->table_queue as $queued_table) {
// In PHP 4 and 5, the == operation returns TRUE for two objects
// if they are instances of the same class and have the same
// attributes and values.
if ($queued_table['relationship'] == $relationship && $queued_table['join'] == $join) {
return $queued_table['alias'];
}
}
return $this->queue_table($table, $relationship, $join);
}
}
/**
* Make sure that the specified table can be properly linked to the primary
* table in the JOINs. This function uses recursion. If the tables
* needed to complete the path back to the primary table are not in the
* query they will be added, but additional copies will NOT be added
* if the table is already there.
*/
function ensure_path($table, $relationship = NULL, $join = NULL, $traced = array(), $add = array()) {
if (!isset($relationship)) {
$relationship = $this->base_table;
}
if (!array_key_exists($relationship, $this->relationships)) {
return FALSE;
}
// If we do not have join info, fetch it.
if (!isset($join)) {
$join = $this->get_join_data($table, $this->relationships[$relationship]['base']);
}
// If it can't be fetched, this won't work.
if (empty($join)) {
return FALSE;
}
// Does a table along this path exist?
if (isset($this->tables[$relationship][$table]) ||
($join && $join->left_table == $relationship) ||
($join && $join->left_table == $this->relationships[$relationship]['table'])) {
// Make sure that we're linking to the correct table for our relationship.
foreach (array_reverse($add) as $table => $path_join) {
$this->queue_table($table, $relationship, $this->adjust_join($path_join, $relationship));
}
return TRUE;
}
// Have we been this way?
if (isset($traced[$join->left_table])) {
// we looped. Broked.
return FALSE;
}
// Do we have to add this table?
$left_join = $this->get_join_data($join->left_table, $this->relationships[$relationship]['base']);
if (!isset($this->tables[$relationship][$join->left_table])) {
$add[$join->left_table] = $left_join;
}
// Keep looking.
$traced[$join->left_table] = TRUE;
return $this->ensure_path($join->left_table, $relationship, $left_join, $traced, $add);
}
/**
* Fix a join to adhere to the proper relationship; the left table can vary
* based upon what relationship items are joined in on.
*/
function adjust_join($join, $relationship) {
if (!empty($join->adjusted)) {
return $join;
}
if (empty($relationship) || empty($this->relationships[$relationship])) {
return $join;
}
// Adjusts the left table for our relationship.
if ($relationship != $this->base_table) {
// If we're linking to the primary table, the relationship to use will
// be the prior relationship. Unless it's a direct link.
// Safety! Don't modify an original here.
$join = drupal_clone($join);
// Do we need to try to ensure a path?
if ($join->left_table != $this->relationships[$relationship]['table'] &&
$join->left_table != $this->relationships[$relationship]['base'] &&
!isset($this->tables[$relationship][$join->left_table]['alias'])) {
$this->ensure_table($join->left_table, $relationship);
}
// First, if this is our link point/anchor table, just use the relationship
if ($join->left_table == $this->relationships[$relationship]['table']) {
$join->left_table = $relationship;
}
// then, try the base alias.
else if (isset($this->tables[$relationship][$join->left_table]['alias'])) {
$join->left_table = $this->tables[$relationship][$join->left_table]['alias'];
}
// But if we're already looking at an alias, use that instead.
else if (isset($this->table_queue[$relationship]['alias'])) {
$join->left_table = $this->table_queue[$relationship]['alias'];
}
}
$join->adjusted = TRUE;
return $join;
}
/**
* Retrieve join data from the larger join data cache.
*
* @param $table
* The table to get the join information for.
* @param $base_table
* The path we're following to get this join.
*
* @return
* A views_join object or child object, if one exists.
*/
function get_join_data($table, $base_table) {
// Check to see if we're linking to a known alias. If so, get the real
// table's data instead.
if (!empty($this->table_queue[$table])) {
$table = $this->table_queue[$table]['table'];
}
return views_get_table_join($table, $base_table);
}
/**
* Get the information associated with a table.
*
* If you need the alias of a table with a particular relationship, use
* ensure_table().
*/
function get_table_info($table) {
if (!empty($this->table_queue[$table])) {
return $this->table_queue[$table];
}
// In rare cases we might *only* have aliased versions of the table.
if (!empty($this->tables[$this->base_table][$table])) {
$alias = $this->tables[$this->base_table][$table]['alias'];
if (!empty($this->table_queue[$alias])) {
return $this->table_queue[$alias];
}
}
}
/**
* Add a field to the query table, possibly with an alias. This will
* automatically call ensure_table to make sure the required table
* exists, *unless* $table is unset.
*
* @param $table
* The table this field is attached to. If NULL, it is assumed this will
* be a formula; otherwise, ensure_table is used to make sure the
* table exists.
* @param $field
* The name of the field to add. This may be a real field or a formula.
* @param $alias
* The alias to create. If not specified, the alias will be $table_$field
* unless $table is NULL. When adding formulae, it is recommended that an
* alias be used.
*
* @return $name
* The name that this field can be referred to as. Usually this is the alias.
*/
function add_field($table, $field, $alias = '', $params = NULL) {
// We check for this specifically because it gets a special alias.
if ($table == $this->base_table && $field == $this->base_field && empty($alias)) {
$alias = $this->base_field;
}
if ($table && empty($this->table_queue[$table])) {
$this->ensure_table($table);
}
if (!$alias && $table) {
$alias = $table . '_' . $field;
}
$name = $alias ? $alias : $field;
// @todo FIXME -- $alias, then $name is inconsistent
if (empty($this->fields[$alias])) {
$this->fields[$name] = array(
'field' => $field,
'table' => $table,
'alias' => $alias,
);
}
foreach ((array)$params as $key => $value) {
$this->fields[$name][$key] = $value;
}
return $name;
}
/**
* Remove all fields that may've been added; primarily used for summary
* mode where we're changing the query because we didn't get data we needed.
*/
function clear_fields() {
$this->fields = array();
}
/**
* Create a new grouping for the WHERE or HAVING clause.
*
* @param $type
* Either 'AND' or 'OR'. All items within this group will be added
* to the WHERE clause with this logical operator.
* @param $group
* An ID to use for this group. If unspecified, an ID will be generated.
* @param $where
* 'where' or 'having'.
*
* @return $group
* The group ID generated.
*/
function set_where_group($type = 'AND', $group = NULL, $where = 'where') {
// Set an alias.
$groups = &$this->$where;
if (!isset($group)) {
$group = empty($groups) ? 1 : max(array_keys($groups)) + 1;
}
// Create an empty group
if (empty($groups[$group])) {
$groups[$group] = array('clauses' => array(), 'args' => array());
}
$groups[$group]['type'] = strtoupper($type);
return $group;
}
/**
* Control how all WHERE and HAVING groups are put together.
*
* @param $type
* Either 'AND' or 'OR'
*/
function set_group_operator($type = 'AND') {
$this->group_operator = strtoupper($type);
}
/**
* Add a simple WHERE clause to the query. The caller is responsible for
* ensuring that all fields are fully qualified (TABLE.FIELD) and that
* the table already exists in the query.
*
* @param $group
* The WHERE group to add these to; groups are used to create AND/OR
* sections. Groups cannot be nested. Use 0 as the default group.
* If the group does not yet exist it will be created as an AND group.
* @param $clause
* The actual clause to add. When adding a where clause it is important
* that all tables are addressed by the alias provided by add_table or
* ensure_table and that all fields are addressed by their alias wehn
* possible. Please use %d and %s for arguments.
* @param ...
* A number of arguments as used in db_query(). May be many args or one
* array full of args.
*/
function add_where($group, $clause) {
$args = func_get_args();
array_shift($args); // ditch $group
array_shift($args); // ditch $clause
// Expand an array of args if it came in.
if (count($args) == 1 && is_array(reset($args))) {
$args = current($args);
}
// Ensure all variants of 0 are actually 0. Thus '', 0 and NULL are all
// the default group.
if (empty($group)) {
$group = 0;
}
// Check for a group.
if (!isset($this->where[$group])) {
$this->set_where_group('AND', $group);
}
// Add the clause and the args.
if (is_array($args)) {
$this->where[$group]['clauses'][] = $clause;
// we use array_values() here to prevent array_merge errors as keys from multiple
// sources occasionally collide.
$this->where[$group]['args'] = array_merge($this->where[$group]['args'], array_values($args));
}
}
/**
* Add a simple HAVING clause to the query. The caller is responsible for
* ensuring that all fields are fully qualified (TABLE.FIELD) and that
* the table and an appropriate GROUP BY already exist in the query.
*
* @param $group
* The HAVING group to add these to; groups are used to create AND/OR
* sections. Groups cannot be nested. Use 0 as the default group.
* If the group does not yet exist it will be created as an AND group.
* @param $clause
* The actual clause to add. When adding a having clause it is important
* that all tables are addressed by the alias provided by add_table or
* ensure_table and that all fields are addressed by their alias wehn
* possible. Please use %d and %s for arguments.
* @param ...
* A number of arguments as used in db_query(). May be many args or one
* array full of args.
*/
function add_having($group, $clause) {
$args = func_get_args();
array_shift($args); // ditch $group
array_shift($args); // ditch $clause
// Expand an array of args if it came in.
if (count($args) == 1 && is_array(reset($args))) {
$args = current($args);
}
// Ensure all variants of 0 are actually 0. Thus '', 0 and NULL are all
// the default group.
if (empty($group)) {
$group = 0;
}
// Check for a group.
if (!isset($this->having[$group])) {
$this->set_where_group('AND', $group, 'having');
}
// Add the clause and the args.
if (is_array($args)) {
$this->having[$group]['clauses'][] = $clause;
$this->having[$group]['args'] = array_merge($this->having[$group]['args'], array_values($args));
}
}
/**
* Add an ORDER BY clause to the query.
*
* @param $table
* The table this field is part of. If a formula, enter NULL.
* @param $field
* The field or formula to sort on. If already a field, enter NULL
* and put in the alias.
* @param $order
* Either ASC or DESC.
* @param $alias
* The alias to add the field as. In SQL, all fields in the order by
* must also be in the SELECT portion. If an $alias isn't specified
* one will be generated for from the $field; however, if the
* $field is a formula, this alias will likely fail.
*/
function add_orderby($table, $field, $order, $alias = '') {
if ($table) {
$this->ensure_table($table);
}
// Only fill out this aliasing if there is a table;
// otherwise we assume it is a formula.
if (!$alias && $table) {
$as = $table . '_' . $field;
}
else {
$as = $alias;
}
if ($field) {
$this->add_field($table, $field, $as);
}
$this->orderby[] = "$as " . strtoupper($order);
// If grouping, all items in the order by must also be in the
// group by clause. Check $table to ensure that this is not a
// formula.
if ($this->groupby && $table) {
$this->add_groupby($as);
}
}
/**
* Add a simple GROUP BY clause to the query. The caller is responsible
* for ensuring that the fields are fully qualified and the table is properly
* added.
*/
function add_groupby($clause) {
// Only add it if it's not already in there.
if (!in_array($clause, $this->groupby)) {
$this->groupby[] = $clause;
}
}
/**
* Construct the "WHERE" or "HAVING" part of the query.
*
* @param $where
* 'where' or 'having'.
*/
function condition_sql($where = 'where') {
$clauses = array();
foreach ($this->$where as $group => $info) {
$clause = implode(") " . $info['type'] . " (", $info['clauses']);
if (count($info['clauses']) > 1) {
$clause = '(' . $clause . ')';
}
$clauses[] = $clause;
}
if ($clauses) {
$keyword = drupal_strtoupper($where);
if (count($clauses) > 1) {
return "$keyword (" . implode(")\n " . $this->group_operator . ' (', $clauses) . ")\n";
}
else {
return "$keyword " . array_shift($clauses) . "\n";
}
}
return "";
}
/**
* Generate a query and a countquery from all of the information supplied
* to the object.
*
* @param $get_count
* Provide a countquery if this is true, otherwise provide a normal query.
*/
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('&gt;' => '>', '&lt;' => '<');
$query = strtr($query, $replace);
return $query;
}
/**
* Get the arguments attached to the WHERE and HAVING clauses of this query.
*/
function get_where_args() {
$args = array();
foreach ($this->where as $group => $where) {
$args = array_merge($args, $where['args']);
}
foreach ($this->having as $group => $having) {
$args = array_merge($args, $having['args']);
}
return $args;
}
}
Reference in a new issue View git blame Copy permalink