Submitting a form rebuilds (expensive) page upon submit

Question

I have a simple menu callback that draws a page with a form on it. The page callback does a very expensive operation (requests a bunch of data from an external API).

function test_menu() {
  $items = array();
  $items['test'] = array(
    'title' => 'Test',
    'page callback' => 'test_page_handler',
    'access callback' => TRUE,
  );
  return $items;
}

function test_page_handler() {
  $data = very_expensive_data_operation();
  $output = drupal_get_form('test_simple_form', $data);
  return $output;
}

function test_simple_form(&$form_state, $data) {
  $form['create'] = array(
    '#type' => 'submit',
    '#value' => t('Submit'),
  );
  return $form;
}

function test_simple_form_submit(&$form, &$form_state) {
  // do something
}

The problem I am seeing is that when the form is submitted, Drupal will re-execute the page callback in the background, resulting in the very_expensive_data_operation() running again.

There are probably lots of great reasons for Drupal to do this, but how can I change my app so that the very_expensive_data_operation() doesn't have to run again when submitting the form (after all, that's why I'm passing $data to the form, rather than having the form run it directly.)

One workaround I can think of is to toss $data into a cache table, but it feels like I'm missing something that available to me in the Drupal+FAPI api.

Answer 1

You can also try using drupal_static

Provides central static variable storage.

All functions requiring a static variable to persist or cache data within a single page request are encouraged to use this function unless it is absolutely certain that the static variable will not need to be reset during the page request. By centralizing static variable storage through this function, other functions can rely on a consistent API for resetting any other function's static variables.

function test_menu() {
  $items = array();
  $items['test'] = array(
    'title' => 'Test',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('test_simple_form'),
    'access callback' => TRUE,
  );
  return $items;
}

function expensive_data() {
  $data = &drupal_static(__FUNCTION__);
  if (!isset($data)) {
    $data = very_expensive_data_operation();
  }
  return $data;
}

function test_simple_form(&$form_state) {
  $data = expensive_data();
  $form['create'] = array(
    '#type' => 'submit',
    '#value' => t('Submit'),
  );
  return $form;
}

function test_simple_form_submit(&$form, &$form_state) {
  // do something
}

You might notice that the static variable technique only stores data for the duration of a single page load. For even better performance try this

function expensive_data() {
  $data = &drupal_static(__FUNCTION__);
  if (!isset($data)) {
    if ($cache = cache_get('my_module_data')) {
      $my_data = $cache->data;
    }
    else {
      $data = very_expensive_data_operation();
      cache_set('my_module_data', $my_data, 'cache');
    }

  }
  return $data;
}

If you want to refresh your cache from time to time you can try

cache_set('my_module_data', $my_data, 'cache', time() + 360); 

OR you can manually rebuild your cache using

cache_clear_all('my_module', 'cache', TRUE); 

Answer 2

I think the best place to run your expensive function is in the form itself, even though you've mentioned you're currently avoiding that.

As it stands, your page callback has no link to the form that's currently being submitted; there are ways you could get it from the cache_form table, but it's a bit messy.

Instead, I'd advise saving the data to a variable in the form, and checking to see if that variable has been submitted in the $form_state array. You'll also need to flag the form to rebuilt in the submit handler:

function test_simple_form(&$form_state) {
  // If the form has already been biult, and we already have the data, don't load it again.
  if (isset($form_state['values']['expensive_data'])) {
    $data = $form_state['values']['expensive_data'];
  }
  else {
    // Otherwise get the data from source.
    $data = my_expensive_function();
  }

  // Store the data
  $form['expensive_data'] = array(
    '#type' => 'value',
    '#value' => $data
  );

  // ...

  return $form;
}

function test_simple_form_submit(&$form, &$form_state) {
  $form_state['rebuild'] = TRUE;
}   

In your submit handler you'll have access to $form_state['values']['expensive_data'], which will contain the results of the function call.

This method has the added benefit of caching the data if the form validation fails, not just when it's submitted successfully.

Judging from the function signature you're using for the form I'm guessing you have a Drupal 6 site, although the above method will work equally well for a Drupal 7 site (the function signature would just need to change).