drupal/modules/simpletest/tests/database_test.test

<?php
// $Id$

/**
 * Dummy class for fetching into a class.
 *
 * PDO supports using a new instance of an arbitrary class for records
 * rather than just a stdClass or array.  This class is for testing that
 * functionality.  (See testQueryFetchClass() below)
 */ 
class FakeRecord { }

/**
 * Base test class for databases.
 * 
 * Because all database tests share the same test data, we can centralize that
 * here.
 */
class DatabaseTestCase extends DrupalWebTestCase {

  function setUp() {
    parent::setUp('database_test');

    try {
      $schema['test'] = drupal_get_schema('test');
      $schema['test_people'] = drupal_get_schema('test_people');
      $schema['test_one_blob'] = drupal_get_schema('test_one_blob');
      $schema['test_two_blobs'] = drupal_get_schema('test_two_blobs');
      $schema['test_task'] = drupal_get_schema('test_task');
  
      $ret = array();
  
      // This ends up being a test for table drop and create, too, which is 
      // nice.
      foreach ($schema as $name => $data) {
        if (db_table_exists($name)) {
          db_drop_table($ret, $name);
        }
        db_create_table($ret, $name, $data);
      }
  
      foreach ($schema as $name => $data) {
        $this->assertTrue(db_table_exists($name), t('Table @name created successfully.', array('@name' => $name)));
      }
      
      $this->addSampleData();
    }
    catch (Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }

  /**
   * Setup our sample data.
   *
   * These are added using db_query(), since we're not trying to test the 
   * INSERT operations here, just populate.
   */
  function addSampleData() {
    db_query("INSERT INTO {test} (name, age, job) VALUES ('John', 25, 'Singer')");
    $john = db_last_insert_id('test', 'id');
    db_query("INSERT INTO {test} (name, age, job) VALUES ('George', 27, 'Singer')");
    $george = db_last_insert_id('test', 'id');
    db_query("INSERT INTO {test} (name, age, job) VALUES ('Ringo', 28, 'Drummer')");
    $ringo = db_last_insert_id('test', 'id');
    db_query("INSERT INTO {test} (name, age, job) VALUES ('Paul', 26, 'Songwriter')");
    $paul = db_last_insert_id('test', 'id');

    db_query("INSERT INTO {test_people} (name, age, job) VALUES ('Meredith', 30, 'Speaker')");

    db_query("INSERT INTO {test_task} (pid, task, priority) VALUES (:pid, :task, :priority)", array(
      ':pid' => $john, 
      ':task' => 'eat', 
      ':priority' => 3,
    ));
    db_query("INSERT INTO {test_task} (pid, task, priority) VALUES (:pid, :task, :priority)", array(
      ':pid' => $john, 
      ':task' => 'sleep', 
      ':priority' => 4,
    ));
    db_query("INSERT INTO {test_task} (pid, task, priority) VALUES (:pid, :task, :priority)", array(
      ':pid' => $john, 
      ':task' => 'code', 
      ':priority' => 1,
    ));
    db_query("INSERT INTO {test_task} (pid, task, priority) VALUES (:pid, :task, :priority)", array(
      ':pid' => $george, 
      ':task' => 'sing', 
      ':priority' => 2,
    ));
    db_query("INSERT INTO {test_task} (pid, task, priority) VALUES (:pid, :task, :priority)", array(
      ':pid' => $george, 
      ':task' => 'sleep', 
      ':priority' => 2,
    ));
    db_query("INSERT INTO {test_task} (pid, task, priority) VALUES (:pid, :task, :priority)", array(
      ':pid' => $paul, 
      ':task' => 'found new band', 
      ':priority' => 1,
    ));
    db_query("INSERT INTO {test_task} (pid, task, priority) VALUES (:pid, :task, :priority)", array(
      ':pid' => $paul, 
      ':task' => 'perform at superbowl', 
      ':priority' => 3,
    ));
  }

}

/**
 * Test fetch actions, part 1.
 * 
 * We get timeout errors if we try to run too many tests at once.
 */
class DatabaseFetchTestCase extends DatabaseTestCase {
  
  function getInfo() {
    return array(
      'name' => t('Fetch tests'),
      'description' => t('Test the Database system\'s various fetch capabilities.'),
      'group' => t('Database'),
    );
  }

  /**
   * Confirm that we can fetch a record properly in default object mode.
   */
  function testQueryFetchDefault() {

    $records = array();
    $result = db_query("SELECT name FROM {test} WHERE age = :age", array(':age' => 25));
    $this->assertTrue($result instanceof DatabaseStatement, t('Result set is a Drupal statement object.'));
    foreach ($result as $record) {
      $records[] = $record;
      $this->assertTrue(is_object($record), t('Record is an object.'));
      $this->assertIdentical($record->name, 'John', t('25 year old is John.'));
    }

    $this->assertIdentical(count($records), 1, t('There is only one record.'));
  }

  /**
   * Confirm that we can fetch a record to an object explicitly.
   */
  function testQueryFetchObject() {
    $records = array();
    $result = db_query("SELECT name FROM {test} WHERE age = :age", array(':age' => 25), array('fetch' => PDO::FETCH_OBJ));
    foreach ($result as $record) {
      $records[] = $record;
      $this->assertTrue(is_object($record), t('Record is an object.'));
      $this->assertIdentical($record->name, 'John', t('25 year old is John.'));
    }

    $this->assertIdentical(count($records), 1, t('There is only one record.'));
  }

  /**
   * Confirm that we can fetch a record to an array associative explicitly.
   */
  function testQueryFetchArray() {
    $records = array();
    $result = db_query("SELECT name FROM {test} WHERE age = :age", array(':age' => 25), array('fetch' => PDO::FETCH_ASSOC));
    foreach ($result as $record) {
      $records[] = $record;
      if ($this->assertTrue(is_array($record), t('Record is an array.'))) {
        $this->assertIdentical($record['name'], 'John', t('Record can be accessed associatively.'));
      }
    }

    $this->assertIdentical(count($records), 1, t('There is only one record.'));
  }

