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.

Thanks for the reply.
I hacked through it a bit as I am new to MySQL but it’s working now.

When I execute your indentation query on your ‘Finding the depths of the nodes’ section, I get the following error message:

Illegal mix of collations (utf8_general_ci,COERCIBLE) and (latin1_swedish_ci,IMPLICIT) for operation ‘concat’

Can you help me? I think the problems lies with the REPEAT function because if you remove it, the query executes (but the result is of-course not what we are trying to get.)

Thank You.