Drupal 8  8.0.2
Select Class Reference
Inheritance diagram for Select:

Public Member Functions

 __construct ($table, $alias=NULL, Connection $connection, $options=array())
 
 addTag ($tag)
 
 hasTag ($tag)
 
 hasAllTags ()
 
 hasAnyTag ()
 
 addMetaData ($key, $object)
 
 getMetaData ($key)
 
 arguments ()
 
 compile (Connection $connection, PlaceholderInterface $queryPlaceholder)
 
 compiled ()
 
 havingCondition ($field, $value=NULL, $operator=NULL)
 
havingConditions ()
 
 havingArguments ()
 
 having ($snippet, $args=array())
 
 havingCompile (Connection $connection)
 
 extend ($extender_name)
 
 havingIsNull ($field)
 
 havingIsNotNull ($field)
 
 havingExists (SelectInterface $select)
 
 havingNotExists (SelectInterface $select)
 
 forUpdate ($set=TRUE)
 
getFields ()
 
getExpressions ()
 
getOrderBy ()
 
getGroupBy ()
 
getTables ()
 
getUnion ()
 
 escapeLike ($string)
 
 escapeField ($string)
 
 getArguments (PlaceholderInterface $queryPlaceholder=NULL)
 
 isPrepared ()
 
 preExecute (SelectInterface $query=NULL)
 
 execute ()
 
 distinct ($distinct=TRUE)
 
 addField ($table_alias, $field, $alias=NULL)
 
 fields ($table_alias, array $fields=array())
 
 addExpression ($expression, $alias=NULL, $arguments=array())
 
 join ($table, $alias=NULL, $condition=NULL, $arguments=array())
 
 innerJoin ($table, $alias=NULL, $condition=NULL, $arguments=array())
 
 leftJoin ($table, $alias=NULL, $condition=NULL, $arguments=array())
 
 rightJoin ($table, $alias=NULL, $condition=NULL, $arguments=array())
 
 addJoin ($type, $table, $alias=NULL, $condition=NULL, $arguments=array())
 
 orderBy ($field, $direction= 'ASC')
 
 orderRandom ()
 
 range ($start=NULL, $length=NULL)
 
 union (SelectInterface $query, $type= '')
 
 groupBy ($field)
 
 countQuery ()
 
 __toString ()
 
 __clone ()
 
- Public Member Functions inherited from Query
 __construct (Connection $connection, $options)
 
 __sleep ()
 
 __wakeup ()
 
 __clone ()
 
 __toString ()
 
 uniqueIdentifier ()
 
 nextPlaceholder ()
 
 comment ($comment)
 
getComments ()
 
- Public Member Functions inherited from ConditionInterface
 condition ($field, $value=NULL, $operator= '=')
 
 where ($snippet, $args=array())
 
 isNull ($field)
 
 isNotNull ($field)
 
 exists (SelectInterface $select)
 
 notExists (SelectInterface $select)
 
conditions ()
 
 conditionGroupFactory ($conjunction= 'AND')
 
 andConditionGroup ()
 
 orConditionGroup ()
 

Protected Member Functions

 prepareCountQuery ()
 
- Protected Member Functions inherited from Query
 execute ()
 

Protected Attributes

 $fields = array()
 
 $expressions = array()
 
 $tables = array()
 
 $order = array()
 
 $group = array()
 
 $having
 
 $distinct = FALSE
 
 $range
 
 $union = array()
 
 $prepared = FALSE
 
 $forUpdate = FALSE
 
- Protected Attributes inherited from Query
 $connection
 
 $connectionTarget
 
 $connectionKey
 
 $queryOptions
 
 $uniqueIdentifier
 
 $nextPlaceholder = 0
 
 $comments = array()
 

Detailed Description

Query builder for SELECT statements.

Constructor & Destructor Documentation

__construct (   $table,
  $alias = NULL,
Connection  $connection,
  $options = array() 
)

Constructs a Select object.

Parameters
string$tableThe name of the table that is being queried.
string$aliasThe alias for the table.
\Drupal\Core\Database\Connection$connectionDatabase connection object.
array$optionsArray of query options.

