Descriptions node_types too long causing queries

Could be, but because every page load the hook_node_info is called it also tries to translate the description with t('').

And because the ones of that node are bigger then 75 chars it ain't cached so causes 4 query's every page load.

Looked into it a little bit more. In node_invoke, node_menu, node_access and more the function 'node_get_types()' is used. This builds the node type list when it has not been made yet. It calls the function '_node_types_build()'. So almost every page loads the node types (you only need to do a node_load or a new menu rebuild or whatever).

/**
 * Builds and returns the list of available node types.
 *
 * The list of types is built by querying hook_node_info() in all modules, and
 * by comparing this information with the node types in the {node_type} table.
 *
 */
function _node_types_build() {
  $_node_types = array();
  $_node_names = array();

  $info_array = module_invoke_all('node_info');
  foreach ($info_array as $type => $info) {
    $info['type'] = $type;
    $_node_types[$type] = (object) _node_type_set_defaults($info);
    $_node_names[$type] = $info['name'];
  }

  $type_result = db_query(db_rewrite_sql('SELECT nt.type, nt.* FROM {node_type} nt ORDER BY nt.type ASC', 'nt', 'type'));
  while ($type_object = db_fetch_object($type_result)) {
    // Check for node types from disabled modules and mark their types for removal.
    // Types defined by the node module in the database (rather than by a separate
    // module using hook_node_info) have a module value of 'node'.
    if ($type_object->module != 'node' && empty($info_array[$type_object->type])) {
      $type_object->disabled = TRUE;
    }
    if (!isset($_node_types[$type_object->type]) || $type_object->modified) {
      $_node_types[$type_object->type] = $type_object;
      $_node_names[$type_object->type] = $type_object->name;

      if ($type_object->type != $type_object->orig_type) {
        unset($_node_types[$type_object->orig_type]);
        unset($_node_names[$type_object->orig_type]);
      }
    }
  }

  asort($_node_names);

  return array($_node_types, $_node_names);
}

As you can see it invokes a hook_node_info there for a lot of modules which specify node_info are loaded:

function forum_node_info() {
  return array(
    'forum' => array(
      'name' => t('Forum topic'),
      'module' => 'forum',
      'description' => t('A <em>forum topic</em> is the initial post to a new discussion thread within a forum.'),
      'title_label' => t('Subject'),
    )
  );
}

The description is too long (75 chars) and there for is not cached in the cache 'locale:LANGCODE' and queried almost each page load though it ain't displayed.

You mean as a seperate cache entry, or in variables? If you want I can do some tests tonight

The node types are already static in node_get_types. This patch makes node_get_types uses cache when available. Since Drupal has alot of rebuild node types functions I used that ones to reset it. I runned the node module tests and they still worked fine.

This needs more work.. currently just one cache is saved though it should be saved using the languagecode.

New patch with language code.

New patch is up which just uses $language->language;

Clearing this each page load would make this patch useless. The idea is that we don't just save the node types in a static like node_get_types() does but save it in cache. How much times are your node types changed? And if so build is called with the $reset parameter.

The reason I want to cache this is because it is doing:
1. module_invoke_all
2. A slow query
3. For each node type with a description longer then 75 char a query to get the translation

So that should be slower then just a unserialize from cache!

Okey, this patch fixes the code style changes.
Benchmarks:
- with apc opcode cache
- enabled modules (Blog, book, comment, DBlog, forum, Help, Locale, Menu, Poll, Simpletest, Taxonomy, Update status)
- dutch d6 PO files for all enabled modules
- no page cache

Command run 'ab -n 500 -c 10 http://drupalhead/'

Without patch:

#1
Requests per second:    52.64 [#/sec] (mean)
Time per request:       189.973 [ms] (mean)

#2
Requests per second:    52.56 [#/sec] (mean)
Time per request:       190.263 [ms] (mean)

#3
Requests per second:    52.59 [#/sec] (mean)
Time per request:       190.133 [ms] (mean)

With patch:

#1
Requests per second:    54.23 [#/sec] (mean)
Time per request:       184.416 [ms] (mean)

#2
Requests per second:    54.51 [#/sec] (mean)
Time per request:       183.441 [ms] (mean)

#3
Requests per second:    54.72 [#/sec] (mean)
Time per request:       182.748 [ms] (mean)

So looks like a small speedgain.. especially when you are using a different memory cache system.

Forgot the patch...

Hmmz back to code needs work then. I'll check it out!