field_sql_storage.test

<?php

/**
 * @file
 * Tests for field_sql_storage.module.
 *
 * Field_sql_storage.module implements the default back-end storage plugin
 * for the Field Strage API.
 */

/**
 * Tests field storage.
 */
class FieldSqlStorageTestCase extends DrupalWebTestCase {
  protected $field;
  protected $instance;
  protected $field_name;
  protected $table;
  protected $revision_table;
  public static function getInfo() {
    return array(
      'name' => 'Field SQL storage tests',
      'description' => "Test field SQL storage module.",
      'group' => 'Field API',
    );
  }
  function setUp() {
    parent::setUp('field_sql_storage', 'field', 'field_test', 'text');
    $this->field_name = strtolower($this
      ->randomName());
    $this->field = array(
      'field_name' => $this->field_name,
      'type' => 'test_field',
      'cardinality' => 4,
    );
    $this->field = field_create_field($this->field);
    $this->instance = array(
      'field_name' => $this->field_name,
      'entity_type' => 'test_entity',
      'bundle' => 'test_bundle',
    );
    $this->instance = field_create_instance($this->instance);
    $this->table = _field_sql_storage_tablename($this->field);
    $this->revision_table = _field_sql_storage_revision_tablename($this->field);
  }

  /**
   * Uses the mysql tables and records to verify
   * field_load_revision works correctly.
   */
  function testFieldAttachLoad() {
    $entity_type = 'test_entity';
    $eid = 0;
    $langcode = LANGUAGE_NONE;
    $columns = array(
      'entity_type',
      'entity_id',
      'revision_id',
      'delta',
      'language',
      $this->field_name . '_value',
    );

    // Insert data for four revisions to the field revisions table
    $query = db_insert($this->revision_table)
      ->fields($columns);
    for ($evid = 0; $evid < 4; ++$evid) {
      $values[$evid] = array();

      // Note: we insert one extra value ('<=' instead of '<').
      for ($delta = 0; $delta <= $this->field['cardinality']; $delta++) {
        $value = mt_rand(1, 127);
        $values[$evid][] = $value;
        $query
          ->values(array(
          $entity_type,
          $eid,
          $evid,
          $delta,
          $langcode,
          $value,
        ));
      }
    }
    $query
      ->execute();

    // Insert data for the "most current revision" into the field table
    $query = db_insert($this->table)
      ->fields($columns);
    foreach ($values[0] as $delta => $value) {
      $query
        ->values(array(
        $entity_type,
        $eid,
        0,
        $delta,
        $langcode,
        $value,
      ));
    }
    $query
      ->execute();

    // Load the "most current revision"
    $entity = field_test_create_stub_entity($eid, 0, $this->instance['bundle']);
    field_attach_load($entity_type, array(
      $eid => $entity,
    ));
    foreach ($values[0] as $delta => $value) {
      if ($delta < $this->field['cardinality']) {
        $this
          ->assertEqual($entity->{$this->field_name}[$langcode][$delta]['value'], $value, "Value {$delta} is loaded correctly for current revision");
      }
      else {
        $this
          ->assertFalse(array_key_exists($delta, $entity->{$this->field_name}[$langcode]), "No extraneous value gets loaded for current revision.");
      }
    }

    // Load every revision
    for ($evid = 0; $evid < 4; ++$evid) {
      $entity = field_test_create_stub_entity($eid, $evid, $this->instance['bundle']);
      field_attach_load_revision($entity_type, array(
        $eid => $entity,
      ));
      foreach ($values[$evid] as $delta => $value) {
        if ($delta < $this->field['cardinality']) {
          $this
            ->assertEqual($entity->{$this->field_name}[$langcode][$delta]['value'], $value, "Value {$delta} for revision {$evid} is loaded correctly");
        }
        else {
          $this
            ->assertFalse(array_key_exists($delta, $entity->{$this->field_name}[$langcode]), "No extraneous value gets loaded for revision {$evid}.");
        }
      }
    }

    // Add a translation in an unavailable language and verify it is not loaded.
    $eid = $evid = 1;
    $unavailable_language = 'xx';
    $entity = field_test_create_stub_entity($eid, $evid, $this->instance['bundle']);
    $values = array(
      $entity_type,
      $eid,
      $evid,
      0,
      $unavailable_language,
      mt_rand(1, 127),
    );
    db_insert($this->table)
      ->fields($columns)
      ->values($values)
      ->execute();
    db_insert($this->revision_table)
      ->fields($columns)
      ->values($values)
      ->execute();
    field_attach_load($entity_type, array(
      $eid => $entity,
    ));
    $this
      ->assertFalse(array_key_exists($unavailable_language, $entity->{$this->field_name}), 'Field translation in an unavailable language ignored');
  }

