You are here

Home » API reference » Taxonomy Edge 8

taxonomy_edge.module in Taxonomy Edge 8

Same filename and directory in other branches
  1. 6 taxonomy_edge.module
  2. 7.2 taxonomy_edge.module
  3. 7 taxonomy_edge.module

Selecting all children of a given taxonomy term can be a pain. This module makes it easier to do this, by maintaining a complete list of edges for each term using the adjecency matrix graph theory.

Example of getting all children from tid:14

SELECT e.tid FROM taxonomy_term_edge e WHERE e.parent = 14;

@todo Fix concurrency issue for queue rebuild and full tree rebuild (lock_may_be_available() inside transaction) @todo Fix drag'n'drop on interface for multiple parents

See also

README.txt

File

taxonomy_edge.module
View source 
<?php

use Drupal\Core\Database\Database;

/**
 * @file
 *
 * Selecting all children of a given taxonomy term can be a pain.
 * This module makes it easier to do this, by maintaining a complete list of
 * edges for each term using the adjecency matrix graph theory.
 *
 * Example of getting all children from tid:14
 *
 * SELECT e.tid
 * FROM taxonomy_term_edge e
 * WHERE e.parent = 14;
 *
 * @todo Fix concurrency issue for queue rebuild and full tree rebuild (lock_may_be_available() inside transaction)
 * @todo Fix drag'n'drop on interface for multiple parents
 *
 * @see README.txt
 */

/**
 * Fail safe for avoiding infite loops when rebuilding edges.
 */
define('TAXONOMY_EDGE_MAX_DEPTH', 100);

/**
 * Default value for realtime building of tree.
 */
define('TAXONOMY_EDGE_BUILD_REALTIME', TRUE);

/**
 * Default value for static caching.
 */
define('TAXONOMY_EDGE_STATIC_CACHING', FALSE);

/**
 * Default value for optimized tree.
 */
define('TAXONOMY_EDGE_OPTIMIZED_GET_TREE', TRUE);

// ---------- HOOKS ----------

/**
 * Implements hook_core_override().
 */
function taxonomy_edge_core_override_info() {
  return array(
    'taxonomy_get_tree' => array(
      'callback' => 'taxonomy_edge_get_tree',
    ),
  );
}

/**
 * Implements hook_help().
 */
function taxonomy_edge_help($section) {
  switch ($section) {
    case 'admin/help#taxonomy_edge':

      // Return a line-break version of the module README.txt
      return check_markup(file_get_contents(dirname(__FILE__) . "/README.txt"));
  }
}

/**
 * Implements hook_perm().
 */
function taxonomy_edge_permission() {
  return array(
    'administer taxonomy edge' => array(
      'title' => t('Administer Taxonomy Edge'),
      'description' => t('Perform administration tasks for Taxonomy Edge.'),
    ),
  );
}

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

  // Bring /level and /all back into taxonomy pages and feeds
  $items['taxonomy/term/%taxonomy_term'] = array(
    'title' => 'Taxonomy term',
    'title callback' => 'taxonomy_term_title',
    'title arguments' => array(
      2,
    ),
    'page callback' => 'taxonomy_edge_term_page',
    'page arguments' => array(
      2,
      3,
    ),
    'access arguments' => array(
      'access content',
    ),
    'file' => 'taxonomy_edge.pages.inc',
  );
  $items['taxonomy/term/%taxonomy_term/%/feed'] = array(
    'title' => 'Taxonomy term',
    'title callback' => 'taxonomy_term_title',
    'title arguments' => array(
      2,
    ),
    'page callback' => 'taxonomy_edge_term_feed',
    'page arguments' => array(
      2,
      3,
    ),
    'access arguments' => array(
      'access content',
    ),
    'file' => 'taxonomy_edge.pages.inc',
  );

  // settings page
  $items['admin/structure/taxonomy/edge'] = array(
    'title' => 'Edge',
    'description' => 'Administer taxonomy edges',
    'page callback' => 'drupal_get_form',
    'page arguments' => array(
      'taxonomy_edge_settings_form',
    ),
    'access arguments' => array(
      'administer taxonomy edge',
    ),
    'type' => MENU_LOCAL_TASK,
    'file' => 'taxonomy_edge.admin.inc',
  );
  $items['admin/structure/taxonomy/rebuild/%/%'] = array(
    'title' => 'Rebuild edges',
    'description' => 'Rebuild taxonomy edges',
    'page callback' => 'drupal_get_form',
    'page arguments' => array(
      'taxonomy_edge_rebuild_page_confirm',
      4,
      5,
    ),
    'access arguments' => array(
      'administer taxonomy edge',
    ),
    'type' => MENU_CALLBACK,
    'file' => 'taxonomy_edge.admin.inc',
  );
  return $items;
}

