function taxonomy_edge_get_tree_optimized in Taxonomy Edge 7.2
Same name and namespace in other branches
- 8 taxonomy_edge.core.inc \taxonomy_edge_get_tree_optimized()
- 6 taxonomy_edge.core.inc \taxonomy_edge_get_tree_optimized()
- 7 taxonomy_edge.core.inc \taxonomy_edge_get_tree_optimized()
Reimplementation of taxonomy_get_tree(). Limit db fetch to only specified parent AND use presorting.
See also
1 call to taxonomy_edge_get_tree_optimized()
- taxonomy_edge_get_tree in ./
taxonomy_edge.module - Reimplementation of taxonomy_get_tree(). Limit db fetch to only specified parent.
File
- ./
taxonomy_edge.core.inc, line 127 - This file contains the core override functions
Code
function taxonomy_edge_get_tree_optimized($vid, $parent = 0, $max_depth = NULL, $load_entities = FALSE) {
static $cache = array();
static $pids = array();
static $parents = array();
static $offsets = array();
$locate = array();
if (variable_get('taxonomy_edge_static_caching', TAXONOMY_EDGE_STATIC_CACHING)) {
if (!isset($cache[$vid])) {
$cache[$vid] = array();
}
if (!isset($parents[$vid][$parent])) {
$parents[$vid][$parent] = db_query("\n SELECT e.parent, e.distance, c.tid\n FROM taxonomy_term_edge_path p \n INNER JOIN taxonomy_term_edge e ON e.pid = p.pid\n INNER JOIN taxonomy_term_edge_path c ON c.pid = e.parent\n WHERE p.tid = :tid\n ", array(
':tid' => $parent,
))
->fetchAllAssoc('parent', PDO::FETCH_ASSOC);
}
$locate = array_intersect(array_keys($parents[$vid][$parent]), array_keys($cache[$vid]));
}
// No duplicates in the root level of query (i.e if the root level of query ($parent) has multiple parents)
if (!isset($pids[$vid][$parent])) {
$pids[$vid][$parent] = db_select('taxonomy_term_edge_path', 'p')
->fields('p', array(
'pid',
))
->condition('p.tid', $parent)
->execute()
->fetchAll(PDO::FETCH_NUM);
$pids[$vid][$parent] = _taxonomy_edge_unify_parents($pids[$vid][$parent]);
}
$pid = reset($pids[$vid][$parent]);
if ($pid == '') {
return array();
}
// If we are extracting a subtree from a previous cache, use that cache
if ($locate) {
$cache_pid = reset($locate);
// If full cache, just return it
if ($parents[$vid][$parent][$cache_pid]['distance'] == 0) {
return $cache[$vid][$cache_pid];
}
// Locate subtree
$tree = array();
$idx = $offsets[$vid][$cache_pid][$pid];
$sub_cache = $cache[$vid][$cache_pid];
$idx_end = count($cache[$vid][$cache_pid]);
$depth = $sub_cache[$idx]->depth + 1;
for ($i = $idx + 1; $i < $idx_end; $i++) {
$term = $sub_cache[$i];
if ($depth > $term->depth) {
break;
}
else {
$term->depth -= $depth;
$tree[] = $term;
}
}
return $tree;
}
else {
$valid_order = taxonomy_edge_is_order_valid($vid);
// No cache, let's fetch from db
$query = db_select('taxonomy_term_edge_path', 'p');
$query
->join('taxonomy_term_data', 'd', 'd.tid = p.tid');
$query
->join('taxonomy_term_edge', 'e', 'e.pid = p.pid');
$query
->join('taxonomy_term_hierarchy', 'h', 'h.tid = d.tid');
$query
->addTag('translatable')
->addTag('term_access')
->fields('p', array(
'pid',
))
->fields('d')
->fields('e', array(
'distance',
))
->fields('h', array(
'parent',
))
->condition('e.parent', $pid)
->condition('e.distance', 0, '>')
->condition('e.vid', $vid);
if ($valid_order) {
$query
->join('taxonomy_term_edge_order', 'o', 'o.pid = p.pid');
$query
->condition('o.vid', $vid);
$query
->orderBy('o.oid');
}
else {
$query
->addExpression(_taxonomy_edge_generate_term_path_query('p.pid'), 'sort_path');
$query
->orderBy('sort_path');
}
$result = $query
->execute();
$tree = array();
$tids = array();
$idx = 0;
foreach ($result as $term) {
if (!isset($tree[$term->pid])) {
$term->depth = $term->distance - 1;
$term->parents = array(
$term->parent,
);
unset($term->distance);
unset($term->parent);
unset($term->sort_path);
$tree[$term->pid] = $term;
$offsets[$vid][$pid][$term->pid] = $idx++;
unset($term->pid);
$tids[] = $term->tid;
}
else {
$tree[$term->pid]->parents[] = $term->parent;
}
}
}
// Load full entities, if necessary. The entity controller statically
// caches the results.
if ($load_entities) {
$term_entities = taxonomy_term_load_multiple($tids);
}
// Original taxonomy_get_tree() has an incremental index. Let's do this as well in a memory efficient way.
$clean_tree = array();
foreach ($tree as $idx => $term) {
$clean_tree[] = $load_entities ? $term_entities[$term->tid] : $term;
unset($tree[$idx]);
}
if (variable_get('taxonomy_edge_static_caching', TAXONOMY_EDGE_STATIC_CACHING)) {
// Store result in static cache
$cache[$vid][$pid] = $clean_tree;
foreach ($pids[$vid][$parent] as $p) {
if ($p != $pid) {
$cache[$vid][$p] =& $cache[$vid][$pid];
$offsets[$vid][$p] =& $offsets[$vid][$pid];
}
}
}
return $clean_tree;
}