field_sql_storage.module

Default implementation of the field storage API.

File

drupal/core/modules/field/modules/field_sql_storage/field_sql_storage.module
View source
<?php

/**
 * @file
 * Default implementation of the field storage API.
 */
use Drupal\Core\Database\Database;
use Drupal\field\FieldUpdateForbiddenException;

/**
 * Implements hook_help().
 */
function field_sql_storage_help($path, $arg) {
  switch ($path) {
    case 'admin/help#field_sql_storage':
      $output = '';
      $output .= '<h3>' . t('About') . '</h3>';
      $output .= '<p>' . t('The Field SQL Storage module stores field data in the database. It is the default field storage module; other field storage mechanisms may be available as contributed modules. See the <a href="@field-help">Field module help page</a> for more information about fields.', array(
        '@field-help' => url('admin/help/field'),
      )) . '</p>';
      return $output;
  }
}

/**
 * Implements hook_field_storage_info().
 */
function field_sql_storage_field_storage_info() {
  return array(
    'field_sql_storage' => array(
      'label' => t('Default SQL storage'),
      'description' => t('Stores fields in the local SQL database, using per-field tables.'),
    ),
  );
}

/**
 * Generates a table name for a field data table.
 *
 * @param $field
 *   The field structure.
 *
 * @return
 *   A string containing the generated name for the database table.
 */
function _field_sql_storage_tablename($field) {
  if ($field['deleted']) {
    return "field_deleted_data_{$field['id']}";
  }
  else {
    return "field_data_{$field['field_name']}";
  }
}

/**
 * Generates a table name for a field revision archive table.
 *
 * @param $name
 *   The field structure.
 *
 * @return
 *   A string containing the generated name for the database table.
 */
function _field_sql_storage_revision_tablename($field) {
  if ($field['deleted']) {
    return "field_deleted_revision_{$field['id']}";
  }
  else {
    return "field_revision_{$field['field_name']}";
  }
}

/**
 * Generates a column name for a field data table.
 *
 * @param $name
 *   The name of the field.
 * @param $column
 *   The name of the column.
 *
 * @return
 *   A string containing a generated column name for a field data table that is
 *   unique among all other fields.
 */
function _field_sql_storage_columnname($name, $column) {
  return in_array($column, field_reserved_columns()) ? $column : $name . '_' . $column;
}

/**
 * Generates an index name for a field data table.
 *
 * @param $name
 *   The name of the field.
 * @param $column
 *   The name of the index.
 *
 * @return
 *   A string containing a generated index name for a field data table that is
 *   unique among all other fields.
 */
function _field_sql_storage_indexname($name, $index) {
  return $name . '_' . $index;
}

/**
 * Returns the database schema for a field.
 *
 * This may contain one or more tables. Each table will contain the columns
 * relevant for the specified field. Leave the $field's 'columns' and 'indexes'
 * keys empty to get only the base schema.
 *
 * @param $field
 *   The field structure for which to generate a database schema.
 * @return
 *   One or more tables representing the schema for the field.
 */