  /**
   * Tests adding a field with an entity ID type of string.
   */
  function testFieldSqlSchemaForEntityWithStringIdentifier() {

    // Test programmatically adding field with string ID.
    $field_name = 'string_id_example';
    $field = array(
      'field_name' => $field_name,
      'type' => 'text',
      'settings' => array(
        'max_length' => 255,
      ),
      'entity_id_type' => 'string',
    );
    field_create_field($field);
    $schema = drupal_get_schema('field_data_' . $field_name);
    $this
      ->assertEqual($schema['fields']['entity_id']['type'], 'varchar');
    $this
      ->assertEqual($schema['fields']['revision_id']['type'], 'varchar');

    // Test programmatically adding field with default ID(int).
    $field_name = 'default_id_example';
    $field = array(
      'field_name' => $field_name,
      'type' => 'text',
      'settings' => array(
        'max_length' => 255,
      ),
    );
    field_create_field($field);
    $schema = drupal_get_schema('field_data_' . $field_name);
    $this
      ->assertEqual($schema['fields']['entity_id']['type'], 'int');
    $this
      ->assertEqual($schema['fields']['revision_id']['type'], 'int');
  }

  /**
   * Reads mysql to verify correct data is
   * written when using insert and update.
   */
  function testFieldAttachInsertAndUpdate() {
    $entity_type = 'test_entity';
    $entity = field_test_create_stub_entity(0, 0, $this->instance['bundle']);
    $langcode = LANGUAGE_NONE;

    // Test insert.
    $values = array();

    // Note: we try to insert one extra value ('<=' instead of '<').
    // TODO : test empty values filtering and "compression" (store consecutive deltas).
    for ($delta = 0; $delta <= $this->field['cardinality']; $delta++) {
      $values[$delta]['value'] = mt_rand(1, 127);
    }
    $entity->{$this->field_name}[$langcode] = $rev_values[0] = $values;
    field_attach_insert($entity_type, $entity);
    $rows = db_select($this->table, 't')
      ->fields('t')
      ->execute()
      ->fetchAllAssoc('delta', PDO::FETCH_ASSOC);
    foreach ($values as $delta => $value) {
      if ($delta < $this->field['cardinality']) {
        $this
          ->assertEqual($rows[$delta][$this->field_name . '_value'], $value['value'], format_string("Value %delta is inserted correctly", array(
          '%delta' => $delta,
        )));
      }
      else {
        $this
          ->assertFalse(array_key_exists($delta, $rows), "No extraneous value gets inserted.");
      }
    }

    // Test update.
    $entity = field_test_create_stub_entity(0, 1, $this->instance['bundle']);
    $values = array();

    // Note: we try to update one extra value ('<=' instead of '<').
    for ($delta = 0; $delta <= $this->field['cardinality']; $delta++) {
      $values[$delta]['value'] = mt_rand(1, 127);
    }
    $entity->{$this->field_name}[$langcode] = $rev_values[1] = $values;
    field_attach_update($entity_type, $entity);
    $rows = db_select($this->table, 't')
      ->fields('t')
      ->execute()
      ->fetchAllAssoc('delta', PDO::FETCH_ASSOC);
    foreach ($values as $delta => $value) {
      if ($delta < $this->field['cardinality']) {
        $this
          ->assertEqual($rows[$delta][$this->field_name . '_value'], $value['value'], format_string("Value %delta is updated correctly", array(
          '%delta' => $delta,
        )));
      }
      else {
        $this
          ->assertFalse(array_key_exists($delta, $rows), "No extraneous value gets updated.");
      }
    }

    // Check that data for both revisions are in the revision table.
    // We make sure each value is stored correctly, then unset it.
    // When an entire revision's values are unset (remembering that we
    // put one extra value in $values per revision), unset the entire
    // revision. Then, if $rev_values is empty at the end, all
    // revision data was found.
    $results = db_select($this->revision_table, 't')
      ->fields('t')
      ->execute();
    foreach ($results as $row) {
      $this
        ->assertEqual($row->{$this->field_name . '_value'}, $rev_values[$row->revision_id][$row->delta]['value'], "Value {$row->delta} for revision {$row->revision_id} stored correctly");
      unset($rev_values[$row->revision_id][$row->delta]);
      if (count($rev_values[$row->revision_id]) == 1) {
        unset($rev_values[$row->revision_id]);
      }
    }
    $this
      ->assertTrue(empty($rev_values), "All values for all revisions are stored in revision table {$this->revision_table}");

    // Check that update leaves the field data untouched if
    // $entity->{$field_name} is absent.
    unset($entity->{$this->field_name});
    field_attach_update($entity_type, $entity);
    $rows = db_select($this->table, 't')
      ->fields('t')
      ->execute()
      ->fetchAllAssoc('delta', PDO::FETCH_ASSOC);
    foreach ($values as $delta => $value) {
      if ($delta < $this->field['cardinality']) {
        $this
          ->assertEqual($rows[$delta][$this->field_name . '_value'], $value['value'], format_string("Update with no field_name entry leaves value %delta untouched", array(
          '%delta' => $delta,
        )));
      }
    }

    // Check that update with an empty $entity->$field_name empties the field.
    $entity->{$this->field_name} = NULL;
    field_attach_update($entity_type, $entity);
    $rows = db_select($this->table, 't')
      ->fields('t')
      ->execute()
      ->fetchAllAssoc('delta', PDO::FETCH_ASSOC);
    $this
      ->assertEqual(count($rows), 0, "Update with an empty field_name entry empties the field.");
  }