/**
 * Implements hook_modules_enabled().
 */
function taxonomy_edge_modules_enabled($modules) {
  if (in_array('taxonomy_edge', $modules)) {

    // Since we're just enabling the module, it should be safe to truncate.
    // Clearing out the tables will make the rebuild faster, and we're rebuilding
    // everything anyways.
    db_truncate('taxonomy_term_edge')
      ->execute();
    db_truncate('taxonomy_term_edge_order')
      ->execute();

    // Rebuild everything.
    module_load_include('rebuild.inc', 'taxonomy_edge');
    $vids = array_keys(taxonomy_vocabulary_load_multiple());
    if (strpos(request_uri(), '/batch') !== 0) {
      taxonomy_edge_rebuild_all_batch($vids);
    }
  }
}

/**
 * Implements hook_cron().
 *
 * Rebuild sorted tree if invalid
 */
function taxonomy_edge_cron() {
  module_load_include('rebuild.inc', 'taxonomy_edge');
  foreach (taxonomy_vocabulary_load_multiple() as $vocabulary) {
    if (!taxonomy_edge_is_order_valid($vocabulary->vid)) {
      $context = array();
      taxonomy_edge_rebuild_order($vocabulary->vid, $context);
      taxonomy_edge_rebuild_finished($context['success'], $context['results'], array());
    }
  }
}

/**
 * Implements hook_cronapi().
 * Regularly rebuild the edge list
 */
function taxonomy_edge_cronapi($op, $job = NULL) {
  switch ($op) {
    case 'list':
      return array(
        'taxonomy_edge_cron_rebuild' => 'Rebuild taxonomy edges',
        'taxonomy_edge_cron' => 'Resort invalid trees',
      );
    case 'rule':
      switch ($job) {
        case 'taxonomy_edge_cron_rebuild':
          return '0 2 * * *';
        case 'taxonomy_edge_cron':
          return '* * * * *';
      }
    case 'settings':
      switch ($job) {
        case 'taxonomy_edge_cron_rebuild':
          return array(
            'enabled' => FALSE,
          );
        case 'taxonomy_edge_cron':
          return array(
            'enabled' => TRUE,
          );
      }
  }
}

/**
 * Implements hook_cron_queue_info().
 */
function taxonomy_edge_cron_queue_info() {
  $queues['taxonomy_edge'] = array(
    'worker callback' => 'taxonomy_edge_process_queue_item',
    'time' => 60,
  );
  return $queues;
}

/**
 * Implements hook_taxonomy_vocabulary_insert().
 */
function taxonomy_edge_taxonomy_vocabulary_insert($vocabulary) {
  taxonomy_edge_taxonomy_vocabulary_delete($vocabulary);
  db_insert('taxonomy_term_edge')
    ->fields(array(
    'vid' => $vocabulary->vid,
  ))
    ->execute();
}

/**
 * Implements hook_taxonomy_vocabulary_delete().
 */
function taxonomy_edge_taxonomy_vocabulary_delete($vocabulary) {
  db_delete('taxonomy_term_edge')
    ->condition('vid', $vocabulary->vid)
    ->execute();
}

/**
 * Implements hook_taxonomy_term_insert().
 */
function taxonomy_edge_taxonomy_term_insert($term) {
  if (taxonomy_edge_is_build_realtime($term->vid)) {
    return _taxonomy_edge_taxonomy_term_insert($term);
  }
  else {
    _taxonomy_edge_taxonomy_term_queue($term, 'insert');
  }
}

/**
 * Implements hook_taxonomy_term_update().
 */
function taxonomy_edge_taxonomy_term_update($term) {
  if (taxonomy_edge_is_build_realtime($term->vid)) {
    return _taxonomy_edge_taxonomy_term_update($term);
  }
  else {
    _taxonomy_edge_taxonomy_term_queue($term, 'update');
  }
}

/**
 * Implements hook_taxonomy_term_delete().
 */
function taxonomy_edge_taxonomy_term_delete($term) {
  if (taxonomy_edge_is_build_realtime($term->vid)) {
    return _taxonomy_edge_taxonomy_term_delete($term);
  }
  else {
    _taxonomy_edge_taxonomy_term_queue($term, 'delete');
  }
}

