many thanks and have a nice week-end!

alex

I’m also belong to nested set model. I’m working with tons of hierarchical data in the database and i have decided to use the nested set model. But as Mukul told that traversal of node in nested set model is very expensive and so performance bottleneck.

So then i tried to find the nested set model with large gap. The above bottleneck is because of the integer that a node represent for left and right. So,if i keep the longer gap between these two terms then it may solve the problem.

Will anybody know about how to implement this kind of gap in nested set model ?

A little help is appreciated.

thanks in advance

Regards
Web-farmer
@Letsnurture

i doubt about performance and integrity what if one wrong update happens

I don’t know whether this page will help you…

http://www.ibase.ru/devinfo/DBMSTrees/sqltrees.html

If you go down to the bottom of the page, there’s an algorithm that converts from adjacent to nested sets. I haven’t used it myself, so I won’t be shed any more light on it. I think it’s designed to work with the example in that page, so if you follow that through it might shed some light on it!

Hope it helps.

Anyhow, I ran into an issue when adding a node. I try using the separate queries for adding nodes to nodes with no children, and adding nodes to nodes with children, and found that using the query that was designed to be used with childless nodes works for all cases, whereas the other seems to bump the node up the hierarchy regardless of where it’s used.

It’s no problem for me, but I thought it might save some head scratching for others!

SELECT parent.name
FROM nested_category2 AS node,
nested_category2 AS parent
WHERE node.lft BETWEEN parent.lft AND parent.rgt
AND node.name = ‘FLASH’
ORDER BY parent.rgt DESC

I just did a different order by and it seems to be working

Everything goes cool, because of my mysql version, now im having nightmares trying to pass the following subselect to joins, any help is welcome:

SELECT node.name, (COUNT(parent.name) – (sub_tree.depth + 1)) AS depth
FROM nested_category AS node,
nested_category AS parent,
nested_category AS sub_parent,
(
SELECT node.name, (COUNT(parent.name) – 1) AS depth
FROM nested_category AS node,
nested_category AS parent
WHERE node.lft BETWEEN parent.lft AND parent.rgt
AND node.name = ‘PORTABLE ELECTRONICS’
GROUP BY node.name
ORDER BY node.lft
)AS sub_tree
WHERE node.lft BETWEEN parent.lft AND parent.rgt
AND node.lft BETWEEN sub_parent.lft AND sub_parent.rgt
AND sub_parent.name = sub_tree.name
GROUP BY node.name
HAVING depth

thanks for an excellent article

I have been reading a lot of Celko’s stuff also but the one thing that isn’t really answered with concrete numbers is what happens with update times when your table grows very large.
Say we have a couple of million records and each time an insert is done on the table, we need to update roughly half the table on average with the new right values.
Any ideas about the performance hit on the table? especially when we’re also doing lots of select operations from numerous clients at the same time…
It seems to me that this might really cripple the performance of a site using this system.

I’m also very interested in benchmarks or speed estimates concerning the difference in nested sets that are very deep compared to nested sets that are very wide.

thanks for any input!

As I’m trying to figure out what the best system might be for some sort of online ‘create a million storylines’ application where anyone can create a story in a collaborative environment, but can pick up the story at any node, there is need for both quick selects and many updates. and with a potentially exponentially growing number of nodes, performance becomes an issue very rapidly. The architecture of this system is therefore of essential value to me.

If I find out anything usefull I will post back here, but in the mean time I’m very curious of your thoughts or findings on this subject.