  /**
   * Tests insert and update with missing or NULL fields.
   */
  function testFieldAttachSaveMissingData() {
    $entity_type = 'test_entity';
    $entity = field_test_create_stub_entity(0, 0, $this->instance['bundle']);
    $langcode = LANGUAGE_NONE;

    // Insert: Field is missing
    field_attach_insert($entity_type, $entity);
    $count = db_select($this->table)
      ->countQuery()
      ->execute()
      ->fetchField();
    $this
      ->assertEqual($count, 0, 'Missing field results in no inserts');

    // Insert: Field is NULL
    $entity->{$this->field_name} = NULL;
    field_attach_insert($entity_type, $entity);
    $count = db_select($this->table)
      ->countQuery()
      ->execute()
      ->fetchField();
    $this
      ->assertEqual($count, 0, 'NULL field results in no inserts');

    // Add some real data
    $entity->{$this->field_name}[$langcode] = array(
      0 => array(
        'value' => 1,
      ),
    );
    field_attach_insert($entity_type, $entity);
    $count = db_select($this->table)
      ->countQuery()
      ->execute()
      ->fetchField();
    $this
      ->assertEqual($count, 1, 'Field data saved');

    // Update: Field is missing. Data should survive.
    unset($entity->{$this->field_name});
    field_attach_update($entity_type, $entity);
    $count = db_select($this->table)
      ->countQuery()
      ->execute()
      ->fetchField();
    $this
      ->assertEqual($count, 1, 'Missing field leaves data in table');

    // Update: Field is NULL. Data should be wiped.
    $entity->{$this->field_name} = NULL;
    field_attach_update($entity_type, $entity);
    $count = db_select($this->table)
      ->countQuery()
      ->execute()
      ->fetchField();
    $this
      ->assertEqual($count, 0, 'NULL field leaves no data in table');

    // Add a translation in an unavailable language.
    $unavailable_language = 'xx';
    db_insert($this->table)
      ->fields(array(
      'entity_type',
      'bundle',
      'deleted',
      'entity_id',
      'revision_id',
      'delta',
      'language',
    ))
      ->values(array(
      $entity_type,
      $this->instance['bundle'],
      0,
      0,
      0,
      0,
      $unavailable_language,
    ))
      ->execute();
    $count = db_select($this->table)
      ->countQuery()
      ->execute()
      ->fetchField();
    $this
      ->assertEqual($count, 1, 'Field translation in an unavailable language saved.');

    // Again add some real data.
    $entity->{$this->field_name}[$langcode] = array(
      0 => array(
        'value' => 1,
      ),
    );
    field_attach_insert($entity_type, $entity);
    $count = db_select($this->table)
      ->countQuery()
      ->execute()
      ->fetchField();
    $this
      ->assertEqual($count, 2, 'Field data saved.');

    // Update: Field translation is missing but field is not empty. Translation
    // data should survive.
    $entity->{$this->field_name}[$unavailable_language] = array(
      mt_rand(1, 127),
    );
    unset($entity->{$this->field_name}[$langcode]);
    field_attach_update($entity_type, $entity);
    $count = db_select($this->table)
      ->countQuery()
      ->execute()
      ->fetchField();
    $this
      ->assertEqual($count, 2, 'Missing field translation leaves data in table.');

    // Update: Field translation is NULL but field is not empty. Translation
    // data should be wiped.
    $entity->{$this->field_name}[$langcode] = NULL;
    field_attach_update($entity_type, $entity);
    $count = db_select($this->table)
      ->countQuery()
      ->execute()
      ->fetchField();
    $this
      ->assertEqual($count, 1, 'NULL field translation is wiped.');
  }

