You are here

Home » API reference » Drupal 9 » StatementWrapper.php

class StatementWrapper in Drupal 9

Same name and namespace in other branches
  1. 10 core/lib/Drupal/Core/Database/StatementWrapper.php \Drupal\Core\Database\StatementWrapper

Implementation of StatementInterface encapsulating PDOStatement.

Hierarchy

Expanded class hierarchy of StatementWrapper

6 files declare their use of StatementWrapper
Connection.php in core/lib/Drupal/Core/Database/Driver/pgsql/Connection.php
Connection.php in core/lib/Drupal/Core/Database/Driver/mysql/Connection.php
ConnectionTest.php in core/tests/Drupal/Tests/Core/Database/ConnectionTest.php
ConnectionTest.php in core/tests/Drupal/KernelTests/Core/Database/ConnectionTest.php
StatementWrapperLegacyTest.php in core/tests/Drupal/KernelTests/Core/Database/StatementWrapperLegacyTest.php

... See full list

File

core/lib/Drupal/Core/Database/StatementWrapper.php, line 10

Namespace

Drupal\Core\Database
View source 
class StatementWrapper implements \IteratorAggregate, StatementInterface {

  /**
   * The Drupal database connection object.
   *
   * @var \Drupal\Core\Database\Connection
   */
  protected $connection;

  /**
   * The client database Statement object.
   *
   * For a \PDO client connection, this will be a \PDOStatement object.
   *
   * @var object
   */
  protected $clientStatement;

  /**
   * Is rowCount() execution allowed.
   *
   * @var bool
   */
  protected $rowCountEnabled = FALSE;

  /**
   * Constructs a StatementWrapper object.
   *
   * @param \Drupal\Core\Database\Connection $connection
   *   Drupal database connection object.
   * @param object $client_connection
   *   Client database connection object, for example \PDO.
   * @param string $query
   *   The SQL query string.
   * @param array $options
   *   Array of query options.
   * @param bool $row_count_enabled
   *   (optional) Enables counting the rows affected. Defaults to FALSE.
   */
  public function __construct(Connection $connection, $client_connection, string $query, array $options, bool $row_count_enabled = FALSE) {
    $this->connection = $connection;
    $this->clientStatement = $client_connection
      ->prepare($query, $options);
    $this->rowCountEnabled = $row_count_enabled;
    $this
      ->setFetchMode(\PDO::FETCH_OBJ);
  }

  /**
   * Implements the magic __get() method.
   *
   * @todo Remove the method before Drupal 10.
   * @see https://www.drupal.org/i/3210310
   */
  public function __get($name) {
    if ($name === 'queryString') {
      @trigger_error("StatementWrapper::\$queryString should not be accessed in drupal:9.1.0 and will error in drupal:10.0.0. Access the client-level statement object via ::getClientStatement(). See https://www.drupal.org/node/3177488", E_USER_DEPRECATED);
      return $this
        ->getClientStatement()->queryString;
    }
    if ($name === 'dbh') {
      @trigger_error(__CLASS__ . '::$dbh should not be accessed in drupal:9.3.0 and will error in drupal:10.0.0. Use $this->connection instead. See https://www.drupal.org/node/3186368', E_USER_DEPRECATED);
      return $this->connection;
    }
    if ($name === 'allowRowCount') {
      @trigger_error(__CLASS__ . '::$allowRowCount should not be accessed in drupal:9.3.0 and will error in drupal:10.0.0. Use $this->rowCountEnabled instead. See https://www.drupal.org/node/3186368', E_USER_DEPRECATED);
      return $this->rowCountEnabled;
    }
  }

  /**
   * Implements the magic __set() method.
   *
   * @todo Remove the method before Drupal 10.
   * @see https://www.drupal.org/i/3210310
   */
  public function __set($name, $value) {
    if ($name === 'allowRowCount') {
      @trigger_error(__CLASS__ . '::$allowRowCount should not be written in drupal:9.3.0 and will error in drupal:10.0.0. Enable row counting by passing the appropriate argument to the constructor instead. See https://www.drupal.org/node/3186368', E_USER_DEPRECATED);
      $this->rowCountEnabled = $value;
    }
  }