/**
 * Hook into the drag'n'drop interface of terms in order to update tree when
 * terms are reordered.
 *
 * @param array $form
 * @param type $form_state
 */
function taxonomy_edge_form_taxonomy_overview_terms_alter(&$form, &$form_state) {
  $form['#submit'][] = 'taxonomy_edge_reorder_submit';
}

/**
 * Hook into the overview of vocabularies to provide rebuild actions.
 */
function taxonomy_edge_form_taxonomy_overview_vocabularies_alter(&$form, &$form_state) {
  if (user_access('administer taxonomy edge')) {
    foreach (taxonomy_vocabulary_load_multiple() as $vocabulary) {
      $form[$vocabulary->vid]['rebuild_edges'] = array(
        '#type' => 'link',
        '#title' => t('rebuild edges'),
        '#href' => "admin/structure/taxonomy/rebuild/edges/{$vocabulary->machine_name}",
      );
      $form[$vocabulary->vid]['rebuild_order'] = array(
        '#type' => 'link',
        '#title' => t('rebuild order'),
        '#href' => "admin/structure/taxonomy/rebuild/order/{$vocabulary->machine_name}",
      );
      $form[$vocabulary->vid]['rebuild_all'] = array(
        '#type' => 'link',
        '#title' => t('rebuild everything'),
        '#href' => "admin/structure/taxonomy/rebuild/all/{$vocabulary->machine_name}",
      );
    }
    $form['#theme'] = 'taxonomy_edge_overview_vocabularies';
  }
}

/**
 * Implements hook_theme().
 */
function taxonomy_edge_theme() {
  return array(
    'taxonomy_edge_overview_vocabularies' => array(
      'render element' => 'form',
      'file' => 'taxonomy_edge.theme.inc',
    ),
  );
}

// ---------- HANDLERS ----------

/**
 * Copy/paste from core taxonomy module.
 * This is the penalty for not having a proper abstraction layer!
 * And for not invoking update hook on terms when changing their parents!
 *
 * @param type $form
 * @param type $form_state
 * @return type
 */
function taxonomy_edge_reorder_submit($form, &$form_state) {
  $vocabulary = $form['#vocabulary'];
  $hierarchy = 0;

  // Update the current hierarchy type as we go.
  $changed_terms = array();
  $tree = taxonomy_get_tree($vocabulary->vid);
  if (empty($tree)) {
    return;
  }

  // Build a list of all terms that need to be updated on previous pages.
  $weight = 0;
  $term = (array) $tree[0];
  while ($term['tid'] != $form['#first_tid']) {
    if ($term['parents'][0] == 0 && $term['weight'] != $weight) {
      $term['parent'] = $term['parents'][0];
      $term['weight'] = $weight;
      $changed_terms[$term['tid']] = $term;
    }
    $weight++;
    $hierarchy = $term['parents'][0] != 0 ? 1 : $hierarchy;
    $term = (array) $tree[$weight];
  }

  // Renumber the current page weights and assign any new parents.
  $level_weights = array();
  foreach ($form_state['values'] as $tid => $values) {
    if (isset($form[$tid]['#term'])) {
      $term = $form[$tid]['#term'];

      // Give terms at the root level a weight in sequence with terms on previous pages.
      if ($values['parent'] == 0 && $term['weight'] != $weight) {
        $term['weight'] = $weight;
        $changed_terms[$term['tid']] = $term;
      }
      elseif ($values['parent'] > 0) {
        $level_weights[$values['parent']] = isset($level_weights[$values['parent']]) ? $level_weights[$values['parent']] + 1 : 0;
        if ($level_weights[$values['parent']] != $term['weight']) {
          $term['weight'] = $level_weights[$values['parent']];
          $changed_terms[$term['tid']] = $term;
        }
      }

      // Update any changed parents.
      if ($values['parent'] != $term['parent']) {
        $term['parent'] = $values['parent'];
        $changed_terms[$term['tid']] = $term;
      }
      $hierarchy = $term['parent'] != 0 ? 1 : $hierarchy;
      $weight++;
    }
  }

  // Build a list of all terms that need to be updated on following pages.
  for ($weight; $weight < count($tree); $weight++) {
    $term = (array) $tree[$weight];
    if ($term['parents'][0] == 0 && $term['weight'] != $weight) {
      $term['parent'] = $term['parents'][0];
      $term['weight'] = $weight;
      $changed_terms[$term['tid']] = $term;
    }
    $hierarchy = $term['parents'][0] != 0 ? 1 : $hierarchy;
  }

  // Save all updated terms.
  foreach ($changed_terms as $changed) {
    $term = (object) $changed;
    $term->parent = array(
      $term->parent,
    );
    _taxonomy_edge_taxonomy_term_update($term);
  }
}