  /**
   * Tests the expected return values of _field_sql_storage_write_compare().
   */
  public function testFieldCompareDataModification() {
    $langcode = LANGUAGE_NONE;
    $field_info = field_info_field($this->field_name);

    // Make sure we have 2 sample field values that are unique.
    $value1 = 0;
    $value2 = 0;
    while ($value1 == $value2) {
      $value1 = mt_rand();
      $value2 = (string) mt_rand();
    }

    // Create the 2 entities to compare.
    $entity = field_test_create_stub_entity();
    $entity->{$this->field_name}[$langcode][]['value'] = $value1;
    $entity1 = clone $entity;
    $entity2 = clone $entity;

    // Make sure that it correctly compares identical entities.
    $this
      ->assert(!_field_sql_storage_write_compare($field_info, $entity1, $entity2), 'The entities are identical.');

    // Compare to an empty object.
    $this
      ->assert(_field_sql_storage_write_compare($field_info, $entity1, new stdClass()), 'The entity is not the same as an empty object.');

    // Change one of the values.
    $entity2->{$this->field_name}[$langcode][0]['value'] = $value2;
    $this
      ->assert(_field_sql_storage_write_compare($field_info, $entity1, $entity2), 'The values are not the same.');

    // Reset $entity2.
    $entity2 = clone $entity;

    // Duplicate the value on one of the entities.
    $entity1->{$this->field_name}[$langcode][]['value'] = $value1;
    $this
      ->assert(_field_sql_storage_write_compare($field_info, $entity1, $entity2), 'The fields do not have the same number of values.');

    // Add a second value to both entities.
    $entity2->{$this->field_name}[$langcode][]['value'] = $value2;
    $this
      ->assert(_field_sql_storage_write_compare($field_info, $entity1, $entity2), 'The values are not the same.');

    // Replace the array containing the value with the actual value.
    $entity2->{$this->field_name}[$langcode] = $entity2->{$this->field_name}[$langcode][0];
    $this
      ->assert(_field_sql_storage_write_compare($field_info, $entity1, $entity2), 'The array to hold field values is replaced by the value.');

    // Null one value.
    $entity2->{$this->field_name}[$langcode] = NULL;
    $this
      ->assert(_field_sql_storage_write_compare($field_info, $entity1, $entity2), 'One field is NULL and the other is not.');

    // Null both values.
    $entity1->{$this->field_name}[$langcode] = NULL;
    $this
      ->assert(!_field_sql_storage_write_compare($field_info, $entity1, $entity2), 'Both fields are NULL.');

    // Unset one of the fields.
    unset($entity2->{$this->field_name});
    $this
      ->assert(_field_sql_storage_write_compare($field_info, $entity1, $entity2), 'One field structure is unset.');

    // Unset both of the fields.
    unset($entity1->{$this->field_name});
    $this
      ->assert(!_field_sql_storage_write_compare($field_info, $entity1, $entity2), 'Both field structures are unset.');
  }