References Select\addJoin(), ConditionInterface\condition(), Select\having(), and Database\RETURN_STATEMENT.

Here is the call graph for this function:

Member Function Documentation

__clone ( )

{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.}

Implements SelectInterface.

References ConditionInterface\condition(), and Select\having().

Here is the call graph for this function:

__toString ( )

{Returns a string representation of how the query will be executed in SQL.

Returns
string The Select Query object expressed as a string.
}

Implements SelectInterface.

References Select\compile(), Select\compiled(), ConditionInterface\condition(), Select\distinct(), Select\fields(), Select\forUpdate(), Select\having(), and Select\range().

Here is the call graph for this function:

addExpression (   $expression,
  $alias = NULL,
  $arguments = 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.

Parameters
$expressionThe expression string. May contain placeholders.
$aliasThe 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.
$argumentsAny placeholder arguments needed for this expression.
Returns
The unique alias that was assigned for this expression.
}

Implements SelectInterface.

Referenced by Select\orderRandom().

Here is the caller graph for this function:

addField (   $table_alias,
  $field,
  $alias = NULL 
)

{Adds a field to the list to be SELECTed.

Parameters
$table_aliasThe 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.
$fieldThe name of the field.
$aliasThe 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.
Returns
The unique alias that was assigned for this field.
}

Implements SelectInterface.

References Select\fields().

Referenced by Select\fields(), and Select\orderBy().

Here is the call graph for this function:

Here is the caller graph for this function:

addJoin (   $type,
  $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.

Parameters
$typeThe type of join. Typically one one of INNER, LEFT OUTER, and RIGHT OUTER.
$tableThe 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. Unless the table name starts with the database / schema name and a dot it will be prefixed.
$aliasThe 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.
$conditionThe 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.
$argumentsAn array of arguments to replace into the $condition of this join.
Returns
The unique alias that was assigned for this table.
}

Implements SelectInterface.

Referenced by Select\__construct(), Select\innerJoin(), Select\join(), Select\leftJoin(), and Select\rightJoin().

Here is the caller graph for this function:

addMetaData (   $key,
  $object 
)

{Adds additional metadata to the query.Often, a query may need to provide additional contextual data to alter hooks. Alter hooks may then use that information to decide if and how to take action.

Parameters
$keyThe unique identifier for this piece of metadata. Must be a string that follows the same rules as any other PHP identifier.
$objectThe additional data to add to the query. May be any valid PHP variable.
Returns
The called object.
}

Implements AlterableInterface.

addTag (   $tag)

{Adds a tag to a query.Tags are strings that identify a query. A query may have any number of tags. Tags are used to mark a query so that alter hooks may decide if they wish to take action. Tags should be all lower-case and contain only letters, numbers, and underscore, and start with a letter. That is, they should follow the same rules as PHP identifiers in general.

Parameters
$tagThe tag to add.
Returns
The called object.
}

Implements AlterableInterface.

arguments ( )

{Gets a complete list of all values to insert into the prepared statement.

Returns
An associative array of placeholders and values.
}

Implements ConditionInterface.

References Select\compiled(), ConditionInterface\condition(), and Select\having().

Referenced by Select\getArguments().

Here is the call graph for this function:

Here is the caller graph for this function:

compile ( Connection  $connection,
PlaceholderInterface  $queryPlaceholder 
)

{Compiles the saved conditions for later retrieval.This method does not return anything, but simply prepares data to be retrieved via __toString() and arguments().

Parameters
$connectionThe database connection for which to compile the conditionals.
$queryPlaceholderThe query this condition belongs to. If not given, the current query is used.
}

Implements ConditionInterface.

References ConditionInterface\condition(), and Select\having().

Referenced by Select\__toString(), and Select\getArguments().

Here is the call graph for this function:

Here is the caller graph for this function:

compiled ( )

{Check whether a condition has been previously compiled.

Returns
TRUE if the condition has been previously compiled.
}

Implements ConditionInterface.

