Some modules use an 'inline' function to load an array for elements that don't change often -- for example, the Addresses module uses the following to load states/provinces once a country has been selected. It uses the same approach for loading countries.
An include file has the following:
function addresses_province_list_us() {
return array(
'AL' => t('Alabama'),
'AK' => t('Alaska'),
'AZ' => t('Arizona'), ...... etc to the end of the list
Another module uses a database extract, querying the table for the info using a join and filtering it as they go to get it in the array using a hook load as in the case of the Recipe module.
For example:
/**
* Implementation of hook_load().
*/
function recipe_load($node) {
$recipe = db_fetch_object(db_query('SELECT * FROM {recipe} WHERE nid = %d', $node->nid));
$recipe->ingredients = recipe_load_ingredients($node);
return $recipe;
}
From a performance standpoint, I can see where there would be less load on the server to subset the data using a database extract; however, you would use less memory to store a 'smaller' array.
I can also see that 'inline' function call would not hit the server, but could use more memory resources since it wouldn't be subsetted.
I can also see that IF you wanted to share data to another module, the hook method would be more appealing.
But since the data is rather static (e.g., all countries of the world, all universities in the world, etc), which method is a 'better practice' to ensure good performance and response.
My background tells me to convert inline functions such as these to database calls, but my brain tells me spend the time on module development and make the database conversion later if needed.
Could someone with more Drupal performance experience please comment on where the line in the sand is located -- when and why do you choose a database load rather than a inline function call?
