MIME-Version: 1.0
From: JoongHyuk Shin <sjh910805@gmail.com>
Date: Thu, 19 Mar 2026 14:40:05 +0900
Message-ID: 
 <CACSdjfO3f82rLGEwAG4WzyZ220NV1=QjNmZpwPGhX_yCe3mgeA@mail.gmail.com>
Subject: pg_dump: fix NOT NULL constraint name comparison using makeObjectName
To: pgsql-hackers@lists.postgresql.org
Content-Type: multipart/mixed; boundary="000000000000e12664064d5a00b1"
Archived-At: 
 <https://www.postgresql.org/message-id/CACSdjfO3f82rLGEwAG4WzyZ220NV1%3DQjNmZpwPGhX_yCe3mgeA%40mail.gmail.com>
Precedence: bulk

--000000000000e12664064d5a00b1
Content-Type: multipart/alternative; boundary="000000000000e12662064d5a00af"

--000000000000e12662064d5a00af
Content-Type: text/plain; charset="UTF-8"

pg_dump decides whether a domain's NOT NULL constraint was auto-generated
by comparing the stored constraint name against a simple
'<domainname>_not_null' string.  This comparison is wrong when the domain
name is longer than 54 bytes, because the server generates the name via
ChooseConstraintName -> makeObjectName, which truncates the domain name to
fit within NAMEDATALEN-1 (63 bytes).  pg_dump skips this truncation, so the
names never match, and it emits an explicit CONSTRAINT clause instead of
plain NOT NULL.

The consequence is a round-trip correctness bug.  When the domain name is
55 bytes, pg_dump emits:

  CONSTRAINT "<55bytes>_not_null" NOT NULL

The restore server receives a 64-byte name that exceeds the 63-byte Name
type limit and silently truncates it to "<55bytes>_not_nul" -- a different
name from the original "<54bytes>_not_null" that makeObjectName would have
produced.  Any DDL that references the original constraint name by string
(ALTER DOMAIN ... DROP CONSTRAINT ...) will then fail on the restored
database.

The same XXX comment and the same structural bug exist in the table column
NOT NULL comparison in getTableAttrs(), where the candidate name is built
as '<tablename>_<colname>_not_null'.

The root cause is that makeObjectName lives in src/backend/commands/
indexcmds.c and is not available to frontend code.  This patch fixes the
problem by:

1. Moving pg_encoding_mbcliplen from src/backend/utils/mb/mbutils.c to
   src/common/wchar.c.  Its dependencies (pg_wchar_table,
   pg_encoding_max_length, and a trivial cliplen helper) are already in
   src/common/wchar.c, so no backend infrastructure is required.

2. Moving makeObjectName from src/backend/commands/indexcmds.c to
   src/common/string.c, adding an 'encoding' parameter to replace the
   implicit GetDatabaseEncoding() call.  src/common/ is the right home for
   this function: it is already a collection of string helpers (strtoint,
   pg_clean_ascii, etc.), it links into both backend and frontend, and
   palloc() is available in frontend via the postgres_fe.h wrapper.

3. Updating all five backend call sites to pass GetDatabaseEncoding().

4. Adding an Archive.server_encoding field and populating it in
   setup_connection() via PQparameterStatus(conn, "server_encoding").
   The server encoding is used for truncation, not the client encoding
   stored in Archive.encoding.

5. Replacing the two XXX psprintf comparisons in pg_dump.c with direct
   calls to makeObjectName(name1, name2, "not_null", fout->server_encoding).

makeObjectName has historically lived in indexcmds.c for no particular
architectural reason -- it has no dependency on index infrastructure.
Moving it to src/common/ is a small cleanup that happens to be necessary
for this fix.

The patch is larger than the two-line conceptual fix, but the bulk of the
size is the mechanical function move (deletion from indexcmds.c, addition
to string.c) and the five backend call-site updates.  An inline
reimplementation in pg_dump was considered but rejected: the truncation
must respect multibyte character boundaries via pg_encoding_mbcliplen, and
duplicating that logic without a reference to the canonical implementation
risks silent divergence in future.

I considered whether the numeric-suffix case (_not_null1, _not_null2, ...)
should also be handled.  When a name collision exists in the same namespace,
ChooseConstraintName appends a pass counter to the label.  pg_dump would
still emit CONSTRAINT for those names.  For a round-trip restore into a
database where the same collision condition holds, the name is stored
verbatim and identity is preserved.  Restoring into a database without that
collision would produce a different constraint name, but that is a
pre-existing limitation shared by any collision-renamed object, not specific
to NOT NULL constraints.  This patch does not address that case.