References ConditionInterface\condition(), and Select\having().

Referenced by Select\__toString(), and Select\arguments().

Here is the call graph for this function:

Here is the caller graph for this function:

countQuery ( )

{Get the equivalent COUNT query of this query as a new query object.

Returns
A new SelectQuery object with no fields or expressions besides COUNT(*).
}

Implements SelectInterface.

References Select\prepareCountQuery().

Here is the call graph for this function:

distinct (   $distinct = TRUE)

{Sets this query to be DISTINCT.

Parameters
$distinctTRUE to flag this query DISTINCT, FALSE to disable it.
Returns
The called object.
}

Implements SelectInterface.

Referenced by Select\__toString().

Here is the caller graph for this function:

escapeField (   $string)

{Escapes a field name string.Force all field names to be strictly alphanumeric-plus-underscore. For some database drivers, it may also wrap the field name in database-specific escape characters.

Parameters
string$stringAn unsanitized field name.
Returns
The sanitized field name string.
}

Implements SelectInterface.

escapeLike (   $string)

{Escapes characters that work as wildcard characters in a LIKE pattern.

Parameters
$stringThe string to escape.
Returns
string The escaped string.
See Also
::escapeLike()
}

Implements SelectInterface.

execute ( )

{Runs the query against the database.

Returns
|null A prepared statement, or NULL if the query is not valid.
}

Implements SelectInterface.

References Select\getArguments(), and Select\preExecute().

Here is the call graph for this function:

extend (   $extender_name)

{Enhance this object by wrapping it in an extender object.

Parameters
$extender_nameThe 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.
Returns
The extender object, which now contains a reference to this object.
}

Implements ExtendableInterface.

fields (   $table_alias,
array  $fields = array() 
)

{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.

Parameters
$table_aliasThe 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.
$fieldsAn 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.
Returns
The called object.
}

Implements SelectInterface.

References Select\addField().

Referenced by Select\__toString(), Select\addField(), and Select\orderBy().

Here is the call graph for this function:

Here is the caller graph for this function:

forUpdate (   $set = TRUE)

{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.

Parameters
$setIF TRUE, FOR UPDATE will be added to the query, if FALSE then it won't.
Returns
The called object.
}

Implements SelectInterface.

Referenced by Select\__toString().

Here is the caller graph for this function:

getArguments ( PlaceholderInterface  $queryPlaceholder = NULL)

{Compiles and returns an associative array of the arguments for this prepared statement.

Parameters
$queryPlaceholderWhen collecting the arguments of a subquery, the main placeholder object should be passed as this parameter.
Returns
An associative array of all placeholder arguments for this query.
}

Implements SelectInterface.

References Select\arguments(), and Select\compile().

Referenced by Select\execute().

Here is the call graph for this function:

Here is the caller graph for this function:

& getExpressions ( )

{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:

$fields =& $query->getExpressions();
Returns
A reference to the expression array structure.
}

Implements SelectInterface.

& getFields ( )

{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:

$fields =& $query->getFields();
Returns
A reference to the fields array structure.
}

Implements SelectInterface.

& getGroupBy ( )

{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:

$fields =& $query->getGroupBy();
Returns
A reference to the group-by array structure.
}

Implements SelectInterface.

getMetaData (   $key)

{Retrieves a given piece of metadata.

Parameters
$keyThe unique identifier for the piece of metadata to retrieve.
Returns
The previously attached metadata object, or NULL if one doesn't exist.
}

Implements AlterableInterface.

& getOrderBy ( )

{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:

$fields =& $query->getOrderBy();
Returns
A reference to the expression array structure.
}

Implements SelectInterface.

& getTables ( )

{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:

$fields =& $query->getTables();
Returns
A reference to the tables array structure.
}

Implements SelectInterface.

& getUnion ( )

{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:

$fields =& $query->getUnion();
Returns
A reference to the union query array structure.
}

Implements SelectInterface.

groupBy (   $field)

{Groups the result set by the specified field.

Parameters
$fieldThe field on which to group. This should be the field as aliased.
Returns
The called object.
}