  /**
   * Confirm that we can fetch a record into a new instance of a custom class.
   *
   * @see FakeRecord
   */
  function testQueryFetchClass() {
    $records = array();
    $result = db_query("SELECT name FROM {test} WHERE age = :age", array(':age' => 25), array('fetch' => 'FakeRecord'));
    foreach ($result as $record) {
      $records[] = $record;
      if ($this->assertTrue($record instanceof FakeRecord, t('Record is an object of class FakeRecord.'))) {
        $this->assertIdentical($record->name, 'John', t('25 year old is John.'));
      }
    }

    $this->assertIdentical(count($records), 1, t('There is only one record.'));
  }
}

/**
 * Test fetch actions, part 2.
 * 
 * We get timeout errors if we try to run too many tests at once.
 */
class DatabaseFetch2TestCase extends DatabaseTestCase {

  function getInfo() {
    return array(
      'name' => t('Fetch tests, part 2'),
      'description' => t('Test the Database system\'s various fetch capabilities.'),
      'group' => t('Database'),
    );
  }

  function setUp() {
    parent::setUp();
  }

  // Confirm that we can fetch a record into an indexed array explicitly.
  function testQueryFetchNum() {
    $records = array();
    $result = db_query("SELECT name FROM {test} WHERE age = :age", array(':age' => 25), array('fetch' => PDO::FETCH_NUM));
    foreach ($result as $record) {
      $records[] = $record;
      if ($this->assertTrue(is_array($record), t('Record is an array.'))) {
        $this->assertIdentical($record[0], 'John', t('Record can be accessed numerically.'));
      }
    }

    $this->assertIdentical(count($records), 1, 'There is only one record');
  }

  /**
   * Confirm that we can fetch a record into a doubly-keyed array explicitly.
   */
  function testQueryFetchBoth() {
    $records = array();
    $result = db_query("SELECT name FROM {test} WHERE age = :age", array(':age' => 25), array('fetch' => PDO::FETCH_BOTH));
    foreach ($result as $record) {
      $records[] = $record;
      if ($this->assertTrue(is_array($record), t('Record is an array.'))) {
        $this->assertIdentical($record[0], 'John', t('Record can be accessed numerically.'));
        $this->assertIdentical($record['name'], 'John', t('Record can be accessed associatively.'));
      }
    }

    $this->assertIdentical(count($records), 1, t('There is only one record.'));
  }

  /**
   * Confirm that we can fetch an entire column of a result set at once.
   */ 
  function testQueryFetchCol() {
    $records = array();
    $result = db_query("SELECT name FROM {test} WHERE age > :age", array(':age' => 25));
    $column = $result->fetchCol();
    $this->assertIdentical(count($column), 3, t('fetchCol() returns the right number of records.'));


    $result = db_query("SELECT name FROM {test} WHERE age > :age", array(':age' => 25));
    $i = 0;
    foreach ($result as $record) {
      $this->assertIdentical($record->name, $column[$i++], t('Column matches direct accesss.'));
    }
  }
}

/**
 * Test the insert builder.
 */
class DatabaseInsertTestCase extends DatabaseTestCase {

  function getInfo() {
    return array(
      'name' => t('Insert tests'),
      'description' => t('Test the Insert query builder.'),
      'group' => t('Database'),
    );
  }