Reproducer:

  CREATE DOMAIN aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa --
55 'a'
      AS integer NOT NULL;

  -- Server stores constraint name: aaaaaa...(54 a's)_not_null  (63 bytes)
  SELECT c.conname, length(c.conname)
  FROM pg_type t JOIN pg_constraint c ON c.contypid = t.oid
  WHERE t.typname LIKE 'aaa%' AND c.contype = 'n';

Before this patch, pg_dump emits:
  CONSTRAINT "aaaa...(55 a's)_not_null" NOT NULL

After this patch, pg_dump emits:
  NOT NULL

TAP tests are included in src/bin/pg_dump/t/002_pg_dump.pl for both
truncation cases: a 55-char domain name (domain_name + "_not_null" exceeds
NAMEDATALEN-1) and a 27-char table with a 27-char column (table_name + "_"
+ column_name + "_not_null" exceeds NAMEDATALEN-1).  Both cases verify that
pg_dump produces output without an explicit CONSTRAINT clause.

Patch attached.

--000000000000e12662064d5a00af
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr">pg_dump decides whether a domain&#39;s NOT NULL constraint=
 was auto-generated<br>by comparing the stored constraint name against a si=
mple<br>&#39;&lt;domainname&gt;_not_null&#39; string.=C2=A0 This comparison=
 is wrong when the domain<br>name is longer than 54 bytes, because the serv=
er generates the name via<br>ChooseConstraintName -&gt; makeObjectName, whi=
ch truncates the domain name to<br>fit within NAMEDATALEN-1 (63 bytes). =C2=
=A0pg_dump skips this truncation, so the<br>names never match, and it emits=
 an explicit CONSTRAINT clause instead of<br>plain NOT NULL.<br><br>The con=
sequence is a round-trip correctness bug.=C2=A0 When the domain name is<br>=
55 bytes, pg_dump emits:<br><br>=C2=A0 CONSTRAINT &quot;&lt;55bytes&gt;_not=
_null&quot; NOT NULL<br><br>The restore server receives a 64-byte name that=
 exceeds the 63-byte Name<br>type limit and silently truncates it to &quot;=
&lt;55bytes&gt;_not_nul&quot; -- a different<br>name from the original &quo=
t;&lt;54bytes&gt;_not_null&quot; that makeObjectName would have<br>produced=
.=C2=A0 Any DDL that references the original constraint name by string<br>(=
ALTER DOMAIN ... DROP CONSTRAINT ...) will then fail on the restored<br>dat=
abase.<br><br>The same XXX comment and the same structural bug exist in the=
 table column<br>NOT NULL comparison in getTableAttrs(), where the candidat=
e name is built<br>as &#39;&lt;tablename&gt;_&lt;colname&gt;_not_null&#39;.=
<br><br>The root cause is that makeObjectName lives in src/backend/commands=
/<br>indexcmds.c and is not available to frontend code.=C2=A0 This patch fi=
xes the<br>problem by:<br><br>1. Moving pg_encoding_mbcliplen from src/back=
end/utils/mb/mbutils.c to<br>=C2=A0 =C2=A0src/common/wchar.c.=C2=A0 Its dep=
endencies (pg_wchar_table,<br>=C2=A0 =C2=A0pg_encoding_max_length, and a tr=
ivial cliplen helper) are already in<br>=C2=A0 =C2=A0src/common/wchar.c, so=
 no backend infrastructure is required.<br><br>2. Moving makeObjectName fro=
m src/backend/commands/indexcmds.c to<br>=C2=A0 =C2=A0src/common/string.c, =
adding an &#39;encoding&#39; parameter to replace the<br>=C2=A0 =C2=A0impli=
cit GetDatabaseEncoding() call. =C2=A0src/common/ is the right home for<br>=
=C2=A0 =C2=A0this function: it is already a collection of string helpers (s=
trtoint,<br>=C2=A0 =C2=A0pg_clean_ascii, etc.), it links into both backend =
and frontend, and<br>=C2=A0 =C2=A0palloc() is available in frontend via the=
 postgres_fe.h wrapper.<br><br>3. Updating all five backend call sites to p=
ass GetDatabaseEncoding().<br><br>4. Adding an Archive.server_encoding fiel=
d and populating it in<br>=C2=A0 =C2=A0setup_connection() via PQparameterSt=
atus(conn, &quot;server_encoding&quot;).<br>=C2=A0 =C2=A0The server encodin=
g is used for truncation, not the client encoding<br>=C2=A0 =C2=A0stored in=
 Archive.encoding.<br><br>5. Replacing the two XXX psprintf comparisons in =
pg_dump.c with direct<br>=C2=A0 =C2=A0calls to makeObjectName(name1, name2,=
 &quot;not_null&quot;, fout-&gt;server_encoding).<br><br>makeObjectName has=
 historically lived in indexcmds.c for no particular<br>architectural reaso=
n -- it has no dependency on index infrastructure.<br>Moving it to src/comm=
on/ is a small cleanup that happens to be necessary<br>for this fix.<br><br=
>The patch is larger than the two-line conceptual fix, but the bulk of the<=
br>size is the mechanical function move (deletion from indexcmds.c, additio=
n<br>to string.c) and the five backend call-site updates.=C2=A0 An inline<b=
r>reimplementation in pg_dump was considered but rejected: the truncation<b=
r>must respect multibyte character boundaries via pg_encoding_mbcliplen, an=
d<br>duplicating that logic without a reference to the canonical implementa=
tion<br>risks silent divergence in future.<br><br>I considered whether the =
numeric-suffix case (_not_null1, _not_null2, ...)<br>should also be handled=
.=C2=A0 When a name collision exists in the same namespace,<br>ChooseConstr=
aintName appends a pass counter to the label. =C2=A0pg_dump would<br>still =
emit CONSTRAINT for those names.=C2=A0 For a round-trip restore into a<br>d=
atabase where the same collision condition holds, the name is stored<br>ver=
batim and identity is preserved.=C2=A0 Restoring into a database without th=
at<br>collision would produce a different constraint name, but that is a<br=
>pre-existing limitation shared by any collision-renamed object, not specif=
ic<br>to NOT NULL constraints.=C2=A0 This patch does not address that case.=
<br><br>Reproducer:<br><br>=C2=A0 CREATE DOMAIN aaaaaaaaaaaaaaaaaaaaaaaaaaa=
aaaaaaaaaaaaaaaaaaaaaaaaaaaa -- 55 &#39;a&#39;<br>=C2=A0 =C2=A0 =C2=A0 AS i=
nteger NOT NULL;<br><br>=C2=A0 -- Server stores constraint name: aaaaaa...(=
54 a&#39;s)_not_null =C2=A0(63 bytes)<br>=C2=A0 SELECT c.conname, length(c.=
conname)<br>=C2=A0 FROM pg_type t JOIN pg_constraint c ON c.contypid =3D t.=
oid<br>=C2=A0 WHERE t.typname LIKE &#39;aaa%&#39; AND c.contype =3D &#39;n&=
#39;;<br><br>Before this patch, pg_dump emits:<br>=C2=A0 CONSTRAINT &quot;a=
aaa...(55 a&#39;s)_not_null&quot; NOT NULL<br><br>After this patch, pg_dump=
 emits:<br>=C2=A0 NOT NULL<br><br>TAP tests are included in src/bin/pg_dump=
/t/<a href=3D"http://002_pg_dump.pl">002_pg_dump.pl</a> for both<br>truncat=
ion cases: a 55-char domain name (domain_name + &quot;_not_null&quot; excee=
ds<br>NAMEDATALEN-1) and a 27-char table with a 27-char column (table_name =
+ &quot;_&quot;<br>+ column_name + &quot;_not_null&quot; exceeds NAMEDATALE=
N-1).=C2=A0 Both cases verify that<br>pg_dump produces output without an ex=
plicit CONSTRAINT clause.<br><br>Patch attached.</div>

--000000000000e12662064d5a00af--

--000000000000e12664064d5a00b1
Content-Type: application/octet-stream;
	name="0001-Move-makeObjectName-to-src-common-and-fix-pg_dump-NO.patch"
Content-Disposition: attachment;
	filename="0001-Move-makeObjectName-to-src-common-and-fix-pg_dump-NO.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mmx1h6hk0>
X-Attachment-Id: f_mmx1h6hk0
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--000000000000e12664064d5a00b1--