  /**
   * Test trying to update a field with data.
   */
  function testUpdateFieldSchemaWithData() {

    // Create a decimal 5.2 field and add some data.
    $field = array(
      'field_name' => 'decimal52',
      'type' => 'number_decimal',
      'settings' => array(
        'precision' => 5,
        'scale' => 2,
      ),
    );
    $field = field_create_field($field);
    $instance = array(
      'field_name' => 'decimal52',
      'entity_type' => 'test_entity',
      'bundle' => 'test_bundle',
    );
    $instance = field_create_instance($instance);
    $entity = field_test_create_stub_entity(0, 0, $instance['bundle']);
    $entity->decimal52[LANGUAGE_NONE][0]['value'] = '1.235';
    field_attach_insert('test_entity', $entity);

    // Attempt to update the field in a way that would work without data.
    $field['settings']['scale'] = 3;
    try {
      field_update_field($field);
      $this
        ->fail(t('Cannot update field schema with data.'));
    } catch (FieldException $e) {
      $this
        ->pass(t('Cannot update field schema with data.'));
    }
  }

  /**
   * Test that failure to create fields is handled gracefully.
   */
  function testFieldUpdateFailure() {

    // Create a text field.
    $field = array(
      'field_name' => 'test_text',
      'type' => 'text',
      'settings' => array(
        'max_length' => 255,
      ),
    );
    $field = field_create_field($field);

    // Attempt to update the field in a way that would break the storage. The
    // parenthesis suffix is needed because SQLite has *very* relaxed rules for
    // data types, so we actually need to provide an invalid SQL syntax in order
    // to break it.
    // @see https://www.sqlite.org/datatype3.html
    $prior_field = $field;
    $field['settings']['max_length'] = '-1)';
    try {
      field_update_field($field);
      $this
        ->fail(t('Update succeeded.'));
    } catch (Exception $e) {
      $this
        ->pass(t('Update properly failed.'));
    }

    // Ensure that the field tables are still there.
    foreach (_field_sql_storage_schema($prior_field) as $table_name => $table_info) {
      $this
        ->assertTrue(db_table_exists($table_name), format_string('Table %table exists.', array(
        '%table' => $table_name,
      )));
    }
  }