  /**
   * Test the very basic insert functionality.
   */
  function testSimpleInsert() {
    try {
      $num_records_before = db_query("SELECT COUNT(*) FROM {test}")->fetchField();
  
      $query = db_insert('test');
      $query->fields(array(
        'name' => 'Yoko',
        'age' => '29',
      ));
      $query->execute();

      $num_records_after = db_query("SELECT COUNT(*) FROM {test}")->fetchField();
      $this->assertIdentical($num_records_before + 1, (int)$num_records_after, t('Record inserts correctly.'));
  
      $saved_age = db_query("SELECT age FROM {test} WHERE name = :name", array(':name' => 'Yoko'))->fetchField();
      $this->assertIdentical($saved_age, '29', t('Can retrieve after inserting.'));
    }
    catch (Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }

  /**
   * Test that we can insert multiple records in one query object.
   */
  function testMultiInsert() {
  	try {
      $num_records_before = (int) db_query("SELECT COUNT(*) FROM {test}")->fetchField();
  
      $query = db_insert('test');
      $query->fields(array(
        'name' => 'Larry',
        'age' => '30',
      ));
  
      // We should be able to specify values in any order if named.
      $query->values(array(
        'age' => '31',
        'name' => 'Curly',
      ));
  
      // We should be able to say "use the field order".
      // This is not the recommended mechanism for most cases, but it should work.
      $query->values(array('Moe', '32'));
      $query->execute();
  
      $num_records_after = (int) db_query("SELECT COUNT(*) FROM {test}")->fetchField();
      $this->assertIdentical($num_records_before + 3, $num_records_after, t('Record inserts correctly.'));
      $saved_age = db_query("SELECT age FROM {test} WHERE name = :name", array(':name' => 'Larry'))->fetchField();
      $this->assertIdentical($saved_age, '30', t('Can retrieve by name.'));
      $saved_age = db_query("SELECT age FROM {test} WHERE name = :name", array(':name' => 'Curly'))->fetchField();
      $this->assertIdentical($saved_age, '31', t('Can retrieve by name.'));
      $saved_age = db_query("SELECT age FROM {test} WHERE name = :name", array(':name' => 'Moe'))->fetchField();
      $this->assertIdentical($saved_age, '32', t('Can retrieve by name.'));
  	}
    catch (Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }

  /**
   * Test that an insert object can be reused with new data after it executes.
   */
  function testRepeatedInsert() {
    try {
      $num_records_before = db_query("SELECT COUNT(*) FROM {test}")->fetchField();
  
      $query = db_insert('test');
  
      $query->fields(array(
        'name' => 'Larry',
        'age' => '30',
      ));
      $query->execute();  // This should run the insert, but leave the fields intact.
  
      // We should be able to specify values in any order if named.
      $query->values(array(
        'age' => '31',
        'name' => 'Curly',
      ));
      $query->execute();
  
      // We should be able to say "use the field order".
      $query->values(array('Moe', '32'));
      $query->execute();
  
      $num_records_after = db_query("SELECT COUNT(*) FROM {test}")->fetchField();
      $this->assertIdentical((int) $num_records_before + 3, (int) $num_records_after, t('Record inserts correctly.'));
      $saved_age = db_query("SELECT age FROM {test} WHERE name = :name", array(':name' => 'Larry'))->fetchField();
      $this->assertIdentical($saved_age, '30', t('Can retrieve by name.'));
      $saved_age = db_query("SELECT age FROM {test} WHERE name = :name", array(':name' => 'Curly'))->fetchField();
      $this->assertIdentical($saved_age, '31', t('Can retrieve by name.'));
      $saved_age = db_query("SELECT age FROM {test} WHERE name = :name", array(':name' => 'Moe'))->fetchField();
      $this->assertIdentical($saved_age, '32', t('Can retrieve by name.'));
  	}
    catch (Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }

  /**
   * Test that we can specify fields without values and specify values later.
   */
  function testInsertFieldOnlyDefinintion() {
    // This is useful for importers, when we want to create a query and define
    // its fields once, then loop over a multi-insert execution.
    db_insert('test')
      ->fields(array('name', 'age'))
      ->values(array('Larry', '30'))
      ->values(array('Curly', '31'))
      ->values(array('Moe', '32'))
      ->execute();
    $saved_age = db_query("SELECT age FROM {test} WHERE name = :name", array(':name' => 'Larry'))->fetchField();
    $this->assertIdentical($saved_age, '30', t('Can retrieve after inserting.'));
  }

  /**
   * Test that inserts return the proper auto-increment ID.
   */
  function testInsertLastInsertID() {
    try {
      $id = db_insert('test')->fields(array(
          'name' => 'Larry',
          'age' => '30',
        ))
        ->execute();
      
      $this->assertIdentical($id, '5', t('Auto-increment ID returned successfully.'));
  	}
    catch (Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }
}

/**
 * Insert tests using LOB fields, which are weird on some databases.
 */
class DatabaseInsertLOBTestCase extends DatabaseTestCase {

  function getInfo() {
    return array(
      'name' => t('Insert tests, LOB fields'),
      'description' => t('Test the Insert query builder with LOB fields.'),
      'group' => t('Database'),
    );
  }

  /**
   * Test that we can insert a single blob field successfully.
   */
  function testInsertOneBlob() {
    $data = "This is\000a test.";
    $this->assertTrue(strlen($data) === 15, t('Test data contains a NULL.'));
    $id = db_insert('test_one_blob')->fields(array('blob1' => $data))->execute();
    $res = db_query('SELECT * FROM {test_one_blob} WHERE id = :id', array(':id' => $id));
    $r = db_fetch_array($res);
    $this->assertTrue($r['blob1'] === $data, t('Can insert a blob: id @id, @data.', array('@id' => $id, '@data' => serialize($r))));
  }

  /**
   * Test that we can insert multiple blob fields in the same query.
   */
  function testInsertMultipleBlob() {
    $id = db_insert('test_two_blobs')->fields(array(
      'blob1' => 'This is', 
      'blob2' => 'a test',
      ))
    ->execute();
    $res = db_query('SELECT * FROM {test_two_blobs} WHERE id = %d', $id);
    $r = db_fetch_array($res);
    $this->assertTrue($r['blob1'] === 'This is' && $r['blob2'] === 'a test', t('Can insert multiple blobs per row.'));
  }
}

/**
 * Insert tests for "database default" values.
 */
class DatabaseInsertDefaultsTestCase extends DatabaseTestCase {

  function getInfo() {
    return array(
      'name' => t('Insert tests, default fields'),
      'description' => t('Test the Insert query builder with default values.'),
      'group' => t('Database'),
    );
  }
 
  /**
   * Test that we can run a query that is "default values for everything".
   */
  function testDefaultInsert() {
    try {
      $query = db_insert('test')->useDefaults(array('job'));
      $id = $query->execute();
      
      $schema = drupal_get_schema('test');
      
      $job = db_query("SELECT job FROM {test} WHERE id = :id", array(':id' => $id))->fetchField();
      $this->assertEqual($job, $schema['fields']['job']['default'], t('Default field value is set.'));
    }
    catch (Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }

  /**
   * Test that we can insert fields with values and defaults in the same query.
   */
  function testDefaultInsertWithFields() {
    try {
      $query = db_insert('test')->fields(array('name' => 'Bob'))->useDefaults(array('job'));
      $id = $query->execute();
      
      $schema = drupal_get_schema('test');
      
      $job = db_query("SELECT job FROM {test} WHERE id = :id", array(':id' => $id))->fetchField();
      $this->assertEqual($job, $schema['fields']['job']['default'], t('Default field value is set.'));
    }
    catch (Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }
}

/**
 * Update builder tests.
 */
class DatabaseUpdateTestCase extends DatabaseTestCase {

  function getInfo() {
    return array(
      'name' => t('Update tests'),
      'description' => t('Test the Update query builder.'),
      'group' => t('Database'),
    );
  }

  /**
   * Confirm that we can update a single record successfully.
   */
  function testSimpleUpdate() {
    $num_updated = db_update('test')->fields(array('name' => 'Tiffany'))->condition('id', 1)->execute();
    $this->assertIdentical($num_updated, 1, t('Updated 1 record.'));

    $saved_name = db_query("SELECT name FROM {test} WHERE id = :id", array(':id' => 1))->fetchField();
    $this->assertIdentical($saved_name, 'Tiffany', t('Updated name successfully.'));
  }
  
  /**
   * Confirm that we can update a multiple records successfully.
   */
  function testMultiUpdate() {
    $num_updated = db_update('test')->fields(array('job' => 'Musician'))->condition('job', 'Singer')->execute();
    $this->assertIdentical($num_updated, 2, t('Updated 2 records.'));

    $num_matches = db_query("SELECT count(*) FROM {test} WHERE job = :job", array(':job' => 'Musician'))->fetchField();
    $this->assertIdentical($num_matches, '2', t('Updated fields successfully.'));
  }

  /**
   * Confirm that we can update a multiple records with a non-equality condition.
   */
  function testMultiGTUpdate() {
    $num_updated = db_update('test')->fields(array('job' => 'Musician'))->condition('age', 26, '>')->execute();
    $this->assertIdentical($num_updated, 2, t('Updated 2 records.'));

    $num_matches = db_query("SELECT count(*) FROM {test} WHERE job = :job", array(':job' => 'Musician'))->fetchField();
    $this->assertIdentical($num_matches, '2', t('Updated fields successfully.'));
  }

  /**
   * Confirm that we can update a multiple records with a where call.
   */
  function testWhereUpdate() {
    $num_updated = db_update('test')->fields(array('job' => 'Musician'))->where('age > :age', array(':age' => 26))->execute();
    $this->assertIdentical($num_updated, 2, t('Updated 2 records.'));

    $num_matches = db_query("SELECT COUNT(*) FROM {test} WHERE job = :job", array(':job' => 'Musician'))->fetchField();
    $this->assertIdentical($num_matches, '2', t('Updated fields successfully.'));
  }

  /**
   * Confirm that we can stack condition and where calls.
   */
  function testWhereAndConditionUpdate() {
    $update = db_update('test')->fields(array('job' => 'Musician'))->where('age > :age', array(':age' => 26))->condition('name', 'Ringo');
    $num_updated = $update->execute();
    $this->assertIdentical($num_updated, 1, t('Updated 1 record.'));

    $num_matches = db_query("SELECT count(*) FROM {test} WHERE job = :job", array(':job' => 'Musician'))->fetchField();
    $this->assertIdentical($num_matches, '1', t('Updated fields successfully.'));
  }
}

/**
 * Tests for more complex update statements.
 */
class DatabaseUpdateComplexTestCase extends DatabaseTestCase {

  function getInfo() {
    return array(
      'name' => t('Update tests, Complex'),
      'description' => t('Test the Update query builder, complex queries.'),
      'group' => t('Database'),
    );
  }

  /**
   * Test updates with OR conditionals.
   */
  function testOrConditionUpdate() {
    $update = db_update('test')
      ->fields(array('job' => 'Musician'))
      ->condition(db_or()
        ->condition('name', 'John')
        ->condition('name', 'Paul')
      );
    $num_updated = $update->execute();
    $this->assertIdentical($num_updated, 2, t('Updated 2 records.'));

    $num_matches = db_query("SELECT count(*) FROM {test} WHERE job = :job", array(':job' => 'Musician'))->fetchField();
    $this->assertIdentical($num_matches, '2', t('Updated fields successfully.'));
  }

  /**
   * Test WHERE IN clauses.
   */
  function testInConditionUpdate() {
    $num_updated = db_update('test')->fields(array('job' => 'Musician'))
      ->condition('name', array('John', 'Paul'), 'IN')
      ->execute();
    $this->assertIdentical($num_updated, 2, t('Updated 2 records.'));

    $num_matches = db_query("SELECT count(*) FROM {test} WHERE job = :job", array(':job' => 'Musician'))->fetchField();
    $this->assertIdentical($num_matches, '2', t('Updated fields successfully.'));
  }

  /**
   * Test WHERE NOT IN clauses.
   */
  function testNotInConditionUpdate() {
    $num_updated = db_update('test')->fields(array('job' => 'Musician'))
      ->condition('name', array('John', 'Paul', 'George'), 'NOT IN')
      ->execute();
    $this->assertIdentical($num_updated, 1, t('Updated 1 record.'));

    $num_matches = db_query("SELECT count(*) FROM {test} WHERE job = :job", array(':job' => 'Musician'))->fetchField();
    $this->assertIdentical($num_matches, '1', t('Updated fields successfully.'));
  }

  /**
   * Test BETWEEN conditional clauses.
   */
  function testBetweenConditionUpdate() {
    try{
      $num_updated = db_update('test')->fields(array('job' => 'Musician'))
        ->condition('age', array(25, 26), 'BETWEEN')
        ->execute();
      $this->assertIdentical($num_updated, 2, t('Updated 2 records.'));
  
      $num_matches = db_query("SELECT count(*) FROM {test} WHERE job = :job", array(':job' => 'Musician'))->fetchField();
      $this->assertIdentical($num_matches, '2', t('Updated fields successfully.'));
    }
    catch (Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }

  /**
   * Test LIKE conditionals.
   */
  function testLikeConditionUpdate() {
    $num_updated = db_update('test')->fields(array('job' => 'Musician'))
      ->condition('name', '%ge%', 'LIKE')
      ->execute();
    $this->assertIdentical($num_updated, 1, t('Updated 1 record.'));

    $num_matches = db_query("SELECT count(*) FROM {test} WHERE job = :job", array(':job' => 'Musician'))->fetchField();
    $this->assertIdentical($num_matches, '1', t('Updated fields successfully.'));
  }

  /**
   * Test update with expression values.
   */
  function testUpdateExpression() {
    try {
      $before_age = db_query("SELECT age FROM {test} WHERE name = 'Ringo'")->fetchField();
      $GLOBALS['larry_test'] = 1;
      $num_updated = db_update('test')
        ->condition('name', 'Ringo')
        ->fields(array('job' => 'Musician'))
        ->expression('age', 'age + :age',array(':age' => 4))
        ->execute();
      $this->assertIdentical($num_updated, 1, t('Updated 1 record.'));
  
      $num_matches = db_query("SELECT count(*) FROM {test} WHERE job = :job", array(':job' => 'Musician'))->fetchField();
      $this->assertIdentical($num_matches, '1', t('Updated fields successfully.'));
      
      $person = db_query("SELECT * FROM {test} WHERE name = :name", array(':name' => 'Ringo'))->fetch();
      $this->assertEqual($person->name, 'Ringo', t('Name set correctly.'));
      $this->assertEqual($person->age, $before_age + 4, t('Age set correctly.'));
      $this->assertEqual($person->job, 'Musician', t('Job set correctly.'));
      $GLOBALS['larry_test'] = 0;
    }
    catch (Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }
}

/**
 * Test update queries involving LOB values.
 */
class DatabaseUpdateLOBTestCase extends DatabaseTestCase {

  function getInfo() {
    return array(
      'name' => t('Update tests, LOB'),
      'description' => t('Test the Update query builder with LOB fields.'),
      'group' => t('Database'),
    );
  }

  /**
   * Confirm that we can update a blob column.
   */
  function testUpdateOneBlob() {
    $data = "This is\000a test.";
    $this->assertTrue(strlen($data) === 15, t('Test data contains a NULL.'));
    $id = db_insert('test_one_blob')->fields(array('blob1' => $data))->execute();

    $data .= $data;
    db_update('test_one_blob')->condition('id', $id)->fields(array('blob1' => $data))->execute();

    $res = db_query('SELECT * FROM {test_one_blob} WHERE id = %d', $id);
    $r = db_fetch_array($res);
    $this->assertTrue($r['blob1'] === $data, t('Can update a blob: id @id, @data.', array('@id' => $id, '@data' => serialize($r))));
  }
  
  /**
   * Confirm that we can update two blob columns in the same table.
   */
  function testUpdateMultipleBlob() {
    $id = db_insert('test_two_blobs')->fields(array(
        'blob1' => 'This is', 
        'blob2' => 'a test')
      )
      ->execute();

    db_update('test_two_blobs')->condition('id', $id)->fields(array('blob1' => 'and so', 'blob2' => 'is this'))->execute();

    $res = db_query('SELECT * FROM {test_two_blobs} WHERE id = %d', $id);
    $r = db_fetch_array($res);
    $this->assertTrue($r['blob1'] === 'and so' && $r['blob2'] === 'is this', t('Can update multiple blobs per row.'));
  }
}

/**
 * Delete tests.
 *
 * The DELETE tests are not as extensive, as all of the interesting code for
 * DELETE queries is in the conditional which is identical to the UPDATE and
 * SELECT conditional handling.
 *
 */
class DatabaseDeleteTestCase extends DatabaseTestCase {

  function getInfo() {
    return array(
      'name' => t('Delete tests'),
      'description' => t('Test the Delete query builder.'),
      'group' => t('Database'),
    );
  }

  /**
   * Confirm that we can delete a single record successfully.
   */
  function testSimpleDelete() {
    $num_records_before = db_query("SELECT COUNT(*) FROM {test}")->fetchField();

    $num_deleted = db_delete('test')->condition('id', 1)->execute();
    $this->assertIdentical($num_deleted, 1, t('Deleted 1 record.'));

    $num_records_after = db_query("SELECT COUNT(*) FROM {test}")->fetchField();
    $this->assertEqual($num_records_before, $num_records_after + $num_deleted, t('Deletion adds up.'));
  }
}

/**
 * Test the MERGE query builder.
 */
class DatabaseMergeTestCase extends DatabaseTestCase {

  function getInfo() {
    return array(
      'name' => t('Merge tests'),
      'description' => t('Test the Merge query builder.'),
      'group' => t('Database'),
    );
  }

  /**
   * Confirm that we can merge-insert a record successfully.
   */
  function testMergeInsert() {
    try{
      $num_records_before = db_query("SELECT COUNT(*) FROM {test_people}")->fetchField();
  
      db_merge('test_people')
        ->key(array('job' => 'Presenter'))
        ->fields(array(
          'age' => 31, 
          'name' => 'Tiffany',
        ))
        ->execute();

      $num_records_after = db_query("SELECT COUNT(*) FROM {test_people}")->fetchField();
      $this->assertEqual($num_records_before + 1, $num_records_after, t('Merge inserted properly.'));
      
      $person = db_query("SELECT * FROM {test_people} WHERE job = :job", array(':job' => 'Presenter'))->fetch();
      $this->assertEqual($person->name, 'Tiffany', t('Name set correctly.'));
      $this->assertEqual($person->age, 31, t('Age set correctly.'));
      $this->assertEqual($person->job, 'Presenter', t('Job set correctly.'));
    }
    catch(Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }

  /**
   * Confirm that we can merge-update a record successfully.
   */
  function testMergeUpdate() {
    $num_records_before = db_query("SELECT COUNT(*) FROM {test_people}")->fetchField();

    db_merge('test_people')->key(array('job' => 'Speaker'))->fields(array('age' => 31, 'name' => 'Tiffany'))->execute();

    $num_records_after = db_query("SELECT COUNT(*) FROM {test_people}")->fetchField();
    $this->assertEqual($num_records_before, $num_records_after, t('Merge updated properly.'));
    
    $person = db_query("SELECT * FROM {test_people} WHERE job = :job", array(':job' => 'Speaker'))->fetch();
    $this->assertEqual($person->name, 'Tiffany', t('Name set correctly.'));
    $this->assertEqual($person->age, 31, t('Age set correctly.'));
    $this->assertEqual($person->job, 'Speaker', t('Job set correctly.'));
  }

  /**
   * Confirm that we can merge-update a record successfully, with exclusion.
   */
  function testMergeUpdateExcept() {
    $num_records_before = db_query("SELECT COUNT(*) FROM {test_people}")->fetchField();

    db_merge('test_people')->key(array('job' => 'Speaker'))->fields(array('age' => 31, 'name' => 'Tiffany'))->updateExcept('age')->execute();

    $num_records_after = db_query("SELECT COUNT(*) FROM {test_people}")->fetchField();
    $this->assertEqual($num_records_before, $num_records_after, t('Merge updated properly.'));
    
    $person = db_query("SELECT * FROM {test_people} WHERE job = :job", array(':job' => 'Speaker'))->fetch();
    $this->assertEqual($person->name, 'Tiffany', t('Name set correctly.'));
    $this->assertEqual($person->age, 30, t('Age skipped correctly.'));
    $this->assertEqual($person->job, 'Speaker', t('Job set correctly.'));
  }

  /**
   * Confirm that we can merge-update a record successfully, with alternate replacement.
   */
  function testMergeUpdateExplicit() {
    $num_records_before = db_query("SELECT COUNT(*) FROM {test_people}")->fetchField();

    db_merge('test_people')->key(array('job' => 'Speaker'))->fields(array('age' => 31, 'name' => 'Tiffany'))->update(array('name' => 'Joe'))->execute();

    $num_records_after = db_query("SELECT COUNT(*) FROM {test_people}")->fetchField();
    $this->assertEqual($num_records_before, $num_records_after, t('Merge updated properly.'));
    
    $person = db_query("SELECT * FROM {test_people} WHERE job = :job", array(':job' => 'Speaker'))->fetch();
    $this->assertEqual($person->name, 'Joe', t('Name set correctly.'));
    $this->assertEqual($person->age, 30, t('Age skipped correctly.'));
    $this->assertEqual($person->job, 'Speaker', t('Job set correctly.'));
  }

  /**
   * Confirm that we can merge-update a record successfully, with expressions.
   */
  function testMergeUpdateExpression() {
    $num_records_before = db_query("SELECT COUNT(*) FROM {test_people}")->fetchField();

    $age_before = db_query("SELECT age FROM {test_people} WHERE job = 'Speaker'")->fetchField();

    // This is a very contrived example, as I have no idea why you'd want to 
    // change age this way, but that's beside the point.
    // Note that we are also double-setting age here, once as a literal and
    // once as an expression.  This test will only pass if the expression wins,
    // which is what is supposed to happen.
    db_merge('test_people')
      ->key(array('job' => 'Speaker'))
      ->fields(array('age' => 31, 'name' => 'Tiffany'))
      ->expression('age', 'age + :age', array(':age' => 4))
      ->execute();

    $num_records_after = db_query("SELECT COUNT(*) FROM {test_people}")->fetchField();
    $this->assertEqual($num_records_before, $num_records_after, t('Merge updated properly.'));
    
    $person = db_query("SELECT * FROM {test_people} WHERE job = :job", array(':job' => 'Speaker'))->fetch();
    $this->assertEqual($person->name, 'Tiffany', t('Name set correctly.'));
    $this->assertEqual($person->age, $age_before + 4, t('Age updated correctly.'));
    $this->assertEqual($person->job, 'Speaker', t('Job set correctly.'));
  }
}

/**
 * Test the SELECT builder.
 *
 */
class DatabaseSelectTestCase extends DatabaseTestCase {

  function getInfo() {
    return array(
      'name' => t('Select tests'),
      'description' => t('Test the Select query builder.'),
      'group' => t('Database'),
    );
  }

  /**
   * Test rudimentary SELECT statements.
   */
  function testSimpleSelect() {
    try {
      $query = db_select('test');
      $name_field = $query->addField('test', 'name');
      $age_field = $query->addField('test', 'age', 'age');
      $result = $query->execute();
      
      $num_records = 0;
      foreach ($result as $record) {
        $num_records++;
      }
      
      $this->assertEqual($num_records, 4, t('Returned the correct number of rows.'));
    }
    catch(Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }

  /**
   * Test basic conditionals on SELECT statements.
   */
  function testSimpleSelectConditional() {
    $query = db_select('test');
    $name_field = $query->addField('test', 'name');
    $age_field = $query->addField('test', 'age', 'age');
    $query->condition('age', 27);
    $result = $query->execute();
    
    // Check that the aliases are being created the way we want.
    $this->assertEqual($name_field, 'test_name', t('Name field alias is correct.'));
    $this->assertEqual($age_field, 'age', t('Age field alias is correct.'));
    
    // Ensure that we got the right record.
    $record = $result->fetch();
    $this->assertEqual($record->$name_field, 'George', t('Fetched name is correct.'));
    $this->assertEqual($record->$age_field, 27, t('Fetched age is correct.'));
  }

  /**
   * Test SELECT statements with expressions.
   */
  function testSimpleSelectExpression() {
    $query = db_select('test');
    $name_field = $query->addField('test', 'name');
    $age_field = $query->addExpression("age*2", 'double_age');
    $query->condition('age', 27);
    $result = $query->execute();
    
    // Check that the aliases are being created the way we want.
    $this->assertEqual($name_field, 'test_name', t('Name field alias is correct.'));
    $this->assertEqual($age_field, 'double_age', t('Age field alias is correct.'));
    
    // Ensure that we got the right record.
    $record = $result->fetch();
    $this->assertEqual($record->$name_field, 'George', t('Fetched name is correct.'));
    $this->assertEqual($record->$age_field, 27*2, t('Fetched age expression is correct.'));
  }
}

/**
 * Test select with order by clauses.
 */
class DatabaseSelectOrderedTestCase extends DatabaseTestCase {

  function getInfo() {
    return array(
      'name' => t('Select tests, ordered'),
      'description' => t('Test the Select query builder.'),
      'group' => t('Database'),
    );
  }

  /**
   * Test basic order by.
   */
  function testSimpleSelectOrdered() {
    try {
      $query = db_select('test');
      $name_field = $query->addField('test', 'name');
      $age_field = $query->addField('test', 'age', 'age');
      $query->orderBy($age_field);
      $result = $query->execute();
      
      $num_records = 0;
      $last_age = 0;
      foreach ($result as $record) {
        $num_records++;
        $this->assertTrue($record->age >= $last_age, t('Results returned in correct order.'));
        $last_age = $record->age;
      }
      
      $this->assertEqual($num_records, 4, t('Returned the correct number of rows.'));
    }
    catch(Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }

  /**
   * Test multiple order by.
   */
  function testSimpleSelectMultiOrdered() {
    try {
      $query = db_select('test');
      $name_field = $query->addField('test', 'name');
      $age_field = $query->addField('test', 'age', 'age');
      $job_field = $query->addField('test', 'job');
      $query->orderBy($job_field);
      $query->orderBy($age_field);
      $result = $query->execute();
      
      $num_records = 0;
      $expected = array(
        array('Ringo', 28, 'Drummer'),
        array('John', 25, 'Singer'),
        array('George', 27, 'Singer'),
        array('Paul', 26, 'Songwriter'),
      );
      $results = $result->fetchAll(PDO::FETCH_NUM);
      foreach ($expected as $k => $record) {
        $num_records++;
        foreach ($record as $kk => $col) {
          if ($expected[$k][$kk] != $results[$k][$kk]) {
            $this->assertTrue(FALSE, t('Results returned in correct order.'));
          }
        }
      }
      $this->assertEqual($num_records, 4, t('Returned the correct number of rows.'));
    }
    catch(Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }


  /**
   * Test order by descending.
   */
  function testSimpleSelectOrderedDesc() {
    try {
      $query = db_select('test');
      $name_field = $query->addField('test', 'name');
      $age_field = $query->addField('test', 'age', 'age');
      $query->orderBy($age_field, 'DESC');
      $result = $query->execute();
      
      $num_records = 0;
      $last_age = 100000000;
      foreach ($result as $record) {
        $num_records++;
        $this->assertTrue($record->age <= $last_age, t('Results returned in correct order.'));
        $last_age = $record->age;
      }
      
      $this->assertEqual($num_records, 4, t('Returned the correct number of rows.'));
    }
    catch(Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }
}

/**
 * Test more complex select statements.
 */
class DatabaseSelectComplexTestCase extends DatabaseTestCase {

  function getInfo() {
    return array(
      'name' => t('Select tests, complex'),
      'description' => t('Test the Select query builder with more complex queries.'),
      'group' => t('Database'),
    );
  }

  /**
   * Test simple JOIN statements.
   */
  function testDefaultJoin() {
    try {
      $query = db_select('test_task', 't');
      $people_alias = $query->join('test', 'p', 't.pid = p.id');
      $name_field = $query->addField($people_alias, 'name', 'name');
      $task_field = $query->addField('t', 'task', 'task');
      $priority_field = $query->addField('t', 'priority', 'priority');
      
      $query->orderBy($priority_field);
      $result = $query->execute();
      
      $num_records = 0;
      $last_priority = 0;
      foreach ($result as $record) {
        $num_records++;
        $this->assertTrue($record->$priority_field >= $last_priority, t('Results returned in correct order.'));
        $this->assertNotEqual($record->$name_field, 'Ringo', t('Taskless person not selected.'));
        $last_priority = $record->$priority_field;
      }
      
      $this->assertEqual($num_records, 7, t('Returned the correct number of rows.'));
    }
    catch(Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }

  /**
   * Test LEFT OUTER joins.
   */
  function testLeftOuterJoin() {
    try {
      $query = db_select('test', 'p');
      $people_alias = $query->leftJoin('test_task', 't', 't.pid = p.id');
      $name_field = $query->addField('p', 'name', 'name');
      $task_field = $query->addField($people_alias, 'task', 'task');
      $priority_field = $query->addField($people_alias, 'priority', 'priority');
      
      $query->orderBy($name_field);
      $result = $query->execute();
      
      $num_records = 0;
      $last_name = 0;
      
      foreach ($result as $record) {
        $num_records++;
        $this->assertTrue(strcmp($record->$name_field, $last_name) >= 0, t('Results returned in correct order.'));
        $last_priority = $record->$name_field;
      }
      
      $this->assertEqual($num_records, 8, t('Returned the correct number of rows.'));
    }
    catch(Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }

  /**
   * Test GROUP BY clauses.
   */
  function testGroupBy() {
    try {
      $query = db_select('test_task', 't');
      $count_field = $query->addExpression('COUNT(task)', 'num');
      $task_field = $query->addField('t', 'task');
      $query->orderBy($count_field);
      $query->groupBy($task_field);
      $result = $query->execute();
      
      $num_records = 0;
      $last_count = 0;
      $records = array();
      foreach ($result as $record) {
        $num_records++;
        $this->assertTrue($record->$count_field >= $last_count, t('Results returned in correct order.'));
        $last_count = $record->$count_field;
        $records[$record->$task_field] = $record->$count_field;
      }
      
      $correct_results = array(
        'eat' => 1,
        'sleep' => 2,
        'code' => 1,
        'found new band' => 1,
        'perform at superbowl' => 1,
      );
      
      foreach ($correct_results as $task => $count) {
        $this->assertEqual($records[$task], $count, t("Correct number of '@task' records found.", array('@task' => $task)));
      }

      $this->assertEqual($num_records, 6, t('Returned the correct number of total rows.'));
    }
    catch(Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }

  /**
   * Test GROUP BY and HAVING clauses together.
   */
  function testGroupByAndHaving() {
    try {
      $query = db_select('test_task', 't');
      $count_field = $query->addExpression('COUNT(task)', 'num');
      $task_field = $query->addField('t', 'task');
      $query->orderBy($count_field);
      $query->groupBy($task_field);
      $query->havingCondition('COUNT(task)', 2, '>=');
      $result = $query->execute();
      
      $num_records = 0;
      $last_count = 0;
      $records = array();
      foreach ($result as $record) {
        $num_records++;
        $this->assertTrue($record->$count_field >= 2, t('Record has the minimum count.'));
        $this->assertTrue($record->$count_field >= $last_count, t('Results returned in correct order.'));
        $last_count = $record->$count_field;
        $records[$record->$task_field] = $record->$count_field;
      }
      
      $correct_results = array(
        'sleep' => 2,
      );
      
      foreach ($correct_results as $task => $count) {
        $this->assertEqual($records[$task], $count, t("Correct number of '@task' records found.", array('@task' => $task)));
      }

      $this->assertEqual($num_records, 1, t('Returned the correct number of total rows.'));
    }
    catch(Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }

  /**
   * Test range queries. The SQL clause varies with the database.
   */
  function testRange() {
    try {
      $query = db_select('test');
      $name_field = $query->addField('test', 'name');
      $age_field = $query->addField('test', 'age', 'age');
      $query->range(0, 2);
      $result = $query->execute();
      
      $num_records = 0;
      foreach ($result as $record) {
        $num_records++;
      }
      
      $this->assertEqual($num_records, 2, t('Returned the correct number of rows.'));
    }
    catch(Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }

  /**
   * Test distinct queries.
   */
  function testDistinct() {
    try {
      $query = db_select('test_task');
      $task_field = $query->addField('test_task', 'task');
      $query->distinct();
      $result = $query->execute();
      
      $num_records = 0;
      foreach ($result as $record) {
        $num_records++;
      }
      
      $this->assertEqual($num_records, 6, t('Returned the correct number of rows.'));
    }
    catch(Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }

  /**
   * Test that we can generate a count query from a built query.
   */
  function testCountQuery() {
    try {
      $query = db_select('test');
      $name_field = $query->addField('test', 'name');
      $age_field = $query->addField('test', 'age', 'age');
      $query->orderBy('name');
      
      $count = $query->countQuery()->execute()->fetchField();
      
      $this->assertEqual($count, 4, t('Counted the correct number of records.'));
      
      // Now make sure we didn't break the original query!  We should still have
      // all of the fields we asked for.
      $record = $query->execute()->fetch();
      $this->assertEqual($record->$name_field, 'George', t('Correct data retrieved.'));
      $this->assertEqual($record->$age_field, 27, t('Correct data retrieved.'));
    }
    catch(Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }
}

/**
 * Select tagging tests.
 * 
 * Tags are a way to flag queries for alter hooks so they know
 * what type of query it is, such as "node_access".
 */
class DatabaseTaggingTestCase extends DatabaseTestCase {

  function getInfo() {
    return array(
      'name' => t('Query tagging tests'),
      'description' => t('Test the tagging capabilities of the Select builder.'),
      'group' => t('Database'),
    );
  }

  /**
   * Confirm that a query has a "tag" added to it.
   */
  function testHasTag() {
    try {
      $query = db_select('test');
      $query->addField('test', 'name');
      $query->addField('test', 'age', 'age');
      
      $query->addTag('test');
      
      $this->assertTrue($query->hasTag('test'), t('hasTag() returned true.'));
      $this->assertFalse($query->hasTag('other'), t('hasTag() returned false.'));
    }
    catch(Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }

  /**
   * Test query tagging "has all of these tags" functionality.
   */
  function testHasAllTags() {
    try {
      $query = db_select('test');
      $query->addField('test', 'name');
      $query->addField('test', 'age', 'age');
      
      $query->addTag('test');
      $query->addTag('other');
      
      $this->assertTrue($query->hasAllTags('test', 'other'), t('hasAllTags() returned true.'));
      $this->assertFalse($query->hasAllTags('test', 'stuff'), t('hasAllTags() returned false.'));
    }
    catch(Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }

  /**
   * Test query tagging "has at least one of these tags" functionality.
   */
  function testHasAnyTag() {
    try {
      $query = db_select('test');
      $query->addField('test', 'name');
      $query->addField('test', 'age', 'age');
      
      $query->addTag('test');
      
      $this->assertTrue($query->hasAnyTag('test', 'other'), t('hasAnyTag() returned true.'));
      $this->assertFalse($query->hasAnyTag('other', 'stuff'), t('hasAnyTag() returned false.'));
    }
    catch(Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }

  /**
   * Test that we can attach meta data to a query object.
   * 
   * This is how we pass additional context to alter hooks.
   */
  function testMetaData() {
    try {
      $query = db_select('test');
      $query->addField('test', 'name');
      $query->addField('test', 'age', 'age');
      
      $data = array(
        'a' => 'A',
        'b' => 'B',
      );
      
      $query->addMetaData('test', $data);
      
      $return = $query->getMetaData('test');
      $this->assertEqual($data, $return, t('Corect metadata returned.'));
      
      $return = $query->getMetaData('nothere');
      $this->assertNull($return, t('Non-existant key returned NULL.'));
    }
    catch(Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }
}

/**
 * Select alter tests.
 * 
 * @see database_test_query_alter().
 */
class DatabaseAlterTestCase extends DatabaseTestCase {

  function getInfo() {
    return array(
      'name' => t('Query altering tests'),
      'description' => t('Test the hook_query_alter capabilities of the Select builder.'),
      'group' => t('Database'),
    );
  }

  /**
   * Test that we can do basic alters.
   */
  function testSimpleAlter() {
    try {
      $query = db_select('test');
      $query->addField('test', 'name');
      $query->addField('test', 'age', 'age');
      $query->addTag('database_test_alter_add_range');

      $result = $query->execute();

      $num_records = 0;
      foreach ($result as $record) {
        $num_records++;
      }
      
      $this->assertEqual($num_records, 2, t('Returned the correct number of rows.'));
    }
    catch(Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }

  /**
   * Test that we can alter the joins on a query.
   */
  function testAlterWithJoin() {
    try {
      $query = db_select('test_task');
      $tid_field = $query->addField('test_task', 'tid');
      $task_field = $query->addField('test_task', 'task');
      $query->orderBy($task_field);
      $query->addTag('database_test_alter_add_join');

      $result = $query->execute();

      $records = $result->fetchAll();
      
      $this->assertEqual(count($records), 2, t('Returned the correct number of rows.'));
      
      $this->assertEqual($records[0]->name, 'George', t('Correct data retrieved.'));
      $this->assertEqual($records[0]->$tid_field, 4, t('Correct data retrieved.'));
      $this->assertEqual($records[0]->$task_field, 'sing', t('Correct data retrieved.'));
      $this->assertEqual($records[1]->name, 'George', t('Correct data retrieved.'));
      $this->assertEqual($records[1]->$tid_field, 5, t('Correct data retrieved.'));
      $this->assertEqual($records[1]->$task_field, 'sleep', t('Correct data retrieved.'));
    }
    catch(Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }

  /**
   * Test that we can alter a query's conditionals.
   */
  function testAlterChangeConditional() {
    try {
      $query = db_select('test_task');
      $tid_field = $query->addField('test_task', 'tid');
      $pid_field = $query->addField('test_task', 'pid');
      $task_field = $query->addField('test_task', 'task');
      $people_alias = $query->join('test', 'people', "test_task.pid = people.id");
      $name_field = $query->addField($people_alias, 'name', 'name');
      $query->condition('test_task.tid', '1');
      $query->orderBy($tid_field);
      $query->addTag('database_test_alter_change_conditional');

      $result = $query->execute();

      $records = $result->fetchAll();

      $this->assertEqual(count($records), 1, t('Returned the correct number of rows.'));
      $this->assertEqual($records[0]->$name_field, 'John', t('Correct data retrieved.'));
      $this->assertEqual($records[0]->$tid_field, 2, t('Correct data retrieved.'));
      $this->assertEqual($records[0]->$pid_field, 1, t('Correct data retrieved.'));
      $this->assertEqual($records[0]->$task_field, 'sleep', t('Correct data retrieved.'));
    }
    catch(Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }
}

/**
 * Select alter tests, part 2.
 * 
 * @see database_test_query_alter().
 */
class DatabaseAlter2TestCase extends DatabaseTestCase {

  function getInfo() {
    return array(
      'name' => t('Query altering tests, part 2'),
      'description' => t('Test the hook_query_alter capabilities of the Select builder.'),
      'group' => t('Database'),
    );
  }

  /**
   * Test that we can alter the fields of a query.
   */
  function testAlterChangeFields() {
    try {
      $query = db_select('test');
      $name_field = $query->addField('test', 'name');
      $age_field = $query->addField('test', 'age', 'age');
      $query->orderBy('name');
      $query->addTag('database_test_alter_change_fields');
      
      $record = $query->execute()->fetch();
      $this->assertEqual($record->$name_field, 'George', t('Correct data retrieved.'));
      $this->assertFalse(isset($record->$age_field), t('Age field not found, as intended.'));
    }
    catch(Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }

  /**
   * Test that we can alter expressions in the query.
   */
  function testAlterExpression() {
    try {
      $query = db_select('test');
      $name_field = $query->addField('test', 'name');
      $age_field = $query->addExpression("age*2", 'double_age');
      $query->condition('age', 27);
      $query->addTag('database_test_alter_change_expressions');
      $result = $query->execute();
      
      // Ensure that we got the right record.
      $record = $result->fetch();

      $this->assertEqual($record->$name_field, 'George', t('Fetched name is correct.'));
      $this->assertEqual($record->$age_field, 27*3, t('Fetched age expression is correct.'));
    }
    catch(Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }

  /**
   * Test that we can remove a range() value from a query.
   */
  function testAlterRemoveRange() {
    try {
      $query = db_select('test');
      $query->addField('test', 'name');
      $query->addField('test', 'age', 'age');
      $query->range(0, 2);
      $query->addTag('database_test_alter_remove_range');

      $num_records = count($query->execute()->fetchAll());

      $this->assertEqual($num_records, 4, t('Returned the correct number of rows.'));
    }
    catch(Exception $e) {
      $this->assertTrue(FALSE, $e->getMessage());
    }
  }
}