MIME-Version: 1.0
References: <19382-4c2060ffee72759b@postgresql.org> <CAOVWO5rVBKsjG4YwO_PJQu2OBGp8qUdF1jineYY6Lm3zc6-KWQ@mail.gmail.com>
In-Reply-To: <CAOVWO5rVBKsjG4YwO_PJQu2OBGp8qUdF1jineYY6Lm3zc6-KWQ@mail.gmail.com>
From: surya poondla <suryapoondla4@gmail.com>
Date: Fri, 23 Jan 2026 17:55:25 -0800
Message-ID: <CAOVWO5rbwKgHWLYJMvKuvGxW9eFSk7LADk=ZxDEvwA1uTefvAg@mail.gmail.com>
Subject: Re: BUG #19382: Server crash at __nss_database_lookup
To: dllggyx@outlook.com, pgsql-bugs@lists.postgresql.org
Content-Type: multipart/mixed; boundary="000000000000f8fa4a06491891e9"
Archived-At: <https://www.postgresql.org/message-id/CAOVWO5rbwKgHWLYJMvKuvGxW9eFSk7LADk%3DZxDEvwA1uTefvAg%40mail.gmail.com>
Precedence: bulk

--000000000000f8fa4a06491891e9
Content-Type: multipart/alternative; boundary="000000000000f8fa4806491891e7"

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

Hi All,

I am working on a patch for this.
>

I built a patch on 17.6 postgres version.

The overall issue is:
When ALTER TYPE modifies column types, the type cache updates its
tupDesc_identifier.
However, existing ExpandedRecordHeader instances still reference the old
tupdesc.
When the record is returned and flattened, the output functions expect data
to match the new type definition but receive data in the old format,
causing type confusion (e.g., interpreting an integer as a text pointer).
This was causing a segfault and crashing the server.

In my solution (attached patch), I added convert_record_for_altered_type()
function which detects type changes by comparing er_tupdesc_id against the
current tupDesc_identifier.
When a mismatch is found, it tries to convert each field value to match the
new type definition, if this fails we error out.
convert_record_for_altered_type() function is called in exec_stmt_return()
and exec_stmt_return_next() before returning records.

I tested my patch and see the below output
postgres=3D# DROP FUNCTION IF EXISTS bar();
DROP FUNCTION
postgres=3D# DROP TYPE IF EXISTS foo CASCADE;
DROP TYPE
postgres=3D# DROP FUNCTION IF EXISTS bar1();
DROP FUNCTION
postgres=3D# DROP TYPE IF EXISTS foo1 CASCADE;
DROP TYPE
postgres=3D# CREATE TYPE foo AS (a INT, b INT);
CREATE TYPE
postgres=3D# CREATE FUNCTION bar() RETURNS RECORD AS $$
postgres$#   DECLARE
postgres$#       r foo :=3D ROW(123, power(2, 30));
postgres$#   BEGIN
postgres$#       ALTER TYPE foo ALTER ATTRIBUTE b TYPE TEXT;
postgres$#       RETURN r;
postgres$#   END;
postgres$#   $$ LANGUAGE plpgsql;
CREATE FUNCTION
postgres=3D#
postgres=3D# SELECT bar();
       bar
------------------
 (123,1073741824)
(1 row)

postgres=3D# CREATE TYPE foo1 AS (a INT, b INT);
CREATE TYPE
postgres=3D#
postgres=3D#   CREATE FUNCTION bar1(OUT r1 foo1) AS $$
postgres$#   BEGIN
postgres$#       r1 :=3D ROW(1, 2);
postgres$#       ALTER TYPE foo1 ALTER ATTRIBUTE b TYPE TEXT;
postgres$#       RETURN;
postgres$#   END;
postgres$#   $$ LANGUAGE plpgsql;
CREATE FUNCTION
postgres=3D#
postgres=3D# SELECT bar1();
 bar1
-------
 (1,2)
(1 row)

postgres=3D# CREATE TYPE foo2 AS (a INT, b TEXT);
CREATE TYPE
postgres=3D# CREATE FUNCTION bar2() RETURNS foo2 AS $$
postgres$#   DECLARE
postgres$#       r foo2 :=3D ROW(1, 'hello');
postgres$#   BEGIN
postgres$#       ALTER TYPE foo2 ALTER ATTRIBUTE b TYPE INT;  -- TEXT =E2=
=86=92 INT
postgres$#       RETURN r;  -- Should get clean error (not crash)
postgres$#   END;
postgres$#   $$ LANGUAGE plpgsql;
CREATE FUNCTION
postgres=3D#
postgres=3D# SELECT bar2();
ERROR:  invalid input syntax for type integer: "hello"
CONTEXT:  PL/pgSQL function bar2() line 6 at RETURN
postgres=3D#

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

<div dir=3D"ltr"><div dir=3D"ltr">Hi All,<br><br></div><div class=3D"gmail_=
quote gmail_quote_container"><blockquote class=3D"gmail_quote" style=3D"mar=
gin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1=
ex"><div dir=3D"ltr"><div dir=3D"ltr"><p style=3D"margin:0px;font-variant-n=
umeric:normal;font-variant-east-asian:normal;font-variant-alternates:normal=
;font-size-adjust:none;font-kerning:auto;font-feature-settings:normal;font-=
stretch:normal;font-size:13px;line-height:normal;font-family:&quot;Helvetic=
a Neue&quot;">
I am working on a patch for this.<br></p></div></div></blockquote><div><br>=
</div><div>I built a patch on 17.6 postgres version.<br><br>The overall iss=
ue=C2=A0is:</div><div>When ALTER TYPE modifies column types, the type cache=
 updates its tupDesc_identifier.=C2=A0</div><div>However, existing Expanded=