Implements SelectInterface.

hasAllTags ( )

{Determines if a given query has all specified tags.

Parameters
$tagsA variable number of arguments, one for each tag to check.
Returns
TRUE if this query has been marked with all specified tags, FALSE otherwise.
}

Implements AlterableInterface.

hasAnyTag ( )

{Determines if a given query has any specified tag.

Parameters
$tagsA variable number of arguments, one for each tag to check.
Returns
TRUE if this query has been marked with at least one of the specified tags, FALSE otherwise.
}

Implements AlterableInterface.

hasTag (   $tag)

{Determines if a given query has a given tag.

Parameters
$tagThe tag to check.
Returns
TRUE if this query has been marked with this tag, FALSE otherwise.
}

Implements AlterableInterface.

Referenced by Select\orderBy().

Here is the caller graph for this function:

having (   $snippet,
  $args = array() 
)

{Adds an arbitrary HAVING clause to the query.

Parameters
$snippetA portion of a HAVING clause as a prepared statement. It must use named placeholders, not ? placeholders.
$args(optional) An associative array of arguments.
Returns
$this
}

Implements SelectInterface.

Referenced by Select\__clone(), Select\__construct(), Select\__toString(), Select\arguments(), Select\compile(), Select\compiled(), Select\havingArguments(), Select\havingCompile(), Select\havingCondition(), Select\havingConditions(), Select\havingExists(), Select\havingIsNotNull(), Select\havingIsNull(), and Select\havingNotExists().

Here is the caller graph for this function:

havingArguments ( )

{Gets a list of all values to insert into the HAVING clause.

Returns
array An associative array of placeholders and values.
}

Implements SelectInterface.

References Select\having().

Here is the call graph for this function:

havingCompile ( Connection  $connection)

{Compiles the HAVING clause for later retrieval.

Parameters
$connectionThe database connection for which to compile the clause.
}

Implements SelectInterface.

References Select\having().

Here is the call graph for this function:

havingCondition (   $field,
  $value = NULL,
  $operator = NULL 
)

{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.

Parameters
$fieldThe name of the field to check. If you would like to add a more complex condition involving operators or functions, use having().
$valueThe 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.
$operatorThe 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.
Returns
The called object.
}

Implements SelectInterface.

References Select\having().

Here is the call graph for this function:

& havingConditions ( )

{Gets a list of all conditions in the HAVING clause.This method returns by reference. That allows alter hooks to access the data structure directly and manipulate it before it gets compiled.

Returns
array An array of conditions.
See Also
::conditions()
}

Implements SelectInterface.

References Select\having().

Here is the call graph for this function:

havingExists ( SelectInterface  $select)

{Sets a HAVING condition that the specified subquery returns values.

Parameters
\Drupal\Core\Database\Query\SelectInterface$selectThe subquery that must contain results.
Returns
$this
}

Implements SelectInterface.

References Select\having().

Here is the call graph for this function:

havingIsNotNull (   $field)

{Sets a condition in the HAVING clause that the specified field be NOT NULL.

Parameters
$fieldThe name of the field to check.
Returns
$this
}

Implements SelectInterface.

References Select\having().

Here is the call graph for this function:

havingIsNull (   $field)

{Sets a condition in the HAVING clause that the specified field be NULL.

Parameters
$fieldThe name of the field to check.
Returns
$this
}

Implements SelectInterface.

References Select\having().

Here is the call graph for this function:

havingNotExists ( SelectInterface  $select)

{Sets a HAVING condition that the specified subquery returns no values.

Parameters
\Drupal\Core\Database\Query\SelectInterface$selectThe subquery that must contain results.
Returns
$this
}

Implements SelectInterface.

References Select\having().

Here is the call graph for this function:

innerJoin (   $table,
  $alias = NULL,
  $condition = NULL,
  $arguments = array() 
)

{Inner Join against another table in the database.

Parameters
$tableThe 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. Unless the table name starts with the database / schema name and a dot it will be prefixed.
$aliasThe 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.
$conditionThe 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.
$argumentsAn array of arguments to replace into the $condition of this join.
Returns
The unique alias that was assigned for this table.
}