function _field_sql_storage_schema($field) {
  $deleted = $field['deleted'] ? 'deleted ' : '';
  $current = array(
    'description' => "Data storage for {$deleted}field {$field['id']} ({$field['field_name']})",
    'fields' => array(
      'entity_type' => array(
        'type' => 'varchar',
        'length' => 128,
        'not null' => TRUE,
        'default' => '',
        'description' => 'The entity type this data is attached to',
      ),
      'bundle' => array(
        'type' => 'varchar',
        'length' => 128,
        'not null' => TRUE,
        'default' => '',
        'description' => 'The field instance bundle to which this row belongs, used when deleting a field instance',
      ),
      'deleted' => array(
        'type' => 'int',
        'size' => 'tiny',
        'not null' => TRUE,
        'default' => 0,
        'description' => 'A boolean indicating whether this data item has been deleted',
      ),
      'entity_id' => array(
        'type' => 'int',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'description' => 'The entity id this data is attached to',
      ),
      'revision_id' => array(
        'type' => 'int',
        'unsigned' => TRUE,
        'not null' => FALSE,
        'description' => 'The entity revision id this data is attached to, or NULL if the entity type is not versioned',
      ),
      // @todo Consider storing langcode as integer.
      'langcode' => array(
        'type' => 'varchar',
        'length' => 32,
        'not null' => TRUE,
        'default' => '',
        'description' => 'The language code for this data item.',
      ),
      'delta' => array(
        'type' => 'int',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'description' => 'The sequence number for this data item, used for multi-value fields',
      ),
    ),
    'primary key' => array(
      'entity_type',
      'entity_id',
      'deleted',
      'delta',
      'langcode',
    ),
    'indexes' => array(
      'entity_type' => array(
        'entity_type',
      ),
      'bundle' => array(
        'bundle',
      ),
      'deleted' => array(
        'deleted',
      ),
      'entity_id' => array(
        'entity_id',
      ),
      'revision_id' => array(
        'revision_id',
      ),
      'langcode' => array(
        'langcode',
      ),
    ),
  );
  $field += array(
    'columns' => array(),
    'indexes' => array(),
    'foreign keys' => array(),
  );

  // Add field columns.
  foreach ($field['columns'] as $column_name => $attributes) {
    $real_name = _field_sql_storage_columnname($field['field_name'], $column_name);
    $current['fields'][$real_name] = $attributes;
  }

  // Add indexes.
  foreach ($field['indexes'] as $index_name => $columns) {
    $real_name = _field_sql_storage_indexname($field['field_name'], $index_name);
    foreach ($columns as $column_name) {

      // Indexes can be specified as either a column name or an array with
      // column name and length. Allow for either case.
      if (is_array($column_name)) {
        $current['indexes'][$real_name][] = array(
          _field_sql_storage_columnname($field['field_name'], $column_name[0]),
          $column_name[1],
        );
      }
      else {
        $current['indexes'][$real_name][] = _field_sql_storage_columnname($field['field_name'], $column_name);
      }
    }
  }

  // Add foreign keys.
  foreach ($field['foreign keys'] as $specifier => $specification) {
    $real_name = _field_sql_storage_indexname($field['field_name'], $specifier);
    $current['foreign keys'][$real_name]['table'] = $specification['table'];
    foreach ($specification['columns'] as $column => $referenced) {
      $sql_storage_column = _field_sql_storage_columnname($field['field_name'], $column_name);
      $current['foreign keys'][$real_name]['columns'][$sql_storage_column] = $referenced;
    }
  }

  // Construct the revision table.
  $revision = $current;
  $revision['description'] = "Revision archive storage for {$deleted}field {$field['id']} ({$field['field_name']})";
  $revision['primary key'] = array(
    'entity_type',
    'entity_id',
    'revision_id',
    'deleted',
    'delta',
    'langcode',
  );
  $revision['fields']['revision_id']['not null'] = TRUE;
  $revision['fields']['revision_id']['description'] = 'The entity revision id this data is attached to';
  return array(
    _field_sql_storage_tablename($field) => $current,
    _field_sql_storage_revision_tablename($field) => $revision,
  );
}

/**
 * Implements hook_field_storage_create_field().
 */
function field_sql_storage_field_storage_create_field($field) {
  $schema = _field_sql_storage_schema($field);
  foreach ($schema as $name => $table) {
    db_create_table($name, $table);
  }
  drupal_get_schema(NULL, TRUE);
}

/**
 * Implements hook_field_update_forbid().
 *
 * Forbids any field update that changes column definitions if there is any
 * data.
 */
function field_sql_storage_field_update_forbid($field, $prior_field, $has_data) {
  if ($has_data && $field['columns'] != $prior_field['columns']) {
    throw new FieldUpdateForbiddenException("field_sql_storage cannot change the schema for an existing field with data.");
  }
}

/**
 * Implements hook_field_storage_update_field().
 */
