Recupero lista collegata nel database MySQL

Question

Ho una tabella del database MySQL con questa struttura:

table 
    id INT NOT NULL PRIMARY KEY 
    data .. 
    next_id INT NULL 

ho bisogno di recuperare i dati in ordine di lista collegata. Ad esempio, in questi dati:

id | next_id 
----+--------- 
    1 |  2 
    2 |  4 
    3 |  9 
    4 |  3 
    9 | NULL 

ho bisogno di recuperare le righe per id = 1, 2, 4, 3, 9, in questo ordine. Come posso fare questo con una query del database? (Posso farlo sul lato client.Sono curioso se questo può essere fatto dal lato del database.Così, dicendo che è impossibile va bene (dato prova sufficiente)).

Sarebbe bello avere anche un punto di terminazione (ad es. Fermarsi dopo 10 recuperi o quando alcune condizioni della fila diventano vere) ma questo non è un requisito (può essere fatto dal lato client). Io (spero di farlo) non è necessario verificare i riferimenti circolari.

Answer 1

Alcune marche di database (ad esempio Oracle, Microsoft SQL Server) supportano la sintassi SQL aggiuntiva per eseguire "query ricorsive", ma MySQL non supporta alcuna soluzione di questo tipo.

Il problema che si sta descrivendo è lo stesso di una struttura ad albero in un database SQL. Hai solo un albero lungo e magro.

Esistono diverse soluzioni per la memorizzazione e il recupero di questo tipo di struttura dati da un RDBMS. Vedere alcune delle seguenti domande:

• "What is the most efficient/elegant way to parse a flat table into a tree?"
• "Is it possible to make a recursive SQL query ?"

---

Dal momento che si parla che si desidera limitare la "profondità" restituito dalla query, è possibile ottenere questo mentre interrogando l'elenco in questo modo:

SELECT * FROM mytable t1 
LEFT JOIN mytable t2 ON (t1.next_id = t2.id) 
LEFT JOIN mytable t3 ON (t2.next_id = t3.id) 
LEFT JOIN mytable t4 ON (t3.next_id = t4.id) 
LEFT JOIN mytable t5 ON (t4.next_id = t5.id) 
LEFT JOIN mytable t6 ON (t5.next_id = t6.id) 
LEFT JOIN mytable t7 ON (t6.next_id = t7.id) 
LEFT JOIN mytable t8 ON (t7.next_id = t8.id) 
LEFT JOIN mytable t9 ON (t8.next_id = t9.id) 
LEFT JOIN mytable t10 ON (t9.next_id = t10.id); 

Sarà perf Mi piace la melassa e il risultato tornerà tutto su una riga (per elenco collegato), ma otterrai il risultato.

Answer 2

Questa è meno una soluzione e più di una soluzione, ma, per una lista lineare (piuttosto che l'albero menzionato da Bill Karwin), potrebbe essere più efficiente utilizzare una colonna di ordinamento nel proprio elenco. Ad esempio:

TABLE `schema`.`my_table` (
    `id` INT NOT NULL PRIMARY KEY, 
    `order` INT, 
    data .., 
    INDEX `ix_order` (`sort_order` ASC) 
); 

Poi:

SELECT * FROM `schema`.`my_table` ORDER BY `order`; 

Questo ha lo svantaggio di inserti più lenti (bisogna riposizionare tutti gli elementi filtrate oltre il punto di inserimento) ma dovrebbe essere veloce per il recupero perché la colonna ordine è indicizzato.

Answer 3

Se ciò che si sta tentando di evitare è avere più query (una per ogni nodo) e si è in grado di aggiungere colonne, si potrebbe avere una nuova colonna che si collega al nodo radice. In questo modo è possibile inserire tutti i dati contemporaneamente dall'ID root, ma sarà comunque necessario ordinare l'elenco (o albero) sul lato client.

Quindi, in questo è caso si ha:

id | next_id | root_id 
----+---------+--------- 
    1 |  2 |  1 
    2 |  4 |  1 
    3 |  9 |  1 
    4 |  3 |  1 
    9 | NULL |  1 

Naturalmente lo svantaggio di questo al contrario di liste tradizionali legate o alberi è che la radice non può cambiare senza scrivere su un ordine di grandezza di O (n) dove n è il numero di nodi. Questo perché dovresti aggiornare l'id root per ogni nodo. Fortunatamente, dovresti sempre essere in grado di farlo in una singola query di aggiornamento, a meno che tu non stia dividendo un elenco/albero nel mezzo.