MIME-Version: 1.0
References: 
 <CACSdjfO3f82rLGEwAG4WzyZ220NV1=QjNmZpwPGhX_yCe3mgeA@mail.gmail.com>
In-Reply-To: 
 <CACSdjfO3f82rLGEwAG4WzyZ220NV1=QjNmZpwPGhX_yCe3mgeA@mail.gmail.com>
From: JoongHyuk Shin <sjh910805@gmail.com>
Date: Thu, 19 Mar 2026 18:12:37 +0900
Message-ID: 
 <CACSdjfPAdaD9SRr=bNwud53PhFY0kpvkJu+oUYPqnGZbsHNyuw@mail.gmail.com>
Subject: Re: pg_dump: fix NOT NULL constraint name comparison using
 makeObjectName
To: pgsql-hackers@lists.postgresql.org
Content-Type: multipart/mixed; boundary="0000000000000d3767064d5cf908"
Archived-At: 
 <https://www.postgresql.org/message-id/CACSdjfPAdaD9SRr%3DbNwud53PhFY0kpvkJu%2BoUYPqnGZbsHNyuw%40mail.gmail.com>
Precedence: bulk

--0000000000000d3767064d5cf908
Content-Type: multipart/alternative; boundary="0000000000000d3764064d5cf906"

--0000000000000d3764064d5cf906
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

v1 failed the meson/Cirrus CI build: libpgtypes.so reported an undefined
reference to palloc.

The cause: v1 placed makeObjectName in string.c.  libpgtypes links against
libpgcommon_shlib, which excludes fe_memutils.c (the frontend palloc
provider).  libpgtypes uses strtoint from string.c, so the linker pulls in
string.c.o -- and with it, the palloc call inside makeObjectName.

v2 moves makeObjectName to its own file, src/common/objectname.c.  Since
nothing in libpgtypes calls makeObjectName, the linker never pulls in
objectname.c.o from the archive, and the palloc symbol stays unresolved
only in an unused object file.

No functional change from v1 otherwise.  The autoconf build and all tests
(regression + pg_dump TAP) pass.

Patch attached.

On Thu, Mar 19, 2026 at 2:40=E2=80=AFPM JoongHyuk Shin <sjh910805@gmail.com=
> wrote:

> 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 t=
o
> fit within NAMEDATALEN-1 (63 bytes).  pg_dump skips this truncation, so t=
he
> 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 differen=
t
> name from the original "<54bytes>_not_null" that makeObjectName would hav=
e
> 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 colum=
n
> 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 fo=
r
>    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, an=
d
> duplicating that logic without a reference to the canonical implementatio=
n
> 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 th=
at
> 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 =3D t.oid
>   WHERE t.typname LIKE 'aaa%' AND c.contype =3D '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" exceed=
s
> NAMEDATALEN-1) and a 27-char table with a 27-char column (table_name + "_=
"
> + column_name + "_not_null" exceeds NAMEDATALEN-1).  Both cases verify th=
at
> pg_dump produces output without an explicit CONSTRAINT clause.
>
> Patch attached.
>

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

<div dir=3D"ltr">v1 failed the meson/Cirrus CI build: libpgtypes.so reporte=
d an undefined<br>reference to palloc.<br><br>The cause: v1 placed makeObje=
ctName in string.c. =C2=A0libpgtypes links against<br>libpgcommon_shlib, wh=
ich excludes fe_memutils.c (the frontend palloc<br>provider). =C2=A0libpgty=
pes uses strtoint from string.c, so the linker pulls in<br>string.c.o -- an=
d with it, the palloc call inside makeObjectName.<br><br>v2 moves makeObjec=
tName to its own file, src/common/objectname.c.=C2=A0 Since<br>nothing in l=
ibpgtypes calls makeObjectName, the linker never pulls in<br>objectname.c.o=
 from the archive, and the palloc symbol stays unresolved<br>only in an unu=
sed object file.<br><br>No functional change from v1 otherwise.=C2=A0 The a=
utoconf build and all tests<br>(regression + pg_dump TAP) pass.<br><br>Patc=
h attached.</div><br><div class=3D"gmail_quote gmail_quote_container"><div =
dir=3D"ltr" class=3D"gmail_attr">On Thu, Mar 19, 2026 at 2:40=E2=80=AFPM Jo=
ongHyuk Shin &lt;<a href=3D"mailto:sjh910805@gmail.com">sjh910805@gmail.com=
</a>&gt; wrote:<br></div><blockquote class=3D"gmail_quote" style=3D"margin:=
0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex">=
<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" target=3D"_blank">002_pg_dump.pl</a> f=
or both<br>truncation cases: a 55-char domain name (domain_name + &quot;_no=
t_null&quot; exceeds<br>NAMEDATALEN-1) and a 27-char table with a 27-char c=
olumn (table_name + &quot;_&quot;<br>+ column_name + &quot;_not_null&quot; =
exceeds NAMEDATALEN-1).=C2=A0 Both cases verify that<br>pg_dump produces ou=
tput without an explicit CONSTRAINT clause.<br><br>Patch attached.</div>
</blockquote></div>

--0000000000000d3764064d5cf906--

--0000000000000d3767064d5cf908
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_mmx94veo0>
X-Attachment-Id: f_mmx94veo0
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--0000000000000d3767064d5cf908--