Python (pytest) test framework + representative TAP→pytest conversions

.github/workflows/pg-ci.yml

@@ -88,6 +88,7 @@ env:
     -Dplperl=enabled
     -Dplpython=enabled
     -Dpltcl=enabled
+    -Dpytest=enabled
     -Dreadline=enabled
     -Dssl=openssl
     -Dtap_tests=enabled
@@ -668,6 +669,15 @@ jobs:
 
       - name: Test world
         shell: *su_postgres_shell
+        # The pytest suite loads libpq in-process via ctypes.  Here libpq is
+        # AddressSanitizer-instrumented, and ASan must come first in the link
+        # order; dlopening it into an otherwise uninstrumented python aborts
+        # with "ASan runtime does not come first".  Preload the ASan runtime
+        # for the test run to satisfy that (a no-op for the already-instrumented
+        # server/client binaries).  Scoped to this step so the build is
+        # unaffected; detect_leaks is already disabled via ASAN_OPTIONS.
+        env:
+          ADDITIONAL_SETUP: export LD_PRELOAD="$(gcc -print-file-name=libasan.so)"
         run: *meson_test_world_cmd
 
       - *linux_collect_cores_step
@@ -710,6 +720,8 @@ jobs:
         openssl
         p5.34-io-tty
         p5.34-ipc-run
+        py312-pexpect
+        py312-pytest
         python312
         tcl
         zstd
@@ -869,6 +881,7 @@ jobs:
         -Dldap=enabled
         -Dplperl=enabled
         -Dplpython=enabled
+        -Dpytest=enabled
         -Dssl=openssl
         -Dtap_tests=enabled
 
@@ -956,9 +969,11 @@ jobs:
       - name: Install dependencies
         shell: pwsh
         run: |
-          # meson is not preinstalled on windows-2022. Install via pip
+          # meson is not preinstalled on windows-2022. Install via pip.
+          # pytest enables the Python test suite (pexpect is omitted: it needs
+          # a pty, which Windows lacks, and the interactive tests importorskip).
           echo ::group::pip
-          python -m pip install --upgrade meson
+          python -m pip install --upgrade meson pytest
           if (!$?) { throw 'cmdfail' }
           echo ::endgroup::
 
@@ -1096,6 +1111,7 @@ jobs:
             ${MINGW_PACKAGE_PREFIX}-meson \
             ${MINGW_PACKAGE_PREFIX}-perl \
             ${MINGW_PACKAGE_PREFIX}-pkgconf \
+            ${MINGW_PACKAGE_PREFIX}-python-pytest \
             ${MINGW_PACKAGE_PREFIX}-readline \
             ${MINGW_PACKAGE_PREFIX}-zlib \
             ${MINGW_PACKAGE_PREFIX}-zstd

contrib/amcheck/verify_nbtree.c

@@ -336,14 +336,16 @@ bt_index_check_callback(Relation indrel, Relation heaprel, void *state, bool rea
 			if (indrel->rd_opfamily[i] == INTERVAL_BTREE_FAM_OID)
 			{
 				has_interval_ops = true;
-				ereport(ERROR,
-						(errcode(ERRCODE_INDEX_CORRUPTED),
-						 errmsg("index \"%s\" metapage incorrectly indicates that deduplication is safe",
-								RelationGetRelationName(indrel)),
-						 has_interval_ops
-						 ? errhint("This is known of \"interval\" indexes last built on a version predating 2023-11.")
-						 : 0));
+				break;
 			}
+
+		ereport(ERROR,
+				(errcode(ERRCODE_INDEX_CORRUPTED),
+				 errmsg("index \"%s\" metapage incorrectly indicates that deduplication is safe",
+						RelationGetRelationName(indrel)),
+				 has_interval_ops
+				 ? errhint("This is known of \"interval\" indexes last built on a version predating 2023-11.")
+				 : 0));
 	}
 
 	/* Check index, possibly against table it is an index on */