Implements SelectInterface.

References Select\addJoin().

Here is the call graph for this function:

isPrepared ( )

{Indicates if preExecute() has already been called on that object.

Returns
TRUE is this query has already been prepared, FALSE otherwise.
}

Implements SelectInterface.

join (   $table,
  $alias = NULL,
  $condition = NULL,
  $arguments = array() 
)

{Default Join against another table in the database.This method is a convenience method for innerJoin().

Parameters
$tableThe 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. Unless the table name starts with the database / schema name and a dot it will be prefixed.
$aliasThe 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.
$conditionThe 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.
$argumentsAn array of arguments to replace into the $condition of this join.
Returns
The unique alias that was assigned for this table.
}

Implements SelectInterface.

References Select\addJoin().

Here is the call graph for this function:

leftJoin (   $table,
  $alias = NULL,
  $condition = NULL,
  $arguments = array() 
)

{Left Outer Join against another table in the database.

Parameters
$tableThe 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. Unless the table name starts with the database / schema name and a dot it will be prefixed.
$aliasThe 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.
$conditionThe 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.
$argumentsAn array of arguments to replace into the $condition of this join.
Returns
The unique alias that was assigned for this table.
}

Implements SelectInterface.

References Select\addJoin().

Here is the call graph for this function:

orderBy (   $field,
  $direction = 'ASC' 
)

{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.

Parameters
$fieldThe field on which to order. The field is escaped for security so only valid field and alias names are possible. To order by an expression, add the expression with addExpression() first and then use the alias to order on.

Example: $query->addExpression('SUBSTRING(thread, 1, (LENGTH(thread) - 1))', 'order_field'); $query->orderBy('order_field', 'ASC');

Parameters
$directionThe direction to sort. Legal values are "ASC" and "DESC". Any other value will be converted to "ASC".
Returns
The called object.
}

Implements SelectInterface.

Referenced by Select\orderRandom().

Here is the caller graph for this function:

orderRandom ( )

{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. Seehttp://jan.kneschke.de/projects/mysql/order-by-rand/for an example of such an alternate sorting mechanism.

Returns
The called object
}

Implements SelectInterface.

References Select\addExpression(), and Select\orderBy().

Here is the call graph for this function:

preExecute ( SelectInterface  $query = NULL)

{Generic preparation and validation for a SELECT query.

Returns
TRUE if the validation was successful, FALSE if not.
}

Implements SelectInterface.

References Drupal\moduleHandler().

Referenced by Select\execute().

Here is the call graph for this function:

Here is the caller graph for this function:

prepareCountQuery ( )
protected

Prepares a count query from the current query object.

Returns
A new query object ready to have COUNT(*) performed on it.

Referenced by Select\countQuery().

Here is the caller graph for this function:

range (   $start = NULL,
  $length = NULL 
)

{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.

Parameters
$startThe first record from the result set to return. If NULL, removes any range directives that are set.
$lengthThe number of records to return from the result set.
Returns
The called object.
}

Implements SelectInterface.

Referenced by Select\__toString().

Here is the caller graph for this function:

rightJoin (   $table,
  $alias = NULL,
  $condition = NULL,
  $arguments = array() 
)

{Right Outer Join against another table in the database.

Parameters
$tableThe 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. Unless the table name starts with the database / schema name and a dot it will be prefixed.
$aliasThe 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.
$conditionThe 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.
$argumentsAn array of arguments to replace into the $condition of this join.
Returns
The unique alias that was assigned for this table.
}

Implements SelectInterface.

References Select\addJoin().

Here is the call graph for this function:

union ( SelectInterface  $query,
  $type = '' 
)

{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.

Parameters
$queryThe query to UNION to this query.
$typeThe type of UNION to add to the query. Defaults to plain UNION.
Returns
The called object.
}

Implements SelectInterface.

Field Documentation

$forUpdate = FALSE
protected

The FOR UPDATE status


The documentation for this class was generated from the following file: