Add initial PG19 support (#983)

Author: JelteF

.github/workflows/build_and_test.yaml

@@ -54,9 +54,14 @@ jobs:
           type: ReleaseStatic
         - version: REL_18_STABLE
           type: Debug
+        - version: master
+          type: Release
 
     runs-on: ubuntu-24.04
 
+    env:
+      PG_MAX_VER: "19"
+
     steps:
       - name: Test details
         run: echo Build and test pg_duckdb with PostgreSQL ${{ matrix.version }} branch

include/pgduckdb/pg/declarations.hpp

@@ -50,8 +50,8 @@ typedef struct ParamListInfoData *ParamListInfo;
 
 struct PlannedStmt;
 
-typedef char *Pointer;
-typedef Pointer Page;
+typedef char PageData;
+typedef PageData *Page;
 
 struct Query;
 

include/pgduckdb/pg/transactions.hpp

@@ -5,12 +5,14 @@
 extern "C" {
 extern bool IsSubTransaction(void);
 
-#define FirstCommandId ((CommandId)0)
-
 /*
  * These enum definitions are vendored in so we can implement a postgres
  * XactCallback in C++. It's not expected that these will ever change.
+ *
+ * They are guarded by XACT_H to avoid redefinition errors when access/xact.h
+ * has already been included.
  */
+#ifndef XACT_H
 typedef enum {
 	XACT_EVENT_COMMIT,
 	XACT_EVENT_PARALLEL_COMMIT,
@@ -32,6 +34,10 @@ typedef enum {
 } SubXactEvent;
 
 typedef void (*SubXactCallback)(SubXactEvent event, SubTransactionId mySubid, SubTransactionId parentSubid, void *arg);
+
+/* Similarly guarded to avoid redefinition errors */
+#define FirstCommandId ((CommandId)0)
+#endif
 }
 
 namespace pgduckdb::pg {

src/pg/memory.cpp

@@ -1,4 +1,5 @@
 #include "pgduckdb/pgduckdb_utils.hpp"
+#include "pgduckdb/pg/memory.hpp"
 
 extern "C" {
 #include "postgres.h"

src/pg/permissions.cpp

@@ -1,3 +1,5 @@
+#include "pgduckdb/pg/permissions.hpp"
+
 extern "C" {
 #include "postgres.h"
 #include "miscadmin.h"         // GetUserId

src/pg/pgduckdb_subscript.cpp

@@ -16,7 +16,7 @@ namespace pgduckdb {
 
 namespace pg {
 
-Node *
+static Node *
 CoerceSubscriptToText(struct ParseState *pstate, A_Indices *subscript, const char *type_name) {
 	if (!subscript->uidx) {
 		elog(ERROR, "Creating a slice out of %s is not supported", type_name);
@@ -69,7 +69,7 @@ CoerceSubscriptToText(struct ParseState *pstate, A_Indices *subscript, const cha
  *
  * See also comments on SubscriptingRef in nodes/subscripting.h
  */
-void
+static void
 AddSubscriptExpressions(SubscriptingRef *sbsref, struct ParseState *pstate, A_Indices *subscript, bool is_slice) {
 	Assert(is_slice || subscript->uidx);
 
@@ -95,7 +95,7 @@ AddSubscriptExpressions(SubscriptingRef *sbsref, struct ParseState *pstate, A_In
  * expressions. All this does is parse those expressions and make sure the
  * subscript returns an an duckdb.unresolved_type again.
  */
-void
+static void
 DuckdbSubscriptTransform(SubscriptingRef *sbsref, List *indirection, struct ParseState *pstate, bool is_slice,
                          bool is_assignment, const char *type_name) {
 	/*
@@ -135,7 +135,7 @@ DuckdbSubscriptTransform(SubscriptingRef *sbsref, List *indirection, struct Pars
  *
  * Currently this is used for duckdb.row and duckdb.struct types.
  */
-void
+static void
 DuckdbTextSubscriptTransform(SubscriptingRef *sbsref, List *indirection, struct ParseState *pstate, bool is_slice,
                              bool is_assignment, const char *type_name) {
 	/*
@@ -217,7 +217,7 @@ DuckdbSubscriptFetchOld(ExprState * /*state*/, ExprEvalStep *op, ExprContext * /
  * shouldn't force usage of DuckDB execution when duckdb types are present in
  * the query. So these methods are just stubs that throw an error when called.
  */
-void
+static void
 DuckdbSubscriptExecSetup(const SubscriptingRef * /*sbsref*/, SubscriptingRefState *sbsrefstate,
                          SubscriptExecSteps *methods, const char *type_name) {
 
@@ -228,13 +228,13 @@ DuckdbSubscriptExecSetup(const SubscriptingRef * /*sbsref*/, SubscriptingRefStat
 	methods->sbs_fetch_old = DuckdbSubscriptFetchOld;
 }
 
-void
+static void
 DuckdbRowSubscriptTransform(SubscriptingRef *sbsref, List *indirection, struct ParseState *pstate, bool is_slice,
                             bool is_assignment) {
 	DuckdbTextSubscriptTransform(sbsref, indirection, pstate, is_slice, is_assignment, "duckdb.row");
 }
 
-void
+static void
 DuckdbRowSubscriptExecSetup(const SubscriptingRef *sbsref, SubscriptingRefState *sbsrefstate,
                             SubscriptExecSteps *methods) {
 	DuckdbSubscriptExecSetup(sbsref, sbsrefstate, methods, "duckdb.row");
@@ -248,13 +248,13 @@ static SubscriptRoutines duckdb_row_subscript_routines = {
     .store_leakproof = true,
 };
 
-void
+static void
 DuckdbUnresolvedTypeSubscriptTransform(SubscriptingRef *sbsref, List *indirection, struct ParseState *pstate,
                                        bool is_slice, bool is_assignment) {
 	DuckdbSubscriptTransform(sbsref, indirection, pstate, is_slice, is_assignment, "duckdb.unresolved_type");
 }
 
-void
+static void
 DuckdbUnresolvedTypeSubscriptExecSetup(const SubscriptingRef *sbsref, SubscriptingRefState *sbsrefstate,
                                        SubscriptExecSteps *methods) {
 	DuckdbSubscriptExecSetup(sbsref, sbsrefstate, methods, "duckdb.unresolved_type");
@@ -268,13 +268,13 @@ static SubscriptRoutines duckdb_unresolved_type_subscript_routines = {
     .store_leakproof = true,
 };
 
-void
+static void
 DuckdbStructSubscriptTransform(SubscriptingRef *sbsref, List *indirection, struct ParseState *pstate, bool is_slice,
                                bool is_assignment) {
 	DuckdbTextSubscriptTransform(sbsref, indirection, pstate, is_slice, is_assignment, "duckdb.struct");
 }
 
-void
+static void
 DuckdbStructSubscriptExecSetup(const SubscriptingRef *sbsref, SubscriptingRefState *sbsrefstate,
                                SubscriptExecSteps *methods) {
 	DuckdbSubscriptExecSetup(sbsref, sbsrefstate, methods, "duckdb.struct");
@@ -288,13 +288,13 @@ static SubscriptRoutines duckdb_struct_subscript_routines = {
     .store_leakproof = true,
 };
 
-void
+static void
 DuckdbMapSubscriptTransform(SubscriptingRef *sbsref, List *indirection, struct ParseState *pstate, bool is_slice,
                             bool is_assignment) {
 	DuckdbSubscriptTransform(sbsref, indirection, pstate, is_slice, is_assignment, "duckdb.map");
 }
 
-void
+static void
 DuckdbMapSubscriptExecSetup(const SubscriptingRef *sbsref, SubscriptingRefState *sbsrefstate,
                             SubscriptExecSteps *methods) {
 	DuckdbSubscriptExecSetup(sbsref, sbsrefstate, methods, "duckdb.map");

src/pg/relations.cpp

@@ -123,7 +123,7 @@ EstimateRelSize(Relation rel) {
 	return cardinality;
 }
 
-Oid
+static Oid
 PGGetRelidFromSchemaAndTable(const char *schema_name, const char *entry_name) {
 	List *name_list = NIL;
 	name_list = lappend(name_list, makeString(pstrdup(schema_name)));

src/pg/transactions.cpp

@@ -6,10 +6,12 @@ extern "C" {
 #include "access/xlog.h" // XactLastRecEnd
 }
 
+#include "pgduckdb/pg/transactions.hpp"
+
 namespace pgduckdb::pg {
 
 CommandId
-GetCurrentCommandId(bool used = false) {
+GetCurrentCommandId(bool used) {
 	return PostgresFunctionGuard(::GetCurrentCommandId, used);
 }
 

src/pgduckdb_background_worker.cpp

@@ -53,6 +53,7 @@ extern "C" {
 #include "utils/acl.h"
 #include "utils/builtins.h"
 #include "utils/guc.h"
+#include "utils/lsyscache.h"
 #include "utils/memutils.h"
 #include "utils/palloc.h"
 #include "utils/snapmgr.h"
@@ -119,14 +120,14 @@ static BackgroundWorkerShmemStruct *BgwShmemStruct;
 MUST be called under a lock
 Get the BGW state for the current database (MyDatabaseId)
 */
-BgwStatePerDB *
+static BgwStatePerDB *
 FindState() {
 	bool found = false;
 	auto state = (BgwStatePerDB *)hash_search(BgwShmemStruct->statePerDB, &MyDatabaseId, HASH_FIND, &found);
 	return found ? state : nullptr;
 }
 
-BgwStatePerDB *
+static BgwStatePerDB *
 GetState() {
 	Assert(is_background_worker);
 	auto state = FindState();
@@ -158,7 +159,7 @@ BackgroundWorkerCheck(duckdb::Connection &connection, int64_t &last_activity_cou
 
 bool CanTakeBgwLockForDatabase(Oid database_oid);
 
-bool
+static bool
 RunOneCheck(int64_t &last_activity_count) {
 	// No need to run if MD is not enabled.
 	if (!IsMotherDuckEnabled()) {
@@ -183,15 +184,15 @@ RunOneCheck(int64_t &last_activity_count) {
 	return false;
 }
 
-void
+static void
 SetBackgroundWorkerState(Oid database_oid) {
 	auto state = (BgwStatePerDB *)hash_search(BgwShmemStruct->statePerDB, &database_oid, HASH_ENTER, NULL);
 	state->latch = MyLatch;
 	state->activity_count = 0;
 	state->bgw_session_hint_is_reused = false;
 }
 
-void
+static void
 BgwMainLoop() {
 	elog(LOG, "pg_duckdb background worker: starting");
 
@@ -245,6 +246,8 @@ BgwMainLoop() {
 
 extern "C" {
 
+PGDLLEXPORT void pgduckdb_background_worker_main(Datum main_arg);
+
 PGDLLEXPORT void
 pgduckdb_background_worker_main(Datum main_arg) {
 	Oid database_oid = DatumGetObjectId(main_arg);
@@ -369,7 +372,7 @@ ShmemStartup(void) {
 
 constexpr const char *PGDUCKDB_SYNC_WORKER_NAME = "pg_duckdb sync worker";
 
-bool
+static bool
 HasBgwRunningForMyDatabase() {
 	const auto num_backends = pgstat_fetch_stat_numbackends();
 	for (int backend_idx = 1; backend_idx <= num_backends; ++backend_idx) {
@@ -545,7 +548,7 @@ PossiblyReuseBgwSessionHint(void) {
 bool doing_motherduck_sync;
 char *current_motherduck_catalog_version;
 
-std::string
+static std::string
 PgSchemaName(const std::string &db_name, const std::string &schema_name, bool is_default_db) {
 	if (is_default_db) {
 		/*
@@ -564,7 +567,7 @@ PgSchemaName(const std::string &db_name, const std::string &schema_name, bool is
 	return oss.str();
 }
 
-std::string
+static std::string
 DropPgRelationString(const char *postgres_schema_name, const char *relation_name, char relation_kind,
                      bool with_cascade) {
 	std::ostringstream oss;
@@ -584,7 +587,7 @@ DropPgRelationString(const char *postgres_schema_name, const char *relation_name
 	return oss.str();
 }
 
-std::string
+static std::string
 CreatePgViewString(duckdb::CreateViewInfo &info, bool is_default_db) {
 	std::ostringstream oss;
 
@@ -640,7 +643,7 @@ CreatePgViewString(duckdb::CreateViewInfo &info, bool is_default_db) {
 	return oss.str();
 }
 
-std::string
+static std::string
 CreatePgTableString(duckdb::CreateTableInfo &info, bool is_default_db) {
 	std::ostringstream oss;
 
@@ -702,7 +705,7 @@ CreatePgSchemaString(std::string postgres_schema_name) {
  * See the following thread for details:
  * https://www.postgresql.org/message-id/flat/CAFcNs%2Bp%2BfD5HEXEiZMZC1COnXkJCMnUK0%3Dr4agmZP%3D9Hi%2BYcJA%40mail.gmail.com
  */
-void
+static void
 SPI_commit_that_works_in_bgworker() {
 	if (is_background_worker) {
 		SPI_finish();

src/pgduckdb_ddl.cpp

@@ -1175,7 +1175,7 @@ DuckdbTruncateTable(Oid relation_oid) {
  * ONCOMMIT_DROP, but this will also handle any new ON COMMIT clauses that
  * might be added to Postgres in future releases.
  */
-void
+static void
 CheckOnCommitSupport(OnCommitAction on_commit) {
 	switch (on_commit) {
 	case ONCOMMIT_NOOP: