[APORTE] Estructura de árbol desde de base de datos

[Nisrokh]

¡Hola amigos de Foros del Web!

Hace unos días me vi obligado a crear una estructura de árbol desde una base de datos, y a partir de allí, crear varios menús jerárquicos, mapas de sitio y "breadcrumbs".

A pesar de que aún lo estoy "puliendo", me ha funcionado de maravillas. Así que pensé en compartirlo con ustedes.

A decir verdad, no es algo tan complicado de hacer... Pero yo quise hacer algo "reutilizable", teniendo en cuenta lo siguiente:

• No depender de una conexión a una base de datos;
• tampoco depender del orden en el que los datos se presenten;
• utilizar una sola sentencia SQL para cada árbol;
• crear un árbol "sín límites" de profundidad;
• poder ordenar el árbol una vez construído;
• y obtener datos por su id.

Antes que nada, como yo trabajo con PHP 5.4+, pense hacer una versión del código alternativa, para versiones de PHP anteriores. Pero aclaro: sólo pude probarlo en las siguientes versiones de PHP: 5.4.7 (ambos códigos) y 5.3.24 (sólo la versión por procedimientos), y funcionó a la perfección.

El código contiene de 2 interfaces y 4 clases, en la version orientada a objetos. Y la versión por procedimientos, una sola función.

Ahora, debido a que en el título menciono "desde base de datos", estoy obligado a mostrarles cómo, pero la verdad es que los datos pueden provenir de cualquier otro medio, solo tiene que respetarse la estructura de tabla (es decir, un array donde cada elemento es una fila, o sea, otro array u objeto con los datos) y contener 2 campos obligatorios: un campo con un ID ÚNICO, y otro campo indicando ese mísmo ID ÚNICO, pero del elemento padre.

A continuación les muestro la base de datos que yo estoy utilizando, solo que con los datos necesarios para esta ocación, cada quien lo puede modificar a su gusto.

Código SQL:

--
-- Estructura de tabla para la tabla `links`
--
 
