field_sql_norevisions.module

<?php

/**
 * Implements hook_field_storage_info_alter().
 * 
 * We override field_sql_storage's module pointer to point to ourself (field_sql_norevisions) so we can override all relevant functions.
 */
function field_sql_norevisions_field_storage_info_alter(&$info) {
  $info['field_sql_storage']['module'] = 'field_sql_norevisions';
}

/**
 * Implements hook_help().
 */
function field_sql_norevisions_help($path, $arg) {
  switch ($path) {
    case 'admin/help#field_sql_norevisions':
      $output = '';
      $output .= '<h3>' . t('About') . '</h3>';
      $output .= '<p>' . t('The Field SQL storage module stores field data in the database. It is based the default field storage module. It does not save field revisons.') . '</p>';
      return $output;
  }
}

/**
 * Implements hook_menu()
 */
function field_sql_norevisions_menu() {
  $items = array();

  $items['admin/config/system/field_sql_norevisions'] = array(
    'title' => 'Field sql norevisions',
    'description' => 'Adjust Field SQL Norevisions settings.',
    'page callback' => 'system_admin_menu_block_page',
    'access arguments' => array('administer site configuration'),
    'position' => 'left',
    'file' => 'system.admin.inc',
    'file path' => 'modules/system/',
  );

  $items['admin/config/system/field_sql_norevisions/field_sql_norevisions_entity_settings'] = array(
    'title' => 'Field SQL Norevisions Entity Settings',
    'description' => 'Enable or disable field norevisions for entities/bundles',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('field_sql_norevisions_entity_settings_form'),
    'access arguments' => array('administer site configuration'),
    'type' => MENU_NORMAL_ITEM,
    'weight' => 0,
  );

  $items['admin/config/system/field_sql_norevisions/field_sql_norevisions_batch_delete'] = array(
    'title' => 'Field SQL Norevisions Batch Delete',
    'description' => 'Delete revisions for entities',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('field_sql_norevisions_batch_delete_form'),
    'access arguments' => array('administer site configuration'),
    'type' => MENU_NORMAL_ITEM,
    'weight' => 1,
  );

  return $items;
}

/**
 * Form callback for batch deletion of revisions
 */
function field_sql_norevisions_batch_delete_form($form, &$form_state) {
  $form = array();

  $entity_info = entity_get_info();

  $defaults = variable_get('field_sql_norevisions_enabled_entities', array());

  foreach ($entity_info as $entity_name => $entity) {
    //First we check if it's fieldable, we don't care about it if it's not
    if(!$entity['fieldable']) continue;

    $form['field_sql_norevisions_' . $entity_name .'_wrapper'] = array(
      '#type' => 'fieldset',
      '#title' => t('Delete revisions for <strong>'.$entity['label'].'</strong> entity bundles'),
      '#collapsible' => TRUE,
      '#collapsed' => FALSE,
    );

    foreach ($entity['bundles'] as $bundle_name => $bundle) {
      $form['field_sql_norevisions_' . $entity_name .'_wrapper']['field_sql_norevisions_'.$entity_name.'_'.$bundle_name.'_delete'] = array(
        '#type' => 'checkbox',
        '#title' => t('Delete '. $bundle['label'] . ' revisions.'),
      );
    }
  }

  $form['submit'] = array(
    '#type' => 'submit',
    '#value' => t('Delete'),
  );

  return $form;
}

function field_sql_norevisions_batch_delete_form_submit($form, &$form_state) {
  $batch = array();
  $batch['finished'] = 'field_sql_norevisions_batch_revision_delete_finish';

  $entity_info = entity_get_info();

  foreach ($entity_info as $entity_name => $entity) {
    foreach ($entity['bundles'] as $bundle => $bundle_settings) {
      if(!empty($form_state['values']['field_sql_norevisions_'.$entity_name.'_'.$bundle.'_delete'])) {
        $fields = field_info_instances($entity_name, $bundle);
        foreach ($fields as $field) {
          $field_info = field_info_field($field['field_name']);
          if($revisions_table = _field_sql_storage_revision_tablename($field_info)) {
            $batch['operations'][] = array('field_sql_norevisions_batch_delete_revisions', array($revisions_table, $bundle));
          }
        }
      }
    }
  }

  if(!empty($batch['operations'])) {
    batch_set($batch);
  } else {
    drupal_set_message("No entities selected, no revisions deleted.");
  }

}


