Est-il un moyen simple pour interroger les enfants d'un nœud?

J'ai été en utilisant la merde hors de l' Ensemble Imbriqué Modèle ces derniers temps. J'ai apprécié la conception de requêtes pour à peu près tous utile de fonctionnement et d'affichage. Une chose que je suis bloqué sur est de savoir comment choisir les enfants immédiats (et seulement les enfants, pas encore des descendants!) d'un nœud.

Pour être honnête, je ne sais d'une façon -, mais il implique ingérable quantités de SQL. Je suis sûr qu'il est plus simple solution.

OriginalL'auteur Metaphile | 2009-03-18

9

Avez-vous lu l'article que vous avez posté? C'est sous la rubrique "Trouver les Subordonnés Immédiats d'un Nœud"
```
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 <= 1
ORDER BY node.lft;
```
Cependant, ce que je fais (c'est de la triche) est j'ai combiné l'ensemble imbriqué avec les listes d'adjacence -- je intégrer un "parent_id" dans la table, donc je peux facilement demander pour les enfants d'un nœud.

"... J'ai combiné l'ensemble imbriqué avec les listes d'adjacence ..." Ha! C'est ce que je fais. Je rejoins un adj. affichage de la liste, basée sur une requête par Joe Celko. Il semble juste comme beaucoup de code. Même l'article lié la solution est ... verbose.
Je veux dire, de comparer la sélection tous les descendants d'un nœud: SÉLECTIONNEZ * à PARTIR des nœuds OÙ les nœuds.leftBound ENTRE parentLeftBound ET parentRightBound;
Eh bien, le "child_view" est assez simple, SÉLECTIONNEZ * à PARTIR des nœuds OÙ parent_id = 123456 😀
+1 pour "tricherie." Généralement lors de l'utilisation d'un ensemble imbriqué modèle de la requête est plus un souci que celui de la table bâtiment. J'ai trouvé que l'ajout de quelques autres choses comme ParentId, et de même Profondeur sont extrêmement utiles pour certains cas et ne coûte pas grand-chose à ajouter à la table de construire. Hybride ensemble imbriqué de contiguïté liste des tableaux sont superbes.

OriginalL'auteur Matt Rogish
7

Il me semble que ce devrait être facilement réalisable sans les sous-requêtes ou d'un parent de la colonne de la redondance! Par exemple, étant donné un parent de gauche et de droite sont déjà connus:
```
SELECT child.id
FROM nodes AS child
LEFT JOIN nodes AS ancestor ON
    ancestor.left BETWEEN @parentleft+1 AND @parentright-1 AND
    child.left BETWEEN ancestor.left+1 AND ancestor.right-1
WHERE
    child.left BETWEEN @parentleft+1 AND @parentright-1 AND
    ancestor.id IS NULL
```
Qui est, “de tous les descendants du nœud en question, choisir ceux avec aucun ancêtre n'entre elles et le nœud”.

Je me demande quelle réponse de meilleures performances, cette l'une ou l'acceptés post. Cependant, les deux solutions fonctionnent. Celui-ci semble un peu plus compact.
Pour les très grands arbres, nous avons trouvé que cela fonctionne mal dans MySQL et le pire dans SQL server, car il nécessite une boucle imbriquée pour être exécutées sur la base de données. Nous avons modifié notre code pour juste récupérer tous les descendants, puis tailler pour seulement les enfants dans notre code de l'application.
Ceci est très similaire à la accepté de répondre, la différence est qu'au lieu de compter les enfants et de filtrage pour ceux avec 1 enfant, il filtre de voir si ancêtre est NUL.. Qui signifie qu'il a moins de travail à faire (pas de tri et de comptage de l'étape). Il devrait être plus rapide, mais je ne l'ai pas testé.
Votre réponse semble répondre andreas (comparaison des méthodes), mais il ne l'est pas. Vous répondez sur l'utilisation de SQL en général d'obtenir les enfants.

OriginalL'auteur bobince
5

C'EST MIEUX ET PLUS PETITES

Utilisateur "bobince" est presque ça. J'ai compris et réussi à le faire fonctionner pour moi parce que j'ai un peu plus de MySQL expérience que la plupart. Cependant, je peux voir pourquoi bobince la réponse pourrait effrayer les gens. Sa requête est incomplète. Vous devez sélectionner le parent_left et parent_right dans mysql variables.

Les deux requêtes ci-dessous supposent que votre table est nommée tree, votre colonne de gauche est nommé lft, la colonne de droite est nommé rgt, et que votre clé primaire est nommé id. Modifier ces valeurs pour répondre à vos besoins. Aussi, examiner la première instruction select. Vous allez voir que je suis à la recherche les descendants immédiats de nœud 5. Changer le numéro 5 de regarder pour les enfants de ce nœud que vous voulez.

Personnellement, je pense que c'est une plus lisse, plus sexy, et le plus efficace de requête que les autres présentées jusqu'à présent.
```
SELECT `lft`, `rgt` INTO @parent_left, @parent_right FROM efm_files WHERE `id` = 5;
SELECT `child`.`id`
FROM `tree` AS `child`
LEFT JOIN `tree` AS `ancestor` ON
    `ancestor`.`lft` BETWEEN @parent_left+1 AND @parent_right-1 AND
    `child`.`lft` BETWEEN `ancestor`.`lft`+1 AND `ancestor`.`rgt`-1
WHERE
    `child`.`lft` BETWEEN @parent_left+1 AND @parent_right-1 AND
    `ancestor`.`id` IS NULL
```
Ce qui est efm_files?
efm_files est le nom d'une table dans ma base de données mysql. Le remplacer par votre propre nom de table de votre base de données.

OriginalL'auteur mrbinky3000
0

je sais im faire un nécro post,
mais voici mon avis.

pourquoi ne pas inclure une "profondeur" de la colonne dans votre ensemble imbriqué?
la profondeur de la colonne indique le "niveau" d'un élément.

donc, pour sélectionner l'immédiat de l'enfant d'un élément, il suffit de faire

select c.* from tree as p join tree as c on (c.left > p.left and c.right < p.right and c.depth = p.dept + 1) where p.id = @parentID

Parce que, à strictement parler, ce n'est plus un ensemble imbriqué, c'est une combinaison de modèles hiérarchiques. Et le plus souvent, de modifier le modèle pour résoudre un problème n'est pas une option.

OriginalL'auteur caydev2010

J'irais avec une profondeur de colonne, trop. Mais l'utilisation

SELECT Child.Node, Child.LEFT, Child.RIGHT
FROM Tree AS Child, Tree AS Parent
WHERE
        Child.Depth = Parent.Depth + 1
        AND Child.LEFT > Parent.LEFT
        AND Child.RIGHT < Parent.RIGHT
        AND Parent.LEFT = 1  -- Given Parent Node Left Index

Wikipédia

Notez qu'elle requiert supplémentaire profondeur le long de la colonne à gauche et à droite de l'Id.

OriginalL'auteur Valentin Klinghammer

J'ai trouvé Lien wikipédia a la bonne version réduite de réponse avec réponse sélectionnée.

SELECT DISTINCT Child.Name
FROM ModelTable AS Child, ModelTable AS Parent 
WHERE Parent.Lft < Child.Lft AND Parent.Rgt > Child.Rgt  -- associate Child Nodes with ancestors
GROUP BY Child.Name
HAVING MAX(Parent.Lft) = @parentId  -- Subset for those with the given Parent Node as the nearest ancestor

Et, tout de vous exprimer avec Linq, veuillez suivre le lien: https://stackoverflow.com/a/25594386/361100

OriginalL'auteur Youngjae

Vous devez vous connecter pour publier un commentaire.