  /**
   * Implements the magic __call() method.
   *
   * @deprecated in drupal:9.1.0 and is removed from drupal:10.0.0. Access the
   *   client-level statement object via ::getClientStatement().
   *
   * @see https://www.drupal.org/node/3177488
   */
  public function __call($method, $arguments) {
    if (is_callable([
      $this
        ->getClientStatement(),
      $method,
    ])) {
      @trigger_error("StatementWrapper::{$method} should not be called in drupal:9.1.0 and will error in drupal:10.0.0. Access the client-level statement object via ::getClientStatement(). See https://www.drupal.org/node/3177488", E_USER_DEPRECATED);
      return call_user_func_array([
        $this
          ->getClientStatement(),
        $method,
      ], $arguments);
    }
    throw new \BadMethodCallException($method);
  }

  /**
   * Returns the client-level database statement object.
   *
   * This method should normally be used only within database driver code.
   *
   * @return object
   *   The client-level database statement, for example \PDOStatement.
   */
  public function getClientStatement() {
    return $this->clientStatement;
  }

  /**
   * {@inheritdoc}
   */
  public function getConnectionTarget() : string {
    return $this->connection
      ->getTarget();
  }

  /**
   * {@inheritdoc}
   */
  public function execute($args = [], $options = []) {
    if (isset($options['fetch'])) {
      if (is_string($options['fetch'])) {

        // \PDO::FETCH_PROPS_LATE tells __construct() to run before properties
        // are added to the object.
        $this
          ->setFetchMode(\PDO::FETCH_CLASS | \PDO::FETCH_PROPS_LATE, $options['fetch']);
      }
      else {
        $this
          ->setFetchMode($options['fetch']);
      }
    }
    $logger = $this->connection
      ->getLogger();
    if (!empty($logger)) {
      $query_start = microtime(TRUE);
    }
    $return = $this->clientStatement
      ->execute($args);
    if (!empty($logger)) {
      $query_end = microtime(TRUE);
      $logger
        ->log($this, $args, $query_end - $query_start, $query_start);
    }
    return $return;
  }

  /**
   * {@inheritdoc}
   */
  public function getQueryString() {
    return $this->clientStatement->queryString;
  }

  /**
   * {@inheritdoc}
   */
  public function fetchCol($index = 0) {
    return $this
      ->fetchAll(\PDO::FETCH_COLUMN, $index);
  }

  /**
   * {@inheritdoc}
   */
  public function fetchAllAssoc($key, $fetch = NULL) {
    $return = [];
    if (isset($fetch)) {
      if (is_string($fetch)) {
        $this
          ->setFetchMode(\PDO::FETCH_CLASS, $fetch);
      }
      else {
        $this
          ->setFetchMode($fetch);
      }
    }
    foreach ($this as $record) {
      $record_key = is_object($record) ? $record->{$key} : $record[$key];
      $return[$record_key] = $record;
    }
    return $return;
  }

  /**
   * {@inheritdoc}
   */
  public function fetchAllKeyed($key_index = 0, $value_index = 1) {
    $return = [];
    $this
      ->setFetchMode(\PDO::FETCH_NUM);
    foreach ($this as $record) {
      $return[$record[$key_index]] = $record[$value_index];
    }
    return $return;
  }

  /**
   * {@inheritdoc}
   */
  public function fetchField($index = 0) {

    // Call \PDOStatement::fetchColumn to fetch the field.
    return $this->clientStatement
      ->fetchColumn($index);
  }

  /**
   * {@inheritdoc}
   */
  public function fetchAssoc() {

    // Call \PDOStatement::fetch to fetch the row.
    return $this
      ->fetch(\PDO::FETCH_ASSOC);
  }

  /**
   * {@inheritdoc}
   */
  public function fetchObject(string $class_name = NULL, array $constructor_arguments = NULL) {
    if ($class_name) {
      return $this->clientStatement
        ->fetchObject($class_name, $constructor_arguments);
    }
    return $this->clientStatement
      ->fetchObject();
  }

  /**
   * {@inheritdoc}
   */
  public function rowCount() {

    // SELECT query should not use the method.
    if ($this->rowCountEnabled) {
      return $this->clientStatement
        ->rowCount();
    }
    else {
      throw new RowCountException();
    }
  }

