On top of that - if you’re just loading it all in with a single query, and THEN transferring it to an array, don’t you lose the advantage of using mysql in the first place (that is, allowing you to use their methods for sorting and filtering)? Seems like you’d be reinventing the wheel.

Lastly - if you’re going to just load everything up all at once - why not just store the whole mess as a serialized array in a single field in the database? Then, at the very least, you could keep yourself from doing all that looping and sorting when you pulled the info out.

This whole thing is a mess. I need very simple hierarchy for about 350 items. Because of some other circumstances, the adjacency method is too slow. I find myself trying to wrap my head around MPTTA just for this? Ugh. Surely there is a simpler way.

1. Preface
2. Fruits
2.1 Apple
2.2 Pear
2.3 Some Very Exotic stuff that make you puke

eeee …. - why you call it a chandler method? it’s a simple nested-numerated list been around before the computer was invented …

what do you want to patent next? scratching your back?

this is why i greet European parliament for voting against software patents in EU.

Actually, no mather the hype, it’s pretty simple. You “improve” the recursive method by taking out the database overhead (the cornerstone of any critics on the recursive method - tooo many querys).

do only one query to database and select ALL THE TREE, store in array and use recursrion there. so query everything and parse it to a array like this

$mytree[parent] = array([item_id]=>1, …)

in other words - two dimensional tree where first level array has parent_id as key, and second level array has item id as array key.

important thing to note is, that you must order the data from database by parent, so the first element is root - eg $mytree[0]

after that it’s really easy to use recursion in order to display data…

why ? because (IMHO) what the recursive method provides, that most other methods lack - it is very hard to break the rock-solid parent_id > child_id relations. You have to do something really dumb to mess it up.

example is a cutout from a class, maybe it illustrates the idea better the i can explain. basically you emulate the database parent>child relation in a code level - and you do only one query.

private function loadTreeData()
{
$sql = ‘SELECT *FROM ‘.$this->tblTreeItems .’
WHERE tree_id = \”.(INT)$this->treeId.’\’
ORDER BY item_parent_id, item_sequence_number ASC
‘;
$this->db->execQuery($sql);
return $this->db->fetchAll(’item_id’);

}

private function processTreeData()
{
if (is_array($this->treeDataRaw)) {
foreach ($this->treeDataRaw AS $key => $value)
{
$this->treeDataArray[$value['item_parent_id']][$key] = $value;
}

}

}
protected function hasChildren($parent_id)
{
if (array_key_exists($parent_id, $this->treeDataArray)) {
return true;
}
else
{
return false;
}
}

protected function getChildren($parent_id)
{
return $this->treeDataArray[$parent_id];
}

/* recursive ul/li list for debugging */
public function printUlList($parent_id)
{
print ”;
if ($this->hasChildren($parent_id)) {
$children = $this->getChildren($parent_id);
foreach ($children AS $child)
{
print ”.$child['item_name'].”;
$this->printUlList($child['item_id']);
}

}
print ”;

}