Sélectionnez tous les parents ou enfants dans la même relation de table SQL Server

SQL développeurs, j'ai un mal programmé de la base de données de la tâche à apprendre beaucoup de choses sur SQL Server 2012.

DONC, il y a la table Elem:

+-----------+----+---+----------+------------+
|VERSION(PK)|NAME|KEY|PARENT_KEY|DIST_KEY(FK)|
+-----------+----+---+----------+------------+
|1          |a   |12 |NULL      |1           |
+-----------+----+---+----------+------------+
|2          |b   |13 |12        |1           |
+-----------+----+---+----------+------------+
|3          |c   |14 |13        |1           |
+-----------+----+---+----------+------------+
|4          |d   |15 |12        |1           |
+-----------+----+---+----------+------------+
|5          |e   |16 |NULL      |1           |
+-----------+----+---+----------+------------+
|6          |e   |17 |NULL      |2           |
+-----------+----+---+----------+------------+

Après la mise à jour de la ligne j'ai besoin de vérifier la clé de parent de l'élément à ne pas permettre à l'élément d'être soi-grand-mère ou quelque chose..

Et quand je supprime la ligne j'ai besoin de supprimer tous les enfants et les enfants des enfants, etc.

Questions sont les suivantes:

Comment puis-je sélectionner tout "parent + un grand-parent + etc" d'un élément de DIST?
Comment puis-je sélectionne tous les "fils + les petits-fils de + etc" d'un élément de DIST?

J'ai lu sur des solutions avec CTE, mais je n'ai aucune racine d'éléments et je ne peux même pas comprendre comment je peux l'utiliser CTE ensuite.

S'il vous plaît, à l'aide!

Grâce.

source d'informationauteur Khronos

J'ai rencontré ce problème，j'ai résolu le problème par cette voie

 --all  "parent + grandparent + etc" @childID Replaced with the ID you need

with tbParent as
(
   select * from Elem where [KEY]=@childID
   union all
   select Elem.* from Elem  join tbParent  on Elem.[KEY]=tbParent.PARENT_KEY
)
 SELECT * FROM  tbParent
 --all "sons + grandsons + etc" @parentID Replaced with the ID you need

with tbsons as
(
  select * from Elem where [KEY]=@parentID
  union all
  select Elem.* from Elem  join tbsons  on Elem.PARENT_KEY=tbsons.[KEY]
)
SELECT * FROM tbsons

PS.Mon anglais n'est pas bon.

voici une requête récursive vous donnant à la fois tous les ancêtres et tous les descendants d'un élément. Utiliser ces ensemble ou séparés en fonction de la situation. Remplacer les clauses where pour obtenir le dossier désiré. Dans cet exemple, je suis à la recherche de la clé de 13 (c'est l'élément nom = b), et à trouver son ancêtre 12/a, et son descendant 14/c.

with all_ancestors(relation, version, name, elem_key, parent_key, dist_key)
as 
(
  -- the record itself
  select 'self      ' as relation, self.version, self.name, self.elem_key, self.parent_key, self.dist_key
  from elem self
  where elem_key = 13
  union all
  -- all its ancestors found recursively
  select 'ancestor  ' as relation, parent.version, parent.name, parent.elem_key, parent.parent_key, parent.dist_key
  from elem parent
  join all_ancestors child on parent.elem_key = child.parent_key
)
, all_descendants(relation, version, name, elem_key, parent_key, dist_key)
as 
(
  -- the record itself
  select 'self      ' as relation, self.version, self.name, self.elem_key, self.parent_key, self.dist_key
  from elem self
  where elem_key = 13
  union all
  -- all its descendants found recursively
  select 'descendant' as relation, child.version, child.name, child.elem_key, child.parent_key, child.dist_key
  from elem child
  join all_descendants parent on parent.elem_key = child.parent_key
)
select * from all_ancestors
union
select * from all_descendants
order by elem_key
;

Voici le SQL violon: http://sqlfiddle.com/#!6/617ee/28.

J'ai créé une fonction pour trouver les parents d'un enfant en particulier où vous devez passer l'Id de l'enfant.

Ce sera le retour de la liste des parents comme une chaîne séparée par des virgules.
Essayez ceci si cela fonctionne pour vous.

Je suis en supposant que le parent_key with null value est la racine.

CREATE FUNCTION checkParent(@childId INT)
RETURNS VARCHAR(MAX)
AS
BEGIN
    DECLARE @parentId VARCHAR(MAX) = NULL
    DECLARE @parentKey INT = null
    SET @parentId = (SELECT parent_key FROM Elem WHERE [KEY] = @childId)

    WHILE(@parentKey IS NOT NULL)
    begin
        SET @parentId = @parentId +  ', ' + (SELECT parent_key FROM Elem WHERE [KEY] = @parentId)
        SET @parentKey = (SELECT parent_key FROM Elem WHERE [KEY] = @parentId)
    END
    RETURN @parentId
END
GO

0

Je ne pense pas que cela peut être fait en un select en tout cas ,de sorte que vous pouvez sélectionner tous les parents,grands-parents ,... . Une façon de le faire est de rejoindre elem table à elle-même ,et que cela dépend du nombre de niveaux de se joindre à vous faire , que le niveau de l'enfant,grandchilds vous allez obtenir.

La solution peut être somethink comme ceci(pour le second )

cela va pour vous sélectionner tous les parents,de l'enfant et grandchilds
```
Select 
parent.key as parent_key,
child.key as child_key,
grandchild.key as grandchild_key 
from elem parent 
join elem child on (elem.key=child.parentkey)
join elem grandchild on (child.key=grandchild.parentkey)
where parent.parentkey is null; -- this make you sure that first level will be parents
```
solution pour le premier cas, c'est juste que vous vous connectez tables pas dans le style de "key=parentkey" mais oppos 'parentkey=key'.

Vous devez vous connecter pour publier un commentaire.