  /**
   * {@inheritdoc}
   */
  public function setFetchMode($mode, $a1 = NULL, $a2 = []) {

    // Call \PDOStatement::setFetchMode to set fetch mode.
    // \PDOStatement is picky about the number of arguments in some cases so we
    // need to be pass the exact number of arguments we where given.
    switch (func_num_args()) {
      case 1:
        return $this->clientStatement
          ->setFetchMode($mode);
      case 2:
        return $this->clientStatement
          ->setFetchMode($mode, $a1);
      case 3:
      default:
        return $this->clientStatement
          ->setFetchMode($mode, $a1, $a2);
    }
  }

  /**
   * {@inheritdoc}
   */
  public function fetch($mode = NULL, $cursor_orientation = NULL, $cursor_offset = NULL) {

    // Call \PDOStatement::fetchAll to fetch all rows.
    // \PDOStatement is picky about the number of arguments in some cases so we
    // need to be pass the exact number of arguments we where given.
    switch (func_num_args()) {
      case 0:
        return $this->clientStatement
          ->fetch();
      case 1:
        return $this->clientStatement
          ->fetch($mode);
      case 2:
        return $this->clientStatement
          ->fetch($mode, $cursor_orientation);
      case 3:
      default:
        return $this->clientStatement
          ->fetch($mode, $cursor_orientation, $cursor_offset);
    }
  }

  /**
   * {@inheritdoc}
   */
  public function fetchAll($mode = NULL, $column_index = NULL, $constructor_arguments = NULL) {

    // Call \PDOStatement::fetchAll to fetch all rows.
    // \PDOStatement is picky about the number of arguments in some cases so we
    // need to be pass the exact number of arguments we where given.
    switch (func_num_args()) {
      case 0:
        return $this->clientStatement
          ->fetchAll();
      case 1:
        return $this->clientStatement
          ->fetchAll($mode);
      case 2:
        return $this->clientStatement
          ->fetchAll($mode, $column_index);
      case 3:
      default:
        return $this->clientStatement
          ->fetchAll($mode, $column_index, $constructor_arguments);
    }
  }

  /**
   * {@inheritdoc}
   */
  public function getIterator() {
    return new \ArrayIterator($this
      ->fetchAll());
  }

  /**
   * Bind a column to a PHP variable.
   *
   * @param mixed $column
   *   Number of the column (1-indexed) or name of the column in the result set.
   *   If using the column name, be aware that the name should match the case of
   *   the column, as returned by the driver.
   * @param mixed $param
   *   Name of the PHP variable to which the column will be bound.
   * @param int $type
   *   (Optional) data type of the parameter, specified by the PDO::PARAM_*
   *   constants.
   * @param int $maxlen
   *   (Optional) a hint for pre-allocation.
   * @param mixed $driverdata
   *   (Optional) optional parameter(s) for the driver.
   *
   * @return bool
   *   Returns TRUE on success or FALSE on failure.
   *
   * @deprecated in drupal:9.1.0 and is removed from drupal:10.0.0.
   *   StatementWrapper::bindColumn should not be called. Access the
   *   client-level statement object via ::getClientStatement().
   *
   * @see https://www.drupal.org/node/3177488
   */
  public function bindColumn($column, &$param, int $type = 0, int $maxlen = 0, $driverdata = NULL) : bool {
    @trigger_error("StatementWrapper::bindColumn should not be called in drupal:9.1.0 and will error in drupal:10.0.0. Access the client-level statement object via ::getClientStatement(). See https://www.drupal.org/node/3177488", E_USER_DEPRECATED);
    switch (func_num_args()) {
      case 2:
        return $this->clientStatement
          ->bindColumn($column, $param);
      case 3:
        return $this->clientStatement
          ->bindColumn($column, $param, $type);
      case 4:
        return $this->clientStatement
          ->bindColumn($column, $param, $type, $maxlen);
      case 5:
        return $this->clientStatement
          ->bindColumn($column, $param, $type, $maxlen, $driverdata);
    }
  }