function field_sql_storage_field_storage_update_field($field, $prior_field, $has_data) {
  if (!$has_data) {

    // There is no data. Re-create the tables completely.
    if (Database::getConnection()
      ->supportsTransactionalDDL()) {

      // If the database supports transactional DDL, we can go ahead and rely
      // on it. If not, we will have to rollback manually if something fails.
      $transaction = db_transaction();
    }
    try {
      $prior_schema = _field_sql_storage_schema($prior_field);
      foreach ($prior_schema as $name => $table) {
        db_drop_table($name, $table);
      }
      $schema = _field_sql_storage_schema($field);
      foreach ($schema as $name => $table) {
        db_create_table($name, $table);
      }
    } catch (Exception $e) {
      if (Database::getConnection()
        ->supportsTransactionalDDL()) {
        $transaction
          ->rollback();
      }
      else {

        // Recreate tables.
        $prior_schema = _field_sql_storage_schema($prior_field);
        foreach ($prior_schema as $name => $table) {
          if (!db_table_exists($name)) {
            db_create_table($name, $table);
          }
        }
      }
      throw $e;
    }
  }
  else {

    // There is data, so there are no column changes. Drop all the
    // prior indexes and create all the new ones, except for all the
    // priors that exist unchanged.
    $table = _field_sql_storage_tablename($prior_field);
    $revision_table = _field_sql_storage_revision_tablename($prior_field);
    foreach ($prior_field['indexes'] as $name => $columns) {
      if (!isset($field['indexes'][$name]) || $columns != $field['indexes'][$name]) {
        $real_name = _field_sql_storage_indexname($field['field_name'], $name);
        db_drop_index($table, $real_name);
        db_drop_index($revision_table, $real_name);
      }
    }
    $table = _field_sql_storage_tablename($field);
    $revision_table = _field_sql_storage_revision_tablename($field);
    foreach ($field['indexes'] as $name => $columns) {
      if (!isset($prior_field['indexes'][$name]) || $columns != $prior_field['indexes'][$name]) {
        $real_name = _field_sql_storage_indexname($field['field_name'], $name);
        $real_columns = array();
        foreach ($columns as $column_name) {

          // Indexes can be specified as either a column name or an array with
          // column name and length. Allow for either case.
          if (is_array($column_name)) {
            $real_columns[] = array(
              _field_sql_storage_columnname($field['field_name'], $column_name[0]),
              $column_name[1],
            );
          }
          else {
            $real_columns[] = _field_sql_storage_columnname($field['field_name'], $column_name);
          }
        }
        db_add_index($table, $real_name, $real_columns);
        db_add_index($revision_table, $real_name, $real_columns);
      }
    }
  }
  drupal_get_schema(NULL, TRUE);
}

/**
 * Implements hook_field_storage_delete_field().
 */
function field_sql_storage_field_storage_delete_field($field) {

  // Mark all data associated with the field for deletion.
  $field['deleted'] = 0;
  $table = _field_sql_storage_tablename($field);
  $revision_table = _field_sql_storage_revision_tablename($field);
  db_update($table)
    ->fields(array(
    'deleted' => 1,
  ))
    ->execute();

  // Move the table to a unique name while the table contents are being deleted.
  $field['deleted'] = 1;
  $new_table = _field_sql_storage_tablename($field);
  $revision_new_table = _field_sql_storage_revision_tablename($field);
  db_rename_table($table, $new_table);
  db_rename_table($revision_table, $revision_new_table);
  drupal_get_schema(NULL, TRUE);
}

/**
 * Implements hook_field_storage_load().
 */
function field_sql_storage_field_storage_load($entity_type, $entities, $age, $fields, $options) {
  $load_current = $age == FIELD_LOAD_CURRENT;
  foreach ($fields as $field_id => $ids) {
    $field = field_info_field_by_id($field_id);
    $field_name = $field['field_name'];
    $table = $load_current ? _field_sql_storage_tablename($field) : _field_sql_storage_revision_tablename($field);
    $query = db_select($table, 't')
      ->fields('t')
      ->condition('entity_type', $entity_type)
      ->condition($load_current ? 'entity_id' : 'revision_id', $ids, 'IN')
      ->condition('langcode', field_available_languages($entity_type, $field), 'IN')
      ->orderBy('delta');
    if (empty($options['deleted'])) {
      $query
        ->condition('deleted', 0);
    }
    $results = $query
      ->execute();
    $delta_count = array();
    foreach ($results as $row) {
      if (!isset($delta_count[$row->entity_id][$row->langcode])) {
        $delta_count[$row->entity_id][$row->langcode] = 0;
      }
      if ($field['cardinality'] == FIELD_CARDINALITY_UNLIMITED || $delta_count[$row->entity_id][$row->langcode] < $field['cardinality']) {
        $item = array();

        // For each column declared by the field, populate the item
        // from the prefixed database column.
        foreach ($field['columns'] as $column => $attributes) {
          $column_name = _field_sql_storage_columnname($field_name, $column);
          $item[$column] = $row->{$column_name};
        }

        // Add the item to the field values for the entity.
        $entities[$row->entity_id]->{$field_name}[$row->langcode][] = $item;
        $delta_count[$row->entity_id][$row->langcode]++;
      }
    }
  }
}

/**
 * Implements hook_field_storage_write().
 */