/**
 * Cron queue worker
 * Process edge for a queued term.
 * @param integer $vid
 *   Vocabulary ID
 */
function taxonomy_edge_process_queue_item($vid) {
  if (lock()
    ->acquire('taxonomy_edge_rebuild_edges_' . $vid)) {
    $queue = DrupalQueue::get('taxonomy_edge_items_' . $vid, TRUE);
    $max = 1000;
    while ($max-- > 0 && ($item = $queue
      ->claimItem())) {
      $term = $item->data;
      switch ($term->operation) {
        case 'insert':
          _taxonomy_edge_taxonomy_term_insert($term);
          break;
        case 'update':
          _taxonomy_edge_taxonomy_term_update($term);
          break;
        case 'delete':
          _taxonomy_edge_taxonomy_term_delete($term);
          break;
      }
      $queue
        ->deleteItem($item);
    }
    lock()
      ->release('taxonomy_edge_rebuild_edges_' . $vid);
  }
}

/**
 * Rebuild edges
 */
function taxonomy_edge_cron_rebuild() {
  module_load_include('rebuild.inc', 'taxonomy_edge');
  foreach (taxonomy_vocabulary_load_multiple() as $vocabulary) {
    $context = array();
    taxonomy_edge_rebuild_edges($vocabulary->vid, $context);
    taxonomy_edge_rebuild_finished($context['success'], $context['results'], array());
  }
}

// ---------- PRIVATE HELPER FUNCTIONS ----------

/**
 * Delete subtree
 *
 * @param $vid
 *   Vocabulary ID
 * @param $tids
 *   Array of term ids to delete subtree from
 * @param $type
 *   Type of delete
 *     0: Delete entire subtree
 *     1: Delete ancestors (detach children from parents in $tids)
 */
function _taxonomy_edge_delete_subtree($vid, $tids, $type = 0) {

  // @fixme MySQL can not use EXISTS or IN without temp tables when deleting.
  //        SQLite cannot perform join delete.
  //        MySQL and Postgres differ in joined delete syntax.
  //        Use optimized joined delete for MySQL and subquery for others.
  //        With MySQL 5.6 we might be able to switch to a subquery method only.
  $db_type = Database::getConnection()
    ->databaseType();
  $type = $type == 0 ? '' : 'AND e2.distance > e.distance';
  switch ($db_type) {
    case 'mysql':
    case 'mysqli':
      db_query("DELETE e2.*\n        FROM {taxonomy_term_edge} e\n        INNER JOIN {taxonomy_term_edge} e2 ON e2.tid = e.tid\n        WHERE e.parent IN (:tids)\n        {$type}\n        AND e.vid = :vid AND e2.vid = :vid\n      ", array(
        ':tids' => $tids,
        ':vid' => $vid,
      ));
      break;
    default:
      db_query("DELETE FROM\n      {taxonomy_term_edge} WHERE eid IN (\n        SELECT e2.eid\n        FROM {taxonomy_term_edge} e\n        INNER JOIN {taxonomy_term_edge} e2 ON e2.tid = e.tid AND e2.vid = e.vid\n        WHERE e.parent IN (:tids)\n        {$type}\n        AND e.vid = :vid\n      )", array(
        ':tids' => $tids,
        ':vid' => $vid,
      ));
      break;
  }
}

/**
 * Detach children from parents in $tids (delete ancestors)
 */
function _taxonomy_edge_detach_subtree($vid, $tids) {
  return _taxonomy_edge_delete_subtree($vid, $tids, 1);
}

/**
 * Attach path and children to new parents
 *
 * @param $vid
 *   Vocabulary ID
 * @param $tid
 *   Term ID
 * @param $parents
 *   Term ID of new parents
 */
function _taxonomy_edge_attach_subtree($vid, $tid, $parents) {

  // Build new parents
  db_query("INSERT INTO {taxonomy_term_edge} (vid, tid, parent, distance)\n  SELECT e.vid, e2.tid, e.parent, e.distance + e2.distance + 1 AS distance\n  FROM {taxonomy_term_edge} e\n  INNER JOIN {taxonomy_term_edge} e2 ON e.tid IN (:parents) AND e2.parent = :tid AND e2.vid = e.vid\n  WHERE e.vid = :vid\n  ", array(
    ':tid' => $tid,
    ':parents' => $parents,
    ':vid' => $vid,
  ));
  taxonomy_edge_invalidate_order($vid);
}

