Add ScopedPostgresResource

include/pgduckdb/common/scoped_postgres_resource.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+namespace pgduckdb {
+
+template <class T>
+class ScopedPostgresResource {
+public:
+	using resource_destructor_t = std::function<void(T)>;
+
+	explicit ScopedPostgresResource(T resource, resource_destructor_t &&destructor)
+	    : resource(resource), destructor(std::move(destructor)) {
+	}
+	~ScopedPostgresResource() {
+		destructor(resource);
+	}
+
+private:
+	T resource;
+	resource_destructor_t destructor;
+};
+
+// Specialization for pointer types
+template <class T>
+class ScopedPostgresResource<T *> {
+public:
+	using resource_destructor_t = std::function<void(T *)>;
+
+	explicit ScopedPostgresResource(T *resource, resource_destructor_t &&destructor)
+	    : resource(resource), destructor(std::move(destructor)) {
+	}
+
+	~ScopedPostgresResource() {
+		destructor(resource);
+	}
+
+	T *
+	operator->() const {
+		return resource;
+	}
+
+	operator void *() const {
+		return static_cast<void *>(resource);
+	}
+
+private:
+	T *resource;
+	resource_destructor_t destructor;
+};
+
+} // namespace pgduckdb

src/pgduckdb_metadata_cache.cpp

@@ -15,6 +15,7 @@ extern "C" {
 #include "utils/syscache.h"
 }
 
