Merge pull request #357 from Mytherin/main

Mytherin · web-flow · commit e58cd1dfed98 · 2025-07-31T11:09:42.000+02:00
Bump to main
diff --git a/.github/workflows/MainDistributionPipeline.yml b/.github/workflows/MainDistributionPipeline.yml
@@ -16,7 +16,7 @@ jobs:
     name: Build extension binaries
     uses: duckdb/extension-ci-tools/.github/workflows/_extension_distribution.yml@v1.3.2
     with:
-      duckdb_version: v1.3.2
+      duckdb_version: main
       ci_tools_version: v1.3.2
       extension_name: postgres_scanner
       exclude_archs: 'wasm_mvp;wasm_eh;wasm_threads;windows_amd64_mingw'
@@ -27,7 +27,7 @@ jobs:
     uses: duckdb/extension-ci-tools/.github/workflows/_extension_deploy.yml@v1.3.2
     secrets: inherit
     with:
-      duckdb_version: v1.3.2
+      duckdb_version: main
       ci_tools_version: v1.3.2
       extension_name: postgres_scanner
       exclude_archs: 'wasm_mvp;wasm_eh;wasm_threads;windows_amd64_mingw'
diff --git a/duckdb b/duckdb
@@ -1 +1 @@
-Subproject commit 0b83e5d2f68bc02dfefde74b846bd039f078affa
+Subproject commit ff0f95954bdb4c7515481ac2b473261407bad18b
diff --git a/src/include/postgres_scanner_extension.hpp b/src/include/postgres_scanner_extension.hpp
@@ -13,11 +13,9 @@ class PostgresScannerExtension : public Extension {
 	std::string Name() override {
 		return "postgres_scanner";
 	}
-	void Load(DuckDB &db) override;
+	void Load(ExtensionLoader &loader) override;
 };
 
 extern "C" {
-DUCKDB_EXTENSION_API void postgres_scanner_init(duckdb::DatabaseInstance &db);
-DUCKDB_EXTENSION_API const char *postgres_scanner_version();
-DUCKDB_EXTENSION_API void postgres_scanner_storage_init(DBConfig &config);
+DUCKDB_CPP_EXTENSION_ENTRY(postgres_scanner, loader);
 }