/**
 * Detach path and children from current parent and attach to new parents
 *
 * @param $vid
 *   Vocabulary ID
 * @param $tid
 *   Term ID
 * @param $parents
 *   Term ID of new parents
 */
function _taxonomy_edge_move_subtree($vid, $tid, $parents) {
  _taxonomy_edge_detach_subtree($vid, array(
    $tid,
  ));
  _taxonomy_edge_attach_subtree($vid, $tid, $parents);
}

/**
 * Insert a term into the edge tree.
 *
 * @param type $term
 */
function _taxonomy_edge_taxonomy_term_insert($term) {
  $vocabulary = taxonomy_vocabulary_load($term->vid);

  // Derive proper parents.
  $parents = _taxonomy_edge_unify_parents($term->parent);
  if ($term->tid > 0) {
    $tx = db_transaction();
    db_insert('taxonomy_term_edge')
      ->fields(array(
      'vid' => $term->vid,
      'tid' => $term->tid,
      'parent' => $term->tid,
    ))
      ->execute();
    db_query("INSERT INTO {taxonomy_term_edge} (vid, tid, parent, distance)\n      SELECT e.vid, :tid AS tid, e.parent, e.distance + 1 AS distance\n      FROM {taxonomy_term_edge} e\n      WHERE e.tid IN (:parents)\n      AND e.vid = :vid\n    ", array(
      ':vid' => $term->vid,
      ':tid' => $term->tid,
      ':parents' => $parents,
    ));
    taxonomy_edge_invalidate_order($term->vid);
  }
  else {
    watchdog('taxonomy_edge', 'Invalid term-id (%tid) received', array(
      '%tid' => $term->tid,
    ), WATCHDOG_ERROR);
  }
}

/**
 * Update a term in the edge tree.
 *
 * @param type $term
 */
function _taxonomy_edge_taxonomy_term_update($term) {
  $tx = db_transaction();

  // Invalidate sorted tree in case of name/weight change
  $modified =& drupal_static('taxonomy_edge_save_check_modified', TRUE);
  if ($modified) {
    taxonomy_edge_invalidate_order($term->vid);
  }
  if (!isset($term->parent)) {

    // Parent not set, no need to update hierarchy.
    return;
  }

  // Derive proper parents.
  $parents = _taxonomy_edge_unify_parents($term->parent);
  _taxonomy_edge_move_subtree($term->vid, $term->tid, $parents);
}

/**
 * Delete a term from the edge tree.
 *
 *  * @param $tid
 *   Term ID.
 */
function _taxonomy_edge_taxonomy_term_delete($term) {
  db_query("DELETE FROM {taxonomy_term_edge} WHERE vid = :vid AND tid = :tid", array(
    ':vid' => $term->vid,
    ':tid' => $term->tid,
  ));
}

/**
 * Queue an operation for the edge tree.
 *
 * @param object $term
 *   Term object
 * @param string $op
 *   insert, update or delete
 */
function _taxonomy_edge_taxonomy_term_queue($term, $op) {

  // Wait for rebuild to clear queue and initiate snapshot of term_hierarchy
  if (lock()
    ->lockMayBeAvailable('taxonomy_edge_rebuild_edges_' . $term->vid)) {
    $queue = DrupalQueue::get('taxonomy_edge_items_' . $term->vid, TRUE);
    $term->operation = $op;
    $queue
      ->createItem($term);
    $queue = DrupalQueue::get('taxonomy_edge', TRUE);
    $queue
      ->createItem($term->vid);
  }
}

/**
 * Unify parents
 *
 * @param mixed $parents
 * @return array
 *   Flattened array of parent term IDs
 */
function _taxonomy_edge_unify_parents($parents) {
  $parents = is_array($parents) ? $parents : array(
    $parents,
  );
  $new_parents = array();
  foreach ($parents as $parent) {
    if (is_array($parent)) {
      foreach ($parent as $new) {
        $new_parents[] = $new;
      }
    }
    else {
      $new_parents[] = $parent;
    }
  }
  return $new_parents;
}

/**
 * Generate query for ordering by dynamically compiled path
 *
 * @param $tid
 *   Term ID to generate dynamic path from.
 * @return
 *   String containing query.
 */
