class Statement in Drupal driver for SQL Server and SQL Azure 8

Hierarchy

• class \Drupal\Core\Database\Statement extends \Drupal\Core\Database\PDOStatement implements StatementInterface
  • class \Drupal\Driver\Database\sqlsrv\Statement implements StatementInterface

File

drivers/lib/Drupal/Driver/Database/sqlsrv/Statement.php, line 19

Definition of Drupal\Driver\Database\sqlsrv\Statement

Namespace

Drupal\Driver\Database\sqlsrv

class Statement extends DatabaseStatement implements StatementInterface {
  protected function __construct(Connection $dbh) {
    $this->allowRowCount = TRUE;
    parent::__construct($dbh);
  }

  // Flag to tell if statement should be run insecure.
  private $insecure = FALSE;

  // Tells the statement to set insecure parameters
  // such as SQLSRV_ATTR_DIRECT_QUERY and ATTR_EMULATE_PREPARES.
  public function RequireInsecure() {
    $this->insecure = TRUE;
  }
  public function execute($args = array(), $options = array()) {
    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 http://drupal.org/node/315092.
        $this
          ->setFetchMode(PDO::FETCH_CLASS, $options['fetch']);
      }
      else {
        $this
          ->setFetchMode($options['fetch']);
      }
    }
    $logger = $this->dbh
      ->getLogger();
    $query_start = microtime(TRUE);

    // If parameteres have already been binded
    // to the statement and we pass an empty array here
    // we will get a PDO Exception.
    if (empty($args)) {
      $args = NULL;
    }

    // Execute the query. Bypass parent override
    // and directly call PDOStatement implementation.
    $return = PDOStatement::execute($args);
    if (!$return) {
      $this
        ->throwPDOException($statement);
    }

    // Bind column types properly.
    $null = array();
    $this->columnNames = array();
    for ($i = 0; $i < $this
      ->columnCount(); $i++) {
      $meta = $this
        ->getColumnMeta($i);
      $this->columnNames[] = $meta['name'];
      $sqlsrv_type = $meta['sqlsrv:decl_type'];
      $parts = explode(' ', $sqlsrv_type);
      $type = reset($parts);
      switch ($type) {
        case 'varbinary':
          $null[$i] = NULL;
          $this
            ->bindColumn($i + 1, $null[$i], PDO::PARAM_LOB, 0, PDO::SQLSRV_ENCODING_BINARY);
          break;
        case 'int':
        case 'bit':
        case 'smallint':
        case 'tinyint':
          $null[$i] = NULL;
          $this
            ->bindColumn($i + 1, $null[$i], PDO::PARAM_INT);
          break;
        case 'nvarchar':
        case 'varchar':
          $null[$i] = NULL;
          $this
            ->bindColumn($i + 1, $null[$i], PDO::PARAM_STR, 0, PDO::SQLSRV_ENCODING_UTF8);
          break;
      }
    }
    if (!empty($logger)) {
      $query_end = microtime(TRUE);
      $logger
        ->log($this, $args, $query_end - $query_start);
    }

    // Remove technical columns from the final result set.
    $droppable_columns = array_flip(isset($options['sqlsrv_drop_columns']) ? $options['sqlsrv_drop_columns'] : array());
    $dropped_columns = array();
    foreach ($this->columnNames as $k => $column) {
      if (substr($column, 0, 2) == '__' || isset($droppable_columns[$column])) {
        $dropped_columns[] = $column;
        unset($this->columnNames[$k]);
      }
    }
    return $return;
  }

  /**
   * Throw a PDO Exception based on the last PDO error.
   *
   * @status: Unfinished.
   */
  protected function throwPDOException(&$statement = NULL) {

    // This is what a SQL Server PDO "no error" looks like.
    $null_error = array(
      0 => '00000',
      1 => NULL,
      2 => NULL,
    );

    // The implementation in Drupal's Core StatementPrefetch Class
    // takes for granted that the error information is in the PDOConnection
    // but it is regularly held in the PDOStatement.
    $error_info_connection = $this->dbh
      ->errorInfo();
    $error_info_statement = !empty($statement) ? $statement
      ->errorInfo() : $null_error;

    // TODO: Concatenate error information when both connection
    // and statement error info are valid.
    // We rebuild a message formatted in the same way as PDO.
    $error_info = $error_info_connection === $null_error ? $error_info_statement : $error_info_connection;
    $exception = new PDOException("SQLSTATE[" . $error_info[0] . "]: General error " . $error_info[1] . ": " . $error_info[2]);
    $exception->errorInfo = $error_info;
    unset($statement);
    throw $exception;
  }

  /**
   * Experimental, do not iterate if not needed.
   *
   * @param mixed $key_index
   * @param mixed $value_index
   * @return array|Statement
   */
  public function fetchAllKeyed($key_index = 0, $value_index = 1) {

    // If we are asked for the default behaviour, rely
    // on the PDO as being faster. The result set needs to exactly bee 2 columns.
    if ($key_index == 0 && $value_index == 1 && $this
      ->columnCount() == 2) {
      $this
        ->setFetchMode(PDO::FETCH_KEY_PAIR);
      return $this
        ->fetchAll();
    }

    // We need to do this manually.
    $return = array();
    $this
      ->setFetchMode(PDO::FETCH_NUM);
    foreach ($this as $record) {
      $return[$record[$key_index]] = $record[$value_index];
    }
    return $return;
  }

}

Members

Name	Modifiers	Type	Description	Overrides
Statement::$allowRowCount	public	property	Is rowCount() execution allowed.
Statement::$dbh	public	property	Reference to the database connection object for this statement.
Statement::$insecure	private	property
Statement::execute	public	function	Executes a prepared statement Overrides Statement::execute
Statement::fetchAll	public	function	Returns an array containing all of the result set rows. Overrides StatementInterface::fetchAll
Statement::fetchAllAssoc	public	function	Returns the result set as an associative array keyed by the given field. Overrides StatementInterface::fetchAllAssoc
Statement::fetchAllKeyed	public	function	Experimental, do not iterate if not needed. Overrides Statement::fetchAllKeyed
Statement::fetchAssoc	public	function	Fetches the next row and returns it as an associative array. Overrides StatementInterface::fetchAssoc
Statement::fetchCol	public	function	Returns an entire single column of a result set as an indexed array. Overrides StatementInterface::fetchCol
Statement::fetchField	public	function	Returns a single field from the next record of a result set. Overrides StatementInterface::fetchField
Statement::getQueryString	public	function	Gets the query string of this statement. Overrides StatementInterface::getQueryString
Statement::RequireInsecure	public	function
Statement::rowCount	public	function	Returns the number of rows affected by the last SQL statement. Overrides StatementInterface::rowCount
Statement::setFetchMode	public	function	Sets the default fetch mode for this statement. Overrides StatementInterface::setFetchMode
Statement::throwPDOException	protected	function	Throw a PDO Exception based on the last PDO error.
Statement::__construct	protected	function	Overrides Statement::__construct
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