duckdb 1.3.4 → 1.4.1-dev2.0

package/src/duckdb/src/logging/log_types.cpp

@@ -1,3 +1,4 @@
+#include "duckdb/main/attached_database.hpp"
 #include "duckdb/logging/file_system_logger.hpp"
 #include "duckdb/logging/log_type.hpp"
 #include "duckdb/common/file_opener.hpp"
@@ -13,7 +14,18 @@ constexpr LogLevel FileSystemLogType::LEVEL;
 constexpr LogLevel QueryLogType::LEVEL;
 constexpr LogLevel HTTPLogType::LEVEL;
 constexpr LogLevel PhysicalOperatorLogType::LEVEL;
+constexpr LogLevel CheckpointLogType::LEVEL;
 
+//===--------------------------------------------------------------------===//
+// QueryLogType
+//===--------------------------------------------------------------------===//
+string QueryLogType::ConstructLogMessage(const string &str) {
+	return str;
+}
+
+//===--------------------------------------------------------------------===//
+// FileSystemLogType
+//===--------------------------------------------------------------------===//
 FileSystemLogType::FileSystemLogType() : LogType(NAME, LEVEL, GetLogType()) {
 }
 
@@ -36,6 +48,9 @@ LogicalType FileSystemLogType::GetLogType() {
 	return LogicalType::STRUCT(child_list);
 }
 
+//===--------------------------------------------------------------------===//
+// HTTPLogType
+//===--------------------------------------------------------------------===//
 HTTPLogType::HTTPLogType() : LogType(NAME, LEVEL, GetLogType()) {
 }
 
@@ -92,6 +107,9 @@ string HTTPLogType::ConstructLogMessage(BaseRequest &request, optional_ptr<HTTPR
 	return Value::STRUCT(child_list).ToString();
 }
 
+//===--------------------------------------------------------------------===//
+// PhysicalOperatorLogType
+//===--------------------------------------------------------------------===//
 PhysicalOperatorLogType::PhysicalOperatorLogType() : LogType(NAME, LEVEL, GetLogType()) {
 }
 
@@ -129,5 +147,50 @@ string PhysicalOperatorLogType::ConstructLogMessage(const PhysicalOperator &phys
 
 	return Value::STRUCT(std::move(child_list)).ToString();
 }
+//===--------------------------------------------------------------------===//
+// CheckpointLogType
+//===--------------------------------------------------------------------===//
+CheckpointLogType::CheckpointLogType() : LogType(NAME, LEVEL, GetLogType()) {
+}
+
+LogicalType CheckpointLogType::GetLogType() {
+	child_list_t<LogicalType> child_list = {
+	    {"database", LogicalType::VARCHAR},
+	    {"schema", LogicalType::VARCHAR},
+	    {"table", LogicalType::VARCHAR},
+	    {"type", LogicalType::VARCHAR},
+	    {"info", LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR)},
+	};
+	return LogicalType::STRUCT(child_list);
+}
+
+string CheckpointLogType::CreateLog(const AttachedDatabase &db, DataTableInfo &table, const char *op_name,
+                                    vector<Value> map_keys, vector<Value> map_values) {
+	child_list_t<Value> child_list = {
+	    {"database", db.name},
+	    {"schema", table.GetSchemaName()},
+	    {"table", table.GetTableName()},
+	    {"type", op_name},
+	    {"info", Value::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR, std::move(map_keys), std::move(map_values))},
+	};
+
+	return Value::STRUCT(std::move(child_list)).ToString();
+}
+
+string CheckpointLogType::ConstructLogMessage(const AttachedDatabase &db, DataTableInfo &table, idx_t segment_idx,
+                                              idx_t merge_count, idx_t target_count, idx_t merge_rows,
+                                              idx_t row_start) {
+	vector<Value> map_keys = {"segment_idx", "merge_count", "target_count", "merge_rows", "row_start"};
+	vector<Value> map_values = {to_string(segment_idx), to_string(merge_count), to_string(target_count),
+	                            to_string(merge_rows), to_string(row_start)};
+	return CreateLog(db, table, "vacuum", std::move(map_keys), std::move(map_values));
+}
+
+string CheckpointLogType::ConstructLogMessage(const AttachedDatabase &db, DataTableInfo &table, idx_t segment_idx,
+                                              RowGroup &row_group) {
+	vector<Value> map_keys = {"segment_idx", "start", "count"};
+	vector<Value> map_values = {to_string(segment_idx), to_string(row_group.start), to_string(row_group.count.load())};
+	return CreateLog(db, table, "checkpoint", std::move(map_keys), std::move(map_values));
+}
 
 } // namespace duckdb