diff --git a/src/include/storage/postgres_delete.hpp b/src/include/storage/postgres_delete.hpp
@@ -14,7 +14,7 @@ namespace duckdb {
 
 class PostgresDelete : public PhysicalOperator {
 public:
-	PostgresDelete(LogicalOperator &op, TableCatalogEntry &table, idx_t row_id_index);
+	PostgresDelete(PhysicalPlan &physical_plan, LogicalOperator &op, TableCatalogEntry &table, idx_t row_id_index);
 
 	//! The table to delete from
 	TableCatalogEntry &table;
diff --git a/src/include/storage/postgres_index.hpp b/src/include/storage/postgres_index.hpp
@@ -16,7 +16,8 @@ namespace duckdb {
 //! PhysicalCreateSequence represents a CREATE SEQUENCE command
 class PostgresCreateIndex : public PhysicalOperator {
 public:
-	explicit PostgresCreateIndex(unique_ptr<CreateIndexInfo> info, TableCatalogEntry &table);
+	explicit PostgresCreateIndex(PhysicalPlan &physical_plan, unique_ptr<CreateIndexInfo> info,
+	                             TableCatalogEntry &table);
 
 	unique_ptr<CreateIndexInfo> info;
 	TableCatalogEntry &table;
diff --git a/src/include/storage/postgres_insert.hpp b/src/include/storage/postgres_insert.hpp
@@ -16,9 +16,11 @@ namespace duckdb {
 class PostgresInsert : public PhysicalOperator {
 public:
 	//! INSERT INTO
-	PostgresInsert(LogicalOperator &op, TableCatalogEntry &table, physical_index_vector_t<idx_t> column_index_map);
+	PostgresInsert(PhysicalPlan &physical_plan, LogicalOperator &op, TableCatalogEntry &table,
+	               physical_index_vector_t<idx_t> column_index_map);
 	//! CREATE TABLE AS
-	PostgresInsert(LogicalOperator &op, SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info);
+	PostgresInsert(PhysicalPlan &physical_plan, LogicalOperator &op, SchemaCatalogEntry &schema,
+	               unique_ptr<BoundCreateTableInfo> info);
 
 	//! The table to insert into
 	optional_ptr<TableCatalogEntry> table;
diff --git a/src/include/storage/postgres_update.hpp b/src/include/storage/postgres_update.hpp
@@ -15,7 +15,8 @@ namespace duckdb {
 
 class PostgresUpdate : public PhysicalOperator {
 public:
-	PostgresUpdate(LogicalOperator &op, TableCatalogEntry &table, vector<PhysicalIndex> columns);
+	PostgresUpdate(PhysicalPlan &physical_plan, LogicalOperator &op, TableCatalogEntry &table,
+	               vector<PhysicalIndex> columns);
 
 	//! The table to delete from
 	TableCatalogEntry &table;
diff --git a/src/postgres_extension.cpp b/src/postgres_extension.cpp
@@ -8,7 +8,7 @@
 
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/parser/parsed_data/create_table_function_info.hpp"
-#include "duckdb/main/extension_util.hpp"
+#include "duckdb/main/extension/extension_loader.hpp"
 #include "duckdb/common/helper.hpp"
 #include "duckdb/main/database_manager.hpp"
 #include "duckdb/main/attached_database.hpp"
@@ -125,41 +125,41 @@ void SetPostgresNullByteReplacement(ClientContext &context, SetScope scope, Valu
 	}
 }
 
-static void LoadInternal(DatabaseInstance &db) {
+static void LoadInternal(ExtensionLoader &loader) {
 	PostgresScanFunction postgres_fun;
-	ExtensionUtil::RegisterFunction(db, postgres_fun);
+	loader.RegisterFunction(postgres_fun);
 
 	PostgresScanFunctionFilterPushdown postgres_fun_filter_pushdown;
-	ExtensionUtil::RegisterFunction(db, postgres_fun_filter_pushdown);
+	loader.RegisterFunction(postgres_fun_filter_pushdown);
 
 	PostgresAttachFunction attach_func;
-	ExtensionUtil::RegisterFunction(db, attach_func);
+	loader.RegisterFunction(attach_func);
 
 	PostgresClearCacheFunction clear_cache_func;
-	ExtensionUtil::RegisterFunction(db, clear_cache_func);
+	loader.RegisterFunction(clear_cache_func);
 
 	PostgresQueryFunction query_func;
-	ExtensionUtil::RegisterFunction(db, query_func);
+	loader.RegisterFunction(query_func);
 
 	PostgresExecuteFunction execute_func;
-	ExtensionUtil::RegisterFunction(db, execute_func);
+	loader.RegisterFunction(execute_func);
 
 	PostgresBinaryCopyFunction binary_copy;
-	ExtensionUtil::RegisterFunction(db, binary_copy);
+	loader.RegisterFunction(binary_copy);
 
 	// Register the new type
 	SecretType secret_type;
 	secret_type.name = "postgres";
 	secret_type.deserializer = KeyValueSecret::Deserialize<KeyValueSecret>;
 	secret_type.default_provider = "config";
 
-	ExtensionUtil::RegisterSecretType(db, secret_type);
+	loader.RegisterSecretType(secret_type);
 
 	CreateSecretFunction postgres_secret_function = {"postgres", "config", CreatePostgresSecretFunction};
 	SetPostgresSecretParameters(postgres_secret_function);
-	ExtensionUtil::RegisterFunction(db, postgres_secret_function);
+	loader.RegisterFunction(postgres_secret_function);
 
-	auto &config = DBConfig::GetConfig(db);
+	auto &config = DBConfig::GetConfig(loader.GetDatabaseInstance());
 	config.storage_extensions["postgres_scanner"] = make_uniq<PostgresStorageExtension>();
 
 	config.AddExtensionOption("pg_use_binary_copy", "Whether or not to use BINARY copy to read data",
@@ -193,26 +193,18 @@ static void LoadInternal(DatabaseInstance &db) {
 	config.optimizer_extensions.push_back(std::move(postgres_optimizer));
 
 	config.extension_callbacks.push_back(make_uniq<PostgresExtensionCallback>());
-	for (auto &connection : ConnectionManager::Get(db).GetConnectionList()) {
+	for (auto &connection : ConnectionManager::Get(loader.GetDatabaseInstance()).GetConnectionList()) {
 		connection->registered_state->Insert("postgres_extension", make_shared_ptr<PostgresExtensionState>());
 	}
 }
 
-void PostgresScannerExtension::Load(DuckDB &db) {
-	LoadInternal(*db.instance);
+void PostgresScannerExtension::Load(ExtensionLoader &loader) {
+	LoadInternal(loader);
 }
 
 extern "C" {
 
-DUCKDB_EXTENSION_API void postgres_scanner_init(duckdb::DatabaseInstance &db) {
-	LoadInternal(db);
-}
-
-DUCKDB_EXTENSION_API const char *postgres_scanner_version() {
-	return DuckDB::LibraryVersion();
-}
-
-DUCKDB_EXTENSION_API void postgres_scanner_storage_init(DBConfig &config) {
-	config.storage_extensions["postgres_scanner"] = make_uniq<PostgresStorageExtension>();
+DUCKDB_CPP_EXTENSION_ENTRY(postgres_scanner, loader) {
+	LoadInternal(loader);
 }
 }
diff --git a/src/postgres_scanner.cpp b/src/postgres_scanner.cpp
@@ -2,7 +2,7 @@
 
 #include <libpq-fe.h>
 
-#include "duckdb/main/extension_util.hpp"
+#include "duckdb/main/extension/extension_loader.hpp"
 #include "duckdb/common/shared_ptr.hpp"
 #include "duckdb/common/helper.hpp"
 #include "duckdb/parser/parsed_data/create_table_function_info.hpp"
diff --git a/src/postgres_storage.cpp b/src/postgres_storage.cpp
@@ -7,9 +7,9 @@
 
 namespace duckdb {
 
-static unique_ptr<Catalog> PostgresAttach(StorageExtensionInfo *storage_info, ClientContext &context,
+static unique_ptr<Catalog> PostgresAttach(optional_ptr<StorageExtensionInfo> storage_info, ClientContext &context,
                                           AttachedDatabase &db, const string &name, AttachInfo &info,
-                                          AccessMode access_mode) {
+                                          AttachOptions &attach_options) {
 	auto &config = DBConfig::GetConfig(context);
 	if (!config.options.enable_external_access) {
 		throw PermissionException("Attaching Postgres databases is disabled through configuration");
@@ -19,11 +19,9 @@ static unique_ptr<Catalog> PostgresAttach(StorageExtensionInfo *storage_info, Cl
 	string secret_name;
 	string schema_to_load;
 	PostgresIsolationLevel isolation_level = PostgresIsolationLevel::REPEATABLE_READ;
-	for (auto &entry : info.options) {
+	for (auto &entry : attach_options.options) {
 		auto lower_name = StringUtil::Lower(entry.first);
-		if (lower_name == "type" || lower_name == "read_only" || lower_name == "read_write") {
-			// already handled
-		} else if (lower_name == "secret") {
+		if (lower_name == "secret") {
 			secret_name = entry.second.ToString();
 		} else if (lower_name == "schema") {
 			schema_to_load = entry.second.ToString();
@@ -46,11 +44,11 @@ static unique_ptr<Catalog> PostgresAttach(StorageExtensionInfo *storage_info, Cl
 		}
 	}
 	auto connection_string = PostgresCatalog::GetConnectionString(context, attach_path, secret_name);
-	return make_uniq<PostgresCatalog>(db, std::move(connection_string), std::move(attach_path), access_mode,
-	                                  std::move(schema_to_load), isolation_level);
+	return make_uniq<PostgresCatalog>(db, std::move(connection_string), std::move(attach_path),
+	                                  attach_options.access_mode, std::move(schema_to_load), isolation_level);
 }
 
-static unique_ptr<TransactionManager> PostgresCreateTransactionManager(StorageExtensionInfo *storage_info,
+static unique_ptr<TransactionManager> PostgresCreateTransactionManager(optional_ptr<StorageExtensionInfo> storage_info,
                                                                        AttachedDatabase &db, Catalog &catalog) {
 	auto &postgres_catalog = catalog.Cast<PostgresCatalog>();
 	return make_uniq<PostgresTransactionManager>(db, postgres_catalog);
diff --git a/src/storage/postgres_delete.cpp b/src/storage/postgres_delete.cpp
@@ -8,8 +8,10 @@
 
 namespace duckdb {
 
-PostgresDelete::PostgresDelete(LogicalOperator &op, TableCatalogEntry &table, idx_t row_id_index)
-    : PhysicalOperator(PhysicalOperatorType::EXTENSION, op.types, 1), table(table), row_id_index(row_id_index) {
+PostgresDelete::PostgresDelete(PhysicalPlan &physical_plan, LogicalOperator &op, TableCatalogEntry &table,
+                               idx_t row_id_index)
+    : PhysicalOperator(physical_plan, PhysicalOperatorType::EXTENSION, op.types, 1), table(table),
+      row_id_index(row_id_index) {
 }
 
 //===--------------------------------------------------------------------===//
diff --git a/src/storage/postgres_index.cpp b/src/storage/postgres_index.cpp
@@ -11,8 +11,10 @@
 
 namespace duckdb {
 
-PostgresCreateIndex::PostgresCreateIndex(unique_ptr<CreateIndexInfo> info, TableCatalogEntry &table)
-    : PhysicalOperator(PhysicalOperatorType::EXTENSION, {LogicalType::BIGINT}, 1), info(std::move(info)), table(table) {
+PostgresCreateIndex::PostgresCreateIndex(PhysicalPlan &physical_plan, unique_ptr<CreateIndexInfo> info,
+                                         TableCatalogEntry &table)
+    : PhysicalOperator(physical_plan, PhysicalOperatorType::EXTENSION, {LogicalType::BIGINT}, 1), info(std::move(info)),
+      table(table) {
 }
 
 //===--------------------------------------------------------------------===//
diff --git a/src/storage/postgres_insert.cpp b/src/storage/postgres_insert.cpp
@@ -14,14 +14,15 @@
 
 namespace duckdb {
 
-PostgresInsert::PostgresInsert(LogicalOperator &op, TableCatalogEntry &table,
+PostgresInsert::PostgresInsert(PhysicalPlan &physical_plan, LogicalOperator &op, TableCatalogEntry &table,
                                physical_index_vector_t<idx_t> column_index_map_p)
-    : PhysicalOperator(PhysicalOperatorType::EXTENSION, op.types, 1), table(&table), schema(nullptr),
+    : PhysicalOperator(physical_plan, PhysicalOperatorType::EXTENSION, op.types, 1), table(&table), schema(nullptr),
       column_index_map(std::move(column_index_map_p)) {
 }
 
-PostgresInsert::PostgresInsert(LogicalOperator &op, SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info)
-    : PhysicalOperator(PhysicalOperatorType::EXTENSION, op.types, 1), table(nullptr), schema(&schema),
+PostgresInsert::PostgresInsert(PhysicalPlan &physical_plan, LogicalOperator &op, SchemaCatalogEntry &schema,
+                               unique_ptr<BoundCreateTableInfo> info)
+    : PhysicalOperator(physical_plan, PhysicalOperatorType::EXTENSION, op.types, 1), table(nullptr), schema(&schema),
       info(std::move(info)) {
 }
 
diff --git a/src/storage/postgres_update.cpp b/src/storage/postgres_update.cpp
@@ -8,8 +8,10 @@
 
 namespace duckdb {
 
-PostgresUpdate::PostgresUpdate(LogicalOperator &op, TableCatalogEntry &table, vector<PhysicalIndex> columns_p)
-    : PhysicalOperator(PhysicalOperatorType::EXTENSION, op.types, 1), table(table), columns(std::move(columns_p)) {
+PostgresUpdate::PostgresUpdate(PhysicalPlan &physical_plan, LogicalOperator &op, TableCatalogEntry &table,
+                               vector<PhysicalIndex> columns_p)
+    : PhysicalOperator(physical_plan, PhysicalOperatorType::EXTENSION, op.types, 1), table(table),
+      columns(std::move(columns_p)) {
 }
 
 //===--------------------------------------------------------------------===//

Original file line number	Diff line number	Diff line change
`@@ -13,11 +13,9 @@ class PostgresScannerExtension : public Extension {`
`13`	`13`	`std::string Name() override {`
`14`	`14`	`return "postgres_scanner";`
`15`	`15`	`}`
`16`		`- void Load(DuckDB &db) override;`
	`16`	`+ void Load(ExtensionLoader &loader) override;`
`17`	`17`	`};`
`18`	`18`
`19`	`19`	`extern "C" {`
`20`		`-DUCKDB_EXTENSION_API void postgres_scanner_init(duckdb::DatabaseInstance &db);`
`21`		`-DUCKDB_EXTENSION_API const char *postgres_scanner_version();`
`22`		`-DUCKDB_EXTENSION_API void postgres_scanner_storage_init(DBConfig &config);`
	`20`	`+DUCKDB_CPP_EXTENSION_ENTRY(postgres_scanner, loader);`
`23`	`21`	`}`