Python đệ quy lồng nhau
Nested List: [['A', 'B', 'C'], ['D', 'E', 'F']] Flattened List: ['A', 'B', 'C', 'D', 'E', 'F']6_______0_______7 # Python program to flatten a nested list 3# Python program to flatten a nested list 4# Python program to flatten a nested list 5# Python program to flatten a nested list 6# Python program to flatten a nested list 7# Python program to flatten a nested list 8 # Python program to flatten a nested list 9# Python program to flatten a nested list 6# explicit function to flatten a 1 Show
Nested List: [['A', 'B', 'C'], ['D', 'E', 'F']] Flattened List: ['A', 'B', 'C', 'D', 'E', 'F']8_______91_______5 # nested list 6# Python program to flatten a nested list 6def 0Nested List: [[1], [2], [3], [4], [5]] Flattened List: [1, 2, 3, 4, 5]07 def 0Nested List: [[1], [2], [3], [4], [5]] Flattened List: [1, 2, 3, 4, 5]09 def 0Nested List: [[1], [2], [3], [4], [5]] Flattened List: [1, 2, 3, 4, 5]11 def 0Nested List: [[1], [2], [3], [4], [5]] Flattened List: [1, 2, 3, 4, 5]13 def 8 WITH RECURSIVE included_parts(sub_part, part, quantity) AS ( SELECT sub_part, part, quantity FROM parts WHERE part = 'our_product' UNION ALL SELECT p.sub_part, p.part, p.quantity * pr.quantity FROM included_parts pr, parts p WHERE p.part = pr.sub_part ) SELECT sub_part, SUM(quantity) as total_quantity FROM included_parts GROUP BY sub_part2 cung cấp một cách để viết các câu lệnh phụ trợ để sử dụng trong một truy vấn lớn hơn. Các câu lệnh này, thường được gọi là Biểu thức bảng chung hoặc CTE, có thể được coi là xác định các bảng tạm thời chỉ tồn tại cho một truy vấn. Mỗi mệnh đề phụ trợ trong mệnh đề WITH RECURSIVE included_parts(sub_part, part, quantity) AS ( SELECT sub_part, part, quantity FROM parts WHERE part = 'our_product' UNION ALL SELECT p.sub_part, p.part, p.quantity * pr.quantity FROM included_parts pr, parts p WHERE p.part = pr.sub_part ) SELECT sub_part, SUM(quantity) as total_quantity FROM included_parts GROUP BY sub_part2 có thể là WITH RECURSIVE included_parts(sub_part, part, quantity) AS ( SELECT sub_part, part, quantity FROM parts WHERE part = 'our_product' UNION ALL SELECT p.sub_part, p.part, p.quantity * pr.quantity FROM included_parts pr, parts p WHERE p.part = pr.sub_part ) SELECT sub_part, SUM(quantity) as total_quantity FROM included_parts GROUP BY sub_part4, WITH RECURSIVE included_parts(sub_part, part, quantity) AS ( SELECT sub_part, part, quantity FROM parts WHERE part = 'our_product' UNION ALL SELECT p.sub_part, p.part, p.quantity * pr.quantity FROM included_parts pr, parts p WHERE p.part = pr.sub_part ) SELECT sub_part, SUM(quantity) as total_quantity FROM included_parts GROUP BY sub_part5, WITH RECURSIVE included_parts(sub_part, part, quantity) AS ( SELECT sub_part, part, quantity FROM parts WHERE part = 'our_product' UNION ALL SELECT p.sub_part, p.part, p.quantity * pr.quantity FROM included_parts pr, parts p WHERE p.part = pr.sub_part ) SELECT sub_part, SUM(quantity) as total_quantity FROM included_parts GROUP BY sub_part6 hoặc WITH RECURSIVE included_parts(sub_part, part, quantity) AS ( SELECT sub_part, part, quantity FROM parts WHERE part = 'our_product' UNION ALL SELECT p.sub_part, p.part, p.quantity * pr.quantity FROM included_parts pr, parts p WHERE p.part = pr.sub_part ) SELECT sub_part, SUM(quantity) as total_quantity FROM included_parts GROUP BY sub_part7; Công cụ sửa đổi WITH RECURSIVE search_tree(id, link, data) AS ( SELECT t.id, t.link, t.data FROM tree t UNION ALL SELECT t.id, t.link, t.data FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree;3 tùy chọn thay đổi WITH RECURSIVE included_parts(sub_part, part, quantity) AS ( SELECT sub_part, part, quantity FROM parts WHERE part = 'our_product' UNION ALL SELECT p.sub_part, p.part, p.quantity * pr.quantity FROM included_parts pr, parts p WHERE p.part = pr.sub_part ) SELECT sub_part, SUM(quantity) as total_quantity FROM included_parts GROUP BY sub_part2 từ một tiện ích cú pháp đơn thuần thành một tính năng hoàn thành những điều không thể có trong SQL tiêu chuẩn. Sử dụng WITH RECURSIVE search_tree(id, link, data) AS ( SELECT t.id, t.link, t.data FROM tree t UNION ALL SELECT t.id, t.link, t.data FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree;3, truy vấn WITH RECURSIVE included_parts(sub_part, part, quantity) AS ( SELECT sub_part, part, quantity FROM parts WHERE part = 'our_product' UNION ALL SELECT p.sub_part, p.part, p.quantity * pr.quantity FROM included_parts pr, parts p WHERE p.part = pr.sub_part ) SELECT sub_part, SUM(quantity) as total_quantity FROM included_parts GROUP BY sub_part2 có thể tham chiếu đến đầu ra của chính nó. Một ví dụ rất đơn giản là truy vấn này để tính tổng các số nguyên từ 1 đến 100 WITH RECURSIVE t(n) AS ( VALUES (1) UNION ALL SELECT n+1 FROM t WHERE n < 100 ) SELECT sum(n) FROM t; Dạng chung của truy vấn WITH RECURSIVE included_parts(sub_part, part, quantity) AS ( SELECT sub_part, part, quantity FROM parts WHERE part = 'our_product' UNION ALL SELECT p.sub_part, p.part, p.quantity * pr.quantity FROM included_parts pr, parts p WHERE p.part = pr.sub_part ) SELECT sub_part, SUM(quantity) as total_quantity FROM included_parts GROUP BY sub_part2 đệ quy luôn là một thuật ngữ không đệ quy, sau đó là WITH RECURSIVE search_tree(id, link, data) AS ( SELECT t.id, t.link, t.data FROM tree t UNION ALL SELECT t.id, t.link, t.data FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree;8 (hoặc WITH RECURSIVE search_tree(id, link, data) AS ( SELECT t.id, t.link, t.data FROM tree t UNION ALL SELECT t.id, t.link, t.data FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree;9), sau đó là thuật ngữ đệ quy, trong đó chỉ thuật ngữ đệ quy có thể chứa tham chiếu đến đầu ra của chính truy vấn. Một truy vấn như vậy được thực hiện như sau Đánh giá truy vấn đệ quy
Ghi chúMặc dù WITH RECURSIVE search_tree(id, link, data) AS ( SELECT t.id, t.link, t.data FROM tree t UNION ALL SELECT t.id, t.link, t.data FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree;3 cho phép các truy vấn được chỉ định theo cách đệ quy, nhưng bên trong các truy vấn đó được đánh giá lặp đi lặp lại Trong ví dụ trên, bảng làm việc chỉ có một hàng trong mỗi bước và nó nhận các giá trị từ 1 đến 100 trong các bước liên tiếp. Ở bước thứ 100, không có đầu ra do mệnh đề WITH RECURSIVE search_tree(id, link, data, path) AS ( SELECT t.id, t.link, t.data, ARRAY[t.id] FROM tree t UNION ALL SELECT t.id, t.link, t.data, path || t.id FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY path;5 và do đó truy vấn kết thúc Truy vấn đệ quy thường được sử dụng để xử lý dữ liệu có cấu trúc phân cấp hoặc cây. Một ví dụ hữu ích là truy vấn này để tìm tất cả các phần phụ trực tiếp và gián tiếp của một sản phẩm, chỉ cung cấp một bảng hiển thị các phần bao gồm ngay lập tức ________số 8_______Khi tính toán duyệt cây bằng truy vấn đệ quy, bạn có thể muốn sắp xếp các kết quả theo thứ tự chiều sâu hoặc chiều rộng trước. Điều này có thể được thực hiện bằng cách tính toán một cột thứ tự cùng với các cột dữ liệu khác và sử dụng cột đó để sắp xếp kết quả ở cuối. Lưu ý rằng điều này không thực sự kiểm soát thứ tự đánh giá truy vấn truy cập các hàng; . Cách tiếp cận này chỉ cung cấp một cách thuận tiện để sắp xếp các kết quả sau đó Để tạo thứ tự theo chiều sâu, chúng tôi tính toán cho mỗi hàng kết quả một mảng các hàng mà chúng tôi đã truy cập cho đến nay. Ví dụ, xem xét truy vấn sau tìm kiếm một bảng WITH RECURSIVE search_tree(id, link, data, path) AS ( SELECT t.id, t.link, t.data, ARRAY[t.id] FROM tree t UNION ALL SELECT t.id, t.link, t.data, path || t.id FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY path;6 bằng cách sử dụng trường WITH RECURSIVE search_tree(id, link, data, path) AS ( SELECT t.id, t.link, t.data, ARRAY[t.id] FROM tree t UNION ALL SELECT t.id, t.link, t.data, path || t.id FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY path;7 WITH RECURSIVE search_tree(id, link, data) AS ( SELECT t.id, t.link, t.data FROM tree t UNION ALL SELECT t.id, t.link, t.data FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree; Để thêm thông tin đặt hàng theo chiều sâu, bạn có thể viết cái này WITH RECURSIVE search_tree(id, link, data, path) AS ( SELECT t.id, t.link, t.data, ARRAY[t.id] FROM tree t UNION ALL SELECT t.id, t.link, t.data, path || t.id FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY path; Trong trường hợp chung khi cần sử dụng nhiều trường để xác định một hàng, hãy sử dụng một mảng các hàng. Ví dụ: nếu chúng tôi cần theo dõi các trường WITH RECURSIVE search_tree(id, link, data, path) AS ( SELECT t.id, t.link, t.data, ARRAY[t.id] FROM tree t UNION ALL SELECT t.id, t.link, t.data, path || t.id FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY path;8 và WITH RECURSIVE search_tree(id, link, data, path) AS ( SELECT t.id, t.link, t.data, ARRAY[t.id] FROM tree t UNION ALL SELECT t.id, t.link, t.data, path || t.id FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY path;9 WITH RECURSIVE search_tree(id, link, data, path) AS ( SELECT t.id, t.link, t.data, ARRAY[ROW(t.f1, t.f2)] FROM tree t UNION ALL SELECT t.id, t.link, t.data, path || ROW(t.f1, t.f2) FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY path; MẹoBỏ qua cú pháp WITH RECURSIVE search_tree(id, link, data, path) AS ( SELECT t.id, t.link, t.data, ARRAY[ROW(t.f1, t.f2)] FROM tree t UNION ALL SELECT t.id, t.link, t.data, path || ROW(t.f1, t.f2) FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY path;0 trong trường hợp phổ biến khi chỉ cần theo dõi một trường. Điều này cho phép sử dụng một mảng đơn giản thay vì một mảng kiểu hỗn hợp, đạt được hiệu quả Để tạo thứ tự tìm kiếm theo chiều rộng, bạn có thể thêm một cột theo dõi độ sâu của tìm kiếm chẳng hạn WITH RECURSIVE search_tree(id, link, data, depth) AS ( SELECT t.id, t.link, t.data, 0 FROM tree t UNION ALL SELECT t.id, t.link, t.data, depth + 1 FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY depth; Để sắp xếp ổn định, hãy thêm các cột dữ liệu làm cột sắp xếp phụ MẹoThuật toán đánh giá truy vấn đệ quy tạo ra kết quả của nó theo thứ tự tìm kiếm theo chiều rộng. Tuy nhiên, đây là một chi tiết triển khai và có lẽ không hợp lý khi dựa vào nó. Thứ tự của các hàng trong mỗi cấp chắc chắn không được xác định, do đó, một số thứ tự rõ ràng có thể được mong muốn trong mọi trường hợp Có cú pháp tích hợp để tính toán cột sắp xếp theo chiều sâu hoặc chiều rộng. Ví dụ WITH RECURSIVE search_tree(id, link, data) AS ( SELECT t.id, t.link, t.data FROM tree t UNION ALL SELECT t.id, t.link, t.data FROM tree t, search_tree st WHERE t.id = st.link ) SEARCH DEPTH FIRST BY id SET ordercol SELECT * FROM search_tree ORDER BY ordercol; WITH RECURSIVE search_tree(id, link, data) AS ( SELECT t.id, t.link, t.data FROM tree t UNION ALL SELECT t.id, t.link, t.data FROM tree t, search_tree st WHERE t.id = st.link ) SEARCH BREADTH FIRST BY id SET ordercol SELECT * FROM search_tree ORDER BY ordercol; Cú pháp này được mở rộng nội bộ thành một cái gì đó tương tự như các biểu mẫu viết tay ở trên. Mệnh đề WITH RECURSIVE search_tree(id, link, data, path) AS ( SELECT t.id, t.link, t.data, ARRAY[ROW(t.f1, t.f2)] FROM tree t UNION ALL SELECT t.id, t.link, t.data, path || ROW(t.f1, t.f2) FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY path;1 chỉ định tìm kiếm đầu tiên theo chiều sâu hay chiều rộng, danh sách các cột cần theo dõi để sắp xếp và tên cột sẽ chứa dữ liệu kết quả có thể được sử dụng để sắp xếp. Cột đó sẽ được thêm hoàn toàn vào các hàng đầu ra của CTE Khi làm việc với các truy vấn đệ quy, điều quan trọng là phải đảm bảo rằng phần đệ quy của truy vấn cuối cùng sẽ không trả về bộ dữ liệu nào, nếu không, truy vấn sẽ lặp vô thời hạn. Đôi khi, sử dụng WITH RECURSIVE search_tree(id, link, data) AS ( SELECT t.id, t.link, t.data FROM tree t UNION ALL SELECT t.id, t.link, t.data FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree;8 thay vì WITH RECURSIVE search_tree(id, link, data) AS ( SELECT t.id, t.link, t.data FROM tree t UNION ALL SELECT t.id, t.link, t.data FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree;9 có thể thực hiện việc này bằng cách loại bỏ các hàng trùng lặp các hàng đầu ra trước đó. Tuy nhiên, thường thì một chu kỳ không liên quan đến các hàng đầu ra hoàn toàn trùng lặp. có thể chỉ cần kiểm tra một hoặc một vài trường để xem liệu điểm tương tự đã đạt được trước đó chưa. Phương pháp tiêu chuẩn để xử lý các tình huống như vậy là tính toán một mảng các giá trị đã truy cập. Ví dụ, hãy xem xét lại truy vấn sau tìm kiếm một bảng WITH RECURSIVE search_tree(id, link, data, path) AS ( SELECT t.id, t.link, t.data, ARRAY[ROW(t.f1, t.f2)] FROM tree t UNION ALL SELECT t.id, t.link, t.data, path || ROW(t.f1, t.f2) FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY path;4 bằng cách sử dụng trường WITH RECURSIVE search_tree(id, link, data, path) AS ( SELECT t.id, t.link, t.data, ARRAY[t.id] FROM tree t UNION ALL SELECT t.id, t.link, t.data, path || t.id FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY path;7 WITH RECURSIVE search_graph(id, link, data, depth) AS ( SELECT g.id, g.link, g.data, 0 FROM graph g UNION ALL SELECT g.id, g.link, g.data, sg.depth + 1 FROM graph g, search_graph sg WHERE g.id = sg.link ) SELECT * FROM search_graph; Truy vấn này sẽ lặp lại nếu mối quan hệ WITH RECURSIVE search_tree(id, link, data, path) AS ( SELECT t.id, t.link, t.data, ARRAY[t.id] FROM tree t UNION ALL SELECT t.id, t.link, t.data, path || t.id FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY path;7 chứa chu trình. Bởi vì chúng tôi yêu cầu đầu ra "độ sâu", chỉ cần thay đổi WITH RECURSIVE search_tree(id, link, data) AS ( SELECT t.id, t.link, t.data FROM tree t UNION ALL SELECT t.id, t.link, t.data FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree;9 thành WITH RECURSIVE search_tree(id, link, data) AS ( SELECT t.id, t.link, t.data FROM tree t UNION ALL SELECT t.id, t.link, t.data FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree;8 sẽ không loại bỏ vòng lặp. Thay vào đó, chúng ta cần nhận ra liệu chúng ta có quay lại cùng một hàng hay không khi đi theo một đường liên kết cụ thể. Chúng tôi thêm hai cột WITH RECURSIVE search_tree(id, link, data, path) AS ( SELECT t.id, t.link, t.data, ARRAY[ROW(t.f1, t.f2)] FROM tree t UNION ALL SELECT t.id, t.link, t.data, path || ROW(t.f1, t.f2) FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY path;9 và WITH RECURSIVE search_tree(id, link, data, depth) AS ( SELECT t.id, t.link, t.data, 0 FROM tree t UNION ALL SELECT t.id, t.link, t.data, depth + 1 FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY depth;0 vào truy vấn dễ bị lặp WITH RECURSIVE search_graph(id, link, data, depth, is_cycle, path) AS ( SELECT g.id, g.link, g.data, 0, false, ARRAY[g.id] FROM graph g UNION ALL SELECT g.id, g.link, g.data, sg.depth + 1, g.id = ANY(path), path || g.id FROM graph g, search_graph sg WHERE g.id = sg.link AND NOT is_cycle ) SELECT * FROM search_graph; Ngoài việc ngăn chặn các chu kỳ, giá trị mảng thường hữu ích theo cách riêng của nó khi đại diện cho “đường dẫn” được thực hiện để đến bất kỳ hàng cụ thể nào Trong trường hợp chung khi cần kiểm tra nhiều trường để nhận ra một chu kỳ, hãy sử dụng một mảng các hàng. Ví dụ: nếu chúng tôi cần so sánh các trường WITH RECURSIVE search_tree(id, link, data, path) AS ( SELECT t.id, t.link, t.data, ARRAY[t.id] FROM tree t UNION ALL SELECT t.id, t.link, t.data, path || t.id FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY path;8 và WITH RECURSIVE search_tree(id, link, data, path) AS ( SELECT t.id, t.link, t.data, ARRAY[t.id] FROM tree t UNION ALL SELECT t.id, t.link, t.data, path || t.id FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY path;9 WITH RECURSIVE search_graph(id, link, data, depth, is_cycle, path) AS ( SELECT g.id, g.link, g.data, 0, false, ARRAY[ROW(g.f1, g.f2)] FROM graph g UNION ALL SELECT g.id, g.link, g.data, sg.depth + 1, ROW(g.f1, g.f2) = ANY(path), path || ROW(g.f1, g.f2) FROM graph g, search_graph sg WHERE g.id = sg.link AND NOT is_cycle ) SELECT * FROM search_graph; MẹoBỏ qua cú pháp WITH RECURSIVE search_tree(id, link, data, path) AS ( SELECT t.id, t.link, t.data, ARRAY[ROW(t.f1, t.f2)] FROM tree t UNION ALL SELECT t.id, t.link, t.data, path || ROW(t.f1, t.f2) FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY path;0 trong trường hợp phổ biến khi chỉ cần kiểm tra một trường để nhận biết chu trình. Điều này cho phép sử dụng một mảng đơn giản thay vì một mảng kiểu hỗn hợp, đạt được hiệu quả Có cú pháp tích hợp để đơn giản hóa việc phát hiện chu kỳ. Truy vấn trên cũng có thể được viết như thế này WITH RECURSIVE included_parts(sub_part, part, quantity) AS ( SELECT sub_part, part, quantity FROM parts WHERE part = 'our_product' UNION ALL SELECT p.sub_part, p.part, p.quantity * pr.quantity FROM included_parts pr, parts p WHERE p.part = pr.sub_part ) SELECT sub_part, SUM(quantity) as total_quantity FROM included_parts GROUP BY sub_part0 và nó sẽ được viết lại nội bộ thành mẫu trên. Mệnh đề WITH RECURSIVE search_tree(id, link, data, depth) AS ( SELECT t.id, t.link, t.data, 0 FROM tree t UNION ALL SELECT t.id, t.link, t.data, depth + 1 FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY depth;4 trước tiên chỉ định danh sách các cột cần theo dõi để phát hiện chu kỳ, sau đó là tên cột sẽ hiển thị liệu một chu kỳ đã được phát hiện hay chưa và cuối cùng là tên của một cột khác sẽ theo dõi đường dẫn. Các cột chu trình và đường dẫn sẽ được thêm hoàn toàn vào các hàng đầu ra của CTE MẹoCột đường chu trình được tính theo cách tương tự như cột thứ tự ưu tiên độ sâu hiển thị trong phần trước. Một truy vấn có thể có cả mệnh đề WITH RECURSIVE search_tree(id, link, data, path) AS ( SELECT t.id, t.link, t.data, ARRAY[ROW(t.f1, t.f2)] FROM tree t UNION ALL SELECT t.id, t.link, t.data, path || ROW(t.f1, t.f2) FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY path;1 và mệnh đề WITH RECURSIVE search_tree(id, link, data, depth) AS ( SELECT t.id, t.link, t.data, 0 FROM tree t UNION ALL SELECT t.id, t.link, t.data, depth + 1 FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY depth;4, nhưng đặc tả tìm kiếm theo chiều sâu đầu tiên và đặc tả phát hiện chu trình sẽ tạo ra các tính toán dư thừa, do đó, sẽ hiệu quả hơn nếu chỉ sử dụng mệnh đề WITH RECURSIVE search_tree(id, link, data, depth) AS ( SELECT t.id, t.link, t.data, 0 FROM tree t UNION ALL SELECT t.id, t.link, t.data, depth + 1 FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY depth;4 và sắp xếp theo cột đường dẫn. Nếu muốn đặt hàng theo chiều rộng trước, thì việc chỉ định cả WITH RECURSIVE search_tree(id, link, data, path) AS ( SELECT t.id, t.link, t.data, ARRAY[ROW(t.f1, t.f2)] FROM tree t UNION ALL SELECT t.id, t.link, t.data, path || ROW(t.f1, t.f2) FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY path;1 và WITH RECURSIVE search_tree(id, link, data, depth) AS ( SELECT t.id, t.link, t.data, 0 FROM tree t UNION ALL SELECT t.id, t.link, t.data, depth + 1 FROM tree t, search_tree st WHERE t.id = st.link ) SELECT * FROM search_tree ORDER BY depth;4 có thể hữu ích Một thủ thuật hữu ích để kiểm tra các truy vấn khi bạn không chắc liệu chúng có thể lặp hay không là đặt một ____________0 trong truy vấn gốc. Ví dụ: truy vấn này sẽ lặp mãi nếu không có WITH RECURSIVE search_tree(id, link, data) AS ( SELECT t.id, t.link, t.data FROM tree t UNION ALL SELECT t.id, t.link, t.data FROM tree t, search_tree st WHERE t.id = st.link ) SEARCH DEPTH FIRST BY id SET ordercol SELECT * FROM search_tree ORDER BY ordercol; WITH RECURSIVE search_tree(id, link, data) AS ( SELECT t.id, t.link, t.data FROM tree t UNION ALL SELECT t.id, t.link, t.data FROM tree t, search_tree st WHERE t.id = st.link ) SEARCH BREADTH FIRST BY id SET ordercol SELECT * FROM search_tree ORDER BY ordercol;0 WITH RECURSIVE included_parts(sub_part, part, quantity) AS ( SELECT sub_part, part, quantity FROM parts WHERE part = 'our_product' UNION ALL SELECT p.sub_part, p.part, p.quantity * pr.quantity FROM included_parts pr, parts p WHERE p.part = pr.sub_part ) SELECT sub_part, SUM(quantity) as total_quantity FROM included_parts GROUP BY sub_part1 Điều này hiệu quả vì quá trình triển khai của PostgreSQL chỉ đánh giá số lượng hàng của truy vấn WITH RECURSIVE included_parts(sub_part, part, quantity) AS ( SELECT sub_part, part, quantity FROM parts WHERE part = 'our_product' UNION ALL SELECT p.sub_part, p.part, p.quantity * pr.quantity FROM included_parts pr, parts p WHERE p.part = pr.sub_part ) SELECT sub_part, SUM(quantity) as total_quantity FROM included_parts GROUP BY sub_part2 như thực tế được tìm nạp bởi truy vấn gốc. Không nên sử dụng thủ thuật này trong sản xuất vì các hệ thống khác có thể hoạt động khác. Ngoài ra, nó thường không hoạt động nếu bạn thực hiện truy vấn bên ngoài sắp xếp kết quả của truy vấn đệ quy hoặc nối chúng với một số bảng khác, bởi vì trong những trường hợp như vậy, truy vấn bên ngoài thường sẽ cố gắng tìm nạp tất cả đầu ra của truy vấn WITH RECURSIVE included_parts(sub_part, part, quantity) AS ( SELECT sub_part, part, quantity FROM parts WHERE part = 'our_product' UNION ALL SELECT p.sub_part, p.part, p.quantity * pr.quantity FROM included_parts pr, parts p WHERE p.part = pr.sub_part ) SELECT sub_part, SUM(quantity) as total_quantity FROM included_parts GROUP BY sub_part2 |