function _taxonomy_edge_generate_term_path_query($tid) {
  $args = func_get_args();
  $db_type = Database::getConnection()
    ->databaseType();
  switch ($db_type) {
    case 'pgsql':
      return "(SELECT array_to_string(array_agg(((tpx.weight + 1500) || tpx.name || '    ' || tpx.tid)), '    ') FROM (SELECT tpd.* FROM {taxonomy_term_edge} tpe INNER JOIN {taxonomy_term_data} tpd ON tpd.tid = tpe.parent WHERE tpe.tid = {$tid} ORDER BY tpe.distance DESC) tpx)";
    case 'mysql':
    case 'mysqli':
      return "(SELECT GROUP_CONCAT(tpd.weight + 1500, tpd.name, '    ', tpd.tid ORDER BY tpe.distance DESC SEPARATOR '    ') FROM {taxonomy_term_edge} tpe INNER JOIN {taxonomy_term_data} tpd ON tpd.tid = tpe.parent WHERE tpe.tid = {$tid})";
    case 'sqlite':
      return "(SELECT GROUP_CONCAT(val, '    ') FROM (SELECT (tpd.weight + 1500) || tpd.name || '    ' || tpd.tid AS val FROM {taxonomy_term_edge} tpe INNER JOIN {taxonomy_term_data} tpd ON tpd.tid = tpe.parent WHERE tpe.tid = {$tid} ORDER BY tpe.distance DESC))";
    case 'sqlsrv':
      return "(SELECT RTRIM((\n                     SELECT CAST(tpd.weight + 1500 as nvarchar) + tpd.name + '    ' + CAST(tpd.tid as nvarchar) + '    '\n                     FROM {taxonomy_term_edge} tpe\n                     JOIN {taxonomy_term_data} tpd ON tpd.tid = tpe.parent\n                     WHERE tpe.tid = {$tid}\n                     ORDER BY tpe.distance DESC\n                     FOR XML PATH ('')))\n                  )";
    default:
  }
}

// ---------- PUBLIC HELPER FUNCTIONS ----------

/**
 * Get max depth of a tree..
 *
 * @param $vid
 *   Vocabulary ID
 * @param $parent (optional)
 *   Parent to max depth of
 * @return
 *   Max depth (distance)
 */
function taxonomy_edge_get_max_depth($vid, $parent = 0) {
  return db_query("SELECT MAX(distance) FROM {taxonomy_term_edge} WHERE vid = :vid AND parent = :parent", array(
    ':vid' => $vid,
    ':parent' => $parent,
  ))
    ->fetchField();
}

/**
 * Checks if it's possible to build an edge realtime.
 *
 * @return boolean
 *   TRUE if possible, FALSE if not.
 */
function taxonomy_edge_is_build_realtime($vid) {
  if (variable_get('taxonomy_edge_build_realtime', TAXONOMY_EDGE_BUILD_REALTIME)) {
    $queue = queue('taxonomy_edge_items_' . $vid, TRUE);
    if ($queue
      ->numberOfItems()) {

      // Don't build realtime, if there are still items left in the queue.
      return FALSE;
    }
    if (!lock()
      ->lockMayBeAvailable('taxonomy_edge_rebuild_edges_' . $vid)) {

      // Don't build realtime, if entire tree rebuild is in progress.
      return FALSE;
    }
    return TRUE;
  }
  return FALSE;
}

/**
 * Check if our sorted tree is still valid
 */
function taxonomy_edge_is_order_valid($vid, $reset = FALSE) {
  static $valid_orders = array();
  if ($reset || !isset($valid_orders[$vid])) {
    $valid_orders[$vid] = db_query_range("SELECT 1 FROM {taxonomy_term_edge_order} WHERE vid = :vid", 0, 1, array(
      ':vid' => -$vid,
    ))
      ->fetchField();
  }
  return $valid_orders[$vid];
}

/**
 * Check if our sorted tree is still valid
 */
function taxonomy_edge_is_order_invalid($reset = FALSE) {
  static $invalid;
  if ($reset || !isset($valid)) {
    $invalid = db_query_range("SELECT 1\n      FROM {taxonomy_vocabulary} v\n      LEFT JOIN {taxonomy_term_edge_order} o ON o.vid = -v.vid AND o.vid < 0\n      WHERE o.oid IS NULL\n    ", 0, 1)
      ->fetchField();
  }
  return $invalid;
}

/**
 * Invalidate order for a vocabulary
 */
function taxonomy_edge_invalidate_order($vid) {
  db_delete('taxonomy_term_edge_order')
    ->condition('vid', -$vid)
    ->execute();
}

