Newer
Older
Dries Buytaert
committed
<?php
/**
* @ingroup database
* @{
*/
require_once __DIR__ . '/query.inc';
Angie Byron
committed
Dries Buytaert
committed
/**
* Interface for extendable query objects.
*
* "Extenders" follow the "Decorator" OOP design pattern. That is, they wrap
* and "decorate" another object. In our case, they implement the same interface
* as select queries and wrap a select query, to which they delegate almost all
* operations. Subclasses of this class may implement additional methods or
* override existing methods as appropriate. Extenders may also wrap other
* extender objects, allowing for arbitrarily complex "enhanced" queries.
*/
interface QueryExtendableInterface {
/**
* Enhance this object by wrapping it in an extender object.
*
* @param $extender_name
* The base name of the extending class. The base name will be checked
* against the current database connection to allow driver-specific subclasses
* as well, using the same logic as the query objects themselves. For example,
* PagerDefault_mysql is the MySQL-specific override for PagerDefault.
Dries Buytaert
committed
* @return QueryExtendableInterface
Dries Buytaert
committed
* The extender object, which now contains a reference to this object.
*/
public function extend($extender_name);
}
/**
* Interface definition for a Select Query object.
*/
interface SelectQueryInterface extends QueryConditionInterface, QueryAlterableInterface, QueryExtendableInterface, QueryPlaceholderInterface {
Dries Buytaert
committed
40
41
42
43
44
45
46
47
48
49
50
51
52
53
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
/* Alter accessors to expose the query data to alter hooks. */
/**
* Returns a reference to the fields array for this query.
*
* Because this method returns by reference, alter hooks may edit the fields
* array directly to make their changes. If just adding fields, however, the
* use of addField() is preferred.
*
* Note that this method must be called by reference as well:
*
* @code
* $fields =& $query->getFields();
* @endcode
*
* @return
* A reference to the fields array structure.
*/
public function &getFields();
/**
* Returns a reference to the expressions array for this query.
*
* Because this method returns by reference, alter hooks may edit the expressions
* array directly to make their changes. If just adding expressions, however, the
* use of addExpression() is preferred.
*
* Note that this method must be called by reference as well:
*
* @code
* $fields =& $query->getExpressions();
* @endcode
*
* @return
* A reference to the expression array structure.
*/
public function &getExpressions();
/**
* Returns a reference to the order by array for this query.
*
* Because this method returns by reference, alter hooks may edit the order-by
* array directly to make their changes. If just adding additional ordering
* fields, however, the use of orderBy() is preferred.
*
* Note that this method must be called by reference as well:
*
* @code
* $fields =& $query->getOrderBy();
* @endcode
*
* @return
* A reference to the expression array structure.
*/
public function &getOrderBy();
/**
* Returns a reference to the group-by array for this query.
*
* Because this method returns by reference, alter hooks may edit the group-by
* array directly to make their changes. If just adding additional grouping
* fields, however, the use of groupBy() is preferred.
*
* Note that this method must be called by reference as well:
*
* @code
* $fields =& $query->getGroupBy();
* @endcode
*
* @return
* A reference to the group-by array structure.
*/
public function &getGroupBy();
Dries Buytaert
committed
/**
* Returns a reference to the tables array for this query.
*
* Because this method returns by reference, alter hooks may edit the tables
* array directly to make their changes. If just adding tables, however, the
* use of the join() methods is preferred.
*
* Note that this method must be called by reference as well:
*
* @code
* $fields =& $query->getTables();
* @endcode
*
* @return
* A reference to the tables array structure.
*/
public function &getTables();
Dries Buytaert
committed
/**
* Returns a reference to the union queries for this query. This include
* queries for UNION, UNION ALL, and UNION DISTINCT.
*
* Because this method returns by reference, alter hooks may edit the tables
* array directly to make their changes. If just adding union queries,
* however, the use of the union() method is preferred.
*
* Note that this method must be called by reference as well:
*
* @code
* $fields =& $query->getUnion();
* @endcode
*
* @return
* A reference to the union query array structure.
*/
public function &getUnion();
Dries Buytaert
committed
/**
* Compiles and returns an associative array of the arguments for this prepared statement.
*
* @param $queryPlaceholder
* When collecting the arguments of a subquery, the main placeholder
* object should be passed as this parameter.
*
Dries Buytaert
committed
* @return
* An associative array of all placeholder arguments for this query.
*/
public function getArguments(QueryPlaceholderInterface $queryPlaceholder = NULL);
Dries Buytaert
committed
/* Query building operations */
/**
* Sets this query to be DISTINCT.
*
* @param $distinct
* TRUE to flag this query DISTINCT, FALSE to disable it.
Dries Buytaert
committed
* @return SelectQueryInterface
Dries Buytaert
committed
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
* The called object.
*/
public function distinct($distinct = TRUE);
/**
* Adds a field to the list to be SELECTed.
*
* @param $table_alias
* The name of the table from which the field comes, as an alias. Generally
* 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
* The alias for this field. If not specified, one will be generated
* automatically based on the $table_alias and $field. The alias will be
* 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);
/**
* Add multiple fields from the same table to be SELECTed.
*
* This method does not return the aliases set for the passed fields. In the
* majority of cases that is not a problem, as the alias will be the field
* 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,
* simply use addField() for the few fields you care about and this method for
* the rest.
*
* @param $table_alias
* The name of the table from which the field comes, as an alias. Generally
* 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
* included in this query. If not specified, $table_alias.* will be generated
* without any aliases.
Dries Buytaert
committed
* @return SelectQueryInterface
Dries Buytaert
committed
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
* The called object.
*/
public function fields($table_alias, array $fields = array());
/**
* Adds an expression to the list of "fields" to be SELECTed.
*
* An expression can be any arbitrary string that is valid SQL. That includes
* various functions, which may in some cases be database-dependent. This
* method makes no effort to correct for database-specific functions.
*
* @param $expression
* The expression string. May contain placeholders.
* @param $alias
* The alias for this expression. If not specified, one will be generated
* automatically in the form "expression_#". The alias will be checked for
* uniqueness, so the requested alias may not be the alias that is assigned
* 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());
/**
* 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
* 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.
* @param $condition
* The condition on which to join this table. If the join requires values,
* this clause should use a named placeholder and the value or values to
* insert should be passed in the 4th parameter. For the first table joined
* on a query, this value is ignored as the first table is taken as the base
* table. The token %alias can be used in this string to be replaced with
* the actual alias. This is useful when $alias is modified by the database
* system, for example, when joining the same table more than once.
Dries Buytaert
committed
* @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());
/**
* Inner Join against another table in the database.
*
* @param $table
* The table against which to join.
* @param $alias
* 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.
* @param $condition
* The condition on which to join this table. If the join requires values,
* this clause should use a named placeholder and the value or values to
* insert should be passed in the 4th parameter. For the first table joined
* on a query, this value is ignored as the first table is taken as the base
* table. The token %alias can be used in this string to be replaced with
* the actual alias. This is useful when $alias is modified by the database
* system, for example, when joining the same table more than once.
Dries Buytaert
committed
* @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());
/**
* Left Outer Join against another table in the database.
*
* @param $table
* The table against which to join.
* @param $alias
* 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.
* @param $condition
* The condition on which to join this table. If the join requires values,
* this clause should use a named placeholder and the value or values to
* insert should be passed in the 4th parameter. For the first table joined
* on a query, this value is ignored as the first table is taken as the base
* table. The token %alias can be used in this string to be replaced with
* the actual alias. This is useful when $alias is modified by the database
* system, for example, when joining the same table more than once.
Dries Buytaert
committed
* @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());
/**
* Right Outer Join against another table in the database.
*
* @param $table
* The table against which to join.
* @param $alias
* 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.
* @param $condition
* The condition on which to join this table. If the join requires values,
* this clause should use a named placeholder and the value or values to
* insert should be passed in the 4th parameter. For the first table joined
* on a query, this value is ignored as the first table is taken as the base
* table. The token %alias can be used in this string to be replaced with
* the actual alias. This is useful when $alias is modified by the database
* system, for example, when joining the same table more than once.
Dries Buytaert
committed
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
* @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());
/**
* 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.
*
* @param $type
* The type of join. Typically one one of INNER, LEFT OUTER, and RIGHT OUTER.
* @param $table
* 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.
* @param $alias
* 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,
* one will be dynamically generated.
* @param $condition
* The condition on which to join this table. If the join requires values,
* this clause should use a named placeholder and the value or values to
* insert should be passed in the 4th parameter. For the first table joined
* on a query, this value is ignored as the first table is taken as the base
* table. The token %alias can be used in this string to be replaced with
* the actual alias. This is useful when $alias is modified by the database
* system, for example, when joining the same table more than once.
Dries Buytaert
committed
* @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 addJoin($type, $table, $alias = NULL, $condition = NULL, $arguments = array());
/**
* 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.
*
* If the query uses DISTINCT or GROUP BY conditions, fields or expressions
* that are used for the order must be selected to be compatible with some
* databases like PostgreSQL. The PostgreSQL driver can handle simple cases
* automatically but it is suggested to explicitly specify them. Additionally,
* when ordering on an alias, the alias must be added before orderBy() is
* called.
*
Dries Buytaert
committed
* @param $field
* The field on which to order.
* @param $direction
* The direction to sort. Legal values are "ASC" and "DESC".
Dries Buytaert
committed
* @return SelectQueryInterface
Dries Buytaert
committed
* The called object.
*/
public function orderBy($field, $direction = 'ASC');
Angie Byron
committed
/**
* Orders the result set by a random value.
*
* This may be stacked with other orderBy() calls. If so, the query will order
* by each specified field, including this one, in the order called. Although
* this method may be called multiple times on the same query, doing so
* is not particularly useful.
*
* Note: The method used by most drivers may not scale to very large result
* sets. If you need to work with extremely large data sets, you may create
* your own database driver by subclassing off of an existing driver and
* implementing your own randomization mechanism. See
*
* http://jan.kneschke.de/projects/mysql/order-by-rand/
*
* for an example of such an alternate sorting mechanism.
*
Dries Buytaert
committed
* @return SelectQueryInterface
Angie Byron
committed
* The called object
*/
public function orderRandom();
Dries Buytaert
committed
/**
* 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
* The first record from the result set to return. If NULL, removes any
* range directives that are set.
* @param $length
Dries Buytaert
committed
* The number of records to return from the result set.
Dries Buytaert
committed
* @return SelectQueryInterface
Dries Buytaert
committed
* The called object.
*/
public function range($start = NULL, $length = NULL);
Dries Buytaert
committed
/**
* Add another Select query to UNION to this one.
*
* Union queries consist of two or more queries whose
* results are effectively concatenated together. Queries
* will be UNIONed in the order they are specified, with
* this object's query coming first. Duplicate columns will
* be discarded. All forms of UNION are supported, using
* the second '$type' argument.
*
* Note: All queries UNIONed together must have the same
* field structure, in the same order. It is up to the
* caller to ensure that they match properly. If they do
* not, an SQL syntax error will result.
*
* @param $query
* The query to UNION to this query.
* @param $type
* The type of UNION to add to the query. Defaults to plain
* UNION.
Dries Buytaert
committed
* @return SelectQueryInterface
Dries Buytaert
committed
* The called object.
*/
public function union(SelectQueryInterface $query, $type = '');
Dries Buytaert
committed
/**
* Groups the result set by the specified field.
*
* @param $field
* The field on which to group. This should be the field as aliased.
Dries Buytaert
committed
* @return SelectQueryInterface
Dries Buytaert
committed
* The called object.
*/
public function groupBy($field);
/**
* Get the equivalent COUNT query of this query as a new query object.
*
Dries Buytaert
committed
* @return SelectQueryInterface
Dries Buytaert
committed
* A new SelectQuery object with no fields or expressions besides COUNT(*).
*/
public function countQuery();
Angie Byron
committed
/**
* Indicates if preExecute() has already been called on that object.
Dries Buytaert
committed
*
* @return
* TRUE is this query has already been prepared, FALSE otherwise.
Angie Byron
committed
*/
public function isPrepared();
/**
* Generic preparation and validation for a SELECT query.
*
* @return
* TRUE if the validation was successful, FALSE if not.
*/
public function preExecute(SelectQueryInterface $query = NULL);
Dries Buytaert
committed
/**
* Helper function to build most common HAVING conditional clauses.
*
* This method can take a variable number of parameters. If called with two
* parameters, they are taken as $field and $value with $operator having a value
* of IN if $value is an array and = otherwise.
*
* @param $field
* The name of the field to check. If you would like to add a more complex
* condition involving operators or functions, use having().
* @param $value
* The value to test the field against. In most cases, this is a scalar. For more
* complex options, it is an array. The meaning of each element in the array is
* dependent on the $operator.
* @param $operator
* The comparison operator, such as =, <, or >=. It also accepts more complex
* options such as IN, LIKE, or BETWEEN. Defaults to IN if $value is an array
* = otherwise.
* @return QueryConditionInterface
* The called object.
*/
public function havingCondition($field, $value = NULL, $operator = NULL);
Dries Buytaert
committed
/**
* Clone magic method.
*
* Select queries have dependent objects that must be deep-cloned. The
* connection object itself, however, should not be cloned as that would
* duplicate the connection itself.
*/
public function __clone();
/**
* Add FOR UPDATE to the query.
*
* FOR UPDATE prevents the rows retrieved by the SELECT statement from being
* modified or deleted by other transactions until the current transaction
* ends. Other transactions that attempt UPDATE, DELETE, or SELECT FOR UPDATE
* of these rows will be blocked until the current transaction ends.
*
* @param $set
* IF TRUE, FOR UPDATE will be added to the query, if FALSE then it won't.
*
* @return QueryConditionInterface
* The called object.
*/
public function forUpdate($set = TRUE);
Dries Buytaert
committed
}
/**
* The base extender class for Select queries.
*/
class SelectQueryExtender implements SelectQueryInterface {
/**
* The SelectQuery object we are extending/decorating.
*
* @var SelectQueryInterface
*/
protected $query;
/**
* The connection object on which to run this query.
*
* @var DatabaseConnection
*/
protected $connection;
Angie Byron
committed
/**
* A unique identifier for this query object.
*/
protected $uniqueIdentifier;
/**
* The placeholder counter.
*/
protected $placeholder = 0;
Dries Buytaert
committed
public function __construct(SelectQueryInterface $query, DatabaseConnection $connection) {
Angie Byron
committed
$this->uniqueIdentifier = uniqid('', TRUE);
Dries Buytaert
committed
$this->query = $query;
$this->connection = $connection;
}
Angie Byron
committed
/**
* Implements QueryPlaceholderInterface::uniqueIdentifier().
*/
public function uniqueIdentifier() {
return $this->uniqueIdentifier;
}
Angie Byron
committed
/**
* Implements QueryPlaceholderInterface::nextPlaceholder().
*/
public function nextPlaceholder() {
return $this->placeholder++;
}
Dries Buytaert
committed
/* Implementations of QueryAlterableInterface. */
public function addTag($tag) {
$this->query->addTag($tag);
return $this;
}
public function hasTag($tag) {
return $this->query->hasTag($tag);
}
public function hasAllTags() {
Dries Buytaert
committed
return call_user_func_array(array($this->query, 'hasAllTags'), func_get_args());
Dries Buytaert
committed
}
public function hasAnyTag() {
Dries Buytaert
committed
return call_user_func_array(array($this->query, 'hasAnyTags'), func_get_args());
Dries Buytaert
committed
}
public function addMetaData($key, $object) {
$this->query->addMetaData($key, $object);
return $this;
}
public function getMetaData($key) {
return $this->query->getMetaData($key);
}
/* Implementations of QueryConditionInterface for the WHERE clause. */
public function condition($field, $value = NULL, $operator = NULL) {
Dries Buytaert
committed
$this->query->condition($field, $value, $operator);
return $this;
}
public function &conditions() {
return $this->query->conditions();
}
public function arguments() {
return $this->query->arguments();
}
public function where($snippet, $args = array()) {
$this->query->where($snippet, $args);
return $this;
}
Angie Byron
committed
public function compile(DatabaseConnection $connection, QueryPlaceholderInterface $queryPlaceholder) {
return $this->query->compile($connection, $queryPlaceholder);
}
public function compiled() {
return $this->query->compiled();
Dries Buytaert
committed
}
/* Implementations of QueryConditionInterface for the HAVING clause. */
Dries Buytaert
committed
public function havingCondition($field, $value = NULL, $operator = '=') {
$this->query->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()) {
Dries Buytaert
committed
$this->query->having($snippet, $args);
Dries Buytaert
committed
return $this;
}
public function havingCompile(DatabaseConnection $connection) {
return $this->query->havingCompile($connection);
}
/* Implementations of QueryExtendableInterface. */
public function extend($extender_name) {
Angie Byron
committed
// The extender can be anywhere so this needs to go to the registry, which
// is surely loaded by now.
$class = $this->connection->getDriverClass($extender_name, array(), TRUE);
return new $class($this, $this->connection);
Dries Buytaert
committed
}
/* Alter accessors to expose the query data to alter hooks. */
public function &getFields() {
return $this->query->getFields();
}
public function &getExpressions() {
return $this->query->getExpressions();
}
public function &getOrderBy() {
return $this->query->getOrderBy();
}
public function &getGroupBy() {
return $this->query->getGroupBy();
}
Dries Buytaert
committed
public function &getTables() {
return $this->query->getTables();
}
Dries Buytaert
committed
public function &getUnion() {
return $this->query->getUnion();
}
public function getArguments(QueryPlaceholderInterface $queryPlaceholder = NULL) {
return $this->query->getArguments($queryPlaceholder);
Dries Buytaert
committed
}
Angie Byron
committed
public function isPrepared() {
return $this->query->isPrepared();
}
public function preExecute(SelectQueryInterface $query = NULL) {
// If no query object is passed in, use $this.
Dries Buytaert
committed
if (!isset($query)) {
Angie Byron
committed
$query = $this;
}
return $this->query->preExecute($query);
}
Dries Buytaert
committed
public function execute() {
Angie Byron
committed
// By calling preExecute() here, we force it to preprocess the extender
// object rather than just the base query object. That means
// hook_query_alter() gets access to the extended object.
if (!$this->preExecute($this)) {
return NULL;
}
Dries Buytaert
committed
721
722
723
724
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
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
return $this->query->execute();
}
public function distinct($distinct = TRUE) {
$this->query->distinct($distinct);
return $this;
}
public function addField($table_alias, $field, $alias = NULL) {
return $this->query->addField($table_alias, $field, $alias);
}
public function fields($table_alias, array $fields = array()) {
$this->query->fields($table_alias, $fields);
return $this;
}
public function addExpression($expression, $alias = NULL, $arguments = array()) {
return $this->query->addExpression($expression, $alias, $arguments);
}
public function join($table, $alias = NULL, $condition = NULL, $arguments = array()) {
return $this->query->join($table, $alias, $condition, $arguments);
}
public function innerJoin($table, $alias = NULL, $condition = NULL, $arguments = array()) {
return $this->query->innerJoin($table, $alias, $condition, $arguments);
}
public function leftJoin($table, $alias = NULL, $condition = NULL, $arguments = array()) {
return $this->query->leftJoin($table, $alias, $condition, $arguments);
}
public function rightJoin($table, $alias = NULL, $condition = NULL, $arguments = array()) {
return $this->query->rightJoin($table, $alias, $condition, $arguments);
}
public function addJoin($type, $table, $alias = NULL, $condition = NULL, $arguments = array()) {
return $this->query->addJoin($type, $table, $alias, $condition, $arguments);
}
public function orderBy($field, $direction = 'ASC') {
$this->query->orderBy($field, $direction);
return $this;
}
Angie Byron
committed
public function orderRandom() {
$this->query->orderRandom();
return $this;
}
Dries Buytaert
committed
public function range($start = NULL, $length = NULL) {
$this->query->range($start, $length);
return $this;
}
Dries Buytaert
committed
public function union(SelectQueryInterface $query, $type = '') {
$this->query->union($query, $type);
return $this;
}
Dries Buytaert
committed
public function groupBy($field) {
$this->query->groupBy($field);
return $this;
}
public function forUpdate($set = TRUE) {
$this->query->forUpdate($set);
return $this;
}
Dries Buytaert
committed
public function countQuery() {
// Create our new query object that we will mutate into a count query.
$count = clone($this);
// Zero-out existing fields and expressions.
$fields =& $count->getFields();
$fields = array();
$expressions =& $count->getExpressions();
$expressions = array();
Angie Byron
committed
// Also remove 'all_fields' statements, which are expanded into tablename.*
// when the query is executed.
Dries Buytaert
committed
$tables = &$count->getTables();
foreach ($tables as $alias => &$table) {
Angie Byron
committed
unset($table['all_fields']);
}
Dries Buytaert
committed
// Ordering a count query is a waste of cycles, and breaks on some
// databases anyway.
$orders = &$count->getOrderBy();
$orders = array();
// COUNT() is an expression, so we add that back in.
$count->addExpression('COUNT(*)');
return $count;
}
Angie Byron
committed
function isNull($field) {
$this->query->isNull($field);
return $this;
}
function isNotNull($field) {
$this->query->isNotNull($field);
return $this;
}
Angie Byron
committed
public function exists(SelectQueryInterface $select) {
$this->query->exists($select);
return $this;
}
public function notExists(SelectQueryInterface $select) {
$this->query->notExists($select);
return $this;
}
Dries Buytaert
committed
public function __toString() {
return (string) $this->query;
Dries Buytaert
committed
}
public function __clone() {
Angie Byron
committed
$this->uniqueIdentifier = uniqid('', TRUE);
Dries Buytaert
committed
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
// We need to deep-clone the query we're wrapping, which in turn may
// deep-clone other objects. Exciting!
$this->query = clone($this->query);
}
/**
* Magic override for undefined methods.
*
* If one extender extends another extender, then methods in the inner extender
* will not be exposed on the outer extender. That's because we cannot know
* in advance what those methods will be, so we cannot provide wrapping
* implementations as we do above. Instead, we use this slower catch-all method
* to handle any additional methods.
*/
public function __call($method, $args) {
$return = call_user_func_array(array($this->query, $method), $args);
// Some methods will return the called object as part of a fluent interface.
// Others will return some useful value. If it's a value, then the caller
// probably wants that value. If it's the called object, then we instead
// return this object. That way we don't "lose" an extender layer when
// chaining methods together.
if ($return instanceof SelectQueryInterface) {
return $this;
}
else {
return $return;
}
}
}
Dries Buytaert
committed
/**
* Query builder for SELECT statements.
*/
Dries Buytaert
committed
class SelectQuery extends Query implements SelectQueryInterface {
Dries Buytaert
committed
/**
* 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.
*
Dries Buytaert
committed
* 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:
Dries Buytaert
committed
*
* array(
* 'type' => $join_type (one of INNER, LEFT OUTER, RIGHT OUTER),
Dries Buytaert
committed
* 'table' => $table,
Dries Buytaert
committed
* 'alias' => $alias_of_the_table,
* 'condition' => $condition_clause_on_which_to_join,
* 'arguments' => $array_of_arguments_for_placeholders_in_the condition.
Angie Byron
committed
* 'all_fields' => TRUE to SELECT $alias.*, FALSE or NULL otherwise.
Dries Buytaert
committed
* )
*
Dries Buytaert
committed
* If $table is a string, it is taken as the name of a table. If it is
Dries Buytaert
committed
* a SelectQuery object, it is taken as a subquery.
*
Dries Buytaert
committed
* @var array
*/
protected $tables = array();
/**
* The fields by which to order this query.
*
Dries Buytaert
committed
* This is an associative array. The keys are the fields to order, and the value
Dries Buytaert
committed
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
* 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;
Dries Buytaert
committed
/**
* 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
*/
protected $union = array();
Angie Byron
committed
/**
* Indicates if preExecute() has already been called.
* @var boolean
*/
protected $prepared = FALSE;
/**
* The FOR UPDATE status
*/
protected $forUpdate = FALSE;
Dries Buytaert
committed
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);
}
Angie Byron
committed
Dries Buytaert
committed
/* Implementations of QueryAlterableInterface. */
Angie Byron
committed
Dries Buytaert
committed
public function addTag($tag) {
$this->alterTags[$tag] = 1;
Dries Buytaert
committed
return $this;