+#include "pgduckdb/common/scoped_postgres_resource.hpp"
 #include "pgduckdb/vendor/pg_list.hpp"
 
 namespace pgduckdb {
@@ -88,7 +89,9 @@ BuildDuckdbOnlyFunctions() {
 	const char *function_names[] = {"read_parquet", "read_csv", "iceberg_scan"};
 
 	for (int i = 0; i < lengthof(function_names); i++) {
-		CatCList *catlist = SearchSysCacheList1(PROCNAMEARGSNSP, CStringGetDatum(function_names[i]));
+		auto catlist =
+		    ScopedPostgresResource<CatCList *>(SearchSysCacheList1(PROCNAMEARGSNSP, CStringGetDatum(function_names[i])),
+		                                       [](CatCList *clist) { ReleaseSysCacheList(clist); });
 
 		for (int j = 0; j < catlist->n_members; j++) {
 			HeapTuple tuple = &catlist->members[j]->tuple;
@@ -102,8 +105,6 @@ BuildDuckdbOnlyFunctions() {
 			cache.duckdb_only_functions = lappend_oid(cache.duckdb_only_functions, function->oid);
 			MemoryContextSwitchTo(oldcontext);
 		}
-
-		ReleaseSysCacheList(catlist);
 	}
 }
 

src/pgduckdb_planner.cpp

@@ -16,6 +16,7 @@ extern "C" {
 #include "pgduckdb/pgduckdb_duckdb.hpp"
 #include "pgduckdb/scan/postgres_scan.hpp"
 #include "pgduckdb/pgduckdb_node.hpp"
+#include "pgduckdb/common/scoped_postgres_resource.hpp"
 #include "pgduckdb/pgduckdb_planner.hpp"
 #include "pgduckdb/pgduckdb_types.hpp"
 #include "pgduckdb/pgduckdb_utils.hpp"
@@ -111,10 +112,10 @@ CreatePlan(Query *query, ParamListInfo bound_params) {
 			return nullptr;
 		}
 
-		HeapTuple tp;
 		Form_pg_type typtup;
 
-		tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(postgresColumnOid));
+		auto tp = pgduckdb::ScopedPostgresResource<HeapTuple>(
+		    SearchSysCache1(TYPEOID, ObjectIdGetDatum(postgresColumnOid)), ReleaseSysCache);
 		if (!HeapTupleIsValid(tp)) {
 			elog(WARNING, "(PGDuckDB/CreatePlan) Cache lookup failed for type %u", postgresColumnOid);
 			return nullptr;
@@ -127,8 +128,6 @@ CreatePlan(Query *query, ParamListInfo bound_params) {
 		duckdb_node->custom_scan_tlist =
 		    lappend(duckdb_node->custom_scan_tlist,
 		            makeTargetEntry((Expr *)var, i + 1, (char *)pstrdup(prepared_query->GetNames()[i].c_str()), false));
-
-		ReleaseSysCache(tp);
 	}
 
 	duckdb_node->custom_private = list_make1(query);

src/scan/postgres_index_scan.cpp

@@ -14,6 +14,7 @@ extern "C" {
 #include "pgduckdb/scan/index_scan_utils.hpp"
 #include "pgduckdb/scan/postgres_index_scan.hpp"
 #include "pgduckdb/pgduckdb_types.hpp"
+#include "pgduckdb/common/scoped_postgres_resource.hpp"
 #include "pgduckdb/vendor/pg_list.hpp"
 
 namespace pgduckdb {
@@ -91,7 +92,7 @@ PostgresIndexScanFunction::PostgresIndexScanBind(duckdb::ClientContext &context,
 
 	RangeTblEntry *rte = planner_rt_fetch(path->parent->relid, planner_info);
 
-	auto rel = RelationIdGetRelation(rte->relid);
+	auto rel = ScopedPostgresResource<Relation>(RelationIdGetRelation(rte->relid), RelationClose);
 	auto relation_descr = RelationGetDescr(rel);
 
 	if (!relation_descr) {
@@ -111,8 +112,6 @@ PostgresIndexScanFunction::PostgresIndexScanBind(duckdb::ClientContext &context,
 		     duck_type.ToString().c_str());
 	}
 
-	RelationClose(rel);
-
 	return duckdb::make_uniq<PostgresIndexScanFunctionData>(cardinality, path, planner_info, rte->relid, snapshot);
 }
 

src/scan/postgres_scan.cpp

@@ -25,6 +25,7 @@ extern "C" {
 }
 
 #include "pgduckdb/scan/postgres_scan.hpp"
+#include "pgduckdb/common/scoped_postgres_resource.hpp"
 #include "pgduckdb/pgduckdb_types.hpp"
 
 namespace pgduckdb {
@@ -186,7 +187,7 @@ PostgresReplacementScan(duckdb::ClientContext &context, duckdb::ReplacementScanI
 	}
 
 	// Check if the Relation is a VIEW
-	auto tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
+	auto tuple = ScopedPostgresResource<HeapTuple>(SearchSysCache1(RELOID, ObjectIdGetDatum(relid)), ReleaseSysCache);
 	if (!HeapTupleIsValid(tuple)) {
 		elog(WARNING, "(PGDuckDB/PostgresReplacementScan) Cache lookup failed for relation %u", relid);
 		return nullptr;
@@ -196,10 +197,8 @@ PostgresReplacementScan(duckdb::ClientContext &context, duckdb::ReplacementScanI
 
 	// Check if the relation is a view
 	if (relForm->relkind == RELKIND_VIEW) {
-		ReleaseSysCache(tuple);
 		return ReplaceView(relid);
 	}
-	ReleaseSysCache(tuple);
 
 	RelOptInfo *node = nullptr;
 	Path *node_path = nullptr;

src/scan/postgres_seq_scan.cpp

@@ -1,6 +1,7 @@
 #include "duckdb.hpp"
 
 #include "pgduckdb/scan/postgres_seq_scan.hpp"
+#include "pgduckdb/common/scoped_postgres_resource.hpp"
 #include "pgduckdb/pgduckdb_types.hpp"
 
 namespace pgduckdb {
@@ -72,12 +73,12 @@ PostgresSeqScanFunction::PostgresSeqScanBind(duckdb::ClientContext &context, duc
 	auto relid = input.named_parameters["relid"].GetValue<uint32_t>();
 	auto snapshot = (reinterpret_cast<Snapshot>(input.named_parameters["snapshot"].GetPointer()));
 
-	auto rel = RelationIdGetRelation(relid);
+	auto rel = ScopedPostgresResource<Relation>(RelationIdGetRelation(relid), RelationClose);
+
 	auto relation_descr = RelationGetDescr(rel);
 
 	if (!relation_descr) {
 		elog(WARNING, "(PGDuckDB/PostgresSeqScanBind) Failed to get tuple descriptor for relation with OID %u", relid);
-		RelationClose(rel);
 		return nullptr;
 	}
 
@@ -92,7 +93,6 @@ PostgresSeqScanFunction::PostgresSeqScanBind(duckdb::ClientContext &context, duc
 		     duck_type.ToString().c_str());
 	}
 
-	RelationClose(rel);
 	return duckdb::make_uniq<PostgresSeqScanFunctionData>(cardinality, relid, snapshot);
 }