/**
 * Batch revision delete callback
 */
function field_sql_norevisions_batch_delete_revisions($field, $bundle, &$context) {
   db_delete($field)
            ->condition('bundle', $bundle)
            ->execute();
}


/**
 * Form callback admin/config/system/field_sql_norevisions
 *
 * Settings form that will get all entities and bundles (if supported) and allow you to enable of disable revisions
 */
function field_sql_norevisions_entity_settings_form($form, &$form_state) {
  $form = array();

  $form['markup'] = array(
    '#markup' => t('<strong>Please NOTE that if any of your entity bundles are sharing fields, it is required that both entities/bundles have no revisions.</strong>'),
  );

  $entity_info = entity_get_info();

  $defaults = variable_get('field_sql_norevisions_enabled_entities', array());

  foreach ($entity_info as $entity_name => $entity) {
    //First we check if it's fieldable, we don't care about it if it's not
    if(!$entity['fieldable']) continue;

    $form['field_sql_norevisions_' . $entity_name .'_wrapper'] = array(
      '#type' => 'fieldset',
      '#title' => t('Disable SQL revisions for <strong>'.$entity['label'].'</strong> entity bundles'),
      '#collapsible' => TRUE,
      '#collapsed' => FALSE,
      '#tree' => TRUE,
    );

    foreach ($entity['bundles'] as $bundle_name => $bundle) {
      $form['field_sql_norevisions_' . $entity_name .'_wrapper']['field_sql_norevisions_'.$entity_name.'_'.$bundle_name.'_enabled'] = array(
        '#type' => 'checkbox',
        '#title' => t($bundle['label']),
        '#default_value' => isset($defaults['field_sql_norevisions_'.$entity_name.'_'.$bundle_name.'_enabled']) ? $defaults['field_sql_norevisions_'.$entity_name.'_'.$bundle_name.'_enabled'] : '',
      );
    }

  }

  $form['submit'] = array(
    '#type' => 'submit',
    '#value' => t('Save'),
  );

  return $form;
}

function field_sql_norevisions_entity_settings_form_submit($form, &$form_state) {
  $entity_info = entity_get_info();
  $save = array();

  foreach ($entity_info as $entity_name => $entity) {
    if(isset($form_state['values']['field_sql_norevisions_' . $entity_name .'_wrapper'])) {
      $save = array_merge($save, $form_state['values']['field_sql_norevisions_' . $entity_name .'_wrapper']);
    }
  }

  variable_set('field_sql_norevisions_enabled_entities', $save);
}

/**
 * Implements hook_field_storage_create_field().
 */
function field_sql_norevisions_field_storage_create_field($field) {
  return field_sql_storage_field_storage_create_field($field);
}

/**
 * Implements hook_field_update_forbid().
 *
 * Forbid any field update that changes column definitions if there is
 * any data.
 */
function field_sql_norevisions_field_update_forbid($field, $prior_field, $has_data) {
  return field_sql_storage_field_update_forbid($field, $prior_field, $has_data);
}

/**
 * Implements hook_field_storage_update_field().
 */
function field_sql_norevisions_field_storage_update_field($field, $prior_field, $has_data) {
  return field_sql_storage_field_storage_update_field($field, $prior_field, $has_data);
}

/**
 * Implements hook_field_storage_delete_field().
 */
function field_sql_norevisions_field_storage_delete_field($field) {
  return field_sql_storage_field_storage_delete_field($field);
}

/**
 * Implements hook_field_storage_load().
 */
function field_sql_norevisions_field_storage_load($entity_type, $entities, $age, $fields, $options) {
  return field_sql_storage_field_storage_load($entity_type, $entities, $age, $fields, $options);
}

/**
 * Implements hook_field_storage_write().
 */
