FetchTest.php in Drupal 8

Namespace

Drupal\KernelTests\Core\Database

File

core/tests/Drupal/KernelTests/Core/Database/FetchTest.php

<?php

namespace Drupal\KernelTests\Core\Database;

use Drupal\Core\Database\RowCountException;
use Drupal\Core\Database\StatementInterface;
use Drupal\Tests\system\Functional\Database\FakeRecord;

/**
 * Tests the Database system's various fetch capabilities.
 *
 * We get timeout errors if we try to run too many tests at once.
 *
 * @group Database
 */
class FetchTest extends DatabaseTestBase {

  /**
   * Confirms that we can fetch a record properly in default object mode.
   */
  public function testQueryFetchDefault() {
    $records = [];
    $result = $this->connection
      ->query('SELECT name FROM {test} WHERE age = :age', [
      ':age' => 25,
    ]);
    $this
      ->assertInstanceOf(StatementInterface::class, $result);
    foreach ($result as $record) {
      $records[] = $record;
      $this
        ->assertIsObject($record);
      $this
        ->assertSame('John', $record->name);
    }
    $this
      ->assertCount(1, $records, 'There is only one record.');
  }

  /**
   * Confirms that we can fetch a record to an object explicitly.
   */
  public function testQueryFetchObject() {
    $records = [];
    $result = $this->connection
      ->query('SELECT name FROM {test} WHERE age = :age', [
      ':age' => 25,
    ], [
      'fetch' => \PDO::FETCH_OBJ,
    ]);
    foreach ($result as $record) {
      $records[] = $record;
      $this
        ->assertIsObject($record);
      $this
        ->assertSame('John', $record->name);
    }
    $this
      ->assertCount(1, $records, 'There is only one record.');
  }

  /**
   * Confirms that we can fetch a record to an associative array explicitly.
   */
  public function testQueryFetchArray() {
    $records = [];
    $result = $this->connection
      ->query('SELECT name FROM {test} WHERE age = :age', [
      ':age' => 25,
    ], [
      'fetch' => \PDO::FETCH_ASSOC,
    ]);
    foreach ($result as $record) {
      $records[] = $record;
      $this
        ->assertIsArray($record);
      $this
        ->assertArrayHasKey('name', $record);
      $this
        ->assertSame('John', $record['name']);
    }
    $this
      ->assertCount(1, $records, 'There is only one record.');
  }

  /**
   * Confirms that we can fetch a record into a new instance of a custom class.
   *
   * @see \Drupal\system\Tests\Database\FakeRecord
   */
  public function testQueryFetchClass() {
    $records = [];
    $result = $this->connection
      ->query('SELECT name FROM {test} WHERE age = :age', [
      ':age' => 25,
    ], [
      'fetch' => FakeRecord::class,
    ]);
    foreach ($result as $record) {
      $records[] = $record;
      $this
        ->assertInstanceOf(FakeRecord::class, $record);
      $this
        ->assertSame('John', $record->name);
    }
    $this
      ->assertCount(1, $records, 'There is only one record.');
  }

  /**
   * Confirms that we can fetch a record into a class using fetchObject.
   *
   * @see \Drupal\system\Tests\Database\FakeRecord
   * @see \Drupal\Core\Database\StatementPrefech::fetchObject
   */
  public function testQueryFetchObjectClass() {
    $records = 0;
    $query = $this->connection
      ->query('SELECT name FROM {test} WHERE age = :age', [
      ':age' => 25,
    ]);
    while ($result = $query
      ->fetchObject(FakeRecord::class)) {
      $records += 1;
      $this
        ->assertInstanceOf(FakeRecord::class, $result);
      $this
        ->assertSame('John', $result->name, '25 year old is John.');
    }
    $this
      ->assertSame(1, $records, 'There is only one record.');
  }