function field_sql_storage_field_storage_write($entity_type, $entity, $op, $fields) {
  $vid = $entity
    ->getRevisionId();
  $id = $entity
    ->id();
  $bundle = $entity
    ->bundle();
  if (!isset($vid)) {
    $vid = $id;
  }
  foreach ($fields as $field_id) {
    $field = field_info_field_by_id($field_id);
    $field_name = $field['field_name'];
    $table_name = _field_sql_storage_tablename($field);
    $revision_name = _field_sql_storage_revision_tablename($field);
    $all_langcodes = field_available_languages($entity_type, $field);
    $field_langcodes = array_intersect($all_langcodes, array_keys((array) $entity->{$field_name}));

    // Delete and insert, rather than update, in case a value was added.
    if ($op == FIELD_STORAGE_UPDATE) {

      // Delete language codes present in the incoming $entity->$field_name.
      // Delete all language codes if $entity->$field_name is empty.
      $langcodes = !empty($entity->{$field_name}) ? $field_langcodes : $all_langcodes;
      if ($langcodes) {

        // Only overwrite the field's base table if saving the default revision
        // of an entity.
        if ($entity
          ->isDefaultRevision()) {
          db_delete($table_name)
            ->condition('entity_type', $entity_type)
            ->condition('entity_id', $id)
            ->condition('langcode', $langcodes, 'IN')
            ->execute();
        }
        db_delete($revision_name)
          ->condition('entity_type', $entity_type)
          ->condition('entity_id', $id)
          ->condition('revision_id', $vid)
          ->condition('langcode', $langcodes, 'IN')
          ->execute();
      }
    }

    // Prepare the multi-insert query.
    $do_insert = FALSE;
    $columns = array(
      'entity_type',
      'entity_id',
      'revision_id',
      'bundle',
      'delta',
      'langcode',
    );
    foreach ($field['columns'] as $column => $attributes) {
      $columns[] = _field_sql_storage_columnname($field_name, $column);
    }
    $query = db_insert($table_name)
      ->fields($columns);
    $revision_query = db_insert($revision_name)
      ->fields($columns);
    foreach ($field_langcodes as $langcode) {
      $items = (array) $entity->{$field_name}[$langcode];
      $delta_count = 0;
      foreach ($items as $delta => $item) {

        // We now know we have someting to insert.
        $do_insert = TRUE;
        $record = array(
          'entity_type' => $entity_type,
          'entity_id' => $id,
          'revision_id' => $vid,
          'bundle' => $bundle,
          'delta' => $delta,
          'langcode' => $langcode,
        );
        foreach ($field['columns'] as $column => $attributes) {
          $record[_field_sql_storage_columnname($field_name, $column)] = isset($item[$column]) ? $item[$column] : NULL;
        }
        $query
          ->values($record);
        if (isset($vid)) {
          $revision_query
            ->values($record);
        }
        if ($field['cardinality'] != FIELD_CARDINALITY_UNLIMITED && ++$delta_count == $field['cardinality']) {
          break;
        }
      }
    }

    // Execute the query if we have values to insert.
    if ($do_insert) {

      // Only overwrite the field's base table if saving the default revision
      // of an entity.
      if ($entity
        ->isDefaultRevision()) {
        $query
          ->execute();
      }
      $revision_query
        ->execute();
    }
  }
}

/**
 * Implements hook_field_storage_delete().
 *
 * This function deletes data for all fields for an entity from the database.
 */
function field_sql_storage_field_storage_delete($entity_type, $entity, $fields) {
  foreach (field_info_instances($entity_type, $entity
    ->bundle()) as $instance) {
    if (isset($fields[$instance['field_id']])) {
      $field = field_info_field_by_id($instance['field_id']);
      field_sql_storage_field_storage_purge($entity_type, $entity, $field, $instance);
    }
  }
}

/**
 * Implements hook_field_storage_purge().
 *
 * This function deletes data from the database for a single field on
 * an entity.
 */
function field_sql_storage_field_storage_purge($entity_type, $entity, $field, $instance) {
  $table_name = _field_sql_storage_tablename($field);
  $revision_name = _field_sql_storage_revision_tablename($field);
  db_delete($table_name)
    ->condition('entity_type', $entity_type)
    ->condition('entity_id', $entity
    ->id())
    ->execute();
  db_delete($revision_name)
    ->condition('entity_type', $entity_type)
    ->condition('entity_id', $entity
    ->id())
    ->execute();
}

/**
 * Implements hook_field_storage_delete_revision().
 *
 * This function actually deletes the data from the database.
 */
function field_sql_storage_field_storage_delete_revision($entity_type, $entity, $fields) {
  $vid = $entity
    ->getRevisionId();
  if (isset($vid)) {
    foreach ($fields as $field_id) {
      $field = field_info_field_by_id($field_id);
      $revision_name = _field_sql_storage_revision_tablename($field);
      db_delete($revision_name)
        ->condition('entity_type', $entity_type)
        ->condition('entity_id', $entity
        ->id())
        ->condition('revision_id', $vid)
        ->execute();
    }
  }
}