RecordHeader instances still reference the old tupdesc.=C2=A0</div><div>Whe=
n the record is returned and flattened, the output functions expect data to=
 match the new type definition but receive data in the old format, causing =
type confusion (e.g., interpreting an integer as a text pointer).<br>This w=
as causing a segfault=C2=A0and crashing the server.</div><div><br></div><di=
v>In my solution (attached patch), I added convert_record_for_altered_type(=
) function which detects type changes by comparing er_tupdesc_id against th=
e current tupDesc_identifier.=C2=A0</div><div>When a mismatch is found, it =
tries to convert each field value to match the new type definition,=C2=A0if=
 this fails we error out. <br>convert_record_for_altered_type() function is=
 called in exec_stmt_return() and exec_stmt_return_next() before returning =
records.<br><br>I tested my patch and see the below output<br>postgres=3D# =
DROP FUNCTION IF EXISTS bar();<br>DROP FUNCTION<br>postgres=3D# DROP TYPE I=
F EXISTS foo CASCADE;<br>DROP TYPE<br>postgres=3D# DROP FUNCTION IF EXISTS =
bar1();<br>DROP FUNCTION<br>postgres=3D# DROP TYPE IF EXISTS foo1 CASCADE;<=
br>DROP TYPE<br>postgres=3D# CREATE TYPE foo AS (a INT, b INT);<br>CREATE T=
YPE<br>postgres=3D# CREATE FUNCTION bar() RETURNS RECORD AS $$<br>postgres$=
# =C2=A0 DECLARE<br>postgres$# =C2=A0 =C2=A0 =C2=A0 r foo :=3D ROW(123, pow=
er(2, 30));<br>postgres$# =C2=A0 BEGIN<br>postgres$# =C2=A0 =C2=A0 =C2=A0 A=
LTER TYPE foo ALTER ATTRIBUTE b TYPE TEXT;<br>postgres$# =C2=A0 =C2=A0 =C2=
=A0 RETURN r;<br>postgres$# =C2=A0 END;<br>postgres$# =C2=A0 $$ LANGUAGE pl=
pgsql;<br>CREATE FUNCTION<br>postgres=3D#<br>postgres=3D# SELECT bar();<br>=
=C2=A0 =C2=A0 =C2=A0 =C2=A0bar<br>------------------<br>=C2=A0(123,10737418=
24)<br>(1 row)<br><br>postgres=3D# CREATE TYPE foo1 AS (a INT, b INT);<br>C=
REATE TYPE<br>postgres=3D#<br>postgres=3D# =C2=A0 CREATE FUNCTION bar1(OUT =
r1 foo1) AS $$<br>postgres$# =C2=A0 BEGIN<br>postgres$# =C2=A0 =C2=A0 =C2=
=A0 r1 :=3D ROW(1, 2);<br>postgres$# =C2=A0 =C2=A0 =C2=A0 ALTER TYPE foo1 A=
LTER ATTRIBUTE b TYPE TEXT;<br>postgres$# =C2=A0 =C2=A0 =C2=A0 RETURN;<br>p=
ostgres$# =C2=A0 END;<br>postgres$# =C2=A0 $$ LANGUAGE plpgsql;<br>CREATE F=
UNCTION<br>postgres=3D#<br>postgres=3D# SELECT bar1();<br>=C2=A0bar1<br>---=
----<br>=C2=A0(1,2)<br>(1 row)<br><br>postgres=3D# CREATE TYPE foo2 AS (a I=
NT, b TEXT);<br>CREATE TYPE<br>postgres=3D# CREATE FUNCTION bar2() RETURNS =
foo2 AS $$<br>postgres$# =C2=A0 DECLARE<br>postgres$# =C2=A0 =C2=A0 =C2=A0 =
r foo2 :=3D ROW(1, &#39;hello&#39;);<br>postgres$# =C2=A0 BEGIN<br>postgres=
$# =C2=A0 =C2=A0 =C2=A0 ALTER TYPE foo2 ALTER ATTRIBUTE b TYPE INT; =C2=A0-=
- TEXT =E2=86=92 INT<br>postgres$# =C2=A0 =C2=A0 =C2=A0 RETURN r; =C2=A0-- =
Should get clean error (not crash)<br>postgres$# =C2=A0 END;<br>postgres$# =
=C2=A0 $$ LANGUAGE plpgsql;<br>CREATE FUNCTION<br>postgres=3D#<br>postgres=
=3D# SELECT bar2();<br>ERROR: =C2=A0invalid input syntax for type integer: =
&quot;hello&quot;<br>CONTEXT: =C2=A0PL/pgSQL function bar2() line 6 at RETU=
RN<br>postgres=3D#</div></div></div>

--000000000000f8fa4806491891e7--
--000000000000f8fa4a06491891e9
Content-Type: application/octet-stream; 
	name="0001-Fix-bug-19382-server-crash-when-ALTER-TYPE-is-used-m.patch"
Content-Disposition: attachment; 
	filename="0001-Fix-bug-19382-server-crash-when-ALTER-TYPE-is-used-m.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mkrnq68c0>
X-Attachment-Id: f_mkrnq68c0
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--000000000000f8fa4a06491891e9--