  /**
   * Confirms that we can fetch a record into a new instance of a custom class.
   * The name of the class is determined from a value of the first column.
   *
   * @see \Drupal\Tests\system\Functional\Database\FakeRecord
   */
  public function testQueryFetchClasstype() {
    $records = [];
    $result = $this->connection
      ->query('SELECT classname, name, job FROM {test_classtype} WHERE age = :age', [
      ':age' => 26,
    ], [
      'fetch' => \PDO::FETCH_CLASS | \PDO::FETCH_CLASSTYPE,
    ]);
    foreach ($result as $record) {
      $records[] = $record;
      $this
        ->assertInstanceOf(FakeRecord::class, $record);
      $this
        ->assertSame('Kay', $record->name);
      $this
        ->assertSame('Web Developer', $record->job);
      $this
        ->assertFalse(isset($record->classname), 'Classname field not found, as intended.');
    }
    $this
      ->assertCount(1, $records, 'There is only one record.');
  }

  /**
   * Confirms that we can fetch a record into an indexed array explicitly.
   */
  public function testQueryFetchNum() {
    $records = [];
    $result = $this->connection
      ->query('SELECT name FROM {test} WHERE age = :age', [
      ':age' => 25,
    ], [
      'fetch' => \PDO::FETCH_NUM,
    ]);
    foreach ($result as $record) {
      $records[] = $record;
      $this
        ->assertIsArray($record);
      $this
        ->assertArrayHasKey(0, $record);
      $this
        ->assertSame('John', $record[0]);
    }
    $this
      ->assertCount(1, $records, 'There is only one record');
  }

  /**
   * Confirms that we can fetch a record into a doubly-keyed array explicitly.
   */
  public function testQueryFetchBoth() {
    $records = [];
    $result = $this->connection
      ->query('SELECT name FROM {test} WHERE age = :age', [
      ':age' => 25,
    ], [
      'fetch' => \PDO::FETCH_BOTH,
    ]);
    foreach ($result as $record) {
      $records[] = $record;
      $this
        ->assertIsArray($record);
      $this
        ->assertArrayHasKey(0, $record);
      $this
        ->assertSame('John', $record[0]);
      $this
        ->assertArrayHasKey('name', $record);
      $this
        ->assertSame('John', $record['name']);
    }
    $this
      ->assertCount(1, $records, 'There is only one record.');
  }

  /**
   * Confirms that we can fetch all records into an array explicitly.
   */
  public function testQueryFetchAllColumn() {
    $query = $this->connection
      ->select('test');
    $query
      ->addField('test', 'name');
    $query
      ->orderBy('name');
    $query_result = $query
      ->execute()
      ->fetchAll(\PDO::FETCH_COLUMN);
    $expected_result = [
      'George',
      'John',
      'Paul',
      'Ringo',
    ];
    $this
      ->assertEqual($query_result, $expected_result, 'Returned the correct result.');
  }

  /**
   * Confirms that we can fetch an entire column of a result set at once.
   */
  public function testQueryFetchCol() {
    $result = $this->connection
      ->query('SELECT name FROM {test} WHERE age > :age', [
      ':age' => 25,
    ]);
    $column = $result
      ->fetchCol();
    $this
      ->assertCount(3, $column, 'fetchCol() returns the right number of records.');
    $result = $this->connection
      ->query('SELECT name FROM {test} WHERE age > :age', [
      ':age' => 25,
    ]);
    $i = 0;
    foreach ($result as $record) {
      $this
        ->assertIdentical($record->name, $column[$i++], 'Column matches direct access.');
    }
  }

  /**
   * Tests that rowCount() throws exception on SELECT query.
   */
  public function testRowCount() {
    $result = $this->connection
      ->query('SELECT name FROM {test}');
    try {
      $result
        ->rowCount();
      $exception = FALSE;
    } catch (RowCountException $e) {
      $exception = TRUE;
    }
    $this
      ->assertTrue($exception, 'Exception was thrown');
  }

}

Classes

Name	Description
FetchTest	Tests the Database system's various fetch capabilities.