function field_sql_norevisions_field_storage_write($entity_type, $entity, $op, $fields) {
  $enabled_entity_bundles = variable_get('field_sql_norevisions_enabled_entities', array());
  $entity_info = entity_get_info($entity_type);

  if(empty($enabled_entity_bundles['field_sql_norevisions_' . $entity_type .'_' . $entity->{$entity_info['entity keys']['bundle']} . '_enabled'])) {
    //We fall back to normal SQL storage function
    field_sql_storage_field_storage_write($entity_type, $entity, $op, $fields);
    return;
  }

  list($id, $vid, $bundle) = entity_extract_ids($entity_type, $entity);
  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);

    $all_languages = field_available_languages($entity_type, $field);
    $field_languages = array_intersect($all_languages, array_keys((array) $entity->$field_name));

    // Delete and insert, rather than update, in case a value was added.
    if ($op == FIELD_STORAGE_UPDATE) {
      // Delete languages present in the incoming $entity->$field_name.
      // Delete all languages if $entity->$field_name is empty.
      $languages = !empty($entity->$field_name) ? $field_languages : $all_languages;
      if ($languages) {
        db_delete($table_name)
          ->condition('entity_type', $entity_type)
          ->condition('entity_id', $id)
          ->condition('language', $languages, 'IN')
          ->execute();
       }
    }

    // Prepare the multi-insert query.
    $do_insert = FALSE;
    $columns = array('entity_type', 'entity_id', 'revision_id', 'bundle', 'delta', 'language');
    foreach ($field['columns'] as $column => $attributes) {
      $columns[] = _field_sql_storage_columnname($field_name, $column);
    }
    $query = db_insert($table_name)->fields($columns);

    foreach ($field_languages 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,
          'language' => $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 ($field['cardinality'] != FIELD_CARDINALITY_UNLIMITED && ++$delta_count == $field['cardinality']) {
          break;
        }
      }
    }

    // Execute the query if we have values to insert.
    if ($do_insert) {
      $query->execute();
    }
  }
}

/**
 * Implements hook_field_storage_delete().
 *
 * This function deletes data for all fields for an entity from the database.
 */
function field_sql_norevisions_field_storage_delete($entity_type, $entity, $fields) {
  list($id, $vid, $bundle) = entity_extract_ids($entity_type, $entity);

  foreach (field_info_instances($entity_type, $bundle) as $instance) {
    if (isset($fields[$instance['field_id']])) {
      $field = field_info_field_by_id($instance['field_id']);
      field_sql_norevisions_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_norevisions_field_storage_purge($entity_type, $entity, $field, $instance) {
  list($id, $vid, $bundle) = entity_extract_ids($entity_type, $entity);

  $table_name = _field_sql_storage_tablename($field);
  db_delete($table_name)
    ->condition('entity_type', $entity_type)
    ->condition('entity_id', $id)
    ->execute();
}

/**
 * Implements hook_field_storage_query().
 */
function field_sql_norevisions_field_storage_query(EntityFieldQuery $query) {
  return field_sql_storage_field_storage_query($query);
}

/**
 * Implements hook_field_storage_delete_revision().
 *
 * This function actually deletes the data from the database.
 */
function field_sql_norevisions_field_storage_delete_revision($entity_type, $entity, $fields) {
  // No revisions so do nothing
}

/**
 * Implements hook_field_storage_delete_instance().
 *
 * This function simply marks for deletion all data associated with the field.
 */
function field_sql_norevisions_field_storage_delete_instance($instance) {
  $field = field_info_field($instance['field_name']);
  $table_name = _field_sql_storage_tablename($field);
  db_update($table_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_norevisions_field_attach_rename_bundle($entity_type, $bundle_old, $bundle_new) {
  field_sql_storage_field_attach_rename_bundle($entity_type, $bundle_old, $bundle_new);
}

/**
 * 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_norevisions_field_storage_purge_field($field) {
  return field_sql_storage_field_storage_purge_field($field);
}

/**
 * Implements hook_field_storage_details().
 */
function field_sql_norevisions_field_storage_details($field) {
  return field_sql_storage_field_storage_details($field);
}