Update tests and reindent for native typed cursor results after OID fix

The previous commit makes pgduck_server send real PostgreSQL type OIDs
in its row description instead of InvalidOid. With proper OIDs, psycopg2
correctly parses each column into its native Python type (int, bool,
datetime, Decimal, memoryview) instead of silently coercing everything
to str via TEXTOID fallback.

Tests written against the old buggy behavior compared expected values
to strings. Update the affected assertions to expect native types — or,
where the test compares a cursor result against a CSV-parsed transmit
result, stringify the cursor side via the existing converters.

Also runs pgindent on type_conversion.{c,h} and duckdb.c to fix
whitespace nits introduced by the previous commit.

Notable test changes:
- test_common/helpers/db.py: run_simple_command now expects [(1,)] not
  [("1",)]; this single helper was responsible for ~17 failures across
  test_pgbench, test_server_protocol_failures, test_psql,
  test_cancellations, and test_simple_server.
- test_types.py: fix the long-standing latent interval-arithmetic
  mismatch — the existing normalizer assumes a 360-day year, but
  psycopg2 converts PG `interval` directly to timedelta using a
  365-day year (and PG normalizes "16 mons 15 days" to "1 yr 4 mons 15
  days"), so PG cursor results need their own expected list.
- test_identity_partitioned_writes.py / test_date_partitioned_writes.py
  / test_truncate_partitioned_writes.py: lake_table.data_file_partition_values.value
  is text, but res[0][0] from pgduck via SELECT DISTINCT col is now
  native — branch on col_type and cast appropriately (BOOLEAN partition
  values are stored as "t"/"f", BYTEA as "\\x...", others compare via
  str()).

Signed-off-by: Marco Slot <marco.slot@snowflake.com>

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: sfc-gh-mslot

pg_lake_table/tests/pytests/test_date_partitioned_writes.py

@@ -164,7 +164,7 @@ def test_calendar_partition_write(
             f"SELECT count(DISTINCT {part_expr}), count(*) FROM '{path}'",
             pgduck_conn,
         )
-        assert res[0][0] == "1"
+        assert res[0][0] == 1
         assert int(res[0][1]) == row_count
 
         res = run_query(
@@ -177,7 +177,9 @@ def test_calendar_partition_write(
             pg_conn,
         )
 
-        assert res_partition[0][0] == res[0][0]
+        # res_partition[0][0] is text; res[0][0] is now native (int for
+        # year/month/day partitions).
+        assert res_partition[0][0] == str(res[0][0])
 
     # register the same table to spark
     # and make sure it can understand our partitioning

pg_lake_table/tests/pytests/test_iceberg_remove_unreferenced_files.py

@@ -900,7 +900,7 @@ def test_remove_unreferenced_files_13(
     res = run_query(
         f"SELECT count(*) FROM read_parquet('{file_paths_q[0][0]}/*')", pgduck_conn
     )
-    assert res[0][0] == "0"
+    assert res[0][0] == 0
 
     # no files inserted
     file_paths = run_query(

pg_lake_table/tests/pytests/test_identity_partitioned_writes.py

@@ -260,21 +260,30 @@ def test_identity_partition_write(
             pg_conn,
         )
 
+        # res_partition is the partition-value text from
+        # lake_table.data_file_partition_values; res[0][0] now comes back as a
+        # native Python type from pgduck_server (the type depends on col_type).
+        partition_text = res_partition[0][0]
+        actual_value = res[0][0]
+
         if col_type == "BOOLEAN":
-            assert bool(res_partition[0][0]) == bool(res[0][0])
+            # partition value is PG bool short form ("t" / "f")
+            expected_bool = partition_text == "t"
+            assert expected_bool == actual_value
         elif col_type in ("TIMESTAMP", "TIMESTAMPTZ"):
-            expected = datetime.datetime.fromisoformat(res_partition[0][0])
-            actual = datetime.datetime.fromisoformat(res[0][0])
-
-            if actual.tzinfo is not None:
+            expected = datetime.datetime.fromisoformat(partition_text)
+            if actual_value.tzinfo is not None and expected.tzinfo is None:
                 expected = expected.replace(tzinfo=datetime.timezone.utc)
-            assert expected == actual
+            assert expected == actual_value
         elif col_type == "DATE":
-            expected = datetime.date.fromisoformat(res_partition[0][0])
-            actual = datetime.date.fromisoformat(res[0][0])
-            assert expected == actual
+            expected = datetime.date.fromisoformat(partition_text)
+            assert expected == actual_value
+        elif col_type == "BYTEA":
+            # partition value is "\\x..." text; cursor returns memoryview
+            assert partition_text == "\\x" + bytes(actual_value).hex()
         else:
-            assert res_partition[0][0] == res[0][0]
+            # All other types compare cleanly via stringification.
+            assert partition_text == str(actual_value)
 
         res = run_query(f"SELECT count(*) FROM '{file_path}'", pgduck_conn)
         # each file should have a distinct value

pg_lake_table/tests/pytests/test_multi_expr_partition_writes.py

@@ -105,7 +105,7 @@ def test_multi_expression_partition_write(
             """,
             pgduck_conn,
         )[0][0]
-        assert part_key_cnt == "1"
+        assert part_key_cnt == 1
 
     # 5) tidy up session GUC
     run_command("RESET pg_lake_table.enable_insert_select_pushdown;", pg_conn)

pg_lake_table/tests/pytests/test_partition_evolution.py

@@ -104,7 +104,7 @@ def test_partition_evolution(
 
     for p in files_stage1:
         rows = run_query(f"SELECT count(*) FROM '{p}'", pgduck_conn)[0][0]
-        assert rows == "2"
+        assert rows == 2
         _file_holds_single_key(p, KEY_STAGE1, pgduck_conn)
 
     # ─── stage 2  ── ALTER SET … + second insert (8 new partitions) ────────
@@ -135,7 +135,7 @@ def test_partition_evolution(
     assert len(files_stage2) == 8
 
     for p in files_stage2:
-        assert run_query(f"SELECT count(*) FROM '{p}'", pgduck_conn)[0][0] == "2"
+        assert run_query(f"SELECT count(*) FROM '{p}'", pgduck_conn)[0][0] == 2
         _file_holds_single_key(p, KEY_STAGE2, pgduck_conn)
 
     # ─── stage 3  ── ALTER DROP partition_by + final insert (un-partitioned) ─
@@ -153,7 +153,7 @@ def test_partition_evolution(
     assert len(files_stage3) == 1
 
     path = next(iter(files_stage3))
-    assert run_query(f"SELECT count(*) FROM '{path}'", pgduck_conn)[0][0] == "4"
+    assert run_query(f"SELECT count(*) FROM '{path}'", pgduck_conn)[0][0] == 4
 
     # ─── cleanup session GUC ────────────────────────────────────────────────
     pg_conn.rollback()

pg_lake_table/tests/pytests/test_truncate_partitioned_writes.py

@@ -154,7 +154,7 @@ def test_truncate_partition_write(
         res = run_query(
             f"SELECT count(DISTINCT {part_expr}), count(*) FROM '{path}'", pgduck_conn
         )
-        assert res[0][0] == "1"
+        assert res[0][0] == 1
         assert int(res[0][1]) == row_count
 
         res = run_query(f"SELECT DISTINCT {part_expr} FROM '{path}'", pgduck_conn)
@@ -163,7 +163,9 @@ def test_truncate_partition_write(
             f"SELECT value FROM lake_table.data_file_partition_values WHERE id='{id}'",
             pg_conn,
         )
-        assert res_partition[0][0].strip() == res[0][0].strip()
+        # res_partition[0][0] is text; res[0][0] is now native (int for
+        # numeric truncations, string for varchar/char/text).
+        assert res_partition[0][0].strip() == str(res[0][0]).strip()
 
     # register the same table to spark
     # and make sure it can understand our partitioning

pgduck_server/include/duckdb/type_conversion.h

@@ -59,6 +59,6 @@ typedef struct DuckDBTypeInfo
 
 extern DuckDBTypeInfo * find_duck_type_info(duckdb_type duckType);
 
-extern Oid duckdb_type_to_pg_oid(duckdb_type duckType);
+extern Oid	duckdb_type_to_pg_oid(duckdb_type duckType);
 
 #endif

pgduck_server/src/duckdb/duckdb.c

@@ -1148,9 +1148,9 @@ duckdb_query_result_send_column_metadata(DuckDBQueryResult * duckdb_query_result
 			pq_writeint16(buf, originalColumnNumber);
 
 			/*
-			 * We convert each DuckDB type to the closest PostgreSQL OID equivalent.
-			 * columnLength and columnTypeMod are left as -1, see TypeInfo struct
-			 * comment for the reasoning.
+			 * We convert each DuckDB type to the closest PostgreSQL OID
+			 * equivalent. columnLength and columnTypeMod are left as -1, see
+			 * TypeInfo struct comment for the reasoning.
 			 */
 			pq_writeint32(buf, duckdb_type_to_pg_oid(duckType));
 			pq_writeint16(buf, -1);

pgduck_server/src/duckdb/type_conversion.c

@@ -348,103 +348,105 @@ find_duck_type_info(duckdb_type duckType)
  * For types with no direct PG equivalent (e.g. UBIGINT, HUGEINT, UHUGEINT,
  * complex logical types), we fall back to TEXTOID so the client can still
  * consume the text-serialised value we always send.
- * 
+ *
  * Note: consider falling back to InvalidOid (0).
  *
  * For DECIMAL we always return NUMERICOID regardless of width/scale;
  * callers that need the typmod should handle that separately.
  */
-Oid duckdb_type_to_pg_oid(duckdb_type duckType)
+Oid
+duckdb_type_to_pg_oid(duckdb_type duckType)
 {
 	switch (duckType)
 	{
-	/* ---- booleans ---- */
-	case DUCKDB_TYPE_BOOLEAN:
-		return BOOLOID;
-
-	/* ---- integers ---- */
-	case DUCKDB_TYPE_TINYINT:
-		return INT2OID; /* no INT1 in PG */
-	case DUCKDB_TYPE_SMALLINT:
-		return INT2OID;
-	case DUCKDB_TYPE_INTEGER:
-		return INT4OID;
-	case DUCKDB_TYPE_BIGINT:
-		return INT8OID;
-
-	/* unsigned — promote to next signed size that fits */
-	case DUCKDB_TYPE_UTINYINT:
-		return INT2OID;
-	case DUCKDB_TYPE_USMALLINT:
-		return INT4OID;
-	case DUCKDB_TYPE_UINTEGER:
-		return INT8OID;
-	case DUCKDB_TYPE_UBIGINT:
-		return INT8OID; /* no u64 in PG, but this is the closest consistent choice */
-	case DUCKDB_TYPE_HUGEINT:
-		return NUMERICOID;
-	case DUCKDB_TYPE_UHUGEINT:
-		return NUMERICOID;
-
-	/* ---- floats ---- */
-	case DUCKDB_TYPE_FLOAT:
-		return FLOAT4OID;
-	case DUCKDB_TYPE_DOUBLE:
-		return FLOAT8OID;
-
-	/* ---- arbitrary precision ---- */
-	case DUCKDB_TYPE_DECIMAL:
-		return NUMERICOID;
-
-	/* ---- text / bytes ---- */
-	case DUCKDB_TYPE_VARCHAR:
-		return TEXTOID;
-	case DUCKDB_TYPE_BLOB:
-		return BYTEAOID;
-	case DUCKDB_TYPE_BIT:
-		return BITOID;
-	case DUCKDB_TYPE_ENUM:
-		return TEXTOID; /* sent as label text */
-
-	/* ---- date / time ---- */
-	case DUCKDB_TYPE_DATE:
-		return DATEOID;
-	case DUCKDB_TYPE_TIME:
-		return TIMEOID;
-	case DUCKDB_TYPE_TIME_TZ:
-		return TIMETZOID;
-	case DUCKDB_TYPE_TIMESTAMP:
-		return TIMESTAMPOID;
-	case DUCKDB_TYPE_TIMESTAMP_S:
-		return TIMESTAMPOID;
-	case DUCKDB_TYPE_TIMESTAMP_MS:
-		return TIMESTAMPOID;
-	case DUCKDB_TYPE_TIMESTAMP_NS:
-		return TIMESTAMPOID;
-	case DUCKDB_TYPE_TIMESTAMP_TZ:
-		return TIMESTAMPTZOID;
-	case DUCKDB_TYPE_INTERVAL:
-		return INTERVALOID;
-
-	/* ---- uuid ---- */
-	case DUCKDB_TYPE_UUID:
-		return UUIDOID;
-
-	/* ---- complex / nested — serialised as text ---- */
-	/* TODO: Handle this case */
-	case DUCKDB_TYPE_LIST:
-		return TEXTOID;
-	case DUCKDB_TYPE_ARRAY:
-		return TEXTOID;
-	case DUCKDB_TYPE_STRUCT:
-		return TEXTOID;
-	case DUCKDB_TYPE_MAP:
-		return TEXTOID;
-	case DUCKDB_TYPE_UNION:
-		return TEXTOID;
-
-	default:
-		return InvalidOid;
+			/* ---- booleans ---- */
+		case DUCKDB_TYPE_BOOLEAN:
+			return BOOLOID;
+
+			/* ---- integers ---- */
+		case DUCKDB_TYPE_TINYINT:
+			return INT2OID;		/* no INT1 in PG */
+		case DUCKDB_TYPE_SMALLINT:
+			return INT2OID;
+		case DUCKDB_TYPE_INTEGER:
+			return INT4OID;
+		case DUCKDB_TYPE_BIGINT:
+			return INT8OID;
+
+			/* unsigned — promote to next signed size that fits */
+		case DUCKDB_TYPE_UTINYINT:
+			return INT2OID;
+		case DUCKDB_TYPE_USMALLINT:
+			return INT4OID;
+		case DUCKDB_TYPE_UINTEGER:
+			return INT8OID;
+		case DUCKDB_TYPE_UBIGINT:
+			return INT8OID;		/* no u64 in PG, but this is the closest
+								 * consistent choice */
+		case DUCKDB_TYPE_HUGEINT:
+			return NUMERICOID;
+		case DUCKDB_TYPE_UHUGEINT:
+			return NUMERICOID;
+
+			/* ---- floats ---- */
+		case DUCKDB_TYPE_FLOAT:
+			return FLOAT4OID;
+		case DUCKDB_TYPE_DOUBLE:
+			return FLOAT8OID;
+
+			/* ---- arbitrary precision ---- */
+		case DUCKDB_TYPE_DECIMAL:
+			return NUMERICOID;
+
+			/* ---- text / bytes ---- */
+		case DUCKDB_TYPE_VARCHAR:
+			return TEXTOID;
+		case DUCKDB_TYPE_BLOB:
+			return BYTEAOID;
+		case DUCKDB_TYPE_BIT:
+			return BITOID;
+		case DUCKDB_TYPE_ENUM:
+			return TEXTOID;		/* sent as label text */
+
+			/* ---- date / time ---- */
+		case DUCKDB_TYPE_DATE:
+			return DATEOID;
+		case DUCKDB_TYPE_TIME:
+			return TIMEOID;
+		case DUCKDB_TYPE_TIME_TZ:
+			return TIMETZOID;
+		case DUCKDB_TYPE_TIMESTAMP:
+			return TIMESTAMPOID;
+		case DUCKDB_TYPE_TIMESTAMP_S:
+			return TIMESTAMPOID;
+		case DUCKDB_TYPE_TIMESTAMP_MS:
+			return TIMESTAMPOID;
+		case DUCKDB_TYPE_TIMESTAMP_NS:
+			return TIMESTAMPOID;
+		case DUCKDB_TYPE_TIMESTAMP_TZ:
+			return TIMESTAMPTZOID;
+		case DUCKDB_TYPE_INTERVAL:
+			return INTERVALOID;
+
+			/* ---- uuid ---- */
+		case DUCKDB_TYPE_UUID:
+			return UUIDOID;
+
+			/* ---- complex / nested — serialised as text ---- */
+			/* TODO: Handle this case */
+		case DUCKDB_TYPE_LIST:
+			return TEXTOID;
+		case DUCKDB_TYPE_ARRAY:
+			return TEXTOID;
+		case DUCKDB_TYPE_STRUCT:
+			return TEXTOID;
+		case DUCKDB_TYPE_MAP:
+			return TEXTOID;
+		case DUCKDB_TYPE_UNION:
+			return TEXTOID;
+
+		default:
+			return InvalidOid;
 	}
 }