  /**
   * Test adding and removing indexes while data is present.
   */
  function testFieldUpdateIndexesWithData() {

    // Create a decimal field.
    $field_name = 'testfield';
    $field = array(
      'field_name' => $field_name,
      'type' => 'text',
    );
    $field = field_create_field($field);
    $instance = array(
      'field_name' => $field_name,
      'entity_type' => 'test_entity',
      'bundle' => 'test_bundle',
    );
    $instance = field_create_instance($instance);
    $tables = array(
      _field_sql_storage_tablename($field),
      _field_sql_storage_revision_tablename($field),
    );

    // Verify the indexes we will create do not exist yet.
    foreach ($tables as $table) {
      $this
        ->assertFalse(Database::getConnection()
        ->schema()
        ->indexExists($table, 'value'), format_string("No index named value exists in %table", array(
        '%table' => $table,
      )));
      $this
        ->assertFalse(Database::getConnection()
        ->schema()
        ->indexExists($table, 'value_format'), format_string("No index named value_format exists in %table", array(
        '%table' => $table,
      )));
    }

    // Add data so the table cannot be dropped.
    $entity = field_test_create_stub_entity(0, 0, $instance['bundle']);
    $entity->{$field_name}[LANGUAGE_NONE][0]['value'] = 'field data';
    field_attach_insert('test_entity', $entity);

    // Add an index
    $field = array(
      'field_name' => $field_name,
      'indexes' => array(
        'value' => array(
          array(
            'value',
            255,
          ),
        ),
      ),
    );
    field_update_field($field);
    foreach ($tables as $table) {
      $this
        ->assertTrue(Database::getConnection()
        ->schema()
        ->indexExists($table, "{$field_name}_value"), format_string("Index on value created in %table", array(
        '%table' => $table,
      )));
    }

    // Add a different index, removing the existing custom one.
    $field = array(
      'field_name' => $field_name,
      'indexes' => array(
        'value_format' => array(
          array(
            'value',
            127,
          ),
          array(
            'format',
            127,
          ),
        ),
      ),
    );
    field_update_field($field);
    foreach ($tables as $table) {
      $this
        ->assertTrue(Database::getConnection()
        ->schema()
        ->indexExists($table, "{$field_name}_value_format"), format_string("Index on value_format created in %table", array(
        '%table' => $table,
      )));
      $this
        ->assertFalse(Database::getConnection()
        ->schema()
        ->indexExists($table, "{$field_name}_value"), format_string("Index on value removed in %table", array(
        '%table' => $table,
      )));
    }

    // Verify that the tables were not dropped.
    $entity = field_test_create_stub_entity(0, 0, $instance['bundle']);
    field_attach_load('test_entity', array(
      0 => $entity,
    ));
    $this
      ->assertEqual($entity->{$field_name}[LANGUAGE_NONE][0]['value'], 'field data', "Index changes performed without dropping the tables");
  }

  /**
   * Test the storage details.
   */
  function testFieldStorageDetails() {
    $current = _field_sql_storage_tablename($this->field);
    $revision = _field_sql_storage_revision_tablename($this->field);

    // Retrieve the field and instance with field_info so the storage details are attached.
    $field = field_info_field($this->field['field_name']);
    $instance = field_info_instance($this->instance['entity_type'], $this->instance['field_name'], $this->instance['bundle']);

    // The storage details are indexed by a storage engine type.
    $this
      ->assertTrue(array_key_exists('sql', $field['storage']['details']), 'The storage type is SQL.');

    // The SQL details are indexed by table name.
    $details = $field['storage']['details']['sql'];
    $this
      ->assertTrue(array_key_exists($current, $details[FIELD_LOAD_CURRENT]), 'Table name is available in the instance array.');
    $this
      ->assertTrue(array_key_exists($revision, $details[FIELD_LOAD_REVISION]), 'Revision table name is available in the instance array.');

    // Test current and revision storage details together because the columns
    // are the same.
    foreach ((array) $this->field['columns'] as $column_name => $attributes) {
      $storage_column_name = _field_sql_storage_columnname($this->field['field_name'], $column_name);
      $this
        ->assertEqual($details[FIELD_LOAD_CURRENT][$current][$column_name], $storage_column_name, format_string('Column name %value matches the definition in %bin.', array(
        '%value' => $column_name,
        '%bin' => $current,
      )));
      $this
        ->assertEqual($details[FIELD_LOAD_REVISION][$revision][$column_name], $storage_column_name, format_string('Column name %value matches the definition in %bin.', array(
        '%value' => $column_name,
        '%bin' => $revision,
      )));
    }
  }