package/src/duckdb/src/main/appender.cpp

@@ -51,85 +51,6 @@ const vector<LogicalType> &BaseAppender::GetActiveTypes() const {
 	return active_types;
 }
 
-InternalAppender::InternalAppender(ClientContext &context_p, TableCatalogEntry &table_p, const idx_t flush_count_p)
-    : BaseAppender(Allocator::DefaultAllocator(), table_p.GetTypes(), AppenderType::PHYSICAL, flush_count_p),
-      context(context_p), table(table_p) {
-}
-
-InternalAppender::~InternalAppender() {
-	Destructor();
-}
-
-Appender::Appender(Connection &con, const string &database_name, const string &schema_name, const string &table_name)
-    : BaseAppender(Allocator::DefaultAllocator(), AppenderType::LOGICAL), context(con.context) {
-
-	description = con.TableInfo(database_name, schema_name, table_name);
-	if (!description) {
-		throw CatalogException(
-		    StringUtil::Format("Table \"%s.%s.%s\" could not be found", database_name, schema_name, table_name));
-	}
-	if (description->readonly) {
-		throw InvalidInputException("Cannot append to a readonly database.");
-	}
-
-	vector<optional_ptr<const ParsedExpression>> defaults;
-	for (auto &column : description->columns) {
-		if (column.Generated()) {
-			continue;
-		}
-		types.push_back(column.Type());
-		defaults.push_back(column.HasDefaultValue() ? &column.DefaultValue() : nullptr);
-	}
-
-	auto binder = Binder::CreateBinder(*context);
-	context->RunFunctionInTransaction([&]() {
-		for (idx_t i = 0; i < types.size(); i++) {
-			auto &type = types[i];
-			auto &expr = defaults[i];
-
-			if (!expr) {
-				// The default value is NULL.
-				default_values[i] = Value(type);
-				continue;
-			}
-
-			auto default_copy = expr->Copy();
-			D_ASSERT(!default_copy->HasParameter());
-
-			ConstantBinder default_binder(*binder, *context, "DEFAULT value");
-			default_binder.target_type = type;
-			auto bound_default = default_binder.Bind(default_copy);
-
-			if (!bound_default->IsFoldable()) {
-				// Not supported yet.
-				continue;
-			}
-
-			Value result_value;
-			auto eval_success = ExpressionExecutor::TryEvaluateScalar(*context, *bound_default, result_value);
-			// Insert the default Value.
-			if (eval_success) {
-				default_values[i] = result_value;
-			}
-		}
-	});
-
-	InitializeChunk();
-	collection = make_uniq<ColumnDataCollection>(allocator, GetActiveTypes());
-}
-
-Appender::Appender(Connection &con, const string &schema_name, const string &table_name)
-    : Appender(con, INVALID_CATALOG, schema_name, table_name) {
-}
-
-Appender::Appender(Connection &con, const string &table_name)
-    : Appender(con, INVALID_CATALOG, DEFAULT_SCHEMA, table_name) {
-}
-
-Appender::~Appender() {
-	Destructor();
-}
-
 void BaseAppender::InitializeChunk() {
 	chunk.Destroy();
 	chunk.Initialize(allocator, GetActiveTypes());
@@ -482,8 +403,101 @@ void BaseAppender::Flush() {
 	column = 0;
 }
 
+void BaseAppender::AppendDefault() {
+	throw NotImplementedException("AppendDefault is only supported when directly appending to a table");
+}
+
+void BaseAppender::AppendDefault(DataChunk &chunk, idx_t col, idx_t row) {
+	throw NotImplementedException("AppendDefault is only supported when directly appending to a table");
+}
+
+void BaseAppender::AddColumn(const string &name) {
+	throw NotImplementedException("AddColumn is only supported when directly appending to a table");
+}
+
+void BaseAppender::ClearColumns() {
+	throw NotImplementedException("ClearColumns is only supported when directly appending to a table");
+}
+
+//===--------------------------------------------------------------------===//
+// Table Appender
+//===--------------------------------------------------------------------===//
+Appender::Appender(Connection &con, const string &database_name, const string &schema_name, const string &table_name)
+    : BaseAppender(Allocator::DefaultAllocator(), AppenderType::LOGICAL), context(con.context) {
+
+	description = con.TableInfo(database_name, schema_name, table_name);
+	if (!description) {
+		throw CatalogException(
+		    StringUtil::Format("Table \"%s.%s.%s\" could not be found", database_name, schema_name, table_name));
+	}
+	if (description->readonly) {
+		throw InvalidInputException("Cannot append to a readonly database.");
+	}
+
+	vector<optional_ptr<const ParsedExpression>> defaults;
+	for (auto &column : description->columns) {
+		if (column.Generated()) {
+			continue;
+		}
+		types.push_back(column.Type());
+		defaults.push_back(column.HasDefaultValue() ? &column.DefaultValue() : nullptr);
+	}
+	auto &context_ref = *con.context;
+	auto binder = Binder::CreateBinder(context_ref);
+	context_ref.RunFunctionInTransaction([&]() {
+		for (idx_t i = 0; i < types.size(); i++) {
+			auto &type = types[i];
+			auto &expr = defaults[i];
+
+			if (!expr) {
+				// The default value is NULL.
+				default_values[i] = Value(type);
+				continue;
+			}
+
+			auto default_copy = expr->Copy();
+			D_ASSERT(!default_copy->HasParameter());
+
+			ConstantBinder default_binder(*binder, context_ref, "DEFAULT value");
+			default_binder.target_type = type;
+			auto bound_default = default_binder.Bind(default_copy);
+
+			if (!bound_default->IsFoldable()) {
+				// Not supported yet.
+				continue;
+			}
+
+			Value result_value;
+			auto eval_success = ExpressionExecutor::TryEvaluateScalar(context_ref, *bound_default, result_value);
+			// Insert the default Value.
+			if (eval_success) {
+				default_values[i] = result_value;
+			}
+		}
+	});
+
+	InitializeChunk();
+	collection = make_uniq<ColumnDataCollection>(allocator, GetActiveTypes());
+}
+
+Appender::Appender(Connection &con, const string &schema_name, const string &table_name)
+    : Appender(con, INVALID_CATALOG, schema_name, table_name) {
+}
+
+Appender::Appender(Connection &con, const string &table_name)
+    : Appender(con, INVALID_CATALOG, DEFAULT_SCHEMA, table_name) {
+}
+
+Appender::~Appender() {
+	Destructor();
+}
+
 void Appender::FlushInternal(ColumnDataCollection &collection) {
-	context->Append(*description, collection, &column_ids);
+	auto context_ref = context.lock();
+	if (!context_ref) {
+		throw InvalidInputException("Appender: Attempting to flush data to a closed connection");
+	}
+	context_ref->Append(*description, collection, &column_ids);
 }
 
 void Appender::AppendDefault() {
@@ -559,18 +573,45 @@ void Appender::ClearColumns() {
 	collection = make_uniq<ColumnDataCollection>(allocator, GetActiveTypes());
 }
 
-void InternalAppender::FlushInternal(ColumnDataCollection &collection) {
-	auto binder = Binder::CreateBinder(context);
-	auto bound_constraints = binder->BindConstraints(table);
-	table.GetStorage().LocalAppend(table, context, collection, bound_constraints, nullptr);
+//===--------------------------------------------------------------------===//
+// Query Appender
+//===--------------------------------------------------------------------===//
+QueryAppender::QueryAppender(Connection &con, string query_p, vector<LogicalType> types_p, vector<string> names_p,
+                             string table_name_p)
+    : BaseAppender(Allocator::DefaultAllocator(), AppenderType::LOGICAL), context(con.context),
+      query(std::move(query_p)), names(std::move(names_p)), table_name(std::move(table_name_p)) {
+	types = std::move(types_p);
+	InitializeChunk();
+	collection = make_uniq<ColumnDataCollection>(allocator, GetActiveTypes());
 }
 
-void InternalAppender::AddColumn(const string &name) {
-	throw InternalException("AddColumn not implemented for InternalAppender");
+QueryAppender::~QueryAppender() {
 }
 
-void InternalAppender::ClearColumns() {
-	throw InternalException("ClearColumns not implemented for InternalAppender");
+void QueryAppender::FlushInternal(ColumnDataCollection &collection) {
+	auto context_ref = context.lock();
+	if (!context_ref) {
+		throw InvalidInputException("Appender: Attempting to flush data to a closed connection");
+	}
+	context_ref->Append(collection, query, names, table_name);
+}
+
+//===--------------------------------------------------------------------===//
+// Internal Appender
+//===--------------------------------------------------------------------===//
+InternalAppender::InternalAppender(ClientContext &context_p, TableCatalogEntry &table_p, const idx_t flush_count_p)
+    : BaseAppender(Allocator::DefaultAllocator(), table_p.GetTypes(), AppenderType::PHYSICAL, flush_count_p),
+      context(context_p), table(table_p) {
+}
+
+InternalAppender::~InternalAppender() {
+	Destructor();
+}
+
+void InternalAppender::FlushInternal(ColumnDataCollection &collection) {
+	auto binder = Binder::CreateBinder(context);
+	auto bound_constraints = binder->BindConstraints(table);
+	table.GetStorage().LocalAppend(table, context, collection, bound_constraints, nullptr);
 }
 
 void BaseAppender::Close() {

package/src/duckdb/src/main/attached_database.cpp

@@ -10,21 +10,33 @@
 #include "duckdb/storage/storage_manager.hpp"
 #include "duckdb/transaction/duck_transaction_manager.hpp"
 #include "duckdb/main/database_path_and_type.hpp"
+#include "duckdb/main/valid_checker.hpp"
 
 namespace duckdb {
 
+StoredDatabasePath::StoredDatabasePath(DatabaseFilePathManager &manager, string path_p, const string &name)
+    : manager(manager), path(std::move(path_p)) {
+}
+
+StoredDatabasePath::~StoredDatabasePath() {
+	manager.EraseDatabasePath(path);
+}
+
+void StoredDatabasePath::OnDetach() {
+	manager.DetachDatabase(path);
+}
+
 //===--------------------------------------------------------------------===//
 // Attach Options
 //===--------------------------------------------------------------------===//
-
 AttachOptions::AttachOptions(const DBConfigOptions &options)
     : access_mode(options.access_mode), db_type(options.database_type) {
 }
 
-AttachOptions::AttachOptions(const unique_ptr<AttachInfo> &info, const AccessMode default_access_mode)
+AttachOptions::AttachOptions(const unordered_map<string, Value> &attach_options, const AccessMode default_access_mode)
     : access_mode(default_access_mode) {
 
-	for (auto &entry : info->options) {
+	for (auto &entry : attach_options) {
 		if (entry.first == "readonly" || entry.first == "read_only") {
 			// Extract the read access mode.
 
@@ -58,15 +70,13 @@ AttachOptions::AttachOptions(const unique_ptr<AttachInfo> &info, const AccessMod
 			default_table = QualifiedName::Parse(StringValue::Get(entry.second.DefaultCastAs(LogicalType::VARCHAR)));
 			continue;
 		}
-
-		options[entry.first] = entry.second;
+		options.emplace(entry.first, entry.second);
 	}
 }
 
 //===--------------------------------------------------------------------===//
 // Attached Database
 //===--------------------------------------------------------------------===//
-
 AttachedDatabase::AttachedDatabase(DatabaseInstance &db, AttachedDatabaseType type)
     : CatalogEntry(CatalogType::DATABASE_ENTRY,
                    type == AttachedDatabaseType::SYSTEM_DATABASE ? SYSTEM_CATALOG : TEMP_CATALOG, 0),
@@ -75,7 +85,9 @@ AttachedDatabase::AttachedDatabase(DatabaseInstance &db, AttachedDatabaseType ty
 	// This database does not have storage, or uses temporary_objects for in-memory storage.
 	D_ASSERT(type == AttachedDatabaseType::TEMP_DATABASE || type == AttachedDatabaseType::SYSTEM_DATABASE);
 	if (type == AttachedDatabaseType::TEMP_DATABASE) {
-		storage = make_uniq<SingleFileStorageManager>(*this, string(IN_MEMORY_PATH), false);
+		unordered_map<string, Value> options;
+		AttachOptions attach_options(options, AccessMode::READ_WRITE);
+		storage = make_uniq<SingleFileStorageManager>(*this, string(IN_MEMORY_PATH), attach_options);
 	}
 
 	catalog = make_uniq<DuckCatalog>(*this);
@@ -86,31 +98,15 @@ AttachedDatabase::AttachedDatabase(DatabaseInstance &db, AttachedDatabaseType ty
 AttachedDatabase::AttachedDatabase(DatabaseInstance &db, Catalog &catalog_p, string name_p, string file_path_p,
                                    AttachOptions &options)
     : CatalogEntry(CatalogType::DATABASE_ENTRY, catalog_p, std::move(name_p)), db(db), parent_catalog(&catalog_p) {
-
 	if (options.access_mode == AccessMode::READ_ONLY) {
 		type = AttachedDatabaseType::READ_ONLY_DATABASE;
 	} else {
 		type = AttachedDatabaseType::READ_WRITE_DATABASE;
 	}
-	for (auto &entry : options.options) {
-		if (StringUtil::CIEquals(entry.first, "block_size")) {
-			continue;
-		}
-		if (StringUtil::CIEquals(entry.first, "encryption_key")) {
-			continue;
-		}
-		if (StringUtil::CIEquals(entry.first, "row_group_size")) {
-			continue;
-		}
-		if (StringUtil::CIEquals(entry.first, "storage_version")) {
-			continue;
-		}
-		throw BinderException("Unrecognized option for attach \"%s\"", entry.first);
-	}
 	// We create the storage after the catalog to guarantee we allow extensions to instantiate the DuckCatalog.
 	catalog = make_uniq<DuckCatalog>(*this);
-	auto read_only = options.access_mode == AccessMode::READ_ONLY;
-	storage = make_uniq<SingleFileStorageManager>(*this, std::move(file_path_p), read_only);
+	stored_database_path = std::move(options.stored_database_path);
+	storage = make_uniq<SingleFileStorageManager>(*this, std::move(file_path_p), options);
 	transaction_manager = make_uniq<DuckTransactionManager>(*this);
 	internal = true;
 }
@@ -125,15 +121,15 @@ AttachedDatabase::AttachedDatabase(DatabaseInstance &db, Catalog &catalog_p, Sto
 		type = AttachedDatabaseType::READ_WRITE_DATABASE;
 	}
 
-	StorageExtensionInfo *storage_info = storage_extension->storage_info.get();
-	catalog = storage_extension->attach(storage_info, context, *this, name, info, options.access_mode);
+	optional_ptr<StorageExtensionInfo> storage_info = storage_extension->storage_info.get();
+	catalog = storage_extension->attach(storage_info, context, *this, name, info, options);
+	stored_database_path = std::move(options.stored_database_path);
 	if (!catalog) {
 		throw InternalException("AttachedDatabase - attach function did not return a catalog");
 	}
 	if (catalog->IsDuckCatalog()) {
 		// The attached database uses the DuckCatalog.
-		auto read_only = options.access_mode == AccessMode::READ_ONLY;
-		storage = make_uniq<SingleFileStorageManager>(*this, info.path, read_only);
+		storage = make_uniq<SingleFileStorageManager>(*this, info.path, options);
 	}
 	transaction_manager = storage_extension->create_transaction_manager(storage_info, *this, *catalog);
 	if (!transaction_manager) {
@@ -163,25 +159,38 @@ bool AttachedDatabase::NameIsReserved(const string &name) {
 	return name == DEFAULT_SCHEMA || name == TEMP_CATALOG || name == SYSTEM_CATALOG;
 }
 
+string AttachedDatabase::StoredPath() const {
+	if (stored_database_path) {
+		return stored_database_path->path;
+	}
+	return string();
+}
+
+static string RemoveQueryParams(const string &name) {
+	auto vec = StringUtil::Split(name, "?");
+	D_ASSERT(!vec.empty());
+	return vec[0];
+}
+
 string AttachedDatabase::ExtractDatabaseName(const string &dbpath, FileSystem &fs) {
 	if (dbpath.empty() || dbpath == IN_MEMORY_PATH) {
 		return "memory";
 	}
-	auto name = fs.ExtractBaseName(dbpath);
+	auto name = RemoveQueryParams(fs.ExtractBaseName(dbpath));
 	if (NameIsReserved(name)) {
 		name += "_db";
 	}
 	return name;
 }
 
-void AttachedDatabase::Initialize(optional_ptr<ClientContext> context, StorageOptions options) {
+void AttachedDatabase::Initialize(optional_ptr<ClientContext> context) {
 	if (IsSystem()) {
 		catalog->Initialize(context, true);
 	} else {
 		catalog->Initialize(context, false);
 	}
 	if (storage) {
-		storage->Initialize(options);
+		storage->Initialize(QueryContext(context));
 	}
 }
 
@@ -189,6 +198,10 @@ void AttachedDatabase::FinalizeLoad(optional_ptr<ClientContext> context) {
 	catalog->FinalizeLoad(context);
 }
 
+bool AttachedDatabase::HasStorageManager() const {
+	return storage.get();
+}
+
 StorageManager &AttachedDatabase::GetStorageManager() {
 	if (!storage) {
 		throw InternalException("Internal system catalog does not have storage");
@@ -225,45 +238,40 @@ void AttachedDatabase::SetReadOnlyDatabase() {
 }
 
 void AttachedDatabase::OnDetach(ClientContext &context) {
-	if (!catalog) {
-		return;
+	if (catalog) {
+		catalog->OnDetach(context);
+	}
+	if (stored_database_path) {
+		stored_database_path->OnDetach();
 	}
-	catalog->OnDetach(context);
 }
 
 void AttachedDatabase::Close() {
-	D_ASSERT(catalog);
 	if (is_closed) {
 		return;
 	}
+	D_ASSERT(catalog);
 	is_closed = true;
 
-	if (!IsSystem() && !catalog->InMemory()) {
-		db.GetDatabaseManager().EraseDatabasePath(catalog->GetDBPath());
-	}
-
-	if (Exception::UncaughtException()) {
-		return;
-	}
-	if (!storage) {
-		return;
-	}
-
 	// shutting down: attempt to checkpoint the database
 	// but only if we are not cleaning up as part of an exception unwind
-	try {
-		if (!storage->InMemory()) {
+	if (!Exception::UncaughtException() && storage && !storage->InMemory() && !ValidChecker::IsInvalidated(db)) {
+		try {
 			auto &config = DBConfig::GetConfig(db);
-			if (!config.options.checkpoint_on_shutdown) {
-				return;
+			if (config.options.checkpoint_on_shutdown) {
+				CheckpointOptions options;
+				options.wal_action = CheckpointWALAction::DELETE_WAL;
+				storage->CreateCheckpoint(QueryContext(), options);
 			}
-			CheckpointOptions options;
-			options.wal_action = CheckpointWALAction::DELETE_WAL;
-			storage->CreateCheckpoint(nullptr, options);
+		} catch (...) { // NOLINT
 		}
-	} catch (...) { // NOLINT
 	}
 
+	transaction_manager.reset();
+	catalog.reset();
+	storage.reset();
+	stored_database_path.reset();
+
 	if (Allocator::SupportsFlush()) {
 		Allocator::FlushAll();
 	}

package/src/duckdb/src/main/capi/aggregate_function-c.cpp

@@ -99,7 +99,7 @@ void CAPIAggregateUpdate(Vector inputs[], AggregateInputData &aggr_input_data, i
 	chunk.SetCardinality(count);
 
 	auto &bind_data = aggr_input_data.bind_data->Cast<CAggregateFunctionBindData>();
-	auto state_data = FlatVector::GetData<duckdb_aggregate_state>(state);
+	auto state_data = FlatVector::GetDataUnsafe<duckdb_aggregate_state>(state);
 	auto c_input_chunk = reinterpret_cast<duckdb_data_chunk>(&chunk);
 
 	CAggregateExecuteInfo exec_info(bind_data.info);
@@ -113,8 +113,8 @@ void CAPIAggregateUpdate(Vector inputs[], AggregateInputData &aggr_input_data, i
 void CAPIAggregateCombine(Vector &state, Vector &combined, AggregateInputData &aggr_input_data, idx_t count) {
 	state.Flatten(count);
 	auto &bind_data = aggr_input_data.bind_data->Cast<CAggregateFunctionBindData>();
-	auto input_state_data = FlatVector::GetData<duckdb_aggregate_state>(state);
-	auto result_state_data = FlatVector::GetData<duckdb_aggregate_state>(combined);
+	auto input_state_data = FlatVector::GetDataUnsafe<duckdb_aggregate_state>(state);
+	auto result_state_data = FlatVector::GetDataUnsafe<duckdb_aggregate_state>(combined);
 	CAggregateExecuteInfo exec_info(bind_data.info);
 	auto c_function_info = reinterpret_cast<duckdb_function_info>(&exec_info);
 	bind_data.info.combine(c_function_info, input_state_data, result_state_data, count);
@@ -127,7 +127,7 @@ void CAPIAggregateFinalize(Vector &state, AggregateInputData &aggr_input_data, V
                            idx_t offset) {
 	state.Flatten(count);
 	auto &bind_data = aggr_input_data.bind_data->Cast<CAggregateFunctionBindData>();
-	auto input_state_data = FlatVector::GetData<duckdb_aggregate_state>(state);
+	auto input_state_data = FlatVector::GetDataUnsafe<duckdb_aggregate_state>(state);
 	auto result_vector = reinterpret_cast<duckdb_vector>(&result);
 
 	CAggregateExecuteInfo exec_info(bind_data.info);
@@ -140,7 +140,7 @@ void CAPIAggregateFinalize(Vector &state, AggregateInputData &aggr_input_data, V
 
 void CAPIAggregateDestructor(Vector &state, AggregateInputData &aggr_input_data, idx_t count) {
 	auto &bind_data = aggr_input_data.bind_data->Cast<CAggregateFunctionBindData>();
-	auto input_state_data = FlatVector::GetData<duckdb_aggregate_state>(state);
+	auto input_state_data = FlatVector::GetDataUnsafe<duckdb_aggregate_state>(state);
 	bind_data.info.destroy(input_state_data, count);
 }
 
@@ -153,8 +153,13 @@ duckdb_aggregate_function duckdb_create_aggregate_function() {
 	                                              duckdb::CAPIAggregateStateInit, duckdb::CAPIAggregateUpdate,
 	                                              duckdb::CAPIAggregateCombine, duckdb::CAPIAggregateFinalize, nullptr,
 	                                              duckdb::CAPIAggregateBind);
-	function->function_info = duckdb::make_shared_ptr<duckdb::CAggregateFunctionInfo>();
-	return reinterpret_cast<duckdb_aggregate_function>(function);
+	try {
+		function->function_info = duckdb::make_shared_ptr<duckdb::CAggregateFunctionInfo>();
+		return reinterpret_cast<duckdb_aggregate_function>(function);
+	} catch (...) {
+		delete function;
+		return nullptr;
+	}
 }
 
 void duckdb_destroy_aggregate_function(duckdb_aggregate_function *function) {
@@ -266,8 +271,12 @@ duckdb_aggregate_function_set duckdb_create_aggregate_function_set(const char *n
 	if (!name || !*name) {
 		return nullptr;
 	}
-	auto function_set = new duckdb::AggregateFunctionSet(name);
-	return reinterpret_cast<duckdb_aggregate_function_set>(function_set);
+	try {
+		auto function_set = new duckdb::AggregateFunctionSet(name);
+		return reinterpret_cast<duckdb_aggregate_function_set>(function_set);
+	} catch (...) {
+		return nullptr;
+	}
 }
 
 void duckdb_destroy_aggregate_function_set(duckdb_aggregate_function_set *set) {