agora inbox for pgsql-hackers@postgresql.org
help / color / mirror / Atom feed[PATCH v52 02/10] Rename cluster.c/h -> repack.c/h
480+ messages / 2 participants
[nested] [flat]
* [PATCH v52 02/10] Rename cluster.c/h -> repack.c/h
@ 2026-03-31 16:55 Álvaro Herrera <alvherre@kurilemu.de>
0 siblings, 0 replies; 480+ messages in thread
From: Álvaro Herrera @ 2026-03-31 16:55 UTC (permalink / raw)
---
src/backend/commands/Makefile | 2 +-
src/backend/commands/matview.c | 2 +-
src/backend/commands/meson.build | 2 +-
src/backend/commands/{cluster.c => repack.c} | 6 +++---
src/backend/commands/tablecmds.c | 2 +-
src/backend/commands/vacuum.c | 6 +++---
src/backend/storage/ipc/procsignal.c | 1 +
src/backend/tcop/postgres.c | 1 +
src/backend/tcop/utility.c | 2 +-
src/include/commands/{cluster.h => repack.h} | 12 ++++++------
10 files changed, 19 insertions(+), 17 deletions(-)
rename src/backend/commands/{cluster.c => repack.c} (99%)
rename src/include/commands/{cluster.h => repack.h} (90%)
diff --git a/src/backend/commands/Makefile b/src/backend/commands/Makefile
index c10fdba2bbb..fe1bba3a9b9 100644
--- a/src/backend/commands/Makefile
+++ b/src/backend/commands/Makefile
@@ -18,7 +18,6 @@ OBJS = \
amcmds.o \
analyze.o \
async.o \
- cluster.o \
collationcmds.o \
comment.o \
constraint.o \
@@ -51,6 +50,7 @@ OBJS = \
proclang.o \
propgraphcmds.o \
publicationcmds.o \
+ repack.o \
schemacmds.o \
seclabel.o \
sequence.o \
diff --git a/src/backend/commands/matview.c b/src/backend/commands/matview.c
index d3be8939011..5db4fe75dce 100644
--- a/src/backend/commands/matview.c
+++ b/src/backend/commands/matview.c
@@ -24,8 +24,8 @@
#include "catalog/namespace.h"
#include "catalog/pg_am.h"
#include "catalog/pg_opclass.h"
-#include "commands/cluster.h"
#include "commands/matview.h"
+#include "commands/repack.h"
#include "commands/tablecmds.h"
#include "commands/tablespace.h"
#include "executor/executor.h"
diff --git a/src/backend/commands/meson.build b/src/backend/commands/meson.build
index 90c7e37a429..f624aae74af 100644
--- a/src/backend/commands/meson.build
+++ b/src/backend/commands/meson.build
@@ -6,7 +6,6 @@ backend_sources += files(
'amcmds.c',
'analyze.c',
'async.c',
- 'cluster.c',
'collationcmds.c',
'comment.c',
'constraint.c',
@@ -39,6 +38,7 @@ backend_sources += files(
'proclang.c',
'propgraphcmds.c',
'publicationcmds.c',
+ 'repack.c',
'schemacmds.c',
'seclabel.c',
'sequence.c',
diff --git a/src/backend/commands/cluster.c b/src/backend/commands/repack.c
similarity index 99%
rename from src/backend/commands/cluster.c
rename to src/backend/commands/repack.c
index f241e18b153..20f0a572236 100644
--- a/src/backend/commands/cluster.c
+++ b/src/backend/commands/repack.c
@@ -1,6 +1,6 @@
/*-------------------------------------------------------------------------
*
- * cluster.c
+ * repack.c
* REPACK a table; formerly known as CLUSTER. VACUUM FULL also uses
* parts of this code.
*
@@ -10,7 +10,7 @@
*
*
* IDENTIFICATION
- * src/backend/commands/cluster.c
+ * src/backend/commands/repack.c
*
*-------------------------------------------------------------------------
*/
@@ -33,9 +33,9 @@
#include "catalog/pg_am.h"
#include "catalog/pg_inherits.h"
#include "catalog/toasting.h"
-#include "commands/cluster.h"
#include "commands/defrem.h"
#include "commands/progress.h"
+#include "commands/repack.h"
#include "commands/tablecmds.h"
#include "commands/vacuum.h"
#include "miscadmin.h"
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 0ce2e81f9c2..e2882a50b3b 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -57,10 +57,10 @@
#include "catalog/storage.h"
#include "catalog/storage_xlog.h"
#include "catalog/toasting.h"
-#include "commands/cluster.h"
#include "commands/comment.h"
#include "commands/defrem.h"
#include "commands/event_trigger.h"
+#include "commands/repack.h"
#include "commands/sequence.h"
#include "commands/tablecmds.h"
#include "commands/tablespace.h"
diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c
index 0ed363d1c85..b179b62b5c8 100644
--- a/src/backend/commands/vacuum.c
+++ b/src/backend/commands/vacuum.c
@@ -9,7 +9,7 @@
*
* VACUUM for heap AM is implemented in vacuumlazy.c, parallel vacuum in
* vacuumparallel.c, ANALYZE in analyze.c, and VACUUM FULL is a variant of
- * CLUSTER, handled in cluster.c.
+ * REPACK, handled in repack.c.
*
*
* Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
@@ -38,9 +38,9 @@
#include "catalog/pg_database.h"
#include "catalog/pg_inherits.h"
#include "commands/async.h"
-#include "commands/cluster.h"
#include "commands/defrem.h"
#include "commands/progress.h"
+#include "commands/repack.h"
#include "commands/vacuum.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
@@ -2293,7 +2293,7 @@ vacuum_rel(Oid relid, RangeVar *relation, VacuumParams params,
if ((params.options & VACOPT_VERBOSE) != 0)
cluster_params.options |= CLUOPT_VERBOSE;
- /* VACUUM FULL is a variant of REPACK; see cluster.c */
+ /* VACUUM FULL is a variant of REPACK; see repack.c */
cluster_rel(REPACK_COMMAND_VACUUMFULL, rel, InvalidOid,
&cluster_params);
/* cluster_rel closes the relation, but keeps lock */
diff --git a/src/backend/storage/ipc/procsignal.c b/src/backend/storage/ipc/procsignal.c
index 7e017c8d53b..7cef6e43661 100644
--- a/src/backend/storage/ipc/procsignal.c
+++ b/src/backend/storage/ipc/procsignal.c
@@ -19,6 +19,7 @@
#include "access/parallel.h"
#include "commands/async.h"
+#include "commands/repack.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "port/pg_bitutils.h"
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index 10be60011ad..9fbaa5c00f0 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -39,6 +39,7 @@
#include "commands/event_trigger.h"
#include "commands/explain_state.h"
#include "commands/prepare.h"
+#include "commands/repack.h"
#include "common/pg_prng.h"
#include "jit/jit.h"
#include "libpq/libpq.h"
diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c
index 2b609bfc824..5f8c766c4be 100644
--- a/src/backend/tcop/utility.c
+++ b/src/backend/tcop/utility.c
@@ -26,7 +26,6 @@
#include "catalog/toasting.h"
#include "commands/alter.h"
#include "commands/async.h"
-#include "commands/cluster.h"
#include "commands/collationcmds.h"
#include "commands/comment.h"
#include "commands/conversioncmds.h"
@@ -46,6 +45,7 @@
#include "commands/proclang.h"
#include "commands/propgraphcmds.h"
#include "commands/publicationcmds.h"
+#include "commands/repack.h"
#include "commands/schemacmds.h"
#include "commands/seclabel.h"
#include "commands/sequence.h"
diff --git a/src/include/commands/cluster.h b/src/include/commands/repack.h
similarity index 90%
rename from src/include/commands/cluster.h
rename to src/include/commands/repack.h
index d6b62c747e8..85061158b0c 100644
--- a/src/include/commands/cluster.h
+++ b/src/include/commands/repack.h
@@ -1,17 +1,17 @@
/*-------------------------------------------------------------------------
*
- * cluster.h
- * header file for postgres cluster command stuff
+ * repack.h
+ * header file for the REPACK command
*
* Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
* Portions Copyright (c) 1994-5, Regents of the University of California
*
- * src/include/commands/cluster.h
+ * src/include/commands/repack.h
*
*-------------------------------------------------------------------------
*/
-#ifndef CLUSTER_H
-#define CLUSTER_H
+#ifndef REPACK_H
+#define REPACK_H
#include "nodes/parsenodes.h"
#include "parser/parse_node.h"
@@ -52,4 +52,4 @@ extern void finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
MultiXactId cutoffMulti,
char newrelpersistence);
-#endif /* CLUSTER_H */
+#endif /* REPACK_H */
--
2.47.3
--gp2pyozrd5pweboh
Content-Type: text/x-diff; charset=utf-8
Content-Disposition: attachment;
filename="v52-0003-Add-CONCURRENTLY-option-to-REPACK-command.patch"
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
* [PATCH v1 1/1] expand refint docs with usage info
@ 2026-05-26 16:46 Nathan Bossart <nathan@postgresql.org>
0 siblings, 0 replies; 480+ messages in thread
From: Nathan Bossart @ 2026-05-26 16:46 UTC (permalink / raw)
---
doc/src/sgml/contrib-spi.sgml | 58 ++++++++++++++++++++++++++++++++++-
1 file changed, 57 insertions(+), 1 deletion(-)
diff --git a/doc/src/sgml/contrib-spi.sgml b/doc/src/sgml/contrib-spi.sgml
index 6fa9479d1b9..7e4e580bc74 100644
--- a/doc/src/sgml/contrib-spi.sgml
+++ b/doc/src/sgml/contrib-spi.sgml
@@ -34,6 +34,14 @@
key mechanism, of course, but the module is still useful as an example.)
</para>
+ <note>
+ <para>
+ <filename>refint</filename> requires a
+ <link linkend="ddl-schemas-patterns">secure schema usage pattern</link> and
+ data types where the equality operator is named <literal>=</literal>.
+ </para>
+ </note>
+
<para>
<function>check_primary_key()</function> checks the referencing table.
To use, create an <literal>AFTER INSERT OR UPDATE</literal> trigger using this
@@ -44,6 +52,29 @@
keys, create a trigger for each reference.
</para>
+ <note>
+ <para>
+ The <emphasis>referenced</emphasis> table name and column name arguments to
+ <function>check_primary_key()</function> are copied as-is into internally
+ generated SQL statements and therefore must be double-quoted by the user as
+ necessary in the <command>CREATE TRIGGER</command> command. See
+ <xref linkend="sql-syntax-identifiers"/> for more information about quoting
+ SQL identifiers. Conversely, the <emphasis>referencing</emphasis> table
+ column name arguments should not be double quoted. See the following mock
+ example of proper use of <function>check_primary_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER INSERT OR UPDATE ON referencing_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_primary_key (
+ 'column A', 'column B', -- referencing table columns
+ 'myschema."referenced table"', -- referenced table
+ '"column A"', '"column B"' -- referenced table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
<function>check_foreign_key()</function> checks the referenced table.
To use, create an <literal>AFTER DELETE OR UPDATE</literal> trigger using this
@@ -53,13 +84,38 @@
(<literal>cascade</literal> — to delete the referencing row,
<literal>restrict</literal> — to abort transaction if referencing keys
exist, <literal>setnull</literal> — to set referencing key fields to null),
- the triggered table's column names which form the primary/unique key, then
+ the referenced table's column names which form the primary/unique key, then
the referencing table name and column names (repeated for as many
referencing tables as were specified by first argument). Note that the
primary/unique key columns should be marked NOT NULL and should have a
unique index.
</para>
+ <note>
+ <para>
+ The <emphasis>referencing</emphasis> table name and column name arguments
+ to <function>check_foreign_key()</function> are copied as-is into
+ internally generated SQL statements and therefore must be double-quoted by
+ the user as necessary in the <command>CREATE TRIGGER</command> command.
+ See <xref linkend="sql-syntax-identifiers"/> for more information about
+ quoting SQL identifiers. Conversely, the <emphasis>referenced</emphasis>
+ table column name arguments should not be double quoted. See the following
+ mock example of proper use of <function>check_foreign_key()</function>:
+<programlisting>
+CREATE TRIGGER mytrigger
+AFTER DELETE OR UPDATE ON referenced_table
+FOR EACH ROW EXECUTE PROCEDURE
+check_foreign_key (
+ 1, -- number of referencing tables
+ 'cascade', -- action
+ 'column A', 'column B', -- referenced table columns
+ 'myschema."referencing table"', -- referencing table
+ '"column A"', '"column B"' -- referencing table columns
+);
+</programlisting>
+ </para>
+ </note>
+
<para>
Note that if these triggers are executed from
another <literal>BEFORE</literal> trigger, they can fail unexpectedly. For
--
2.50.1 (Apple Git-155)
--3pMPqxRi+4qCFlgd--
^ permalink raw reply [nested|flat] 480+ messages in thread
end of thread, other threads:[~2026-05-26 16:46 UTC | newest]
Thread overview: 480+ messages (download: mbox mbox.gz follow: Atom feed)
-- links below jump to the message on this page --
2026-03-31 16:55 [PATCH v52 02/10] Rename cluster.c/h -> repack.c/h Álvaro Herrera <alvherre@kurilemu.de>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
2026-05-26 16:46 [PATCH v1 1/1] expand refint docs with usage info Nathan Bossart <nathan@postgresql.org>
This inbox is served by agora; see mirroring instructions
for how to clone and mirror all data and code used for this inbox