/**
 * Implements hook_field_storage_delete_instance().
 *
 * This function simply marks for deletion all data associated with the field.
 */
function field_sql_storage_field_storage_delete_instance($instance) {
  $field = field_info_field($instance['field_name']);
  $table_name = _field_sql_storage_tablename($field);
  $revision_name = _field_sql_storage_revision_tablename($field);
  db_update($table_name)
    ->fields(array(
    'deleted' => 1,
  ))
    ->condition('entity_type', $instance['entity_type'])
    ->condition('bundle', $instance['bundle'])
    ->execute();
  db_update($revision_name)
    ->fields(array(
    'deleted' => 1,
  ))
    ->condition('entity_type', $instance['entity_type'])
    ->condition('bundle', $instance['bundle'])
    ->execute();
}

/**
 * Implements hook_field_attach_rename_bundle().
 */
function field_sql_storage_field_attach_rename_bundle($entity_type, $bundle_old, $bundle_new) {

  // We need to account for deleted or inactive fields and instances.
  $instances = field_read_instances(array(
    'entity_type' => $entity_type,
    'bundle' => $bundle_new,
  ), array(
    'include_deleted' => TRUE,
    'include_inactive' => TRUE,
  ));
  foreach ($instances as $instance) {
    $field = field_info_field_by_id($instance['field_id']);
    if ($field['storage']['type'] == 'field_sql_storage') {
      $table_name = _field_sql_storage_tablename($field);
      $revision_name = _field_sql_storage_revision_tablename($field);
      db_update($table_name)
        ->fields(array(
        'bundle' => $bundle_new,
      ))
        ->condition('entity_type', $entity_type)
        ->condition('bundle', $bundle_old)
        ->execute();
      db_update($revision_name)
        ->fields(array(
        'bundle' => $bundle_new,
      ))
        ->condition('entity_type', $entity_type)
        ->condition('bundle', $bundle_old)
        ->execute();
    }
  }
}

/**
 * Implements hook_field_storage_purge_field().
 *
 * All field data items and instances have already been purged, so all that is
 * left is to delete the table.
 */
function field_sql_storage_field_storage_purge_field($field) {
  $table_name = _field_sql_storage_tablename($field);
  $revision_name = _field_sql_storage_revision_tablename($field);
  db_drop_table($table_name);
  db_drop_table($revision_name);
}

/**
 * Implements hook_field_storage_details().
 */
function field_sql_storage_field_storage_details($field) {
  $details = array();
  if (!empty($field['columns'])) {

    // Add field columns.
    foreach ($field['columns'] as $column_name => $attributes) {
      $real_name = _field_sql_storage_columnname($field['field_name'], $column_name);
      $columns[$column_name] = $real_name;
    }
    return array(
      'sql' => array(
        FIELD_LOAD_CURRENT => array(
          _field_sql_storage_tablename($field) => $columns,
        ),
        FIELD_LOAD_REVISION => array(
          _field_sql_storage_revision_tablename($field) => $columns,
        ),
      ),
    );
  }
}

Functions

Namesort descending Description
field_sql_storage_field_attach_rename_bundle Implements hook_field_attach_rename_bundle().
field_sql_storage_field_storage_create_field Implements hook_field_storage_create_field().
field_sql_storage_field_storage_delete Implements hook_field_storage_delete().
field_sql_storage_field_storage_delete_field Implements hook_field_storage_delete_field().
field_sql_storage_field_storage_delete_instance Implements hook_field_storage_delete_instance().
field_sql_storage_field_storage_delete_revision Implements hook_field_storage_delete_revision().
field_sql_storage_field_storage_details Implements hook_field_storage_details().
field_sql_storage_field_storage_info Implements hook_field_storage_info().
field_sql_storage_field_storage_load Implements hook_field_storage_load().
field_sql_storage_field_storage_purge Implements hook_field_storage_purge().
field_sql_storage_field_storage_purge_field Implements hook_field_storage_purge_field().
field_sql_storage_field_storage_update_field Implements hook_field_storage_update_field().
field_sql_storage_field_storage_write Implements hook_field_storage_write().
field_sql_storage_field_update_forbid Implements hook_field_update_forbid().
field_sql_storage_help Implements hook_help().
_field_sql_storage_columnname Generates a column name for a field data table.
_field_sql_storage_indexname Generates an index name for a field data table.
_field_sql_storage_revision_tablename Generates a table name for a field revision archive table.
_field_sql_storage_schema Returns the database schema for a field.
_field_sql_storage_tablename Generates a table name for a field data table.