@@ -2889,7 +2891,7 @@ bt_normalize_tuple(BtreeCheckState *state, IndexTuple itup)
 							ItemPointerGetOffsetNumber(&(itup->t_tid)),
 							RelationGetRelationName(state->rel))));
 		else if (!VARATT_IS_COMPRESSED(DatumGetPointer(normalized[i])) &&
-				 VARSIZE(DatumGetPointer(normalized[i])) > TOAST_INDEX_TARGET &&
+				 VARSIZE_ANY(DatumGetPointer(normalized[i])) > TOAST_INDEX_TARGET &&
 				 (att->attstorage == TYPSTORAGE_EXTENDED ||
 				  att->attstorage == TYPSTORAGE_MAIN))
 		{

contrib/jsonb_plperl/jsonb_plperl.c

@@ -3,6 +3,7 @@
 #include <math.h>
 
 #include "fmgr.h"
+#include "miscadmin.h"
 #include "plperl.h"
 #include "utils/fmgrprotos.h"
 #include "utils/jsonb.h"
@@ -66,6 +67,9 @@ Jsonb_to_SV(JsonbContainer *jsonb)
 	JsonbIterator *it;
 	JsonbIteratorToken r;
 
+	/* this can recurse via JsonbValue_to_SV() */
+	check_stack_depth();
+
 	it = JsonbIteratorInit(jsonb);
 	r = JsonbIteratorNext(&it, &v, true);
 
@@ -179,9 +183,20 @@ SV_to_JsonbValue(SV *in, JsonbInState *jsonb_state, bool is_elem)
 	dTHX;
 	JsonbValue	out;			/* result */
 
+	/* this can recurse via AV_to_JsonbValue() or HV_to_JsonbValue() */
+	check_stack_depth();
+
 	/* Dereference references recursively. */
 	while (SvROK(in))
+	{
+		/*
+		 * It's possible for circular references to make this an infinite
+		 * loop.  Checking for such a situation seems like much more trouble
+		 * than it's worth, but let's provide a way to break out of the loop.
+		 */
+		CHECK_FOR_INTERRUPTS();
 		in = SvRV(in);
+	}
 
 	switch (SvTYPE(in))
 	{

contrib/jsonb_plpython/jsonb_plpython.c

@@ -1,5 +1,6 @@
 #include "postgres.h"
 
+#include "miscadmin.h"
 #include "plpy_elog.h"
 #include "plpy_typeio.h"
 #include "plpy_util.h"
@@ -143,6 +144,9 @@ PLyObject_FromJsonbContainer(JsonbContainer *jsonb)
 	JsonbIterator *it;
 	PyObject   *result;
 
+	/* this can recurse via PLyObject_FromJsonbValue() */
+	check_stack_depth();
+
 	it = JsonbIteratorInit(jsonb);
 	r = JsonbIteratorNext(&it, &v, true);
 
@@ -410,6 +414,9 @@ PLyObject_ToJsonbValue(PyObject *obj, JsonbInState *jsonb_state, bool is_elem)
 {
 	JsonbValue *out;
 
+	/* this can recurse via PLyMapping_ToJsonbValue() */
+	check_stack_depth();
+
 	if (!PyUnicode_Check(obj))
 	{
 		if (PySequence_Check(obj))

contrib/ltree/expected/ltree.out

@@ -8226,3 +8226,13 @@ DETAIL:  Total size of level exceeds the maximum allowed (65535 bytes).
 SELECT (repeat('a|', 65535) || 'a')::lquery;
 ERROR:  lquery level has too many variants
 DETAIL:  Number of variants exceeds the maximum allowed (65535).
+-- Test that ltree_compare() does not overflow with very deep paths.
+WITH s AS (SELECT 'a'::ltree AS v),
+     l AS (SELECT (repeat('a.', 14999) || 'a')::ltree AS v)
+SELECT (l.v > s.v) AS gt_ok, (l.v < s.v) AS lt_ok, (l.v = s.v) AS eq_ok
+  FROM s, l;
+ gt_ok | lt_ok | eq_ok 
+-------+-------+-------
+ t     | f     | f
+(1 row)
+

contrib/ltree/ltree.h

@@ -206,6 +206,7 @@ bool		ltree_execute(ITEM *curitem, void *checkval,
 						  bool calcnot, bool (*chkcond) (void *checkval, ITEM *val));
 
 int			ltree_compare(const ltree *a, const ltree *b);
+float		ltree_compare_distance(const ltree *a, const ltree *b);
 bool		inner_isparent(const ltree *c, const ltree *p);
 bool		compare_subnode(ltree_level *t, char *qn, int len, bool prefix, bool ci);
 ltree	   *lca_inner(ltree **a, int len);

contrib/ltree/ltree_gist.c

@@ -264,11 +264,11 @@ ltree_penalty(PG_FUNCTION_ARGS)
 	ltree_gist *newval = (ltree_gist *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
 	float	   *penalty = (float *) PG_GETARG_POINTER(2);
 	int			siglen = LTREE_GET_SIGLEN();
-	int32		cmpr,
+	float		cmpr,
 				cmpl;
 
-	cmpl = ltree_compare(LTG_GETLNODE(origval, siglen), LTG_GETLNODE(newval, siglen));
-	cmpr = ltree_compare(LTG_GETRNODE(newval, siglen), LTG_GETRNODE(origval, siglen));
+	cmpl = ltree_compare_distance(LTG_GETLNODE(origval, siglen), LTG_GETLNODE(newval, siglen));
+	cmpr = ltree_compare_distance(LTG_GETRNODE(newval, siglen), LTG_GETRNODE(origval, siglen));
 
 	*penalty = Max(cmpl, 0) + Max(cmpr, 0);
 

contrib/ltree/ltree_op.c

@@ -42,6 +42,9 @@ PG_FUNCTION_INFO_V1(ltree2text);
 PG_FUNCTION_INFO_V1(text2ltree);
 PG_FUNCTION_INFO_V1(ltreeparentsel);
 
+/*
+ * btree-comparison function.
+ */
 int
 ltree_compare(const ltree *a, const ltree *b)
 {
@@ -54,18 +57,52 @@ ltree_compare(const ltree *a, const ltree *b)
 	{
 		int			res;
 
-		if ((res = memcmp(al->name, bl->name, Min(al->len, bl->len))) == 0)
+		res = memcmp(al->name, bl->name, Min(al->len, bl->len));
+		if (res == 0)
+		{
+			if (al->len != bl->len)
+				return (int) al->len - (int) bl->len;
+		}
+		else
+			return res;
+
+		an--;
+		bn--;
+		al = LEVEL_NEXT(al);
+		bl = LEVEL_NEXT(bl);
+	}
+
+	return a->numlevel - b->numlevel;
+}
+
+/*
+ * Returns a "distance" between a and b.  If a < b, the distance is negative,
+ * consistent with the ltree_compare() ordering.
+ */
+float
+ltree_compare_distance(const ltree *a, const ltree *b)
+{
+	ltree_level *al = LTREE_FIRST(a);
+	ltree_level *bl = LTREE_FIRST(b);
+	int			an = a->numlevel;
+	int			bn = b->numlevel;
+
+	while (an > 0 && bn > 0)
+	{
+		int			res;
+
+		res = memcmp(al->name, bl->name, Min(al->len, bl->len));
+		if (res == 0)
 		{
 			if (al->len != bl->len)
-				return (al->len - bl->len) * 10 * (an + 1);
+				return (float) (al->len - bl->len) * 10.0 * (an + 1);
 		}
 		else
 		{
 			if (res < 0)
-				res = -1;
+				return -1.0 * 10.0 * (an + 1);
 			else
-				res = 1;
-			return res * 10 * (an + 1);
+				return 1.0 * 10.0 * (an + 1);
 		}
 
 		an--;
@@ -74,7 +111,7 @@ ltree_compare(const ltree *a, const ltree *b)
 		bl = LEVEL_NEXT(bl);
 	}
 
-	return (a->numlevel - b->numlevel) * 10 * (an + 1);
+	return ((float) (a->numlevel - b->numlevel)) * 10.0 * (an + 1);
 }
 
 #define RUNCMP						\

contrib/ltree/sql/ltree.sql

@@ -477,3 +477,9 @@ SELECT (repeat('x', 255) || repeat('|' || repeat('x', 255), 256))::lquery;
 --- Test for overflow of lquery_level.numvar, with a set of single-char
 --- variants in one level.
 SELECT (repeat('a|', 65535) || 'a')::lquery;
+
+-- Test that ltree_compare() does not overflow with very deep paths.
+WITH s AS (SELECT 'a'::ltree AS v),
+     l AS (SELECT (repeat('a.', 14999) || 'a')::ltree AS v)
+SELECT (l.v > s.v) AS gt_ok, (l.v < s.v) AS lt_ok, (l.v = s.v) AS eq_ok
+  FROM s, l;

contrib/postgres_fdw/postgres_fdw.c

@@ -6024,7 +6024,7 @@ remattrmap_cmp(const void *v1, const void *v2)
 	const RemoteAttributeMapping *r1 = v1;
 	const RemoteAttributeMapping *r2 = v2;
 
-	return strncmp(r1->remote_attname, r2->remote_attname, NAMEDATALEN);
+	return strcmp(r1->remote_attname, r2->remote_attname);
 }
 
 /*

contrib/seg/expected/seg.out

@@ -263,7 +263,8 @@ SELECT '12.345678901234560000000000000000000000000000000000000000000000000000000
  12.3457
 (1 row)
 
--- Numbers with certainty indicators
+-- Numbers and ranges with certainty indicators.  Certainty indicators
+-- are stored and preserved on output, but ignored by operators.
 SELECT '~6.5'::seg AS seg;
  seg  
 ------
@@ -300,6 +301,48 @@ SELECT '> 6.5'::seg AS seg;
  >6.5
 (1 row)
 
+SELECT '~1.5 .. 2.5'::seg AS seg;
+     seg     
+-------------
+ ~1.5 .. 2.5
+(1 row)
+
+SELECT '1.5 .. ~2.5'::seg AS seg;
+     seg     
+-------------
+ 1.5 .. ~2.5
+(1 row)
+
+SELECT '~1.5 .. ~2.5'::seg AS seg;
+     seg      
+--------------
+ ~1.5 .. ~2.5
+(1 row)
+
+SELECT '<1.5 .. 2.5'::seg AS seg;
+     seg     
+-------------
+ <1.5 .. 2.5
+(1 row)
+
+SELECT '1.5 .. <2.5'::seg AS seg;
+     seg     
+-------------
+ 1.5 .. <2.5
+(1 row)
+
+SELECT '>1.5 .. 2.5'::seg AS seg;
+     seg     
+-------------
+ >1.5 .. 2.5
+(1 row)
+
+SELECT '1.5 .. >2.5'::seg AS seg;
+     seg     
+-------------
+ 1.5 .. >2.5
+(1 row)
+
 -- Open intervals
 SELECT '0..'::seg AS seg;
  seg  

contrib/seg/seg.c

@@ -152,7 +152,7 @@ seg_out(PG_FUNCTION_ARGS)
 		{
 			/* print the upper boundary if exists */
 			p += sprintf(p, " ");
-			if (seg->u_ext == '>' || seg->u_ext == '<' || seg->l_ext == '~')
+			if (seg->u_ext == '>' || seg->u_ext == '<' || seg->u_ext == '~')
 				p += sprintf(p, "%c", seg->u_ext);
 			p += restore(p, seg->upper, seg->u_sigd);
 		}

contrib/seg/sql/seg.sql

@@ -63,14 +63,23 @@ SELECT '12.34567890123456'::seg AS seg;
 -- Same, with a very long input
 SELECT '12.3456789012345600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'::seg AS seg;
 
--- Numbers with certainty indicators
+-- Numbers and ranges with certainty indicators.  Certainty indicators
+-- are stored and preserved on output, but ignored by operators.
 SELECT '~6.5'::seg AS seg;
 SELECT '<6.5'::seg AS seg;
 SELECT '>6.5'::seg AS seg;
 SELECT '~ 6.5'::seg AS seg;
 SELECT '< 6.5'::seg AS seg;
 SELECT '> 6.5'::seg AS seg;
 
+SELECT '~1.5 .. 2.5'::seg AS seg;
+SELECT '1.5 .. ~2.5'::seg AS seg;
+SELECT '~1.5 .. ~2.5'::seg AS seg;
+SELECT '<1.5 .. 2.5'::seg AS seg;
+SELECT '1.5 .. <2.5'::seg AS seg;
+SELECT '>1.5 .. 2.5'::seg AS seg;
+SELECT '1.5 .. >2.5'::seg AS seg;
+
 -- Open intervals
 SELECT '0..'::seg AS seg;
 SELECT '0...'::seg AS seg;