  /**
   * Binds a parameter to the specified variable name.
   *
   * @param mixed $parameter
   *   Parameter identifier. For a prepared statement using named placeholders,
   *   this will be a parameter name of the form :name.
   * @param mixed $variable
   *   Name of the PHP variable to bind to the SQL statement parameter.
   * @param int $data_type
   *   (Optional) explicit data type for the parameter using the PDO::PARAM_*
   *   constants. To return an INOUT parameter from a stored procedure, use the
   *   bitwise OR operator to set the PDO::PARAM_INPUT_OUTPUT bits for the
   *   data_type parameter.
   * @param int $length
   *   (Optional) length of the data type. To indicate that a parameter is an
   *   OUT parameter from a stored procedure, you must explicitly set the
   *   length.
   * @param mixed $driver_options
   *   (Optional) Driver options.
   *
   * @return bool
   *   Returns TRUE on success or FALSE on failure.
   *
   * @deprecated in drupal:9.1.0 and is removed from drupal:10.0.0.
   *   StatementWrapper::bindParam should not be called. Access the
   *   client-level statement object via ::getClientStatement().
   *
   * @see https://www.drupal.org/node/3177488
   */
  public function bindParam($parameter, &$variable, int $data_type = \PDO::PARAM_STR, int $length = 0, $driver_options = NULL) : bool {
    @trigger_error("StatementWrapper::bindParam should not be called in drupal:9.1.0 and will error in drupal:10.0.0. Access the client-level statement object via ::getClientStatement(). See https://www.drupal.org/node/3177488", E_USER_DEPRECATED);
    switch (func_num_args()) {
      case 2:
        return $this->clientStatement
          ->bindParam($parameter, $variable);
      case 3:
        return $this->clientStatement
          ->bindParam($parameter, $variable, $data_type);
      case 4:
        return $this->clientStatement
          ->bindParam($parameter, $variable, $data_type, $length);
      case 5:
        return $this->clientStatement
          ->bindParam($parameter, $variable, $data_type, $length, $driver_options);
    }
  }

}

Members

Namesort descending Modifiers Type Description Overrides
StatementWrapper::$clientStatement protected property The client database Statement object.
StatementWrapper::$connection protected property The Drupal database connection object.
StatementWrapper::$rowCountEnabled protected property Is rowCount() execution allowed.
StatementWrapper::bindColumn Deprecated public function Bind a column to a PHP variable.
StatementWrapper::bindParam Deprecated public function Binds a parameter to the specified variable name.
StatementWrapper::execute public function Executes a prepared statement. Overrides StatementInterface::execute
StatementWrapper::fetch public function Fetches the next row from a result set. Overrides StatementInterface::fetch
StatementWrapper::fetchAll public function Returns an array containing all of the result set rows. Overrides StatementInterface::fetchAll
StatementWrapper::fetchAllAssoc public function Returns the result set as an associative array keyed by the given field. Overrides StatementInterface::fetchAllAssoc
StatementWrapper::fetchAllKeyed public function Returns the entire result set as a single associative array. Overrides StatementInterface::fetchAllKeyed
StatementWrapper::fetchAssoc public function Fetches the next row and returns it as an associative array. Overrides StatementInterface::fetchAssoc
StatementWrapper::fetchCol public function Returns an entire single column of a result set as an indexed array. Overrides StatementInterface::fetchCol
StatementWrapper::fetchField public function Returns a single field from the next record of a result set. Overrides StatementInterface::fetchField
StatementWrapper::fetchObject public function Fetches the next row and returns it as an object. Overrides StatementInterface::fetchObject
StatementWrapper::getClientStatement public function Returns the client-level database statement object.
StatementWrapper::getConnectionTarget public function
StatementWrapper::getIterator public function
StatementWrapper::getQueryString public function Gets the query string of this statement. Overrides StatementInterface::getQueryString
StatementWrapper::rowCount public function Returns the number of rows affected by the last SQL statement. Overrides StatementInterface::rowCount
StatementWrapper::setFetchMode public function Sets the default fetch mode for this statement. Overrides StatementInterface::setFetchMode
StatementWrapper::__call Deprecated public function Implements the magic __call() method.
StatementWrapper::__construct public function Constructs a StatementWrapper object.
StatementWrapper::__get public function Implements the magic __get() method.
StatementWrapper::__set public function Implements the magic __set() method.