  /**
   * Test foreign key support.
   */
  function testFieldSqlStorageForeignKeys() {

    // Create a 'shape' field, with a configurable foreign key (see
    // field_test_field_schema()).
    $field_name = 'testfield';
    $foreign_key_name = 'shape';
    $field = array(
      'field_name' => $field_name,
      'type' => 'shape',
      'settings' => array(
        'foreign_key_name' => $foreign_key_name,
      ),
    );
    field_create_field($field);

    // Retrieve the field definition and check that the foreign key is in place.
    $field = field_info_field($field_name);
    $this
      ->assertEqual($field['foreign keys'][$foreign_key_name]['table'], $foreign_key_name, 'Foreign key table name preserved through CRUD');
    $this
      ->assertEqual($field['foreign keys'][$foreign_key_name]['columns'][$foreign_key_name], 'id', 'Foreign key column name preserved through CRUD');

    // Update the field settings, it should update the foreign key definition
    // too.
    $foreign_key_name = 'color';
    $field['settings']['foreign_key_name'] = $foreign_key_name;
    field_update_field($field);

    // Retrieve the field definition and check that the foreign key is in place.
    $field = field_info_field($field_name);
    $this
      ->assertEqual($field['foreign keys'][$foreign_key_name]['table'], $foreign_key_name, 'Foreign key table name modified after update');
    $this
      ->assertEqual($field['foreign keys'][$foreign_key_name]['columns'][$foreign_key_name], 'id', 'Foreign key column name modified after update');

    // Now grab the SQL schema and verify that too.
    $schema = drupal_get_schema(_field_sql_storage_tablename($field), TRUE);
    $this
      ->assertEqual(count($schema['foreign keys']), 1, 'There is 1 foreign key in the schema');
    $foreign_key = reset($schema['foreign keys']);
    $foreign_key_column = _field_sql_storage_columnname($field['field_name'], $foreign_key_name);
    $this
      ->assertEqual($foreign_key['table'], $foreign_key_name, 'Foreign key table name preserved in the schema');
    $this
      ->assertEqual($foreign_key['columns'][$foreign_key_column], 'id', 'Foreign key column name preserved in the schema');
  }

  /**
   * Test handling multiple conditions on one column of a field.
   *
   * Tests both the result and the complexity of the query.
   */
  function testFieldSqlStorageMultipleConditionsSameColumn() {
    $entity = field_test_create_stub_entity(NULL, NULL);
    $entity->{$this->field_name}[LANGUAGE_NONE][0] = array(
      'value' => 1,
    );
    field_test_entity_save($entity);
    $entity = field_test_create_stub_entity(NULL, NULL);
    $entity->{$this->field_name}[LANGUAGE_NONE][0] = array(
      'value' => 2,
    );
    field_test_entity_save($entity);
    $entity = field_test_create_stub_entity(NULL, NULL);
    $entity->{$this->field_name}[LANGUAGE_NONE][0] = array(
      'value' => 3,
    );
    field_test_entity_save($entity);
    $query = new EntityFieldQuery();

    // This tag causes field_test_query_store_global_test_query_alter() to be
    // invoked so that the query can be tested.
    $query
      ->addTag('store_global_test_query');
    $query
      ->entityCondition('entity_type', 'test_entity');
    $query
      ->entityCondition('bundle', 'test_bundle');
    $query
      ->fieldCondition($this->field_name, 'value', 1, '<>', 0, LANGUAGE_NONE);
    $query
      ->fieldCondition($this->field_name, 'value', 2, '<>', 0, LANGUAGE_NONE);
    $result = field_sql_storage_field_storage_query($query);

    // Test the results.
    $this
      ->assertEqual(1, count($result), format_string('One result should be returned, got @count', array(
      '@count' => count($result),
    )));

    // Test the complexity of the query.
    $query = $GLOBALS['test_query'];
    $this
      ->assertNotNull($query, 'Precondition: the query should be available');
    $tables = $query
      ->getTables();
    $this
      ->assertEqual(1, count($tables), 'The query contains just one table.');

    // Clean up.
    unset($GLOBALS['test_query']);
  }

