Conjuntos MySQL aninhadas - Como encontrar a mãe do nó?

StackOverflow https://stackoverflow.com/questions/1602536

Pergunta

Eu tenho o seu funcionamento do moinho aninhado configuração set tipo de hierarquia com as seguintes colunas:

nome da tabela: 

myset

colunas: 

id, name, lft, rgt

Alguém sabe uma consulta para determinar o pai de um nó?

Eu li um par de lugares que é útil também ter um parent_id coluna na tabela para acompanhar isso, mas parece redundante e parece que ele poderia ficar fora de sincronia com a nested conjunto se uma consulta foi executada de forma incorrecta ao adicionar / remover / mover qualquer coisa dentro do conjunto.

Outras dicas

TOP é um comando MSSQL, limitar o uso para o MySQL: 

SELECT title, (SELECT title 
       FROM tree t2 
       WHERE t2.lft < t1.lft AND t2.rgt > t1.rgt    
       ORDER BY t2.rgt-t1.rgt ASC
       LIMIT 1) 
AS parent FROM tree t1 
ORDER BY (rgt-lft) DESC

Deve fazer o truque ..

apenas para acrescentar a estas respostas, que me ajudou muito,

Eu precisava encontrar o pai imediato de um nó, assim como o pai nível muito alto de uma cadeia nó em alguns casos,

Eu usei o seguinte como uma base para obter os itens em ordem de filho para pai 

SELECT parent.*  FROM
        nested_set node,
        nested_set parent
        WHERE (
            node.set_left BETWEEN parent.set_left AND parent.set_right          
        )
        AND node.set_id={CHILD_NODE_ID_HERE}
        ORDER BY parent.set_right - parent.set_left
        #LIMIT 1,1

é então uma questão de adicionar o LIMIT 1,1 para capturar apenas a segunda linha o que seria o pai imediato

também deve ser notado que, com a consulta acima, se o próprio nó é o pai nível muito alto, então ele não teria um pai imediato , assim com o LIMIT 1,1 ele deve retornar um resultado vazio set

para obter o pai nível muito superior i inverteu a ordem por cláusula, incluída uma verificação se o próprio nó é o topo pai, e limitou o resultado para a primeira linha 

SELECT parent.* AS top_level_right FROM
        nested_set node,
        nested_set parent
        WHERE (
            node.set_left >= parent.set_left 
            AND node.set_left <= parent.set_right
        )
        AND node.set_id={CHILD_NODE_ID_HERE}
        ORDER BY parent.set_left - parent.set_right
        LIMIT 1

na última consulta i utilizado operadores >= <= de modo que o intervalo selecionado engloba o nó filho se ele também passa a ser o pai de nível superior

Eu tive um problema com a consulta de Lucasz. Minha versão do mysql não entendia o comando TOP. Eu tive que usar LIMIT vez. Aqui está a revisão do código. 

SELECT 
   `id`, 
   (SELECT 
      `id`
    FROM 
       `[*** YOUR TABLE ***]` AS `t2` 
    WHERE 
       `t2`.`left_id`  < `t1`.`left_id`AND 
       `t2`.`right_id` > `t1`.`right_id`
    ORDER BY 
       `t2`.`right_id`-`t1`.`right_id`ASC 
    LIMIT 
       1) AS `parent`
FROM 
    `[*** YOUR TABLE ***]` AS `t1`
WHERE 
    `t1`.`id` = [*** ID OF THE NODE WHOS PARENT YOU WISH TO LOOKUP ***]
ORDER BY 
    `right_id`-`left_id` DESC

Obviamente, mudar as coisas no [] 's para atender às suas necessidades. remover também os '] s [. Esta consulta retorna apenas uma linha. Como assim ... 

id  parent
7   3

select * from myset
  where lft < :lftOfCurrent and rgt > :lftOfCurrent
  order lft desc
  limit 1

Você pode usar um máximo em vez de ordem / limite e você pode precisar de outra palavra-chave para limitar os resultados a uma linha dependendo do seu banco de dados. Entre em vez de iria funcionar se o seu banco de dados retorna o conjunto exclusivo, que MySQL não. 

SELECT parent.name 
FROM myset AS node, myset AS parent 
WHERE parent.lft < node.lft 
AND parent.rgt > node.rgt 
AND node.id = {YOUR CATEGORY ID} 
ORDER BY ( parent.rgt - parent.lft ) ASC LIMIT 1;

Todos os antepassados ??são retornados por 

SELECT id FROM thetable
WHERE x BETWEEN lft and rgt;

Então, o pai direto é o ancestral com a menor diferença entre LFT e rgt. 

SELECT id FROM thetable
WHERE x BETWEEN lft and rgt
ORDER BY (rgt-lft)
LIMIT 1

O código de spankmaster79 não estava completamente errado. I modificado seu código e funcionou. 

SELECT parent . * FROM Nested_Category AS node, Nested_Category AS parent 
enter code hereWHERE node.leftSide
BETWEEN parent.leftSide
AND parent.rightSide
AND node.id ='Enter the Node ID'
ORDER BY (
parent.rightSide - parent.leftSide
)
LIMIT 1 , 1
Não afiliado a StackOverflow
scroll top