class StatementBase in Drupal driver for SQL Server and SQL Azure 8.2

Default implementation of StatementInterface.

\PDO allows us to extend the \PDOStatement class to provide additional functionality beyond that offered by default. We do need extra functionality. By default, this class is not driver-specific. If a given driver needs to set a custom statement class, it may do so in its constructor.

Hierarchy

• class \Drupal\Driver\Database\sqlsrv\StatementBase extends \mssql\Statement implements StatementInterface

See also

http://php.net/pdostatement

File

drivers/lib/Drupal/Driver/Database/sqlsrv/StatementBase.php, line 23

Contains \Drupal\Core\Database\Statement.

Namespace

Drupal\Driver\Database\sqlsrv

class StatementBase extends Statement implements StatementInterface {

  /**
   * Reference to the database connection object for this statement.
   *
   * The name $dbh is inherited from \PDOStatement.
   *
   * @var \Drupal\Core\Database\Connection
   */
  public $dbh;

  /**
   * Is rowCount() execution allowed.
   *
   * @var bool
   */
  public $allowRowCount = false;
  protected function __construct(Connection $dbh) {
    $this->dbh = $dbh;
    $this
      ->setFetchMode(\PDO::FETCH_OBJ);
  }

  /**
   * {@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->dbh
      ->getLogger();
    if (!empty($logger)) {
      $query_start = microtime(true);
    }
    $return = parent::execute($args);
    if (!empty($logger)) {
      $query_end = microtime(true);
      $logger
        ->log($this, $args, $query_end - $query_start);
    }
    return $return;
  }

  /**
   * {@inheritdoc}
   */
  public function getQueryString() {
    return $this->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
      ->fetchColumn($index);
  }

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

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

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

    // SELECT query should not use the method.
    if ($this->allowRowCount) {
      return parent::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 parent::setFetchMode($mode);
      case 2:
        return parent::setFetchMode($mode, $a1);
      case 3:
      default:
        return parent::setFetchMode($mode, $a1, $a2);
    }
  }

  /**
   * {@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 parent::fetchAll();
      case 1:
        return parent::fetchAll($mode);
      case 2:
        return parent::fetchAll($mode, $column_index);
      case 3:
      default:
        return parent::fetchAll($mode, $column_index, $constructor_arguments);
    }
  }

}

Members

Name	Modifiers	Type	Description	Overrides
StatementBase::$allowRowCount	public	property	Is rowCount() execution allowed.
StatementBase::$dbh	public	property	Reference to the database connection object for this statement.
StatementBase::execute	public	function	Executes a prepared statement Overrides StatementInterface::execute
StatementBase::fetchAll	public	function	Returns an array containing all of the result set rows. Overrides StatementInterface::fetchAll
StatementBase::fetchAllAssoc	public	function	Returns the result set as an associative array keyed by the given field. Overrides StatementInterface::fetchAllAssoc
StatementBase::fetchAllKeyed	public	function	Returns the entire result set as a single associative array. Overrides StatementInterface::fetchAllKeyed
StatementBase::fetchAssoc	public	function	Fetches the next row and returns it as an associative array. Overrides StatementInterface::fetchAssoc
StatementBase::fetchCol	public	function	Returns an entire single column of a result set as an indexed array. Overrides StatementInterface::fetchCol
StatementBase::fetchField	public	function	Returns a single field from the next record of a result set. Overrides StatementInterface::fetchField
StatementBase::getQueryString	public	function	Gets the query string of this statement. Overrides StatementInterface::getQueryString
StatementBase::rowCount	public	function	Returns the number of rows affected by the last SQL statement. Overrides StatementInterface::rowCount
StatementBase::setFetchMode	public	function	Sets the default fetch mode for this statement. Overrides StatementInterface::setFetchMode
StatementBase::__construct	protected	function
StatementInterface::fetch	public	function	Fetches the next row from a result set.	2
StatementInterface::fetchObject	public	function	Fetches the next row and returns it as an object.	2