/**
 * Get parent from edge list.
 *
 * @param $tid
 *   term id to get parent from.
 * @return array
 *   array of term ids.
 */
function taxonomy_edge_get_parents($tid) {
  return db_query("\n    SELECT e.distance, e.parent\n    FROM {taxonomy_term_data} d\n    INNER JOIN {taxonomy_term_edge} e ON e.parent = d.tid\n    WHERE e.tid = :tid\n    AND e.tid > 0\n    AND e.distance > 0\n    ORDER BY e.distance\n  ", array(
    ':tid' => $tid,
  ))
    ->fetchAllKeyed();
}

/**
 * Get top term ids.
 *
 * @param $tid
 *   Term ID to get top term ID from.
 * @return array
 *   Top term IDs.
 */
function taxonomy_edge_get_top_tids($tid) {
  return db_query("SELECT DISTINCT e2.parent\n    FROM {taxonomy_term_edge} e\n    JOIN {taxonomy_term_edge} e2 ON e2.tid = e.tid AND e2.distance = e.distance - 1 AND e2.parent <> e.parent\n    WHERE e.tid = :tid\n    AND e.parent = 0\n    AND e.vid = e2.vid\n  ", array(
    ':tid' => $tid,
  ))
    ->fetchAllKeyed(0, 0);
}

/**
 * Get top term id.
 *
 * @param $tid
 *   Term ID to get top term ID from.
 * @return int
 *   Top term ID.
 */
function taxonomy_edge_get_top_tid($tid) {
  $tids = taxonomy_edge_get_top_tids(array(
    $tid,
  ));
  return reset($tids);
}

// ---------- CORE OVERRIDES ----------

/**
 * Reimplementation of taxonomy_get_tree().
 * Limit db fetch to only specified parent.
 * @see taxonomy_get_tree()
 */
function taxonomy_edge_get_tree($vid, $parent = 0, $max_depth = NULL, $load_entities = FALSE) {

  // @todo Use regular taxonomy_get_tree if realtime build is disabled,
  //       as this function might be unreliable.
  module_load_include('core.inc', 'taxonomy_edge');

  // Use optimized version if possible
  if (variable_get('taxonomy_edge_optimized_get_tree', TAXONOMY_EDGE_OPTIMIZED_GET_TREE)) {
    return taxonomy_edge_get_tree_optimized($vid, $parent, $max_depth, $load_entities);
  }
  else {
    return taxonomy_edge_get_tree_generic($vid, $parent, $max_depth, $load_entities);
  }
}

/**
 * Reimplementation of taxonomy_select_nodes() re-allowing depth modifier.
 */
function taxonomy_edge_select_nodes($tid, $pager = TRUE, $limit = FALSE, $depth = 0, $order = NULL) {
  if (!variable_get('taxonomy_maintain_index_table', TRUE)) {
    return array();
  }

  // If no depth, just use core (faster query due to no joins)
  if ($depth == 0) {
    $args = $order ? array(
      $tid,
      $pager,
      $limit,
      $order,
    ) : array(
      $tid,
      $pager,
      $limit,
    );
    return call_user_func_array('taxonomy_select_nodes', $args);
  }

  // Set default order if not specified
  if (!isset($order)) {
    $order = array(
      'n.sticky' => 'DESC',
      'n.created' => 'DESC',
      'n.nid' => 'DESC',
    );
  }

  // Lookup vid for better query on edge table
  $vid = db_query("SELECT vid FROM {taxonomy_term_data} WHERE tid = :tid", array(
    ':tid' => $tid,
  ))
    ->fetchField();

  // Locate tids to search in
  $subquery = db_select('taxonomy_term_edge', 'e');
  $subquery
    ->condition('e.parent', $tid);
  $subquery
    ->condition('e.vid', $vid);
  $subquery
    ->condition('e.distance', $depth, '<=');
  $subquery
    ->fields('e', array(
    'tid',
  ));

  // Find nodes
  $query = db_select('taxonomy_index', 't');
  $query
    ->join('node', 'n', 'n.nid = t.nid');
  $query
    ->addTag('node_access');
  $query
    ->condition('t.tid', $subquery, 'IN');
  if ($pager) {
    $count_query = db_select('taxonomy_index', 't');
    $count_query
      ->join('taxonomy_term_edge', 'e', 'e.tid = t.tid');
    $count_query
      ->condition('e.parent', $tid);
    $count_query
      ->condition('e.vid', $vid);
    $count_query
      ->condition('e.distance', $depth, '<=');
    $count_query
      ->addExpression('COUNT(1)');
    $query = $query
      ->extend('PagerDefault');
    if ($limit !== FALSE) {
      $query = $query
        ->limit($limit);
    }
    $query
      ->setCountQuery($count_query);
  }
  else {
    if ($limit !== FALSE) {
      $query
        ->range(0, $limit);
    }
  }
  $query
    ->addField('n', 'nid');
  $query
    ->addField('t', 'tid');
  foreach ($order as $field => $direction) {
    $query
      ->orderBy($field, $direction);

    // ORDER BY fields need to be loaded too, assume they are in the form
    // table_alias.name
    list($table_alias, $name) = explode('.', $field);
    $query
      ->addField($table_alias, $name);
  }
  return $query
    ->execute()
    ->fetchCol();
}

