class SelectExtender
Same name in other branches
- 9 core/lib/Drupal/Core/Database/Query/SelectExtender.php \Drupal\Core\Database\Query\SelectExtender
- 8.9.x core/lib/Drupal/Core/Database/Query/SelectExtender.php \Drupal\Core\Database\Query\SelectExtender
- 11.x core/lib/Drupal/Core/Database/Query/SelectExtender.php \Drupal\Core\Database\Query\SelectExtender
The base extender class for Select queries.
Hierarchy
- class \Drupal\Core\Database\Query\SelectExtender implements \Drupal\Core\Database\Query\SelectInterface
Expanded class hierarchy of SelectExtender
5 files declare their use of SelectExtender
- NodeSearch.php in core/
modules/ node/ src/ Plugin/ Search/ NodeSearch.php - SearchQuery.php in core/
modules/ search/ src/ SearchQuery.php - SelectExtenderTest.php in core/
tests/ Drupal/ KernelTests/ Core/ Database/ SelectExtenderTest.php - SelectTest.php in core/
tests/ Drupal/ KernelTests/ Core/ Database/ SelectTest.php - TaggingTest.php in core/
tests/ Drupal/ KernelTests/ Core/ Database/ TaggingTest.php
File
-
core/
lib/ Drupal/ Core/ Database/ Query/ SelectExtender.php, line 10
Namespace
Drupal\Core\Database\QueryView source
class SelectExtender implements SelectInterface {
/**
* The Select query object we are extending/decorating.
*
* @var \Drupal\Core\Database\Query\SelectInterface
*/
protected $query;
/**
* The connection object on which to run this query.
*
* @var \Drupal\Core\Database\Connection
*/
protected $connection;
/**
* A unique identifier for this query object.
*
* @var string
*/
protected $uniqueIdentifier;
/**
* The placeholder counter.
*
* @var int
*/
protected $placeholder = 0;
public function __construct(SelectInterface $query, Connection $connection) {
$this->uniqueIdentifier = uniqid('', TRUE);
$this->query = $query;
$this->connection = $connection;
}
/**
* {@inheritdoc}
*/
public function uniqueIdentifier() {
return $this->uniqueIdentifier;
}
/**
* {@inheritdoc}
*/
public function nextPlaceholder() {
return $this->placeholder++;
}
/**
* {@inheritdoc}
*/
public function addTag($tag) {
$this->query
->addTag($tag);
return $this;
}
/**
* {@inheritdoc}
*/
public function hasTag($tag) {
return $this->query
->hasTag($tag);
}
/**
* {@inheritdoc}
*/
public function hasAllTags() {
return call_user_func_array([
$this->query,
'hasAllTags',
], func_get_args());
}
/**
* {@inheritdoc}
*/
public function hasAnyTag() {
return call_user_func_array([
$this->query,
'hasAnyTag',
], func_get_args());
}
/**
* {@inheritdoc}
*/
public function addMetaData($key, $object) {
$this->query
->addMetaData($key, $object);
return $this;
}
/**
* {@inheritdoc}
*/
public function getMetaData($key) {
return $this->query
->getMetaData($key);
}
/**
* {@inheritdoc}
*/
public function condition($field, $value = NULL, $operator = '=') {
$this->query
->condition($field, $value, $operator);
return $this;
}
/**
* {@inheritdoc}
*/
public function &conditions() {
return $this->query
->conditions();
}
/**
* {@inheritdoc}
*/
public function arguments() {
return $this->query
->arguments();
}
/**
* {@inheritdoc}
*/
public function where($snippet, $args = []) {
$this->query
->where($snippet, $args);
return $this;
}
/**
* {@inheritdoc}
*/
public function compile(Connection $connection, PlaceholderInterface $queryPlaceholder) {
return $this->query
->compile($connection, $queryPlaceholder);
}
/**
* {@inheritdoc}
*/
public function compiled() {
return $this->query
->compiled();
}
/**
* {@inheritdoc}
*/
public function havingCondition($field, $value = NULL, $operator = '=') {
$this->query
->havingCondition($field, $value, $operator);
return $this;
}
/**
* {@inheritdoc}
*/
public function &havingConditions() {
return $this->query
->havingConditions();
}
/**
* {@inheritdoc}
*/
public function havingArguments() {
return $this->query
->havingArguments();
}
/**
* {@inheritdoc}
*/
public function having($snippet, $args = []) {
$this->query
->having($snippet, $args);
return $this;
}
/**
* {@inheritdoc}
*/
public function havingCompile(Connection $connection) {
return $this->query
->havingCompile($connection);
}
/**
* {@inheritdoc}
*/
public function havingIsNull($field) {
$this->query
->havingIsNull($field);
return $this;
}
/**
* {@inheritdoc}
*/
public function havingIsNotNull($field) {
$this->query
->havingIsNotNull($field);
return $this;
}
/**
* {@inheritdoc}
*/
public function havingExists(SelectInterface $select) {
$this->query
->havingExists($select);
return $this;
}
/**
* {@inheritdoc}
*/
public function havingNotExists(SelectInterface $select) {
$this->query
->havingNotExists($select);
return $this;
}
/**
* {@inheritdoc}
*/
public function extend($extender_name) {
// We cannot call $this->query->extend(), because with multiple extenders
// you will replace all the earlier extenders with the last extender,
// instead of creating list of objects that extend each other.
$parts = explode('\\', $extender_name);
$class = end($parts);
$driver_class = $this->connection
->getDriverClass($class);
if ($driver_class !== $class) {
return new $driver_class($this, $this->connection);
}
return new $extender_name($this, $this->connection);
}
/* Alter accessors to expose the query data to alter hooks. */
/**
* {@inheritdoc}
*/
public function &getFields() {
return $this->query
->getFields();
}
/**
* {@inheritdoc}
*/
public function &getExpressions() {
return $this->query
->getExpressions();
}
/**
* {@inheritdoc}
*/
public function &getOrderBy() {
return $this->query
->getOrderBy();
}
/**
* {@inheritdoc}
*/
public function &getGroupBy() {
return $this->query
->getGroupBy();
}
/**
* {@inheritdoc}
*/
public function &getTables() {
return $this->query
->getTables();
}
/**
* {@inheritdoc}
*/
public function &getUnion() {
return $this->query
->getUnion();
}
/**
* {@inheritdoc}
*/
public function escapeLike($string) {
return $this->query
->escapeLike($string);
}
/**
* {@inheritdoc}
*/
public function escapeField($string) {
$this->query
->escapeField($string);
return $this;
}
/**
* {@inheritdoc}
*/
public function getArguments(?PlaceholderInterface $queryPlaceholder = NULL) {
return $this->query
->getArguments($queryPlaceholder);
}
/**
* {@inheritdoc}
*/
public function isPrepared() {
return $this->query
->isPrepared();
}
/**
* {@inheritdoc}
*/
public function preExecute(?SelectInterface $query = NULL) {
// If no query object is passed in, use $this.
if (!isset($query)) {
$query = $this;
}
return $this->query
->preExecute($query);
}
/**
* {@inheritdoc}
*/
public function execute() {
// 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;
}
return $this->query
->execute();
}
/**
* {@inheritdoc}
*/
public function distinct($distinct = TRUE) {
$this->query
->distinct($distinct);
return $this;
}
/**
* {@inheritdoc}
*/
public function addField($table_alias, $field, $alias = NULL) {
return $this->query
->addField($table_alias, $field, $alias);
}
/**
* {@inheritdoc}
*/
public function fields($table_alias, array $fields = []) {
$this->query
->fields($table_alias, $fields);
return $this;
}
/**
* {@inheritdoc}
*/
public function addExpression($expression, $alias = NULL, $arguments = []) {
return $this->query
->addExpression($expression, $alias, $arguments);
}
/**
* {@inheritdoc}
*/
public function join($table, $alias = NULL, $condition = NULL, $arguments = []) {
return $this->query
->join($table, $alias, $condition, $arguments);
}
/**
* {@inheritdoc}
*/
public function innerJoin($table, $alias = NULL, $condition = NULL, $arguments = []) {
return $this->query
->innerJoin($table, $alias, $condition, $arguments);
}
/**
* {@inheritdoc}
*/
public function leftJoin($table, $alias = NULL, $condition = NULL, $arguments = []) {
return $this->query
->leftJoin($table, $alias, $condition, $arguments);
}
/**
* {@inheritdoc}
*/
public function addJoin($type, $table, $alias = NULL, $condition = NULL, $arguments = []) {
return $this->query
->addJoin($type, $table, $alias, $condition, $arguments);
}
/**
* {@inheritdoc}
*/
public function orderBy($field, $direction = 'ASC') {
$this->query
->orderBy($field, $direction);
return $this;
}
/**
* {@inheritdoc}
*/
public function orderRandom() {
$this->query
->orderRandom();
return $this;
}
/**
* {@inheritdoc}
*/
public function range($start = NULL, $length = NULL) {
$this->query
->range($start, $length);
return $this;
}
/**
* {@inheritdoc}
*/
public function union(SelectInterface $query, $type = '') {
$this->query
->union($query, $type);
return $this;
}
/**
* {@inheritdoc}
*/
public function groupBy($field) {
$this->query
->groupBy($field);
return $this;
}
/**
* {@inheritdoc}
*/
public function forUpdate($set = TRUE) {
$this->query
->forUpdate($set);
return $this;
}
/**
* {@inheritdoc}
*/
public function countQuery() {
return $this->query
->countQuery();
}
/**
* {@inheritdoc}
*/
public function isNull($field) {
$this->query
->isNull($field);
return $this;
}
/**
* {@inheritdoc}
*/
public function isNotNull($field) {
$this->query
->isNotNull($field);
return $this;
}
/**
* {@inheritdoc}
*/
public function exists(SelectInterface $select) {
$this->query
->exists($select);
return $this;
}
/**
* {@inheritdoc}
*/
public function notExists(SelectInterface $select) {
$this->query
->notExists($select);
return $this;
}
/**
* {@inheritdoc}
*/
public function alwaysFalse() {
$this->query
->alwaysFalse();
return $this;
}
/**
* {@inheritdoc}
*/
public function __toString() {
return (string) $this->query;
}
/**
* {@inheritdoc}
*/
public function __clone() {
$this->uniqueIdentifier = uniqid('', TRUE);
// 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([
$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 SelectInterface) {
return $this;
}
else {
return $return;
}
}
/**
* {@inheritdoc}
*/
public function conditionGroupFactory($conjunction = 'AND') {
return $this->connection
->condition($conjunction);
}
/**
* {@inheritdoc}
*/
public function andConditionGroup() {
return $this->conditionGroupFactory('AND');
}
/**
* {@inheritdoc}
*/
public function orConditionGroup() {
return $this->conditionGroupFactory('OR');
}
}
Members
Title Sort descending | Modifiers | Object type | Summary | Overriden Title | Overrides |
---|---|---|---|---|---|
SelectExtender::$connection | protected | property | The connection object on which to run this query. | ||
SelectExtender::$placeholder | protected | property | The placeholder counter. | ||
SelectExtender::$query | protected | property | The Select query object we are extending/decorating. | ||
SelectExtender::$uniqueIdentifier | protected | property | A unique identifier for this query object. | ||
SelectExtender::addExpression | public | function | Adds an expression to the list of "fields" to be SELECTed. | Overrides SelectInterface::addExpression | |
SelectExtender::addField | public | function | Adds a field to the list to be SELECTed. | Overrides SelectInterface::addField | |
SelectExtender::addJoin | public | function | Join against another table in the database. | Overrides SelectInterface::addJoin | |
SelectExtender::addMetaData | public | function | Adds additional metadata to the query. | Overrides AlterableInterface::addMetaData | |
SelectExtender::addTag | public | function | Adds a tag to a query. | Overrides AlterableInterface::addTag | |
SelectExtender::alwaysFalse | public | function | Sets a condition that is always false. | Overrides ConditionInterface::alwaysFalse | |
SelectExtender::andConditionGroup | public | function | Creates a new group of conditions ANDed together. | Overrides ConditionInterface::andConditionGroup | |
SelectExtender::arguments | public | function | Gets a complete list of all values to insert into the prepared statement. | Overrides ConditionInterface::arguments | |
SelectExtender::compile | public | function | Compiles the saved conditions for later retrieval. | Overrides ConditionInterface::compile | |
SelectExtender::compiled | public | function | Check whether a condition has been previously compiled. | Overrides ConditionInterface::compiled | |
SelectExtender::condition | public | function | Helper function: builds the most common conditional clauses. | Overrides ConditionInterface::condition | |
SelectExtender::conditionGroupFactory | public | function | Creates an object holding a group of conditions. | Overrides ConditionInterface::conditionGroupFactory | |
SelectExtender::conditions | public | function | Gets the, possibly nested, list of conditions in this conditional clause. | Overrides ConditionInterface::conditions | 1 |
SelectExtender::countQuery | public | function | Get the equivalent COUNT query of this query as a new query object. | Overrides SelectInterface::countQuery | 1 |
SelectExtender::distinct | public | function | Sets this query to be DISTINCT. | Overrides SelectInterface::distinct | |
SelectExtender::escapeField | public | function | Escapes a field name string. | Overrides SelectInterface::escapeField | |
SelectExtender::escapeLike | public | function | Escapes characters that work as wildcard characters in a LIKE pattern. | Overrides SelectInterface::escapeLike | |
SelectExtender::execute | public | function | Runs the query against the database. | Overrides SelectInterface::execute | 2 |
SelectExtender::exists | public | function | Sets a condition that the specified subquery returns values. | Overrides ConditionInterface::exists | |
SelectExtender::extend | public | function | Enhance this object by wrapping it in an extender object. | Overrides ExtendableInterface::extend | |
SelectExtender::fields | public | function | Add multiple fields from the same table to be SELECTed. | Overrides SelectInterface::fields | |
SelectExtender::forUpdate | public | function | Add FOR UPDATE to the query. | Overrides SelectInterface::forUpdate | |
SelectExtender::getArguments | public | function | Compiles and returns an associative array of the arguments for this prepared statement. | Overrides SelectInterface::getArguments | |
SelectExtender::getExpressions | public | function | Returns a reference to the expressions array for this query. | Overrides SelectInterface::getExpressions | |
SelectExtender::getFields | public | function | Returns a reference to the fields array for this query. | Overrides SelectInterface::getFields | |
SelectExtender::getGroupBy | public | function | Returns a reference to the group-by array for this query. | Overrides SelectInterface::getGroupBy | |
SelectExtender::getMetaData | public | function | Retrieves a given piece of metadata. | Overrides AlterableInterface::getMetaData | |
SelectExtender::getOrderBy | public | function | Returns a reference to the order by array for this query. | Overrides SelectInterface::getOrderBy | |
SelectExtender::getTables | public | function | Returns a reference to the tables array for this query. | Overrides SelectInterface::getTables | |
SelectExtender::getUnion | public | function | Returns a reference to the union queries for this query. | Overrides SelectInterface::getUnion | |
SelectExtender::groupBy | public | function | Groups the result set by the specified field. | Overrides SelectInterface::groupBy | |
SelectExtender::hasAllTags | public | function | Determines if a given query has all specified tags. | Overrides AlterableInterface::hasAllTags | |
SelectExtender::hasAnyTag | public | function | Determines if a given query has any specified tag. | Overrides AlterableInterface::hasAnyTag | |
SelectExtender::hasTag | public | function | Determines if a given query has a given tag. | Overrides AlterableInterface::hasTag | |
SelectExtender::having | public | function | Adds an arbitrary HAVING clause to the query. | Overrides SelectInterface::having | |
SelectExtender::havingArguments | public | function | Gets a list of all values to insert into the HAVING clause. | Overrides SelectInterface::havingArguments | |
SelectExtender::havingCompile | public | function | Compiles the HAVING clause for later retrieval. | Overrides SelectInterface::havingCompile | |
SelectExtender::havingCondition | public | function | Helper function to build most common HAVING conditional clauses. | Overrides SelectInterface::havingCondition | |
SelectExtender::havingConditions | public | function | Gets a list of all conditions in the HAVING clause. | Overrides SelectInterface::havingConditions | |
SelectExtender::havingExists | public | function | Sets a HAVING condition that the specified subquery returns values. | Overrides SelectInterface::havingExists | |
SelectExtender::havingIsNotNull | public | function | Sets a condition in the HAVING clause that the specified field be NOT NULL. | Overrides SelectInterface::havingIsNotNull | |
SelectExtender::havingIsNull | public | function | Sets a condition in the HAVING clause that the specified field be NULL. | Overrides SelectInterface::havingIsNull | |
SelectExtender::havingNotExists | public | function | Sets a HAVING condition that the specified subquery returns no values. | Overrides SelectInterface::havingNotExists | |
SelectExtender::innerJoin | public | function | Inner Join against another table in the database. | Overrides SelectInterface::innerJoin | |
SelectExtender::isNotNull | public | function | Sets a condition that the specified field be NOT NULL. | Overrides ConditionInterface::isNotNull | |
SelectExtender::isNull | public | function | Sets a condition that the specified field be NULL. | Overrides ConditionInterface::isNull | |
SelectExtender::isPrepared | public | function | Indicates if preExecute() has already been called on that object. | Overrides SelectInterface::isPrepared | |
SelectExtender::join | public | function | Default Join against another table in the database. | Overrides SelectInterface::join | |
SelectExtender::leftJoin | public | function | Left Outer Join against another table in the database. | Overrides SelectInterface::leftJoin | |
SelectExtender::nextPlaceholder | public | function | Returns the next placeholder ID for the query. | Overrides PlaceholderInterface::nextPlaceholder | |
SelectExtender::notExists | public | function | Sets a condition that the specified subquery returns no values. | Overrides ConditionInterface::notExists | |
SelectExtender::orConditionGroup | public | function | Creates a new group of conditions ORed together. | Overrides ConditionInterface::orConditionGroup | |
SelectExtender::orderBy | public | function | Orders the result set by a given field. | Overrides SelectInterface::orderBy | |
SelectExtender::orderRandom | public | function | Orders the result set by a random value. | Overrides SelectInterface::orderRandom | |
SelectExtender::preExecute | public | function | Generic preparation and validation for a SELECT query. | Overrides SelectInterface::preExecute | 1 |
SelectExtender::range | public | function | Restricts a query to a given range in the result set. | Overrides SelectInterface::range | |
SelectExtender::union | public | function | Add another Select query to UNION to this one. | Overrides SelectInterface::union | |
SelectExtender::uniqueIdentifier | public | function | Returns a unique identifier for this object. | Overrides PlaceholderInterface::uniqueIdentifier | |
SelectExtender::where | public | function | Adds an arbitrary WHERE clause to the query. | Overrides ConditionInterface::where | |
SelectExtender::__call | public | function | Magic override for undefined methods. | ||
SelectExtender::__clone | public | function | Clone magic method. | Overrides SelectInterface::__clone | |
SelectExtender::__construct | public | function | 2 | ||
SelectExtender::__toString | public | function | Returns a string representation of how the query will be executed in SQL. | Overrides SelectInterface::__toString |
Buggy or inaccurate documentation? Please file an issue. Need support? Need help programming? Connect with the Drupal community.