CREATE TABLE IF NOT EXISTS `links` (
  `id` SMALLINT(5) UNSIGNED NOT NULL AUTO_INCREMENT,
  `name` VARCHAR(200) NOT NULL DEFAULT '',
  PRIMARY KEY (`id`),
  UNIQUE KEY `name` (`name`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8;
 
--
-- Estructura de tabla para la tabla `links_hierarchy`
--
CREATE TABLE IF NOT EXISTS `links_hierarchy` (
  `link_id` SMALLINT(5) UNSIGNED NOT NULL,
  `parent_id` SMALLINT(5) UNSIGNED NOT NULL DEFAULT '0',
  `group_id` SMALLINT(5) UNSIGNED NOT NULL DEFAULT '0',
  `order_no` SMALLINT(5) NOT NULL DEFAULT '0',
  KEY `parent_id` (`parent_id`),
  KEY `group_id` (`group_id`),
  KEY `link_id` (`link_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
 
--
-- Filtros para la tabla `links_hierarchy`
--
ALTER TABLE `links_hierarchy`
  ADD CONSTRAINT `links_hierarchy_ibfk_1`
  FOREIGN KEY (`link_id`)
  REFERENCES `links` (`id`)
  ON DELETE CASCADE
  ON UPDATE CASCADE;
 

Ahora, la razón por la que decidí dividirlo en 2 tablas distintas, no es sólo para mantener la base de datos más ordenada. Primero les explico los campos extras:

group_id => Es simplemente para poder agrupar árboles. Como dije antes, necesitaba crear varios árboles, por eso creí que sería útil agrupar los datos de esa forma. Por ejemplo, si quiero crear un árbol para un menú principal, y otro para un submenú, asocio al grupo "0" los elementos del menú principal y al grupo "1" los elementos del submenú. Entonces, a la hora de obtener los datos, los filtro por su grupo, con la cláusula WHERE group_id = 0

order_no => Es simplemente para poder ordenar los elementos de forma manual, asignando un número de orden.

Ahora sí, el motivo por el cual separo los datos en 2 tablas, es porque me permite mostrar 1 elemento en varios grupos, sín la necesidad de copiar todos los datos, además que no se puede teniendo las filas con ID único. Por lo tanto, sólo agregamos una fila en links_hierarchy para ubicar un elemento en otro grupo.

Para obtener los datos, la siguiente consulta me ha funcionado bastante bien:

Código PHP:

$sql_query = '
    SELECT
        links.id,
        links.name,
        links_hierarchy.group_id,
        links_hierarchy.parent_id,
        links_hierarchy.order_no
    FROM links
    INNER JOIN links_hierarchy
        ON links_hierarchy.link_id = links.id
    WHERE links_hierarchy.group_id = 0
        AND links.id > 0
';
 

Importante: no creo que alguien lo haga, pero NO utilizar el id 0 en la base de datos, ya que al generar el árbol, como éste es también tratado como un nodo en sí, se le asigna el id "0", al ser la raíz de todo el árbol.

Ahora, empecemos con la versión por procedimientos; es una función que acepta 3 parametros:

Código:

array table_tree(array $table[, bool $sort = false[, array $options = array()]])

$table => Es la tabla de datos de donde se construirá el árbol. Ejemplo:

Código PHP:

// Normalmente el resultado obtenido de una tabla de una base de datos,
// luego de ejecutar mysqli_fetch_assoc() o mysqli_fetch_object(), por ejemplo
$table = array(
    0 => array('campo1' => 'valor1', 'campo2' => 'valor2', 'campo3' => 'valor3'),
    1 => array('campo1' => 'valor1', 'campo2' => 'valor2', 'campo3' => 'valor3'),
    2 => array('campo1' => 'valor1', 'campo2' => 'valor2', 'campo3' => 'valor3')
    // ...
);
 

Nota: en caso de que se obtengan las filas con mysqli_fetch_object(), el código forzará la fila hacia un array, sólo para obtener los ids necesarios. El valor del nodo seguirá siendo la fila (objeto) original.

$sort => Indica si queremos ordenar el árbol, o no. Por defecto, es falso.
$options => Indica opciones de entrada/salida de datos. Estos son los valores que se utilizan por defecto:

Código PHP:

$options = array(
    // Índices de entrada; nombre de los campos en la base de datos
    // o el alias utilizado en la consulta
    'id_key'        => 'id',
    'parent_id_key' => 'parent_id',
    // Índices de salida; los primeros tres serán los índices de los datos
    // en cada nodo, y del árbol resultante en sí; y los otros dos son los
    // extra que contiene el nodo del árbol; el primero contiene referencias
    // a todos los nodos en el arbol, por su id; y el segundo, los nodos cuyo
    // padre no se pudo encontrar
    'value_key'     => 'value',
    'parent_key'    => 'parent',
    'children_key'  => 'children',
    'nodes_key'     => 'nodes',
    'orphans_key'   => 'orphans',
    // Comparador para ordenar los nodos, debe ser de tipo "callable"
    // como especifíca la función usort(), o un int, para especificar "flags"
    // como en la función sort()
    'comparator'    => SORT_REGULAR
);
 

A continuación, les muestro cómo la función construye la estructura de árbol:

Código PHP:

// Estructura de un nodo
$node = array(
    // Puede ser un objeto, depende de como obtenemos los filas
    $options['value_key'] => array(/* datos de fila */),
    $options['parent_key'] => &$parent_node,
    $options['children_key'] => array(
        0 => $node,
        1 => $node,
        2 => $node
        // ...
    )
);
// Estructura de del árbol final
$node = array(
    // Los dos primeros, sólo para seguir con la estructura de un nodo, aunque
    // se le podría agregar un valor manualmente
    $options['value_key'] => null,
    $options['parent_key'] => null,
    $options['children_key'] => array(
        0 => $node,
        1 => $node,
        2 => $node
        // ...
    ),
    // Mapa de nodos, por referencias ('id' => &$nodo)
    $options['nodes_key'] => array(
        'node_id' => &$node,
        'node_id' => &$node,
        'node_id' => &$node,
        // ...
    ),
    // Los nodos que deberían tener un padre, pero no se encontro en la tabla
    $options['orphans_key'] => array(
        'parent_node_id' => array(
            0 => $orphan_node,
            1 => $orphan_node,
            2 => $orphan_node
            // etc.
        ),
        'parent_node_id' => array(/* nodos huerfanos */),
        'parent_node_id' => array(/* nodos huerfanos */)
        // ...
    )
);
 

(Continúa en comentarios)

[Nisrokh]

La función table_tree():

Código PHP:

<?php
 
/**
 * @author Diego P. M. Baltar <[email protected]>
 * @copyright (c) 2013
 */
 
/**
 * Construye una estructura de árbol desde una tabla, donde cada fila tiene un
 * campo con su id único, y un campo indicando el id de su padre.
 * 
 * La estructura de las opciones:
 * <pre>
 * array(
 *     // Claves de entrada
 *     'id_key'        => 'id',
 *     'parent_id_key' => 'parent_id',
 *     // Claves de salida
 *     'value_key'     => 'value',
 *     'parent_key'    => 'parent',
 *     'children_key'  => 'children',
 *     'nodes_key'     => 'nodes',
 *     'orphans_key'   => 'orphans',
 *     // Comparador para ordenar los nodos
 *     'comparator'    => SORT_REGULAR // O un "callable" usado por usort()
 * )
 * </pre>
 * 
 * @todo Detectar errores recursivos.
 * @todo Detectar ubicaciones múltiples (en un mísmo grupo).
 * 
 * @param array $table La tabla de datos.
 * @param bool $sort Indica si los nodos deben ser ordenados, o no.
 * @param array $options Opciones de entrada y salida.
 * @return array
 */
function table_tree($table, $sort = false, $options = array())
{
    if (!is_array($table) || empty($table)) {
        return array();
    }
    
    // Opciones por defecto
    static $default_options = array(
        'id_key'        => 'id',
        'parent_id_key' => 'parent_id',
        'value_key'     => 'value',
        'parent_key'    => 'parent',
        'children_key'  => 'children',
        'nodes_key'     => 'nodes',
        'orphans_key'   => 'orphans',
        'comparator'    => SORT_REGULAR
    );
    
    // Establecer opciones que no fueron especificadas
    if (empty($options)) {
        $options = $default_options;
    } else {
        foreach ($default_options as $name => $value) {
            if (!isset($options[$name])) {
                $options[$name] = $value;
            }
        }
    }
    
    // Acceso corto a las claves de entrada
    $id_key = $options['id_key'];
    $parent_id_key = $options['parent_id_key'];
    
    // Acceso corto a las claves de salida
    $value_key = $options['value_key'];
    $parent_key = $options['parent_key'];
    $children_key = $options['children_key'];
    $nodes_key = $options['nodes_key'];
    $orphans_key = $options['orphans_key'];
    
    // El árbol final (sigue la estructura de un nodo, más 2 items)
    $tree = array(
        $value_key    => null,
        $parent_key   => null,
        $children_key => array(),
        $nodes_key    => array(),
        $orphans_key  => array()
    );
    
    // Datos temporales
    $nodes = &$tree[$nodes_key];     // Mapa de nodos (ref. nodos en el árbol)
    $orphans = &$tree[$orphans_key]; // Nodos que no se encontro su padre
    $on_hold = array();              // Lista de nodos en espera de su padre
    $on_hold_children = array();     // Nodos en lista de espera
    $on_hold_children_map = array(); // Mapa de nodos en lista de espera
    $sortable_children = array();    // Nodos que deberían ser ordenados
    
    // Agregar el árbol al mapa de nodos bajo el id "0"
    $nodes[0] = &$tree;
    
    // Construír el árbol
    foreach ($table as $index => $row) {
        // Forzar los datos hacia un array, sólo para obtener los ids
        $row = (array) $row;
        $node_id = $row[$id_key];
        $node_parent_id = $row[$parent_id_key];
        
        // Ignorar filas con id = "0"
        if ((int) $node_id === 0) {
            continue;
        }
        
        // Crear nodo
        $new_node = array(
            $value_key => $table[$index],
            $parent_key => null,
            $children_key => array()
        );
        
        // Indica si el padre del nodo actual está en espera
        $parent_is_on_hold = false;
        
        // ¿Se ha encontrado ya el nodo padre de este nodo?
        if (isset($nodes[$node_parent_id])) {
            $parent = &$nodes[$node_parent_id];
        } elseif (isset($on_hold[$node_parent_id])) {
            $on_hold_key = $on_hold[$node_parent_id];
            $parent = &$on_hold_children_map[$on_hold_key][$node_parent_id];
            $parent_is_on_hold = true;
        } elseif (isset($parent)) {
            unset($parent);
        }
        
        // Dar nodo a su padre (si éste ha sido encontrado)
        if (isset($parent)) {
            $parent_children = &$parent[$children_key];
            $parent_children[] = $new_node;
            $parent_children_count = count($parent_children);
            $node = &$parent_children[$parent_children_count - 1];
            
            // Establecer el nodo padre
            $node[$parent_key] = &$parent;
            
            if ($parent_is_on_hold) {
                // Agregar nodo al mapa de nodos en espera
                $on_hold[$node_id] = $on_hold[$node_parent_id];
                $on_hold_children_map[$on_hold[$node_id]][$node_id] = &$node;
            } else {
                // Agregar nodo al mapa final
                $nodes[$node_id] = &$node;
            }
            
            // Agregar nodos hijos para ordenar, sólo si es necesario
            if ($sort && $parent_children_count > 1
                    && !isset($sortable_children[$node_parent_id])) {
                $sortable_children[$node_parent_id] = &$parent_children;
            }
        } else {
            // Agregar nodo a la lista de espera, hasta que aparezca su padre
            $on_hold[$node_id] = $node_parent_id;
            
            if (!isset($on_hold_children[$node_parent_id])) {
                $on_hold_children[$node_parent_id] = array();
            }
            
            // Poner el nodo en espera
            $on_hold_children[$node_parent_id][] = $new_node;
            $node = &$on_hold_children[$node_parent_id]
                [count($on_hold_children[$node_parent_id]) - 1];
            
            if (!isset($on_hold_children_map[$node_parent_id])) {
                $on_hold_children_map[$node_parent_id] = array();
            }
            
            // Agregar nodo al mapa de lista de espera
            $on_hold_children_map[$node_parent_id][$node_id] = &$node;
        }
        
        // ¿És este nodo el padre de alguno de los nodos en espera?
        if (isset($on_hold_children[$node_id])) {
            // Agregar nodo al árbol final, actualizar referencias, y establecer
            // su nodo padre (manipular 1 nodo manualmente)
            if (count($on_hold_children[$node_id]) < 2) {
                $on_hold_node = &$on_hold_children[$node_id][0];
                $on_hold_node[$parent_key] = &$node;
                $node[$children_key][] = $on_hold_node;
                $on_hold_node_value = (array) $on_hold_node[$value_key];
                $on_hold_node_id = $on_hold_node_value[$id_key];
                $on_hold_children_map[$node_id][$on_hold_node_id]
                    = &$node[$children_key][count($node[$children_key]) - 1];
            } else {
                foreach ($on_hold_children[$node_id] as &$on_hold_node) {
                    $on_hold_node[$parent_key] = &$node;
                    $node[$children_key][] = $on_hold_node;
                    $on_hold_node_value = (array) $on_hold_node[$value_key];
                    $on_hold_node_id = $on_hold_node_value[$id_key];
                    $on_hold_children_map[$node_id][$on_hold_node_id]
                        = &$node[$children_key]
                            [count($node[$children_key]) - 1];
                }
            }
            
            // Agregar nodos al mapa final
            $tree[$nodes_key]+= $on_hold_children_map[$node_id];
            
            // Borrar referencias hacia la lista de espera
            unset($on_hold_children[$node_id]);
            unset($on_hold_children_map[$node_id]);
            
            // Agregar nodos hijos para ordenar, sólo si es necesario
            if ($sort && count($node[$children_key]) > 1
                    && !isset($sortable_children[$node_id])) {
                $sortable_children[$node_id] = &$node[$children_key];
            }
        }
    }
    
    // Obtener los nodos "huérfanos", donde su parent_id != 0 pero de todas
    // maneras no ha sido encontrado
    if (!empty($on_hold_children)) {
        $orphans = $on_hold_children;
    }
    
    // Ordernar los nodos, sólo si es necesario
    if (!empty($sortable_children)) {
        // Obtener el comparador establecido
        $comparator = $options['comparator'];
        
        foreach ($sortable_children as &$unsorted_children) {
            if (is_callable($comparator)) {
                usort($unsorted_children, $comparator);
            } else {
                sort($unsorted_children, $comparator);
            }
        }
    }
    
    return $tree;
}
 

Ahora, un simple ejemplo de como utilizarlo con una base de datos:

Código PHP:

// MySQL info.
define('MYSQL_HOSTNAME', 'localhost');
define('MYSQL_USERNAME', 'root');
define('MYSQL_PASSWORD', '123456');
define('MYSQL_DATABASE', 'test');
 
// Crear conexión
$sql_connection = mysqli_connect(
    MYSQL_HOSTNAME,
    MYSQL_USERNAME,
    MYSQL_PASSWORD,
    MYSQL_DATABASE
);
 
if (!$sql_connection) {
    exit(sprintf(
        'Database connection error: (%s) %s',
        mysqli_connect_errno(),
        mysqli_connect_error()
    ));
} else {
    mysqli_query($sql_connection, 'SET NAMES \'utf8\'');
}
 
// Obtener los datos del grupo "0"
$sql_query = '
    SELECT
        links.id,
        links.name,
        links_hierarchy.group_id,
        links_hierarchy.parent_id,
        links_hierarchy.order_no
    FROM links
    INNER JOIN links_hierarchy
        ON links_hierarchy.link_id = links.id
    WHERE links_hierarchy.group_id = 0
        AND links.id > 0
';
 
// Ejecutar consulta
$sql_query_result = mysqli_query($sql_connection, $sql_query);
$table = array();
 
while ($row = mysqli_fetch_assoc($sql_query_result)) {
    $table[] = $row;
}
 
mysqli_free_result($sql_query_result);
mysqli_close($sql_connection);
 
// Aplicar shuffle() sólo para demostrarles que no importa el orden, el árbol
// siempre se construirá normalmente
shuffle($table);
 
// Función para el ordenamiento por el campo "name"
function compare_nodes($a, $b) {
    $a = $a['value']['name'];
    $b = $b['value']['name'];
    
    return strcasecmp($a, $b);
}
 
// Crear árbol
$tree = table_tree(
    $table,
    true,
    array(
        'comparator' => 'compare_nodes'
    )
);
 
// Obtener el nodo con el id "24"
$node = $tree['nodes'][24];
// Obtener la referencia al nodo padre
$parent_node = $node['parent'];
// Obtener el nodo hijo no. 3, suponiendo que existe
$child_node_3 = $node['children'][2];
// Obtener el valor del nodo (la fila original, obtenida de la consulta SQL)
$node_value = $node['value'];
 
// Los nombres de las claves, serán distintas si las especificamos en el
// parámetro $options, pero estas son utilizadas por defecto
 

(Continúa en comentarios)

[Nisrokh]

Ahora les muestro la versión orientada a objetos, que básicamente hace lo mismo, sólo que de manera diferente.

En vez de un array, el resultado será una instanca de la clase Diba\GenericTree\TableTree, que extiende la clase Diba\GenericTree\Node, y por ende, implementa a la interface Diba\Tree\Node. Y los hijos son contenidos por una instancia de la clase que implementa a Diba\Tree\NodeList.

Al crear una instancia de Diba\GenericTree\TableTree, opcionalmente se puede pasar una instancia de Diba\GenericTree\TableTreeOptions, por si queremos cambiar los 2 valores de entrada necesarios (clave del id y clave del parent_id) y el comparador para ordenar los nodos.

A continuación, las 2 interfaces:

Diba\Tree\Node

Código PHP:

<?php
 
/**
 * @author Diego P. M. Baltar <[email protected]>
 * @copyright (c) 2013
 * @package Diba
 * @subpackage Tree
 */
namespace Diba\Tree;
 
/**
 * Define los requisitos para un nodo.
 */
interface Node
{
    /**
     * Devuelve una colección de los nodos hijos.
     * 
     * @return \Diba\Tree\NodeList
     */
    public function getChildren();
    
    /**
     * Devuelve el nodo padre (si existe), o de lo contrario null.
     * 
     * @return \Diba\Tree\Node|null
     */
    public function getParent();
    
    /**
     * Devuelve el valor del nodo.
     * 
     * @return mixed
     */
    public function getValue();
    
    /**
     * Indica si el nodo contiene hijos.
     * 
     * @return bool
     */
    public function hasChildren();
    
    /**
     * Indica si el nodo contiene padre.
     * 
     * @return bool
     */
    public function hasParent();
}
 

Diba\Tree\NodeList

Código PHP:

<?php
 
/**
 * @author Diego P. M. Baltar <[email protected]>
 * @copyright (c) 2013
 * @package Diba
 * @subpackage Tree
 */
namespace Diba\Tree;
 
use ArrayAccess;
use Countable;
use IteratorAggregate;
 
/**
 * Define los requisitos para una colección de nodos.
 */
interface NodeList extends ArrayAccess, Countable, IteratorAggregate
{
    /**
     * Agrega un nodo a la colección.
     * 
     * @param \Diba\Tree\Node $node El nodo que será agregado.
     * @return void
     */
    public function add(Node $node);
    
    /**
     * Limpia la colección de nodos.
     * 
     * @return void
     */
    public function clear();
    
    /**
     * Indica si la colección contiene el nodo especificado.
     * 
     * @param \Diba\Tree\Node $node El nodo a buscar.
     * @return bool
     */
    public function contains(Node $node);
    
    /**
     * Indica si la colección de nodos está vacía.
     * 
     * @return bool
     */
    public function isEmpty();
    
    /**
     * Quita el nodo especificado de la colección.
     * 
     * @param \Diba\Tree\Node $node El nodo a quitar.
     * @return void
     */
    public function remove(Node $node);
    
    /**
     * Devuelve una copia de la colección, como array.
     * 
     * @return array
     */
    public function toArray();
}
 

(Continúa en comentarios)

[Nisrokh]

Ahora, las implementaciones para la construcción del árbol.

Diba\GenericTree\Node

Código PHP:

<?php
 
/**
 * @author Diego P. M. Baltar <[email protected]>
 * @copyright (c) 2013
 * @package Diba
 * @subpackage GenericTree
 */
namespace Diba\GenericTree;
 
use Diba\Tree\Node as INode;
use Diba\Tree\NodeList as INodeList;
use InvalidArgumentException;
 
/**
 * Implementación de \Diba\Tree\Node.
 */
class Node implements INode
{
    /**
     * Colección de nodos hijos.
     * 
     * @var \Diba\Tree\NodeList
     */
    protected $children;
    
    /**
     * El nodo padre.
     * 
     * @var \Diba\Tree\Node
     */
    protected $parent;
    
    /**
     * El valor del nodo.
     * 
     * @var mixed
     */
    protected $value;
    
    // \Diba\Tree\Node
    
    /**
     * Devuelve una colección de los nodos hijos.
     * 
     * @return \Diba\Tree\NodeList
     */
    public function getChildren()
    {
        if (!$this->children instanceof INodeList) {
            $this->children = new NodeList();
        }
        
        return $this->children;
    }
    
    /**
     * Devuelve el nodo padre (si existe), o de lo contrario null.
     * 
     * @return \Diba\Tree\Node|null
     */
    public function getParent()
    {
        return $this->parent;
    }
    
    /**
     * Devuelve el valor del nodo.
     * 
     * @return mixed
     */
    public function getValue()
    {
        return $this->value;
    }
    
    /**
     * Indica si el nodo contiene hijos.
     * 
     * @return bool
     */
    public function hasChildren()
    {
        $hasChildren = false;
        
        if (isset($this->children)) {
            if (!$this->children->isEmpty()) {
                $hasChildren = true;
            }
        }
        
        return $hasChildren;
    }
    
    /**
     * Indica si el nodo contiene padre.
     * 
     * @return bool
     */
    public function hasParent()
    {
        return isset($this->parent);
    }
    
    // \Diba\GenericTree\Node
    
    /**
     * Constructor
     * 
     * @param mixed $value El valor para el nodo.
     * @param \Diba\Tree\Node $parent El padre de este nodo.
     * @param \Diba\Tree\NodeList $children Los hijos de este nodo.
     * @return \Diba\GenericTree\Node
     */
    public function __construct(
        $value = null,
        INode $parent = null,
        INodeList $children = null
    ) {
        $this->value = $value;
        $this->parent = $parent;
        $this->children = $children;
    }
    
    /**
     * Reestablece el nodo a su estado inicial.
     * 
     * @return void
     */
    public function reset()
    {
        $this->children = null;
        $this->parent = null;
        $this->value = null;
    }
    
    /**
     * Establece los hijos de este nodo.
     * 
     * @return void
     */
    public function setChildren(INodeList $children)
    {
        $this->children = $children;
    }
    
    /**
     * Establece el padre de este nodo.
     * 
     * @return void
     * @throws \InvalidArgumentException
     * When trying to set a node as its own parent.
     */
    public function setParent(INode $node)
    {
        if ($node === $this) {
            throw new InvalidArgumentException(
                'Cannot set node as its own parent'
            );
        }
        
        $this->parent = $node;
    }
    
    /**
     * Establece el valor de este nodo.
     * 
     * @return void
     */
    public function setValue($value)
    {
        $this->value = $value;
    }
}
 

(Continúa en comentarios)

[Nisrokh]

Diba\GenericTree\NodeList

Código PHP:

<?php
 
/**
 * @author Diego P. M. Baltar <[email protected]>
 * @copyright (c) 2013
 * @package Diba
 * @subpackage GenericTree
 */
namespace Diba\GenericTree;
 
use Diba\Tree\Node as INode;
use Diba\Tree\NodeList as INodeList;
use ArrayIterator;
use InvalidArgumentException;
use OutOfBoundsException;
 
/**
 * Implementación de \Diba\Tree\NodeList.
 */
class NodeList implements INodeList
{
    /**
     * El comparador para odernar los nodos.
     * 
     * @var callable|int
     */
    protected $comparator;
    
    /**
     * Colección de nodos.
     * 
     * @var array
     */
    protected $nodes = [];
    
    // \ArrayAccess
    
    /**
     * Indica si un índice existe.
     *
     * @see http://php.net/arrayaccess.offsetexists
     *
     * @param int $index El índice a ser comprobado.
     * @return bool
     */
    public function offsetExists($index)
    {
        return (int) $index >= 0 && (int) $index < count($this->nodes);
    }
    
    /**
     * Devuelve el nodo contenido por el índice especificado.
     *
     * @see http://php.net/arrayaccess.offsetget
     *
     * @param int $index El índice del nodo a devolver.
     * @return \Diba\Tree\Node
     * @throws \OutOfBoundsException
     * Si el índice está fuera de rango.
     */
    public function offsetGet($index)
    {
        $index = (int) $index;
        
        if ($index < 0 || $index >= count($this->nodes)) {
            throw new OutOfBoundsException('Index is out of range');
        }
        
        return $this->nodes[$index];
    }
    
    /**
     * Inserta un nodo en el índice especificado, y mueve todos los nodos
     * siguientes hacia la derecha, incrementando su índice en: $index + 1.
     *
     * @see http://php.net/arrayaccess.offsetset
     *
     * @param int $index Índice donde se insertará el nodo.
     * @param mixed $node El nodo a insertar.
     * @return void
     * @throws \InvalidArgumentException
     * Si el nodo no implementa a \Diba\Tree\Node.
     * @throws \OutOfBoundsException
     * Si el índice está fuera de rango.
     */
    public function offsetSet($index, $node)
    {
        if (!$node instanceof INode) {
            throw new InvalidArgumentException(
                'Invalid node type: instance of "\Diba\Tree\Node" expected, '
                    .gettype($node). ' given'
            );
        }
        
        if ($index === null) {
            $this->nodes[] = $node;
            
            return;
        } elseif (!$this->offsetExists($index)) {
            throw new OutOfBoundsException('Index is out of range');
        }
        
        $index = (int) $index;
        
        if ($index === 0) {
            array_unshift($this->nodes, $node);
                
            return;
        }
        
        $right = array_splice($this->nodes, $index);
        $this->nodes[] = $node;
        $this->nodes = array_merge($this->nodes, $right);
    }
    
    /**
     * Quita el nodo contenido por el índice especificado, y mueve todos los
     * nodos siguientes hacia la izquierda, reduciendo su índice en: $index - 1.
     *
     * @see http://php.net/arrayaccess.offsetunset
     *
     * @param int $index Índice del nodo a ser quitado.
     * @return void
     * @throws \OutOfBoundsException
     * Si el índice está fuera de rango.
     */
    public function offsetUnset($index)
    {
        $index = (int) $index;
        
        if ($index < 0 || $index >= count($this->nodes)) {
            throw new OutOfBoundsException('Index is out of range');
        }
        
        array_splice($this->nodes, $index, 1);
    }
    
    // \Countable
    
    /**
     * Devuelve el número de nodos en ésta colección.
     * 
     * @see http://php.net/class.countable
     * 
     * @return int
     */
    public function count()
    {
        return count($this->nodes);
    }
    
    // \IteratorAggregate
    
    /**
     * Devuelve un iterador externo.
     *
     * @see http://php.net/class.iteratoraggregate
     *
     * @return \Iterator
     */
    public function getIterator()
    {
        return new ArrayIterator($this->nodes);
    }
    
    // \Diba\Tree\NodeList
    
    /**
     * Agrega un nodo a la colección.
     * 
     * @param \Diba\Tree\Node $node El nodo que será agregado.
     * @return void
     */
    public function add(INode $node)
    {
        $this->nodes[] = $node;
    }
    
    /**
     * Limpia la colección de nodos.
     * 
     * @return void
     */
    public function clear()
    {
        $this->nodes = [];
    }
    
    /**
     * Indica si la colección contiene el nodo especificado.
     * 
     * @param \Diba\Tree\Node $node El nodo a buscar.
     * @return bool
     */
    public function contains(INode $node)
    {
        $search = array_search($node, $this->nodes, true);
        
        return ($search !== false);
    }
    
    /**
     * Indica si la colección de nodos está vacía.
     * 
     * @return bool
     */
    public function isEmpty()
    {
        return empty($this->nodes);
    }
    
    /**
     * Quita el nodo especificado de la colección.
     * 
     * @param \Diba\Tree\Node $node El nodo a quitar.
     * @return void
     */
    public function remove(INode $node)
    {
        $previousCount = count($this->nodes);
        
        while (($index = $this->indexOf($node)) > -1) {
            unset($this->nodes[$index]);
        }
        
        if ($previousCount < count($this->nodes)) {
            $this->nodes = array_values($this->nodes);
        }
    }
    
    /**
     * Devuelve una copia de la colección, como array.
     * 
     * @return array
     */
    public function toArray()
    {
        return $this->nodes;
    }
    
    // \Diba\GenericTree\NodeList
    
    /**
     * Inserta un nodo en el índice especificado, y mueve todos los nodos
     * siguientes hacia la derecha, incrementando su índice en: $index + 1.
     * 
     * @param int $index Índice del nodo a ser insertado.
     * @param \Diba\Tree\Node $node El nodo a insertar.
     * @return void
     * @throws \OutOfBoundsException
     * Si el índice está fuera de rango.
     */
    public function addAt($index, INode $node)
    {
        $this->offsetSet($index, $node);
    }
    
    /**
     * Devuelve el nodo contenido por el índice especificado.
     * 
     * @param int $index El índice del nodo a obtener.
     * @return \Diba\Tree\Node
     * @throws \OutOfBoundsException
     * Si el índice está fuera de rango.
     */
    public function get($index)
    {
        return $this->offsetGet($index);
    }
    
    /**
     * Devuelve el comparador de nodos.
     * 
     * @return callable|int
     */
    public function getComparator()
    {
        return $this->comparator;
    }
    
    /**
     * Devuelve el primer índice de un nodo, si existe.
     * 
     * @param \Diba\Tree\Node $node El nodo a buscar.
     * @return int -1 si el índice no existe.
     */
    public function indexOf(INode $node)
    {
        $search = array_search($node, $this->nodes, true);
        
        return ($search !== false ? $search : -1);
    }
    
    /**
     * Une la colección de nodos especificada con ésta mísma.
     * 
     * @param \Diba\Tree\NodeList $nodeList La colección de nodos a unir.
     * @return bool Verdadero si ésta colección ha cambiado.
     */
    public function merge(INodeList $nodeList)
    {
        $previousCount = count($this->nodes);
        
        // Manipular hasta 3 nodos manualmente
        switch ($nodeList->count()) {
            case 0:
                return false;
                break;
            case 1:
                $this->nodes[] = $nodeList->get(0);
                break;
            case 2:
                $this->nodes[] = $nodeList->get(0);
                $this->nodes[] = $nodeList->get(1);
                break;
            case 3:
                $this->nodes[] = $nodeList->get(0);
                $this->nodes[] = $nodeList->get(1);
                $this->nodes[] = $nodeList->get(2);
                break;
            default:
                if ($previousCount < 1) {
                    $this->nodes = $nodeList->toArray();
                } else {
                    array_merge($this->nodes, $nodeList->toArray());
                }
                break;
        }
        
        return count($this->nodes) > $previousCount;
    }
    
    /**
     * Quita el nodo contenido por el índice especificado, y mueve todos los
     * nodos siguientes hacia la izquierda, reduciendo su índice en: $index - 1.
     * 
     * @param int $index Índice del nodo a ser quitado.
     * @return \Diba\Tree\Node El nodo previo en el índice especificado.
     * @throws \OutOfBoundsException
     * Si el índice está fuera de rango.
     */
    public function removeAt($index)
    {
        $previousNode = $this->offsetGet($index);
        $this->offsetUnset($index);
        
        return $previousNode;
    }
    
    /**
     * Establece el nodo en el índice especificado, y sobreescribe al anterior.
     * 
     * @param int $index El índice del nodo a establecer.
     * @param \Diba\Tree\Node $node El nodo a establecer.
     * @return \Diba\Tree\Node El nodo previo, si existía.
     * @throws \OutOfBoundsException
     * Si el índice está fuera de rango.
     */
    public function set($index, INode $node)
    {
        $previousNode = $this->offsetGet($index);
        $this->nodes[$index] = $node;
        
        return $previousNode;
    }
    
    /**
     * Establece el nodo padre para todos los nodos de ésta colección.
     * 
     * @param \Diba\Tree\Node $node El nodo padre.
     * @return bool Verdadero si la ejecución ha cambiado a los nodos.
     */
    public function setParent(INode $node)
    {
        // Manipular hasta 3 nodos manualmente
        switch (count($this->nodes)) {
            case 0:
                return false;
                break;
            case 1:
                $this->nodes[0]->setParent($node);
                break;
            case 2:
                $this->nodes[0]->setParent($node);
                $this->nodes[1]->setParent($node);
                break;
            case 3:
                $this->nodes[0]->setParent($node);
                $this->nodes[1]->setParent($node);
                $this->nodes[2]->setParent($node);
                break;
            default:
                foreach ($this->nodes as $childNode) {
                    $childNode->setParent($node);
                }
                break;
        }
        
        return true;
    }
    
    /**
     * Establece el comparador, y devuelve el anterior.
     * 
     * @param callable|int $comparator El callable o integer "flags".
     * @return callable|int
     * @throws \InvalidArgumentException
     * Cuando el argumento $comparator no es de tipo callable o integer.
     */
    public function setComparator($comparator)
    {
        if (is_callable($comparator) || is_int($comparator)) {
            $previousComparator = $this->comparator;
            $this->comparator = $comparator;
            
            return $previousComparator;
        } else {
            throw new InvalidArgumentException(sprintf(
                'Invalid $comparator type: callable/int expected, %s given',
                gettype($comparator)
            ));
        }
    }
    
    /**
     * Ordena los nodos de acuerdo al comparador establecido.
     * 
     * @return void
     */
    public function sort()
    {
        if (is_callable($this->comparator)) {
            usort($this->nodes, $this->comparator);
        } else {
            sort($this->nodes, $this->comparator);
        }
    }
}
 

(Continúa en comentarios)

[Nisrokh]

Diba\GenericTree\TableTreeOptions

Código PHP:

<?php
 
/**
 * @author Diego P. M. Baltar <[email protected]>
 * @copyright (c) 2013
 * @package Diba
 * @subpackage GenericTree
 */
namespace Diba\GenericTree;
 
use Diba\Tree\Node as INode;
use Diba\Tree\NodeList as INodeList;
use InvalidArgumentException;
 
/**
 * Opciones utilizdas por una instancia de \Diba\GenericTree\TableTree.
 */
class TableTreeOptions
{
    /**
     * El comparador utilizado para ordenar los nodos, o "flags" utlizados por
     * la función usort().
     * 
     * @see \Diba\GenericTree\NodeList::getComparator()
     * @see \Diba\GenericTree\NodeList::sort()
     * 
     * @var callable|int
     */
    private $comparator;
    
    /**
     * Nombre de la clave del id de entrada.
     * 
     * @var string
     */
    private $idKey;
    
    /**
     * Nombre de la clave del id padre de entrada.
     * 
     * @var string
     */
    private $parentIdKey;
    
    /**
     * Constructor
     * 
     * @param string $idKey Clave de entrada del id.
     * @param string $parentIdKey Clave de entrada del id padre.
     * @param callable|int $comparator El comparador de nodos.
     * @return \Diba\GenericTree\TableTreeOptions
     * @throws \InvalidArgumentException
     * Cuando los argumentos $idKey y/o $parentIdKey no son de tipo string.
     * @throws \InvalidArgumentException
     * Cuando el argumento $comparator no es de tipo callable o integer.
     */
    public function __construct(
        $idKey = 'id',
        $parentIdKey = 'parentId',
        $comparator = \SORT_REGULAR
    ) {
        $this->setComparator($comparator);
        $this->setIdKey($idKey);
        $this->setParentIdKey($parentIdKey);
    }
    
    /**
     * Devuelve el comparador establecido.
     * 
     * @return callable|int
     */
    public function getComparator()
    {
        return $this->comparator;
    }
    
    /**
     * Devuelve el nombre de la clave id establecida.
     * 
     * @return string
     */
    public function getIdKey()
    {
        return $this->idKey;
    }
    
    /**
     * Devuelve el nombre de la clave id padre establecida.
     * 
     * @return string
     */
    public function getParentIdKey()
    {
        return $this->parentIdKey;
    }
    
    /**
     * Establece el comparador, y devuelve el anterior.
     * 
     * @param callable|int $comparator El nuevo comparador.
     * @return callable|int
     * @throws \InvalidArgumentException
     * Cuando el argumento $comparator no es de tipo callable o integer.
     */
    public function setComparator($comparator)
    {
        if (is_callable($comparator) || is_int($comparator)) {
            $previousComparator = $this->comparator;
            $this->comparator = $comparator;
            
            return $previousComparator;
        } else {
            throw new InvalidArgumentException(sprintf(
                'Invalid $comparator type: callable/int expected, %s given',
                gettype($comparator)
            ));
        }
    }
    
    /**
     * Establece el nombre de la clave del id, y devuelve el anterior.
     * 
     * @param string $name La nueva clave del id.
     * @return string
     * @throws \InvalidArgumentException
     * Cuando el argumento $name no es de tipo string.
     */
    public function setIdKey($name)
    {
        if (!is_string($name)) {
            throw new InvalidArgumentException(sprintf(
                'Invalid $name type: string expected, %s given',
                gettype($name)
            ));
        }
        
        $previousIdKey = $this->idKey;
        $this->idKey = $name;
        
        return $previousIdKey;
    }
    
    /**
     * Establece el nombre de la clave del id padre, y devuelve el anterior.
     * 
     * @param string $name La nueva clave del id padre.
     * @return string
     * @throws \InvalidArgumentException
     * Cuando el argumento $name no es de tipo string.
     */
    public function setParentIdKey($name)
    {
        if (!is_string($name)) {
            throw new InvalidArgumentException(sprintf(
                'Invalid $name type: string expected, %s given',
                gettype($name)
            ));
        }
        
        $previousParentIdKey = $this->parentIdKey;
        $this->parentIdKey = $name;
        
        return $previousParentIdKey;
    }
}
 

(Continúa en comentarios)

[Nisrokh]

Diba\GenericTree\TableTree

Código PHP:

<?php
 
/**
 * @author Diego P. M. Baltar <[email protected]>
 * @copyright (c) 2013
 * @package Diba
 * @subpackage GenericTree
 */
namespace Diba\GenericTree;
 
use Diba\Tree\Node as INode;
use Diba\Tree\NodeList as INodeList;
 
/**
 * Implementación genérica de un árbol, construída desde una tabla.
 */
class TableTree extends Node
{
    /**
     * Mapa de nodos por su id.
     * 
     * @var array
     */
    protected $nodes = [];
    
    /**
     * Opciones de entrada y salida.
     * 
     * @var \Diba\GenericTree\TableTreeOptions
     */
    protected $options;
    
    /**
     * Mapa de colección de nodos "huérfanos" por su id de padre, es decir,
     * aquellos que deberían tener un padre pero no fue encontrado.
     * 
     * @var array
     */
    protected $orphans = [];
    
    /**
     * Constructor
     * 
     * @param \Diba\GenericTree\TableTreeOptions $options
     * Opciones de entrada y salida.
     * @return \Diba\GenericTree\TableTree
     */
    public function __construct(TableTreeOptions $options = null)
    {
        if ($options === null) {
            $this->options = new TableTreeOptions();
        } else {
            $this->options = $options;
        }
    }
    
    /**
     * Construye el árbol desde una tabla.
     * 
     * @todo Detectar errores recursivos.
     * @todo Detectar multiples ubicaciones (en un mísmo grupo).
     * 
     * @param array $table La tabla de datos.
     * @param bool $sort Indica si los nodos deben ser ordenados.
     * @return bool Verdadero si el árbol ha cambiado.
     */
    public function build(array $table, $sort = false)
    {
        if (empty($table)) {
            return false;
        }
        
        // Acceso corto a los nombres de las claves de los ids de entrada
        $idKey = $this->options->getIdKey();
        $parentIdKey = $this->options->getParentIdKey();
        
        // Datos temporales
        $onHold = [];            // The "on hold" list
        $onHoldChildren = [];    // Children on hold nodes
        $onHoldChildrenMap = []; // Children on hold map
        $sortableChildren = [];  // Children that should be sorted
        
        // Agregar el árbol en sí, al mapa de nodos bajo el id "0"
        $this->nodes[0] = $this;
        
        // Construir árbol
        foreach ($table as $index => $row) {
            // Forzar fila hacia un array, para obtener los ids
            $row = (array) $row;
            $nodeId = $row[$idKey];
            $nodeParentId = $row[$parentIdKey];
            
            // Ignorar filas con clave "0"
            if ((int) $nodeId === 0) {
                continue;
            }
            
            // Crear nodo
            $node = new Node($table[$index]);
            
            // Indica si el nodo padre del nodo actual está en espera
            $parentIsOnHold = false;
            
            // ¿Se ha encontrado ya el nodo padre de este nodo?
            if (isset($this->nodes[$nodeParentId])) {
                $parent = $this->nodes[$nodeParentId];
            } elseif (isset($onHold[$nodeParentId])) {
                $onHoldKey = $onHold[$nodeParentId];
                $parent = $onHoldChildrenMap[$onHoldKey][$nodeParentId];
                $parentIsOnHold = true;
            } elseif (isset($parent)) {
                unset($parent);
            }
            
            // Dar nodo a su padre (si éste ha sido encontrado)
            if (isset($parent)) {
                $parentChildren = $parent->getChildren();
                // Establecer el nodo padre y agregar sus hijos
                $node->setParent($parent);
                $parentChildren->add($node);
                
                if ($parentIsOnHold) {
                    // Agregar nodo al mapa de lista de espera
                    $onHold[$nodeId] = $onHold[$nodeParentId];
                    $onHoldChildrenMap[$onHold[$nodeId]][$nodeId] = $node;
                } else {
                    // Agregar nodo al mapa final
                    $this->nodes[$nodeId] = $node;
                }
                
                // Agregar nodos hijos para ordenar, sólo si es necesario
                if ($sort && $parentChildren->count() > 1
                        && !isset($sortableChildren[$nodeParentId])) {
                    $sortableChildren[$nodeParentId] = $parentChildren;
                }
            } else {
                // Agregar nodo a la lista de espera
                $onHold[$nodeId] = $nodeParentId;
                
                if (!isset($onHoldChildren[$nodeParentId])) {
                    $onHoldChildren[$nodeParentId] = new NodeList();
                }
                
                if (!isset($onHoldChildrenMap[$nodeParentId])) {
                    $onHoldChildrenMap[$nodeParentId] = [];
                }
                
                // Agregar el nodo al mapa de lista de espera
                $onHoldChildren[$nodeParentId]->add($node);
                $onHoldChildrenMap[$nodeParentId][$nodeId] = $node;
            }
            
            // ¿És este nodo el padre de alguno de los nodos en espera?
            if (isset($onHoldChildren[$nodeId])) {
                $nodeChildren = $node->getChildren();
                
                // Establecer el nodo padre, y agregar a sus hijos
                $onHoldChildren[$nodeId]->setParent($node);
                $nodeChildren->merge($onHoldChildren[$nodeId]);
                
                // Agregar nodos al mapa final
                $this->nodes+= $onHoldChildrenMap[$nodeId];
                
                // Borrar referencias del nodo hacia la lista de espera
                unset($onHoldChildren[$nodeId]);
                unset($onHoldChildrenMap[$nodeId]);
                
                // Agregar nodos hijos para ordenar, sólo si es necesario
                if ($sort && $nodeChildren->count() > 1
                        && !isset($sortableChildren[$nodeId])) {
                    $sortableChildren[$nodeId] = $nodeChildren;
                }
            }
        }
        
        // Obtener los nodos "huérfanos", donde su parent_id != 0 pero de todas
        // maneras no ha sido encontrado
        if (!empty($onHoldChildren)) {
            $this->orphans = $onHoldChildren;
        }
        
        // Ordenar los nodos, sólo si es necesario
        if (!empty($sortableChildren)) {
            foreach ($sortableChildren as $unsortedChildren) {
                $unsortedChildren->setComparator(
                    $this->options->getComparator()
                );
                $unsortedChildren->sort();
            }
        }
        
        return true;
    }
    
    /**
     * Devuelve un nodo obtenido por su id.
     * 
     * @param scalar $id El id del nodo a buscar.
     * @return \Diba\Tree\Node|null
     */
    public function getNodeById($id)
    {
        $id = (string) $id;
        $node = null;
        
        if (isset($this->nodes[$id])) {
            $node = $this->nodes[$id];
        }
        
        return $node;
    }
    
    /**
     * Devuelve la instancia de las opciones de entrada y salida.
     * 
     * @return \Diba\GenericTree\TableTreeOptions
     */
    public function getOptions()
    {
        return $this->options;
    }
    
    /**
     * Devuelve una colección de nodos "huérfanos", agrupados por el id de su
     * padre (no encontrado).
     * 
     * @return array
     */
    public function getOrphans()
    {
        return $this->orphans;
    }
    
    /**
     * Reestablece el árbol.
     * 
     * @return void
     * @override \Diba\GenericTree\Node::reset()
     */
    public function reset()
    {
        $this->nodes = [];
        $this->orphans = [];
        
        parent::reset();
    }
    
    /**
     * Establece las opciones de entrada y salida, y devuelve las anteriores.
     * 
     * @param \Diba\GenericTree\TableTreeOptions $options
     * La nueva instancia de las opciones de entrada y salida.
     * @return \Diba\GenericTree\TableTreeOptions
     */
    public function setOptions(TableTreeOptions $options)
    {
        $previousOptions = $this->options;
        $this->options = $options;
        
        return $previousOptions;
    }
}
 

(Continúa en comentarios)

[Nisrokh]

Ahora, un ejemplo igual al anterior, pero con el código orientado a objetos:

Nota: sólo por si acaso, les comento que me gusta utilizar siempre "camelCase" en código orientado a objetos y clases, y con guión bajo en funciones. Por eso mísmo, notar ésta diferencia: en las opciones por defecto de la función, utilizan guión bajo, y en la orientada a objetos, "camelCase" (por eso el alias en la consulta).

Código PHP:

<?php
 
use Diba\GenericTree\Node;
use Diba\GenericTree\NodeList;
use Diba\GenericTree\TableTree;
use Diba\GenericTree\TableTreeOptions;
use Diba\GenericTree\TableTreeHelper;
 
// MySQL info.
define('MYSQL_HOSTNAME', 'localhost');
define('MYSQL_USERNAME', 'root');
define('MYSQL_PASSWORD', '123456');
define('MYSQL_DATABASE', 'test');
 
// Crear conexión
try {
    $sqlConnection = new PDO(
        'mysql:dbname=' .MYSQL_DATABASE. ';host=' .MYSQL_HOSTNAME,
        MYSQL_USERNAME,
        MYSQL_PASSWORD
    );
} catch (PDOException $e) {
    exit(sprintf(
        'Database connection error: %s', $e->getMessage()
    ));
}
 
$sqlConnection->query('SET NAMES \'utf8\'');
 
// Obtener todas las filas del grupo "0"
$sqlQuery = '
    SELECT
        links.id,
        links.name,
        links_hierarchy.group_id AS groupId,
        links_hierarchy.parent_id AS parentId,
        links_hierarchy.order_no AS orderNo
    FROM links
    INNER JOIN links_hierarchy
        ON links_hierarchy.link_id = links.id
    WHERE links_hierarchy.group_id = :group
        AND links.id > 0
';
 
// Crear "statement"
$sqlStatement = $sqlConnection->prepare($sqlQuery);
$sqlStatement->bindValue(':group', 0, PDO::PARAM_INT);
$sqlStatement->execute();
 
// Obtener los resultados
$sqlResult = $sqlStatement->fetchAll(PDO::FETCH_OBJ);
 
// Aplicar shuffle() sólo para demostrarles que no importa el orden, el árbol
// siempre se construirá normalmente
shuffle($sqlResult);
 
// Crear árbol desde la tabla de datos
$treeOptions = new TableTreeOptions();
$treeOptions->setIdKey('id');
$treeOptions->setParentIdKey('parentId');
$treeOptions->setComparator(function($a, $b) {
    $a = $a->getValue()->name;
    $b = $b->getValue()->name;
    
    return strcasecmp($a, $b);
});
 
$tree = new TableTree($treeOptions);
$tree->build($sqlResult, true);
 

Bueno, eso es todo amigos... Espero que les sea útil y les haya gustado.

Les dejo un ejemplo online donde implementé el código con un menú (jQuery Sooperfish Menu Plugin), un breadcrumb, y algo similar a un "Tree View" (jQuery Nested Sortable Plugin) para administrar las ubicaciones con un simple "Drag and Drop":

http://test.dpmbaltar.com.ar/tree/ex...procedural.php

¡Hasta luego!

[Nisrokh]

Les indico un error que recién me doy cuenta... En la clase Diba\GenericTree\TableTreeOptions, las variables de la clase deberían tener los siguientes valores por defecto:

Código PHP:

// ...
    private $comparator = \SORT_REGULAR;
    private $idKey = 'id';
    private $parentIdKey = 'parentId';
    // ...
 

Y ejemplos que me faltaron en la versión orientada a objetos:

Código PHP:

// Obtener el nodo con el id "24"
$node = $tree->getNodeById(24);
// Obtener el nodo padre
$parentNode = $node->getParent();
// Obtener el nodo padre, del nodo padre
$parentNodeParent = $node->getParent()->getParent();
// Obtener el nodo hijo no. 3, suponiendo que existe
$childNode3 = $node->getChildren()->get(2);
// Obtener el valor del nodo (la fila original, obtenida de la consulta SQL)
$nodeValue = $node->getValue();
 

Mis disculpas y saludos.

[carlos_belisario]

creo que sería un poco más visible ver el aporte en un repo como github de manera que pueda jugarse con los directorios, ver autoload, etc, etc, etc y es mas simple de contribuir y hacerle clone si esta en el tiempo de algún dev de aqui (no lo mire lo suficiente como para darte una opinión por eso no me vez diciendote ningún disparáte )
saludos

[Nisrokh]

Gracias por tu comentario, crearé el repositorio en Git.

[dashtrash]

Aparte de opiniones estilisticas (si una clase tiene exactamente el mismo nombre que un interface, es que no existe ese interface), cargar *todos* los elementos de un árbol, reconstruirlo en memoria, para devolver un nodo, o la lista de nodos hijos directos de un nodo...
Obtener 1 nodo , o sus hijos directos, se consigue con 1 query, sin necesidad de una clase que reconstruya el árbol entero en memoria.
Incluso para alguna operación más, con arrays se puede crear el código equivalente en unas 4 o 5 líneas.(pista: si el select ya va ordenado por nodo-padre, campo-por-el-que-ordenar-hijos), no es necesario sort, usort,etc).

Por otro lado,si te ha funcionado es porque la tabla que utilizas, tiene sólo unos cuantos elementos.Por eso puedes hacer un select + inner join de toda la tabla.
Supón que la tabla tiene 1 millón de filas.

De todo lo que he visto sobre árboles, especialmente en base de datos, (y hay algún libro exclusivamente dedicado a cómo implementar árboles en SQL) lo que mejor me ha funcionado es mantener el path completo desde el root, hasta el nodo, en un campo de la tabla.

[Erick_MD9]

Hola, me gusta tu aporte, felicidades.

Le veo un buen potencial de uso genral y reuso.

En lo personal me gusta el uso del "Adjacency List Model" para variables de aplicaciones creadas por el usuario.
Tienes un buen modelo para hacer comparaciones de uso vs "The Nested Set Model".

Es importante que atiendas el concepto completo desde el nodo, no desde el grupo, asi evitaras un uso inecesario de memoria y con ello podras incrementar la flexibilidad y funcionalidad.

Saludos.

[EderBarriosCamargo]

Me gustaría saber el repositorio en Git Para Probar algunas cosas, lo veo bien, solo puedo decir eso.

Gracias por el aprote.