From 651030a3d7b44e0f448f860f6cccc1b0eff26ac6 Mon Sep 17 00:00:00 2001 From: Bruce Momjian Date: Thu, 7 Dec 2023 19:36:52 -0500 Subject: [PATCH] doc, intagg: fix one-to-many mention to many-to-many Reported-by: Christophe Courtois Discussion: https://postgr.es/m/aa7cfd73-0d8d-596a-b684-39faa479afa5@dalibo.com Author: Christophe Courtois Backpatch-through: master --- doc/src/sgml/intagg.sgml | 42 ++++++++++++++++++++++------------------ 1 file changed, 23 insertions(+), 19 deletions(-) diff --git a/doc/src/sgml/intagg.sgml b/doc/src/sgml/intagg.sgml index 44a766eb4b..29e74ce146 100644 --- a/doc/src/sgml/intagg.sgml +++ b/doc/src/sgml/intagg.sgml @@ -54,20 +54,22 @@ Sample Uses - Many database systems have the notion of a one to many table. Such a table + Many database systems have the notion of a many to many table. Such a table usually sits between two indexed tables, for example: -CREATE TABLE left (id INT PRIMARY KEY, ...); -CREATE TABLE right (id INT PRIMARY KEY, ...); -CREATE TABLE one_to_many(left INT REFERENCES left, right INT REFERENCES right); +CREATE TABLE left_table (id INT PRIMARY KEY, ...); +CREATE TABLE right_table (id INT PRIMARY KEY, ...); +CREATE TABLE many_to_many(id_left INT REFERENCES left_table, + id_right INT REFERENCES right_table); It is typically used like this: -SELECT right.* from right JOIN one_to_many ON (right.id = one_to_many.right) - WHERE one_to_many.left = item; +SELECT right_table.* +FROM right_table JOIN many_to_many ON (right_table.id = many_to_many.id_right) +WHERE many_to_many.id_left = item; This will return all the items in the right hand table for an entry @@ -76,7 +78,7 @@ SELECT right.* from right JOIN one_to_many ON (right.id = one_to_many.right) Now, this methodology can be cumbersome with a very large number of - entries in the one_to_many table. Often, + entries in the many_to_many table. Often, a join like this would result in an index scan and a fetch for each right hand entry in the table for a particular left hand entry. If you have a very dynamic system, there is not much you @@ -85,9 +87,9 @@ SELECT right.* from right JOIN one_to_many ON (right.id = one_to_many.right) CREATE TABLE summary AS - SELECT left, int_array_aggregate(right) AS right - FROM one_to_many - GROUP BY left; + SELECT id_left, int_array_aggregate(id_right) AS rights + FROM many_to_many + GROUP BY id_left; This will create a table with one row per left item, and an array @@ -95,33 +97,35 @@ CREATE TABLE summary AS the array; that's why there is an array enumerator. You can do -SELECT left, int_array_enum(right) FROM summary WHERE left = item; +SELECT id_left, int_array_enum(rights) FROM summary WHERE id_left = item; The above query using int_array_enum produces the same results as -SELECT left, right FROM one_to_many WHERE left = item; +SELECT id_left, id_right FROM many_to_many WHERE id_left = item; The difference is that the query against the summary table has to get only one row from the table, whereas the direct query against - one_to_many must index scan and fetch a row for each entry. + many_to_many must index scan and fetch a row for each entry. On one system, an EXPLAIN showed a query with a cost of 8488 was reduced to a cost of 329. The original query was a join involving the - one_to_many table, which was replaced by: + many_to_many table, which was replaced by: -SELECT right, count(right) FROM - ( SELECT left, int_array_enum(right) AS right - FROM summary JOIN (SELECT left FROM left_table WHERE left = item) AS lefts - ON (summary.left = lefts.left) +SELECT id_right, count(id_right) FROM + ( SELECT id_left, int_array_enum(rights) AS id_right + FROM summary + JOIN (SELECT id FROM left_table + WHERE id = item) AS lefts + ON (summary.id_left = lefts.id) ) AS list - GROUP BY right + GROUP BY id_right ORDER BY count DESC;