Functions

Namesort descending Description
taxonomy_edge_core_override_info Implements hook_core_override().
taxonomy_edge_cron Implements hook_cron().
taxonomy_edge_cronapi Implements hook_cronapi(). Regularly rebuild the edge list
taxonomy_edge_cron_queue_info Implements hook_cron_queue_info().
taxonomy_edge_cron_rebuild Rebuild edges
taxonomy_edge_form_taxonomy_overview_terms_alter Hook into the drag'n'drop interface of terms in order to update tree when terms are reordered.
taxonomy_edge_form_taxonomy_overview_vocabularies_alter Hook into the overview of vocabularies to provide rebuild actions.
taxonomy_edge_get_max_depth Get max depth of a tree..
taxonomy_edge_get_parents Get parent from edge list.
taxonomy_edge_get_top_tid Get top term id.
taxonomy_edge_get_top_tids Get top term ids.
taxonomy_edge_get_tree Reimplementation of taxonomy_get_tree(). Limit db fetch to only specified parent.
taxonomy_edge_help Implements hook_help().
taxonomy_edge_invalidate_order Invalidate order for a vocabulary
taxonomy_edge_is_build_realtime Checks if it's possible to build an edge realtime.
taxonomy_edge_is_order_invalid Check if our sorted tree is still valid
taxonomy_edge_is_order_valid Check if our sorted tree is still valid
taxonomy_edge_menu Implements hook_menu().
taxonomy_edge_modules_enabled Implements hook_modules_enabled().
taxonomy_edge_permission Implements hook_perm().
taxonomy_edge_process_queue_item Cron queue worker Process edge for a queued term.
taxonomy_edge_reorder_submit Copy/paste from core taxonomy module. This is the penalty for not having a proper abstraction layer! And for not invoking update hook on terms when changing their parents!
taxonomy_edge_select_nodes Reimplementation of taxonomy_select_nodes() re-allowing depth modifier.
taxonomy_edge_taxonomy_term_delete Implements hook_taxonomy_term_delete().
taxonomy_edge_taxonomy_term_insert Implements hook_taxonomy_term_insert().
taxonomy_edge_taxonomy_term_update Implements hook_taxonomy_term_update().
taxonomy_edge_taxonomy_vocabulary_delete Implements hook_taxonomy_vocabulary_delete().
taxonomy_edge_taxonomy_vocabulary_insert Implements hook_taxonomy_vocabulary_insert().
taxonomy_edge_theme Implements hook_theme().
_taxonomy_edge_attach_subtree Attach path and children to new parents
_taxonomy_edge_delete_subtree Delete subtree
_taxonomy_edge_detach_subtree Detach children from parents in $tids (delete ancestors)
_taxonomy_edge_generate_term_path_query Generate query for ordering by dynamically compiled path
_taxonomy_edge_move_subtree Detach path and children from current parent and attach to new parents
_taxonomy_edge_taxonomy_term_delete Delete a term from the edge tree.
_taxonomy_edge_taxonomy_term_insert Insert a term into the edge tree.
_taxonomy_edge_taxonomy_term_queue Queue an operation for the edge tree.
_taxonomy_edge_taxonomy_term_update Update a term in the edge tree.
_taxonomy_edge_unify_parents Unify parents

Constants

Namesort descending Description
TAXONOMY_EDGE_BUILD_REALTIME Default value for realtime building of tree.
TAXONOMY_EDGE_MAX_DEPTH Fail safe for avoiding infite loops when rebuilding edges.
TAXONOMY_EDGE_OPTIMIZED_GET_TREE Default value for optimized tree.
TAXONOMY_EDGE_STATIC_CACHING Default value for static caching.