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;