Default implementation of the field storage API.
<?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,
),
),
);
}
}