class StatementPrefetch in Drupal 10
Same name and namespace in other branches
- 8 core/lib/Drupal/Core/Database/StatementPrefetch.php \Drupal\Core\Database\StatementPrefetch
- 9 core/lib/Drupal/Core/Database/StatementPrefetch.php \Drupal\Core\Database\StatementPrefetch
An implementation of StatementInterface that prefetches all data.
This class behaves very similar to a StatementWrapper of a \PDOStatement but as it always fetches every row it is possible to manipulate those results.
Hierarchy
- class \Drupal\Core\Database\StatementPrefetch implements \Drupal\Core\Database\Iterator, StatementInterface
Expanded class hierarchy of StatementPrefetch
1 file declares its use of StatementPrefetch
- Statement.php in core/
modules/ sqlite/ src/ Driver/ Database/ sqlite/ Statement.php
File
- core/
lib/ Drupal/ Core/ Database/ StatementPrefetch.php, line 12
Namespace
Drupal\Core\DatabaseView source
class StatementPrefetch implements \Iterator, StatementInterface {
/**
* The query string.
*
* @var string
*/
protected $queryString;
/**
* Driver-specific options. Can be used by child classes.
*
* @var array
*/
protected $driverOptions;
/**
* The Drupal database connection object.
*
* @var \Drupal\Core\Database\Connection
*/
protected $connection;
/**
* Reference to the PDO connection object for this statement.
*
* @var \PDO
*/
protected $pdoConnection;
/**
* Main data store.
*
* @var array
*/
protected $data = [];
/**
* The current row, retrieved in \PDO::FETCH_ASSOC format.
*
* @var array
*/
protected $currentRow = NULL;
/**
* The key of the current row.
*
* @var int
*/
protected $currentKey = NULL;
/**
* The list of column names in this result set.
*
* @var array
*/
protected $columnNames = NULL;
/**
* The number of rows affected by the last query.
*
* @var int
*/
protected $rowCount = NULL;
/**
* The number of rows in this result set.
*
* @var int
*/
protected $resultRowCount = 0;
/**
* Holds the current fetch style (which will be used by the next fetch).
* @see \PDOStatement::fetch()
*
* @var int
*/
protected $fetchStyle = \PDO::FETCH_OBJ;
/**
* Holds supplementary current fetch options (which will be used by the next fetch).
*
* @var array
*/
protected $fetchOptions = [
'class' => 'stdClass',
'constructor_args' => [],
'object' => NULL,
'column' => 0,
];
/**
* Holds the default fetch style.
*
* @var int
*/
protected $defaultFetchStyle = \PDO::FETCH_OBJ;
/**
* Holds supplementary default fetch options.
*
* @var array
*/
protected $defaultFetchOptions = [
'class' => 'stdClass',
'constructor_args' => [],
'object' => NULL,
'column' => 0,
];
/**
* Is rowCount() execution allowed.
*
* @var bool
*/
protected $rowCountEnabled = FALSE;
/**
* Constructs a StatementPrefetch object.
*
* @param \PDO $pdo_connection
* An object of the PDO class representing a database connection.
* @param \Drupal\Core\Database\Connection $connection
* The database connection.
* @param string $query
* The query string.
* @param array $driver_options
* Driver-specific options.
* @param bool $row_count_enabled
* (optional) Enables counting the rows affected. Defaults to FALSE.
*/
public function __construct(\PDO $pdo_connection, Connection $connection, $query, array $driver_options = [], bool $row_count_enabled = FALSE) {
$this->pdoConnection = $pdo_connection;
$this->connection = $connection;
$this->queryString = $query;
$this->driverOptions = $driver_options;
$this->rowCountEnabled = $row_count_enabled;
}
/**
* {@inheritdoc}
*/
public function getConnectionTarget() : string {
return $this->connection
->getTarget();
}
/**
* {@inheritdoc}
*/
public function execute($args = [], $options = []) {
if (isset($options['fetch'])) {
if (is_string($options['fetch'])) {
// Default to an object. Note: db fields will be added to the object
// before the constructor is run. If you need to assign fields after
// the constructor is run. See https://www.drupal.org/node/315092.
$this
->setFetchMode(\PDO::FETCH_CLASS, $options['fetch']);
}
else {
$this
->setFetchMode($options['fetch']);
}
}
$logger = $this->connection
->getLogger();
if (!empty($logger)) {
$query_start = microtime(TRUE);
}
// Prepare the query.
$statement = $this
->getStatement($this->queryString, $args);
if (!$statement) {
$this
->throwPDOException();
}
$return = $statement
->execute($args);
if (!$return) {
$this
->throwPDOException();
}
if ($this->rowCountEnabled) {
$this->rowCount = $statement
->rowCount();
}
// Fetch all the data from the reply, in order to release any lock
// as soon as possible.
$this->data = $statement
->fetchAll(\PDO::FETCH_ASSOC);
// Destroy the statement as soon as possible. See the documentation of
// \Drupal\sqlite\Driver\Database\sqlite\Statement for an explanation.
unset($statement);
$this->resultRowCount = count($this->data);
if ($this->resultRowCount) {
$this->columnNames = array_keys($this->data[0]);
}
else {
$this->columnNames = [];
}
if (!empty($logger)) {
$query_end = microtime(TRUE);
$logger
->log($this, $args, $query_end - $query_start, $query_start);
}
// Initialize the first row in $this->currentRow.
$this
->next();
return $return;
}
/**
* Throw a PDO Exception based on the last PDO error.
*/
protected function throwPDOException() {
$error_info = $this->connection
->errorInfo();
// We rebuild a message formatted in the same way as PDO.
$exception = new \PDOException("SQLSTATE[" . $error_info[0] . "]: General error " . $error_info[1] . ": " . $error_info[2]);
$exception->errorInfo = $error_info;
throw $exception;
}
/**
* Grab a PDOStatement object from a given query and its arguments.
*
* Some drivers (including SQLite) will need to perform some preparation
* themselves to get the statement right.
*
* @param $query
* The query.
* @param array|null $args
* An array of arguments. This can be NULL.
*
* @return \PDOStatement
* A PDOStatement object.
*/
protected function getStatement($query, &$args = []) {
return $this->connection
->prepare($query, $this->driverOptions);
}
/**
* {@inheritdoc}
*/
public function getQueryString() {
return $this->queryString;
}
/**
* {@inheritdoc}
*/
public function setFetchMode($mode, $a1 = NULL, $a2 = []) {
$this->defaultFetchStyle = $mode;
switch ($mode) {
case \PDO::FETCH_CLASS:
$this->defaultFetchOptions['class'] = $a1;
if ($a2) {
$this->defaultFetchOptions['constructor_args'] = $a2;
}
break;
case \PDO::FETCH_COLUMN:
$this->defaultFetchOptions['column'] = $a1;
break;
case \PDO::FETCH_INTO:
$this->defaultFetchOptions['object'] = $a1;
break;
}
// Set the values for the next fetch.
$this->fetchStyle = $this->defaultFetchStyle;
$this->fetchOptions = $this->defaultFetchOptions;
}
/**
* Return the current row formatted according to the current fetch style.
*
* This is the core method of this class. It grabs the value at the current
* array position in $this->data and format it according to $this->fetchStyle
* and $this->fetchMode.
*
* @return mixed
* The current row formatted as requested.
*/
#[\ReturnTypeWillChange]
public function current() {
if (isset($this->currentRow)) {
switch ($this->fetchStyle) {
case \PDO::FETCH_ASSOC:
return $this->currentRow;
case \PDO::FETCH_BOTH:
// \PDO::FETCH_BOTH returns an array indexed by both the column name
// and the column number.
return $this->currentRow + array_values($this->currentRow);
case \PDO::FETCH_NUM:
return array_values($this->currentRow);
case \PDO::FETCH_LAZY:
// We do not do lazy as everything is fetched already. Fallback to
// \PDO::FETCH_OBJ.
case \PDO::FETCH_OBJ:
return (object) $this->currentRow;
case \PDO::FETCH_CLASS | \PDO::FETCH_CLASSTYPE:
$class_name = array_shift($this->currentRow);
// Deliberate no break.
case \PDO::FETCH_CLASS:
if (!isset($class_name)) {
$class_name = $this->fetchOptions['class'];
}
if (count($this->fetchOptions['constructor_args'])) {
$reflector = new \ReflectionClass($class_name);
$result = $reflector
->newInstanceArgs($this->fetchOptions['constructor_args']);
}
else {
$result = new $class_name();
}
foreach ($this->currentRow as $k => $v) {
$result->{$k} = $v;
}
return $result;
case \PDO::FETCH_INTO:
foreach ($this->currentRow as $k => $v) {
$this->fetchOptions['object']->{$k} = $v;
}
return $this->fetchOptions['object'];
case \PDO::FETCH_COLUMN:
if (isset($this->columnNames[$this->fetchOptions['column']])) {
return $this->currentRow[$this->columnNames[$this->fetchOptions['column']]];
}
else {
return;
}
}
}
}
/**
* {@inheritdoc}
*/
#[\ReturnTypeWillChange]
public function key() {
return $this->currentKey;
}
/**
* {@inheritdoc}
*/
#[\ReturnTypeWillChange]
public function rewind() {
// Nothing to do: our DatabaseStatement can't be rewound.
}
/**
* {@inheritdoc}
*/
#[\ReturnTypeWillChange]
public function next() {
if (!empty($this->data)) {
$this->currentRow = reset($this->data);
$this->currentKey = key($this->data);
unset($this->data[$this->currentKey]);
}
else {
$this->currentRow = NULL;
}
}
/**
* {@inheritdoc}
*/
#[\ReturnTypeWillChange]
public function valid() {
return isset($this->currentRow);
}
/**
* {@inheritdoc}
*/
public function rowCount() {
// SELECT query should not use the method.
if ($this->rowCountEnabled) {
return $this->rowCount;
}
else {
throw new RowCountException();
}
}
/**
* {@inheritdoc}
*/
public function fetch($fetch_style = NULL, $cursor_orientation = \PDO::FETCH_ORI_NEXT, $cursor_offset = NULL) {
if (isset($this->currentRow)) {
// Set the fetch parameter.
$this->fetchStyle = $fetch_style ?? $this->defaultFetchStyle;
$this->fetchOptions = $this->defaultFetchOptions;
// Grab the row in the format specified above.
$return = $this
->current();
// Advance the cursor.
$this
->next();
// Reset the fetch parameters to the value stored using setFetchMode().
$this->fetchStyle = $this->defaultFetchStyle;
$this->fetchOptions = $this->defaultFetchOptions;
return $return;
}
else {
return FALSE;
}
}
public function fetchColumn($index = 0) {
if (isset($this->currentRow) && isset($this->columnNames[$index])) {
// We grab the value directly from $this->data, and format it.
$return = $this->currentRow[$this->columnNames[$index]];
$this
->next();
return $return;
}
else {
return FALSE;
}
}
/**
* {@inheritdoc}
*/
public function fetchField($index = 0) {
return $this
->fetchColumn($index);
}
/**
* {@inheritdoc}
*/
public function fetchObject(string $class_name = NULL, array $constructor_arguments = NULL) {
if (isset($this->currentRow)) {
if (!isset($class_name)) {
// Directly cast to an object to avoid a function call.
$result = (object) $this->currentRow;
}
else {
$this->fetchStyle = \PDO::FETCH_CLASS;
$this->fetchOptions = [
'class' => $class_name,
'constructor_args' => $constructor_arguments,
];
// Grab the row in the format specified above.
$result = $this
->current();
// Reset the fetch parameters to the value stored using setFetchMode().
$this->fetchStyle = $this->defaultFetchStyle;
$this->fetchOptions = $this->defaultFetchOptions;
}
$this
->next();
return $result;
}
else {
return FALSE;
}
}
/**
* {@inheritdoc}
*/
public function fetchAssoc() {
if (isset($this->currentRow)) {
$result = $this->currentRow;
$this
->next();
return $result;
}
else {
return FALSE;
}
}
/**
* {@inheritdoc}
*/
public function fetchAll($mode = NULL, $column_index = NULL, $constructor_arguments = NULL) {
$this->fetchStyle = $mode ?? $this->defaultFetchStyle;
$this->fetchOptions = $this->defaultFetchOptions;
if (isset($column_index)) {
$this->fetchOptions['column'] = $column_index;
}
if (isset($constructor_arguments)) {
$this->fetchOptions['constructor_args'] = $constructor_arguments;
}
$result = [];
// Traverse the array as PHP would have done.
while (isset($this->currentRow)) {
// Grab the row in the format specified above.
$result[] = $this
->current();
$this
->next();
}
// Reset the fetch parameters to the value stored using setFetchMode().
$this->fetchStyle = $this->defaultFetchStyle;
$this->fetchOptions = $this->defaultFetchOptions;
return $result;
}
/**
* {@inheritdoc}
*/
public function fetchCol($index = 0) {
if (isset($this->columnNames[$index])) {
$result = [];
// Traverse the array as PHP would have done.
while (isset($this->currentRow)) {
$result[] = $this->currentRow[$this->columnNames[$index]];
$this
->next();
}
return $result;
}
else {
return [];
}
}
/**
* {@inheritdoc}
*/
public function fetchAllKeyed($key_index = 0, $value_index = 1) {
if (!isset($this->columnNames[$key_index]) || !isset($this->columnNames[$value_index])) {
return [];
}
$key = $this->columnNames[$key_index];
$value = $this->columnNames[$value_index];
$result = [];
// Traverse the array as PHP would have done.
while (isset($this->currentRow)) {
$result[$this->currentRow[$key]] = $this->currentRow[$value];
$this
->next();
}
return $result;
}
/**
* {@inheritdoc}
*/
public function fetchAllAssoc($key, $fetch_style = NULL) {
$this->fetchStyle = $fetch_style ?? $this->defaultFetchStyle;
$this->fetchOptions = $this->defaultFetchOptions;
$result = [];
// Traverse the array as PHP would have done.
while (isset($this->currentRow)) {
// Grab the row in its raw \PDO::FETCH_ASSOC format.
$result_row = $this
->current();
$result[$this->currentRow[$key]] = $result_row;
$this
->next();
}
// Reset the fetch parameters to the value stored using setFetchMode().
$this->fetchStyle = $this->defaultFetchStyle;
$this->fetchOptions = $this->defaultFetchOptions;
return $result;
}
}
Members
Name | Modifiers | Type | Description | Overrides |
---|---|---|---|---|
StatementPrefetch:: |
protected | property | The list of column names in this result set. | |
StatementPrefetch:: |
protected | property | The Drupal database connection object. | |
StatementPrefetch:: |
protected | property | The key of the current row. | |
StatementPrefetch:: |
protected | property | The current row, retrieved in \PDO::FETCH_ASSOC format. | |
StatementPrefetch:: |
protected | property | Main data store. | |
StatementPrefetch:: |
protected | property | Holds supplementary default fetch options. | |
StatementPrefetch:: |
protected | property | Holds the default fetch style. | |
StatementPrefetch:: |
protected | property | Driver-specific options. Can be used by child classes. | |
StatementPrefetch:: |
protected | property | Holds supplementary current fetch options (which will be used by the next fetch). | |
StatementPrefetch:: |
protected | property | Holds the current fetch style (which will be used by the next fetch). | |
StatementPrefetch:: |
protected | property | Reference to the PDO connection object for this statement. | |
StatementPrefetch:: |
protected | property | The query string. | |
StatementPrefetch:: |
protected | property | The number of rows in this result set. | |
StatementPrefetch:: |
protected | property | The number of rows affected by the last query. | |
StatementPrefetch:: |
protected | property | Is rowCount() execution allowed. | |
StatementPrefetch:: |
public | function | ||
StatementPrefetch:: |
public | function |
Executes a prepared statement. Overrides StatementInterface:: |
1 |
StatementPrefetch:: |
public | function |
Fetches the next row from a result set. Overrides StatementInterface:: |
|
StatementPrefetch:: |
public | function |
Returns an array containing all of the result set rows. Overrides StatementInterface:: |
|
StatementPrefetch:: |
public | function |
Returns the result set as an associative array keyed by the given field. Overrides StatementInterface:: |
|
StatementPrefetch:: |
public | function |
Returns the entire result set as a single associative array. Overrides StatementInterface:: |
|
StatementPrefetch:: |
public | function |
Fetches the next row and returns it as an associative array. Overrides StatementInterface:: |
|
StatementPrefetch:: |
public | function |
Returns an entire single column of a result set as an indexed array. Overrides StatementInterface:: |
|
StatementPrefetch:: |
public | function | ||
StatementPrefetch:: |
public | function |
Returns a single field from the next record of a result set. Overrides StatementInterface:: |
|
StatementPrefetch:: |
public | function |
Fetches the next row and returns it as an object. Overrides StatementInterface:: |
|
StatementPrefetch:: |
public | function |
Returns the target connection this statement is associated with. Overrides StatementInterface:: |
|
StatementPrefetch:: |
public | function |
Gets the query string of this statement. Overrides StatementInterface:: |
|
StatementPrefetch:: |
protected | function | Grab a PDOStatement object from a given query and its arguments. | 1 |
StatementPrefetch:: |
public | function | ||
StatementPrefetch:: |
public | function | ||
StatementPrefetch:: |
public | function | ||
StatementPrefetch:: |
public | function |
Returns the number of rows affected by the last SQL statement. Overrides StatementInterface:: |
|
StatementPrefetch:: |
public | function |
Sets the default fetch mode for this statement. Overrides StatementInterface:: |
|
StatementPrefetch:: |
protected | function | Throw a PDO Exception based on the last PDO error. | |
StatementPrefetch:: |
public | function | ||
StatementPrefetch:: |
public | function | Constructs a StatementPrefetch object. |