Sql
class Sql extends QueryPluginBase (View source)
Views query plugin for an SQL query.
Traits
Wrapper methods for \Drupal\Core\StringTranslation\TranslationInterface.
Provides dependency injection friendly methods for serialization.
Provides a trait for the messenger service.
Constants
| DERIVATIVE_SEPARATOR |
A string which is used to separate base plugin IDs from the derivative ID. |
| INCLUDE_NEGOTIATED |
Include negotiated languages when listing languages. |
| INCLUDE_ENTITY |
Include entity row languages when listing languages. |
| VIEWS_QUERY_LANGUAGE_SITE_DEFAULT |
Query string to indicate the site default language. |
Properties
| protected string | $pluginId | The plugin_id. |
from PluginBase |
| protected array | $pluginDefinition | The plugin implementation definition. |
from PluginBase |
| protected array | $configuration | Configuration information passed into the plugin. |
from PluginBase |
| protected TranslationInterface | $stringTranslation | The string translation service. |
from StringTranslationTrait |
| protected array | $_serviceIds | An array of service IDs keyed by property name used for serialization. |
from DependencySerializationTrait |
| protected array | $_entityStorages | An array of entity type IDs keyed by the property name of their storages. |
from DependencySerializationTrait |
| protected MessengerInterface | $messenger | The messenger. |
|
| array | $options | Options for this plugin will be held here. |
from PluginBase |
| ViewExecutable | $view | The top object of a view. |
from PluginBase |
| DisplayPluginBase | $displayHandler | The display object this plugin is for. |
from PluginBase |
| array | $definition | Plugins's definition. |
from PluginBase |
| protected bool | $usesOptions | Denotes whether the plugin has an additional options form. |
from PluginBase |
| protected RendererInterface | $renderer | Stores the render API renderer. |
from PluginBase |
| views_plugin_pager | $pager | A pager plugin that should be provided by the display. |
from QueryPluginBase |
| protected int | $limit | Stores the limit of items that should be requested in the query. |
from QueryPluginBase |
| protected | $tableQueue | A list of tables in the order they should be added, keyed by alias. |
|
| $tables | Holds an array of tables and counts added so that we can create aliases. |
||
| $relationships | Holds an array of relationships, which are aliases of the primary table that represent different ways to join the same table in. |
||
| $where | 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. |
||
| $having | 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. |
||
| protected string | $groupOperator | The default operator to use when connecting the WHERE groups. May be AND or OR. |
|
| $orderby | A simple array of order by clauses. |
||
| $groupby | A simple array of group by clauses. |
||
| $fields | An array of fields. |
||
| bool | $distinct | A flag as to whether or not to make the primary field distinct. |
|
| protected bool | $hasAggregate | ||
| protected | $getCountOptimized | Should this query be optimized for counts, for example no sorts. |
|
| protected | $fieldAliases | An array mapping table aliases and field names to field aliases. |
|
| $tags | Query tags which will be passed over to the dbtng query object. |
||
| protected bool | $noDistinct | Is the view marked as not distinct. |
|
| protected EntityTypeManagerInterface | $entityTypeManager | The entity type manager. |
|
| protected DateSqlInterface | $dateSql | The database-specific date handler. |
Methods
Constructs a Sql object.
Translates a string to the current language or to a given language.
Formats a string containing a count of items.
Returns the number of plurals supported by a given language.
Gets the string translation service.
Creates an instance of the plugin.
Initialize the plugin.
Information about options for all kinds of purposes will be held here.
Fills up the options of the plugin with defaults.
Filter out stored options depending on the defined options.
Do the work to filter out stored options depending on the defined options.
Unpack options over our existing defaults, drilling down into arrays so that defaults don't get totally blown away.
Lists the trusted callbacks provided by the implementing class.
Generate a query and a countquery from all of the information supplied to the object.
Provide a full list of possible theme templates used by this style.
Returns a string with any core tokens replaced.
Replaces Views' tokens in a given string. The resulting string will be sanitized with Xss::filterAdmin.
Returns an array of available token replacements.
Adds elements for available core tokens to a form.
Moves form elements into fieldsets for presentation purposes.
Flattens the structure of form elements.
Calculates dependencies for the configured plugin.
Makes an array of languages, optionally including special languages.
Returns substitutions for Views queries for languages.
Executes the query and fills the associated view object with according values.
Get aggregation info for group by queries.
Set a LIMIT on the query, specifying a maximum number of results.
Set an OFFSET on the query, specifying a number of results to skip.
Create a new grouping for the WHERE or HAVING clause.
Control how all WHERE and HAVING groups are put together.
Loads all entities contained in the passed-in $results.
Returns a Unix timestamp to database native timestamp expression.
Set the database to the current user timezone.
Creates cross-database date formatting.
Returns an array of all tables from the query that map to an entity type.
The maximum age for which this object may be cached.
The cache tags associated with this object.
Applies a timezone offset to the given field.
Returns a reference to the table queue array for this query.
Set the view to be distinct (per base field).
Set what field the query will count() on for paging.
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.
Add a table to the query, ensuring the path exists.
Add a table to the query without ensuring the path.
No description
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.
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.
Fix a join to adhere to the proper relationship; the left table can vary based upon what relationship items are joined in on.
Retrieve join data from the larger join data cache.
Get the information associated with a table.
Add a field to the query table, possibly with an alias. This will automatically call ensureTable to make sure the required table exists, unless $table is unset.
Remove all fields that may have been added; primarily used for summary mode where we're changing the query because we didn't get data we needed.
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.
Add a complex WHERE clause to the query.
Add a complex HAVING clause to the query.
Add an ORDER BY clause to the query.
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.
Returns the alias for the given field added to $table.
Adds a query tag to the sql object.
Generates a unique placeholder used in the db query.
Construct the "WHERE" or "HAVING" part of the query.
Returns a list of non-aggregates to be added to the "group by" clause.
Gets the database connection to use for the view.
Get the arguments attached to the WHERE and HAVING clauses of this query.
Sets entities onto the view result row objects.
Gets all the involved entities of the view.
No description
No description
Details
__construct(array $configuration, string $plugin_id, mixed $plugin_definition, EntityTypeManagerInterface $entity_type_manager, DateSqlInterface $date_sql, MessengerInterface $messenger)
Constructs a Sql object.
string
getPluginId()
Gets the plugin_id of the plugin instance.
string
getBaseId()
Gets the base_plugin_id of the plugin instance.
string|null
getDerivativeId()
Gets the derivative_id of the plugin instance.
array
getPluginDefinition()
Gets the definition of the plugin implementation.
bool
isConfigurable()
Determines if the plugin is configurable.
protected TranslatableMarkup
t(string $string, array $args = [], array $options = [])
Translates a string to the current language or to a given language.
See \Drupal\Core\StringTranslation\TranslatableMarkup::__construct() for important security information and usage guidelines.
In order for strings to be localized, make them available in one of the ways supported by the
protected
formatPlural($count, $singular, $plural, array $args = [], array $options = [])
Formats a string containing a count of items.
protected
getNumberOfPlurals($langcode = NULL)
Returns the number of plurals supported by a given language.
protected TranslationInterface
getStringTranslation()
Gets the string translation service.
$this
setStringTranslation(TranslationInterface $translation)
Sets the string translation service to use.
__sleep()
{@inheritdoc}
__wakeup()
{@inheritdoc}
setMessenger(MessengerInterface $messenger)
Sets the messenger.
MessengerInterface
messenger()
Gets the messenger.
static ContainerFactoryPluginInterface
create(ContainerInterface $container, array $configuration, string $plugin_id, mixed $plugin_definition)
Creates an instance of the plugin.
init(ViewExecutable $view, DisplayPluginBase $display, array $options = NULL)
Initialize the plugin.
protected array
defineOptions()
Information about options for all kinds of purposes will be held here.
protected
setOptionDefaults(array $storage, array $options)
Fills up the options of the plugin with defaults.
filterByDefinedOptions(array $storage)
Filter out stored options depending on the defined options.
protected
doFilterByDefinedOptions(array $storage, array $options)
Do the work to filter out stored options depending on the defined options.
unpackOptions($storage, $options, $definition = NULL, $all = TRUE, $check = TRUE)
Unpack options over our existing defaults, drilling down into arrays so that defaults don't get totally blown away.
destroy()
Clears a plugin.
buildOptionsForm($form, FormStateInterface $form_state)
Add settings for the ui.
static string[]
trustedCallbacks()
Lists the trusted callbacks provided by the implementing class.
Trusted callbacks are public methods on the implementing class and can be invoked via \Drupal\Core\Security\DoTrustedCallbackTrait::doTrustedCallback().
validateOptionsForm($form, FormStateInterface $form_state)
Validate the options form.
submitOptionsForm($form, FormStateInterface $form_state)
Special submit handling.
query($get_count = FALSE)
Generate a query and a countquery from all of the information supplied to the object.
themeFunctions()
Provide a full list of possible theme templates used by this style.
An
validate()
Validate that the plugin is correct and can be saved.
summaryTitle()
Returns the summary of the settings in the display.
pluginTitle()
Return the human readable name of the display.
This appears on the ui beside each plugin and beside the settings link.
usesOptions()
Returns the usesOptions property.
string
globalTokenReplace(string $string = '', array $options = [])
Returns a string with any core tokens replaced.
protected string
viewsTokenReplace($text, $tokens)
Replaces Views' tokens in a given string. The resulting string will be sanitized with Xss::filterAdmin.
array
getAvailableGlobalTokens(bool $prepared = FALSE, array $types = [])
Returns an array of available token replacements.
globalTokenForm(array $form, FormStateInterface $form_state)
Adds elements for available core tokens to a form.
static array
preRenderAddFieldsetMarkup(array $form)
Moves form elements into fieldsets for presentation purposes.
Many views forms use #tree = TRUE to keep their values in a hierarchy for easier storage. Moving the form elements into fieldsets during form building would break up that hierarchy. Therefore, we wait until the pre_render stage, where any changes we make affect presentation only and aren't reflected in $form_state->getValues().
static array
preRenderFlattenData(array $form)
Flattens the structure of form elements.
If a form element has #flatten = TRUE, then all of its children get moved to the same level as the element itself. So $form['to_be_flattened'][$key] becomes $form[$key], and $form['to_be_flattened'] gets unset.
array
calculateDependencies()
Calculates dependencies for the configured plugin.
Dependencies are saved in the plugin's configuration entity and are used to determine configuration synchronization order. For example, if the plugin integrates with specific user roles, this method should return an array of dependencies listing the specified roles.
string
getProvider()
Returns the plugin provider.
protected array
listLanguages(int $flags = LanguageInterface::STATE_ALL, array $current_values = NULL)
Makes an array of languages, optionally including special languages.
static array
queryLanguageSubstitutions()
Returns substitutions for Views queries for languages.
This is needed so that the language options returned by PluginBase::listLanguages() are able to be used in queries. It is called by the Views module implementation of hook_views_query_substitutions() to get the language-related substitutions.
protected RendererInterface
getRenderer()
Returns the render API renderer.
alter(ViewExecutable $view)
Let modules modify the query just prior to finalizing it.
build(ViewExecutable $view)
Builds the necessary info to execute the query.
execute(ViewExecutable $view)
Executes the query and fills the associated view object with according values.
Values to set: $view->result, $view->total_rows, $view->execute_time, $view->current_page.
addSignature(ViewExecutable $view)
Add a signature to the query, if such a thing is feasible.
This signature is something that can be used when perusing query logs to discern where particular queries might be coming from.
getAggregationInfo()
Get aggregation info for group by queries.
If NULL, aggregation is not allowed.
setLimit($limit)
Set a LIMIT on the query, specifying a maximum number of results.
setOffset($offset)
Set an OFFSET on the query, specifying a number of results to skip.
getLimit()
Returns the limit of the query.
The
setWhereGroup($type = 'AND', $group = NULL, $where = 'where')
Create a new grouping for the WHERE or HAVING clause.
setGroupOperator($type = 'AND')
Control how all WHERE and HAVING groups are put together.
loadEntities($results)
Loads all entities contained in the passed-in $results.
If the entity belongs to the base table, then it gets stored in $result->_entity. Otherwise, it gets stored in $result->_relationship_entities[$relationship_id];
string
getDateField(string $field, bool $string_date = FALSE, bool $calculate_offset = TRUE)
Returns a Unix timestamp to database native timestamp expression.
string
setupTimezone()
Set the database to the current user timezone.
string
getDateFormat(string $field, string $format, bool $string_date = FALSE)
Creates cross-database date formatting.
array
getEntityTableInfo()
Returns an array of all tables from the query that map to an entity type.
Includes the base table and all relationships, if eligible.
Available keys for each table:
- base: The actual base table (i.e. "user" for an author relationship).
- relationship_id: The id of the relationship, or "none".
- alias: The alias used for the relationship.
- entity_type: The entity type matching the base table.
- revision: A boolean that specifies whether the table is a base table or a revision table of the entity type.
int
getCacheMaxAge()
The maximum age for which this object may be cached.
string[]
getCacheContexts()
The cache contexts associated with this object.
These identify a specific variation/representation of the object.
Cache contexts are tokens: placeholders that are converted to cache keys by the @cache_contexts_manager service. The replacement value depends on the request context (the current URL, language, and so on). They're converted before storing an object in cache.
string[]
getCacheTags()
The cache tags associated with this object.
When this object is modified, these cache tags will be invalidated.
setFieldTimezoneOffset(string $field, int $offset)
Applies a timezone offset to the given field.
int
getTimezoneOffset()
Get the timezone offset in seconds.
array
getTableQueue()
Returns a reference to the table queue 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 addTable() method is preferred.
Note that if you want to manipulate the table queue array, this method must be called by reference as well:
protected
setDistinct(bool $value = TRUE)
Set the view to be distinct (per base field).
setCountField($table, $field, $alias = NULL)
Set what field the query will count() on for paging.
addRelationship($alias, JoinPluginBase $join, $base, $link_point = NULL)
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 node reference table. If you have a node reference 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.
string
addTable($table, $relationship = NULL, JoinPluginBase $join = NULL, $alias = NULL)
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->queueTable() instead.
string
queueTable($table, $relationship = NULL, JoinPluginBase $join = NULL, $alias = NULL)
Add a table to the query without ensuring the path.
This is a pretty internal function to Views and addTable() or ensureTable() should be used instead of this one, unless you are absolutely sure this is what you want.
protected
markTable($table, $relationship, $alias)
No description
The
ensureTable($table, $relationship = NULL, JoinPluginBase $join = NULL)
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.
protected
ensurePath($table, $relationship = NULL, $join = NULL, $traced = [], $add = [])
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.
protected
adjustJoin($join, $relationship)
Fix a join to adhere to the proper relationship; the left table can vary based upon what relationship items are joined in on.
JoinPluginBase
getJoinData($table, $base_table)
Retrieve join data from the larger join data cache.
getTableInfo($table)
Get the information associated with a table.
If you need the alias of a table with a particular relationship, use ensureTable().
string
addField($table, $field, $alias = '', $params = [])
Add a field to the query table, possibly with an alias. This will automatically call ensureTable to make sure the required table exists, unless $table is unset.
clearFields()
Remove all fields that may have been added; primarily used for summary mode where we're changing the query because we didn't get data we needed.
addWhere($group, $field, $value = NULL, $operator = NULL)
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.
The $field, $value and $operator arguments can also be passed in with a single DatabaseCondition object, like this:
addWhereExpression($group, $snippet, $args = [])
Add a complex 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. Internally the dbtng method "where" is used.
addHavingExpression($group, $snippet, $args = [])
Add a complex 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. Internally the dbtng method "having" is used.
addOrderBy($table, $field = NULL, $order = 'ASC', $alias = '', $params = [])
Add an ORDER BY clause to the query.
addGroupBy($clause)
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.
protected
getFieldAlias($table_alias, $field)
Returns the alias for the given field added to $table.
addTag($tag)
Adds a query tag to the sql object.
placeholder($base = 'views')
Generates a unique placeholder used in the db query.
protected
buildCondition($where = 'where')
Construct the "WHERE" or "HAVING" part of the query.
As views has to wrap the conditions from arguments with AND, a special group is wrapped around all conditions. This special group has the ID 0. There is other code in filters which makes sure that the group IDs are higher than zero.
protected array
getNonAggregates()
Returns a list of non-aggregates to be added to the "group by" clause.
Non-aggregates are fields that have no aggregation function (count, sum, etc) applied. Since the SQL standard requires all fields to either have an aggregation function applied, or to be in the GROUP BY clause, Views gathers those fields and adds them to the GROUP BY clause.
protected
compileFields(SelectInterface $query)
Adds fields to the query.
Connection
getConnection()
Gets the database connection to use for the view.
The returned database connection does not have to be the default database connection. It can also be to another database connection when the view is to an external database or a replica database.
getWhereArgs()
Get the arguments attached to the WHERE and HAVING clauses of this query.
protected ResultRow[]
assignEntitiesToResult(array[] $ids, array $entities, array $results)
Sets entities onto the view result row objects.
This method takes into account the relationship in which the entity was needed in the first place.
protected EntityInterface[]
getAllEntities()
Gets all the involved entities of the view.
aggregationMethodSimple($group_type, $field)
No description
aggregationMethodDistinct($group_type, $field)
No description