  /**
   * Test handling multiple conditions on multiple columns of one field.
   *
   * Tests both the result and the complexity of the query.
   */
  function testFieldSqlStorageMultipleConditionsDifferentColumns() {

    // Create the multi-column shape field
    $field_name = strtolower($this
      ->randomName());
    $field = array(
      'field_name' => $field_name,
      'type' => 'shape',
      'cardinality' => 4,
    );
    $field = field_create_field($field);
    $instance = array(
      'field_name' => $field_name,
      'entity_type' => 'test_entity',
      'bundle' => 'test_bundle',
    );
    $instance = field_create_instance($instance);
    $entity = field_test_create_stub_entity(NULL, NULL);
    $entity->{$field_name}[LANGUAGE_NONE][0] = array(
      'shape' => 'A',
      'color' => 'X',
    );
    field_test_entity_save($entity);
    $entity = field_test_create_stub_entity(NULL, NULL);
    $entity->{$field_name}[LANGUAGE_NONE][0] = array(
      'shape' => 'B',
      'color' => 'X',
    );
    field_test_entity_save($entity);
    $entity = field_test_create_stub_entity(NULL, NULL);
    $entity->{$field_name}[LANGUAGE_NONE][0] = array(
      'shape' => 'A',
      'color' => 'Y',
    );
    field_test_entity_save($entity);
    $query = new EntityFieldQuery();

    // This tag causes field_test_query_store_global_test_query_alter() to be
    // invoked so that the query can be tested.
    $query
      ->addTag('store_global_test_query');
    $query
      ->entityCondition('entity_type', 'test_entity');
    $query
      ->entityCondition('bundle', 'test_bundle');
    $query
      ->fieldCondition($field_name, 'shape', 'B', '=', 'something', LANGUAGE_NONE);
    $query
      ->fieldCondition($field_name, 'color', 'X', '=', 'something', LANGUAGE_NONE);
    $result = field_sql_storage_field_storage_query($query);

    // Test the results.
    $this
      ->assertEqual(1, count($result), format_string('One result should be returned, got @count', array(
      '@count' => count($result),
    )));

    // Test the complexity of the query.
    $query = $GLOBALS['test_query'];
    $this
      ->assertNotNull($query, 'Precondition: the query should be available');
    $tables = $query
      ->getTables();
    $this
      ->assertEqual(1, count($tables), 'The query contains just one table.');

    // Clean up.
    unset($GLOBALS['test_query']);
  }

  /**
   * Test handling multiple conditions on multiple columns of one field for multiple languages.
   *
   * Tests both the result and the complexity of the query.
   */
  function testFieldSqlStorageMultipleConditionsDifferentColumnsMultipleLanguages() {
    field_test_entity_info_translatable('test_entity', TRUE);

    // Create the multi-column shape field
    $field_name = strtolower($this
      ->randomName());
    $field = array(
      'field_name' => $field_name,
      'type' => 'shape',
      'cardinality' => 4,
      'translatable' => TRUE,
    );
    $field = field_create_field($field);
    $instance = array(
      'field_name' => $field_name,
      'entity_type' => 'test_entity',
      'bundle' => 'test_bundle',
      'settings' => array(
        // Prevent warning from field_test_field_load().
        'test_hook_field_load' => FALSE,
      ),
    );
    $instance = field_create_instance($instance);
    $entity = field_test_create_stub_entity(NULL, NULL);
    $entity->{$field_name}[LANGUAGE_NONE][0] = array(
      'shape' => 'A',
      'color' => 'X',
    );
    $entity->{$field_name}['en'][0] = array(
      'shape' => 'B',
      'color' => 'Y',
    );
    field_test_entity_save($entity);
    $entity = field_test_entity_test_load($entity->ftid);
    $query = new EntityFieldQuery();

    // This tag causes field_test_query_store_global_test_query_alter() to be
    // invoked so that the query can be tested.
    $query
      ->addTag('store_global_test_query');
    $query
      ->entityCondition('entity_type', 'test_entity');
    $query
      ->entityCondition('bundle', 'test_bundle');
    $query
      ->fieldCondition($field_name, 'color', 'X', '=', NULL, LANGUAGE_NONE);
    $query
      ->fieldCondition($field_name, 'shape', 'B', '=', NULL, 'en');
    $result = field_sql_storage_field_storage_query($query);

    // Test the results.
    $this
      ->assertEqual(1, count($result), format_string('One result should be returned, got @count', array(
      '@count' => count($result),
    )));

    // Test the complexity of the query.
    $query = $GLOBALS['test_query'];
    $this
      ->assertNotNull($query, 'Precondition: the query should be available');
    $tables = $query
      ->getTables();
    $this
      ->assertEqual(2, count($tables), 'The query contains two tables.');

    // Clean up.
    unset($GLOBALS['test_query']);
  }

}