duckdb 0.10.2-dev0.0 → 0.10.2-dev3.0

package/src/duckdb/src/include/duckdb/function/udf_function.hpp

@@ -13,31 +13,33 @@
 
 namespace duckdb {
 
+// NOLINTBEGIN
+
 struct UDFWrapper {
 public:
-	template <typename TR, typename... Args>
-	inline static scalar_function_t CreateScalarFunction(const string &name, TR (*udf_func)(Args...)) {
-		const std::size_t num_template_argc = sizeof...(Args);
+	template <typename TR, typename... ARGS>
+	inline static scalar_function_t CreateScalarFunction(const string &name, TR (*udf_func)(ARGS...)) {
+		const std::size_t num_template_argc = sizeof...(ARGS);
 		switch (num_template_argc) {
 		case 1:
-			return CreateUnaryFunction<TR, Args...>(name, udf_func);
+			return CreateUnaryFunction<TR, ARGS...>(name, udf_func);
 		case 2:
-			return CreateBinaryFunction<TR, Args...>(name, udf_func);
+			return CreateBinaryFunction<TR, ARGS...>(name, udf_func);
 		case 3:
-			return CreateTernaryFunction<TR, Args...>(name, udf_func);
+			return CreateTernaryFunction<TR, ARGS...>(name, udf_func);
 		default: // LCOV_EXCL_START
 			throw std::runtime_error("UDF function only supported until ternary!");
 		} // LCOV_EXCL_STOP
 	}
 
-	template <typename TR, typename... Args>
-	inline static scalar_function_t CreateScalarFunction(const string &name, vector<LogicalType> args,
-	                                                     LogicalType ret_type, TR (*udf_func)(Args...)) {
+	template <typename TR, typename... ARGS>
+	inline static scalar_function_t CreateScalarFunction(const string &name, const vector<LogicalType> &args,
+	                                                     const LogicalType &ret_type, TR (*udf_func)(ARGS...)) {
 		if (!TypesMatch<TR>(ret_type)) { // LCOV_EXCL_START
 			throw std::runtime_error("Return type doesn't match with the first template type.");
 		} // LCOV_EXCL_STOP
 
-		const std::size_t num_template_types = sizeof...(Args);
+		const std::size_t num_template_types = sizeof...(ARGS);
 		if (num_template_types != args.size()) { // LCOV_EXCL_START
 			throw std::runtime_error(
 			    "The number of templated types should be the same quantity of the LogicalType arguments.");
@@ -45,25 +47,25 @@ public:
 
 		switch (num_template_types) {
 		case 1:
-			return CreateUnaryFunction<TR, Args...>(name, args, ret_type, udf_func);
+			return CreateUnaryFunction<TR, ARGS...>(name, args, ret_type, udf_func);
 		case 2:
-			return CreateBinaryFunction<TR, Args...>(name, args, ret_type, udf_func);
+			return CreateBinaryFunction<TR, ARGS...>(name, args, ret_type, udf_func);
 		case 3:
-			return CreateTernaryFunction<TR, Args...>(name, args, ret_type, udf_func);
+			return CreateTernaryFunction<TR, ARGS...>(name, args, ret_type, udf_func);
 		default: // LCOV_EXCL_START
 			throw std::runtime_error("UDF function only supported until ternary!");
 		} // LCOV_EXCL_STOP
 	}
 
-	template <typename TR, typename... Args>
+	template <typename TR, typename... ARGS>
 	inline static void RegisterFunction(const string &name, scalar_function_t udf_function, ClientContext &context,
 	                                    LogicalType varargs = LogicalType(LogicalTypeId::INVALID)) {
 		vector<LogicalType> arguments;
-		GetArgumentTypesRecursive<Args...>(arguments);
+		GetArgumentTypesRecursive<ARGS...>(arguments);
 
 		LogicalType ret_type = GetArgumentType<TR>();
 
-		RegisterFunction(name, arguments, ret_type, udf_function, context, varargs);
+		RegisterFunction(name, arguments, ret_type, std::move(udf_function), context, std::move(varargs));
 	}
 
 	static void RegisterFunction(string name, vector<LogicalType> args, LogicalType ret_type,
@@ -82,8 +84,8 @@ public:
 	}
 
 	template <typename UDF_OP, typename STATE, typename TR, typename TA>
-	inline static AggregateFunction CreateAggregateFunction(const string &name, LogicalType ret_type,
-	                                                        LogicalType input_type) {
+	inline static AggregateFunction CreateAggregateFunction(const string &name, const LogicalType &ret_type,
+	                                                        const LogicalType &input_type) {
 		if (!TypesMatch<TR>(ret_type)) { // LCOV_EXCL_START
 			throw std::runtime_error("The return argument don't match!");
 		} // LCOV_EXCL_STOP
@@ -96,33 +98,34 @@ public:
 	}
 
 	template <typename UDF_OP, typename STATE, typename TR, typename TA, typename TB>
-	inline static AggregateFunction CreateAggregateFunction(const string &name, LogicalType ret_type,
-	                                                        LogicalType input_typeA, LogicalType input_typeB) {
+	inline static AggregateFunction CreateAggregateFunction(const string &name, const LogicalType &ret_type,
+	                                                        const LogicalType &input_type_a,
+	                                                        const LogicalType &input_type_b) {
 		if (!TypesMatch<TR>(ret_type)) { // LCOV_EXCL_START
 			throw std::runtime_error("The return argument don't match!");
 		}
 
-		if (!TypesMatch<TA>(input_typeA)) {
+		if (!TypesMatch<TA>(input_type_a)) {
 			throw std::runtime_error("The first input argument don't match!");
 		}
 
-		if (!TypesMatch<TB>(input_typeB)) {
+		if (!TypesMatch<TB>(input_type_b)) {
 			throw std::runtime_error("The second input argument don't match!");
 		} // LCOV_EXCL_STOP
 
-		return CreateBinaryAggregateFunction<UDF_OP, STATE, TR, TA, TB>(name, ret_type, input_typeA, input_typeB);
+		return CreateBinaryAggregateFunction<UDF_OP, STATE, TR, TA, TB>(name, ret_type, input_type_a, input_type_b);
 	}
 
 	//! A generic CreateAggregateFunction ---------------------------------------------------------------------------//
 	inline static AggregateFunction
-	CreateAggregateFunction(string name, vector<LogicalType> arguments, LogicalType return_type,
+	CreateAggregateFunction(const string &name, const vector<LogicalType> &arguments, const LogicalType &return_type,
 	                        aggregate_size_t state_size, aggregate_initialize_t initialize, aggregate_update_t update,
 	                        aggregate_combine_t combine, aggregate_finalize_t finalize,
 	                        aggregate_simple_update_t simple_update = nullptr, bind_aggregate_function_t bind = nullptr,
 	                        aggregate_destructor_t destructor = nullptr) {
 
-		AggregateFunction aggr_function(std::move(name), std::move(arguments), std::move(return_type), state_size,
-		                                initialize, update, combine, finalize, simple_update, bind, destructor);
+		AggregateFunction aggr_function(name, arguments, return_type, state_size, initialize, update, combine, finalize,
+		                                simple_update, bind, destructor);
 		aggr_function.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 		return aggr_function;
 	}
@@ -167,21 +170,21 @@ private:
 		return udf_function;
 	}
 
-	template <typename TR, typename... Args>
+	template <typename TR, typename... ARGS>
 	inline static scalar_function_t CreateUnaryFunction(const string &name,
-	                                                    TR (*udf_func)(Args...)) { // LCOV_EXCL_START
+	                                                    TR (*udf_func)(ARGS...)) { // LCOV_EXCL_START
 		throw std::runtime_error("Incorrect number of arguments for unary function");
 	} // LCOV_EXCL_STOP
 
-	template <typename TR, typename... Args>
+	template <typename TR, typename... ARGS>
 	inline static scalar_function_t CreateBinaryFunction(const string &name,
-	                                                     TR (*udf_func)(Args...)) { // LCOV_EXCL_START
+	                                                     TR (*udf_func)(ARGS...)) { // LCOV_EXCL_START
 		throw std::runtime_error("Incorrect number of arguments for binary function");
 	} // LCOV_EXCL_STOP
 
-	template <typename TR, typename... Args>
+	template <typename TR, typename... ARGS>
 	inline static scalar_function_t CreateTernaryFunction(const string &name,
-	                                                      TR (*udf_func)(Args...)) { // LCOV_EXCL_START
+	                                                      TR (*udf_func)(ARGS...)) { // LCOV_EXCL_START
 		throw std::runtime_error("Incorrect number of arguments for ternary function");
 	} // LCOV_EXCL_STOP
 
@@ -208,10 +211,10 @@ private:
 		} // LCOV_EXCL_STOP
 	}
 
-	template <typename TA, typename TB, typename... Args>
+	template <typename TA, typename TB, typename... ARGS>
 	inline static void GetArgumentTypesRecursive(vector<LogicalType> &arguments) {
 		arguments.push_back(GetArgumentType<TA>());
-		GetArgumentTypesRecursive<TB, Args...>(arguments);
+		GetArgumentTypesRecursive<TB, ARGS...>(arguments);
 	}
 
 	template <typename TA>
@@ -222,16 +225,16 @@ private:
 private:
 	//-------------------------------- Argumented functions --------------------------------//
 
-	template <typename TR, typename... Args>
-	inline static scalar_function_t CreateUnaryFunction(const string &name, vector<LogicalType> args,
-	                                                    LogicalType ret_type,
-	                                                    TR (*udf_func)(Args...)) { // LCOV_EXCL_START
+	template <typename TR, typename... ARGS>
+	inline static scalar_function_t CreateUnaryFunction(const string &name, const vector<LogicalType> &args,
+	                                                    const LogicalType &ret_type,
+	                                                    TR (*udf_func)(ARGS...)) { // LCOV_EXCL_START
 		throw std::runtime_error("Incorrect number of arguments for unary function");
 	} // LCOV_EXCL_STOP
 
 	template <typename TR, typename TA>
-	inline static scalar_function_t CreateUnaryFunction(const string &name, vector<LogicalType> args,
-	                                                    LogicalType ret_type, TR (*udf_func)(TA)) {
+	inline static scalar_function_t CreateUnaryFunction(const string &name, const vector<LogicalType> &args,
+	                                                    const LogicalType &ret_type, TR (*udf_func)(TA)) {
 		if (args.size() != 1) { // LCOV_EXCL_START
 			throw std::runtime_error("The number of LogicalType arguments (\"args\") should be 1!");
 		}
@@ -246,16 +249,16 @@ private:
 		return udf_function;
 	}
 
-	template <typename TR, typename... Args>
-	inline static scalar_function_t CreateBinaryFunction(const string &name, vector<LogicalType> args,
-	                                                     LogicalType ret_type,
-	                                                     TR (*udf_func)(Args...)) { // LCOV_EXCL_START
+	template <typename TR, typename... ARGS>
+	inline static scalar_function_t CreateBinaryFunction(const string &name, const vector<LogicalType> &args,
+	                                                     const LogicalType &ret_type,
+	                                                     TR (*udf_func)(ARGS...)) { // LCOV_EXCL_START
 		throw std::runtime_error("Incorrect number of arguments for binary function");
 	} // LCOV_EXCL_STOP
 
 	template <typename TR, typename TA, typename TB>
-	inline static scalar_function_t CreateBinaryFunction(const string &name, vector<LogicalType> args,
-	                                                     LogicalType ret_type, TR (*udf_func)(TA, TB)) {
+	inline static scalar_function_t CreateBinaryFunction(const string &name, const vector<LogicalType> &args,
+	                                                     const LogicalType &ret_type, TR (*udf_func)(TA, TB)) {
 		if (args.size() != 2) { // LCOV_EXCL_START
 			throw std::runtime_error("The number of LogicalType arguments (\"args\") should be 2!");
 		}
@@ -272,16 +275,16 @@ private:
 		return udf_function;
 	}
 
-	template <typename TR, typename... Args>
-	inline static scalar_function_t CreateTernaryFunction(const string &name, vector<LogicalType> args,
-	                                                      LogicalType ret_type,
-	                                                      TR (*udf_func)(Args...)) { // LCOV_EXCL_START
+	template <typename TR, typename... ARGS>
+	inline static scalar_function_t CreateTernaryFunction(const string &name, const vector<LogicalType> &args,
+	                                                      const LogicalType &ret_type,
+	                                                      TR (*udf_func)(ARGS...)) { // LCOV_EXCL_START
 		throw std::runtime_error("Incorrect number of arguments for ternary function");
 	} // LCOV_EXCL_STOP
 
 	template <typename TR, typename TA, typename TB, typename TC>
-	inline static scalar_function_t CreateTernaryFunction(const string &name, vector<LogicalType> args,
-	                                                      LogicalType ret_type, TR (*udf_func)(TA, TB, TC)) {
+	inline static scalar_function_t CreateTernaryFunction(const string &name, const vector<LogicalType> &args,
+	                                                      const LogicalType &ret_type, TR (*udf_func)(TA, TB, TC)) {
 		if (args.size() != 3) { // LCOV_EXCL_START
 			throw std::runtime_error("The number of LogicalType arguments (\"args\") should be 3!");
 		}
@@ -350,8 +353,8 @@ private:
 	}
 
 	template <typename UDF_OP, typename STATE, typename TR, typename TA>
-	inline static AggregateFunction CreateUnaryAggregateFunction(const string &name, LogicalType ret_type,
-	                                                             LogicalType input_type) {
+	inline static AggregateFunction CreateUnaryAggregateFunction(const string &name, const LogicalType &ret_type,
+	                                                             const LogicalType &input_type) {
 		AggregateFunction aggr_function =
 		    AggregateFunction::UnaryAggregate<STATE, TR, TA, UDF_OP>(input_type, ret_type);
 		aggr_function.name = name;
@@ -361,19 +364,22 @@ private:
 	template <typename UDF_OP, typename STATE, typename TR, typename TA, typename TB>
 	inline static AggregateFunction CreateBinaryAggregateFunction(const string &name) {
 		LogicalType return_type = GetArgumentType<TR>();
-		LogicalType input_typeA = GetArgumentType<TA>();
-		LogicalType input_typeB = GetArgumentType<TB>();
-		return CreateBinaryAggregateFunction<UDF_OP, STATE, TR, TA, TB>(name, return_type, input_typeA, input_typeB);
+		LogicalType input_type_a = GetArgumentType<TA>();
+		LogicalType input_type_b = GetArgumentType<TB>();
+		return CreateBinaryAggregateFunction<UDF_OP, STATE, TR, TA, TB>(name, return_type, input_type_a, input_type_b);
 	}
 
 	template <typename UDF_OP, typename STATE, typename TR, typename TA, typename TB>
-	inline static AggregateFunction CreateBinaryAggregateFunction(const string &name, LogicalType ret_type,
-	                                                              LogicalType input_typeA, LogicalType input_typeB) {
+	inline static AggregateFunction CreateBinaryAggregateFunction(const string &name, const LogicalType &ret_type,
+	                                                              const LogicalType &input_type_a,
+	                                                              const LogicalType &input_type_b) {
 		AggregateFunction aggr_function =
-		    AggregateFunction::BinaryAggregate<STATE, TA, TB, TR, UDF_OP>(input_typeA, input_typeB, ret_type);
+		    AggregateFunction::BinaryAggregate<STATE, TA, TB, TR, UDF_OP>(input_type_a, input_type_b, ret_type);
 		aggr_function.name = name;
 		return aggr_function;
 	}
 }; // end UDFWrapper
 
+// NOLINTEND
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/main/appender.hpp

@@ -29,7 +29,7 @@ enum class AppenderType : uint8_t {
 class BaseAppender {
 protected:
 	//! The amount of tuples that will be gathered in the column data collection before flushing
-	static constexpr const idx_t FLUSH_COUNT = STANDARD_VECTOR_SIZE * 100;
+	static constexpr const idx_t FLUSH_COUNT = STANDARD_VECTOR_SIZE * 100ULL;
 
 	Allocator &allocator;
 	//! The append types
@@ -66,8 +66,8 @@ public:
 	DUCKDB_API void Append(const char *value, uint32_t length);
 
 	// prepared statements
-	template <typename... Args>
-	void AppendRow(Args... args) {
+	template <typename... ARGS>
+	void AppendRow(ARGS... args) {
 		BeginRow();
 		AppendRowRecursive(args...);
 	}
@@ -80,7 +80,7 @@ public:
 	vector<LogicalType> &GetTypes() {
 		return types;
 	}
-	idx_t CurrentColumn() {
+	idx_t CurrentColumn() const {
 		return column;
 	}
 	DUCKDB_API void AppendDataChunk(DataChunk &value);
@@ -102,8 +102,8 @@ protected:
 		EndRow();
 	}
 
-	template <typename T, typename... Args>
-	void AppendRowRecursive(T value, Args... args) {
+	template <typename T, typename... ARGS>
+	void AppendRowRecursive(T value, ARGS... args) {
 		Append<T>(value);
 		AppendRowRecursive(args...);
 	}

package/src/duckdb/src/include/duckdb/main/attached_database.hpp

@@ -43,10 +43,11 @@ public:
 	                 const AttachInfo &info, AccessMode access_mode);
 	~AttachedDatabase() override;
 
-	void Initialize();
+	void Initialize(optional_ptr<ClientContext> context = nullptr);
 	void Close();
 
 	Catalog &ParentCatalog() override;
+	const Catalog &ParentCatalog() const override;
 	StorageManager &GetStorageManager();
 	Catalog &GetCatalog();
 	TransactionManager &GetTransactionManager();
@@ -61,6 +62,7 @@ public:
 	bool IsReadOnly() const;
 	bool IsInitialDatabase() const;
 	void SetInitialDatabase();
+	void SetReadOnlyDatabase();
 
 	static bool NameIsReserved(const string &name);
 	static string ExtractDatabaseName(const string &dbpath, FileSystem &fs);

package/src/duckdb/src/include/duckdb/main/buffered_data/buffered_data.hpp

@@ -23,7 +23,7 @@ class ClientContextLock;
 
 struct BlockedSink {
 public:
-	BlockedSink(InterruptState state, idx_t chunk_size) : state(state), chunk_size(chunk_size) {
+	BlockedSink(InterruptState state, idx_t chunk_size) : state(std::move(state)), chunk_size(chunk_size) {
 	}
 
 public:
@@ -38,7 +38,7 @@ protected:
 	enum class Type { SIMPLE };
 
 public:
-	BufferedData(Type type, weak_ptr<ClientContext> context) : type(type), context(context) {
+	BufferedData(Type type, weak_ptr<ClientContext> context) : type(type), context(std::move(context)) {
 	}
 	virtual ~BufferedData() {
 	}

package/src/duckdb/src/include/duckdb/main/buffered_data/simple_buffered_data.hpp

@@ -28,7 +28,7 @@ private:
 	static constexpr idx_t BUFFER_SIZE = 100000;
 
 public:
-	SimpleBufferedData(weak_ptr<ClientContext> context);
+	explicit SimpleBufferedData(weak_ptr<ClientContext> context);
 	~SimpleBufferedData() override;
 
 public:

package/src/duckdb/src/include/duckdb/main/capi/capi_internal.hpp

@@ -75,8 +75,8 @@ struct DuckDBResultData {
 duckdb_type ConvertCPPTypeToC(const LogicalType &type);
 LogicalTypeId ConvertCTypeToCPP(duckdb_type c_type);
 idx_t GetCTypeSize(duckdb_type type);
-duckdb_state duckdb_translate_result(unique_ptr<QueryResult> result, duckdb_result *out);
-bool deprecated_materialize_result(duckdb_result *result);
+duckdb_state DuckDBTranslateResult(unique_ptr<QueryResult> result, duckdb_result *out);
+bool DeprecatedMaterializeResult(duckdb_result *result);
 duckdb_statement_type StatementTypeToC(duckdb::StatementType statement_type);
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/main/chunk_scan_state/query_result.hpp

@@ -9,8 +9,8 @@ class QueryResult;
 
 class QueryResultChunkScanState : public ChunkScanState {
 public:
-	QueryResultChunkScanState(QueryResult &result);
-	~QueryResultChunkScanState();
+	explicit QueryResultChunkScanState(QueryResult &result);
+	~QueryResultChunkScanState() override;
 
 public:
 	bool LoadNextChunk(ErrorData &error) override;

package/src/duckdb/src/include/duckdb/main/client_context.hpp

@@ -167,7 +167,7 @@ public:
 	                                                 bool requires_valid_transaction = true);
 
 	//! Equivalent to CURRENT_SETTING(key) SQL function.
-	DUCKDB_API SettingLookupResult TryGetCurrentSetting(const std::string &key, Value &result);
+	DUCKDB_API SettingLookupResult TryGetCurrentSetting(const std::string &key, Value &result) const;
 
 	//! Returns the parser options for this client context
 	DUCKDB_API ParserOptions GetParserOptions() const;

package/src/duckdb/src/include/duckdb/main/client_context_file_opener.hpp

@@ -24,9 +24,10 @@ public:
 	SettingLookupResult TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &info) override;
 	SettingLookupResult TryGetCurrentSetting(const string &key, Value &result) override;
 
-	ClientContext *TryGetClientContext() override {
+	optional_ptr<ClientContext> TryGetClientContext() override {
 		return &context;
-	};
+	}
+	optional_ptr<DatabaseInstance> TryGetDatabase() override;
 
 private:
 	ClientContext &context;

package/src/duckdb/src/include/duckdb/main/client_data.hpp

@@ -64,6 +64,7 @@ struct ClientData {
 
 public:
 	DUCKDB_API static ClientData &Get(ClientContext &context);
+	DUCKDB_API static const ClientData &Get(const ClientContext &context);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/main/client_properties.hpp

@@ -11,7 +11,8 @@
 #include <string>
 
 namespace duckdb {
-enum ArrowOffsetSize { REGULAR, LARGE };
+
+enum class ArrowOffsetSize : uint8_t { REGULAR, LARGE };
 
 //! A set of properties from the client context that can be used to interpret the query result
 struct ClientProperties {

package/src/duckdb/src/include/duckdb/main/config.hpp

@@ -34,6 +34,7 @@
 
 namespace duckdb {
 
+class BufferManager;
 class BufferPool;
 class CastFunctionSet;
 class ClientContext;
@@ -59,7 +60,7 @@ typedef void (*set_global_function_t)(DatabaseInstance *db, DBConfig &config, co
 typedef void (*set_local_function_t)(ClientContext &context, const Value &parameter);
 typedef void (*reset_global_function_t)(DatabaseInstance *db, DBConfig &config);
 typedef void (*reset_local_function_t)(ClientContext &context);
-typedef Value (*get_setting_function_t)(ClientContext &context);
+typedef Value (*get_setting_function_t)(const ClientContext &context);
 
 struct ConfigurationOption {
 	const char *name;
@@ -75,6 +76,7 @@ struct ConfigurationOption {
 typedef void (*set_option_callback_t)(ClientContext &context, SetScope scope, Value &parameter);
 
 struct ExtensionOption {
+	// NOLINTNEXTLINE: work around bug in clang-tidy
 	ExtensionOption(string description_p, LogicalType type_p, set_option_callback_t set_function_p,
 	                Value default_value_p)
 	    : description(std::move(description_p)), type(std::move(type_p)), set_function(set_function_p),
@@ -127,6 +129,9 @@ struct DBConfigOptions {
 	bool use_temporary_directory = true;
 	//! Directory to store temporary structures that do not fit in memory
 	string temporary_directory;
+	//! Whether or not to invoke filesystem trim on free blocks after checkpoint. This will reclaim
+	//! space for sparse files, on platforms that support it.
+	bool trim_free_blocks = false;
 	//! Whether or not to allow printing unredacted secrets
 	bool allow_unredacted_secrets = false;
 	//! The collation type of the database
@@ -170,6 +175,8 @@ struct DBConfigOptions {
 	string extension_directory;
 	//! Whether unsigned extensions should be loaded
 	bool allow_unsigned_extensions = false;
+	//! Whether extensions with missing metadata should be loaded
+	bool allow_extensions_metadata_mismatch = false;
 	//! Enable emitting FSST Vectors
 	bool enable_fsst_vectors = false;
 	//! Start transactions immediately in all attached databases - instead of lazily when a database is referenced
@@ -181,7 +188,7 @@ struct DBConfigOptions {
 	//! Whether or not the configuration settings can be altered
 	bool lock_configuration = false;
 	//! Whether to print bindings when printing the plan (debug mode only)
-	static bool debug_print_bindings;
+	static bool debug_print_bindings; // NOLINT: debug setting
 	//! The peak allocation threshold at which to flush the allocator after completing a task (1 << 27, ~128MB)
 	idx_t allocator_flush_threshold = 134217728;
 	//! DuckDB API surface
@@ -200,7 +207,7 @@ struct DBConfig {
 
 public:
 	DUCKDB_API DBConfig();
-	DUCKDB_API DBConfig(bool read_only);
+	explicit DUCKDB_API DBConfig(bool read_only);
 	DUCKDB_API DBConfig(const case_insensitive_map_t<Value> &config_dict, bool read_only);
 	DUCKDB_API ~DBConfig();
 
@@ -233,6 +240,8 @@ public:
 	case_insensitive_map_t<duckdb::unique_ptr<StorageExtension>> storage_extensions;
 	//! A buffer pool can be shared across multiple databases (if desired).
 	shared_ptr<BufferPool> buffer_pool;
+	//! Provide a custom buffer manager implementation (if desired).
+	shared_ptr<BufferManager> buffer_manager;
 	//! Set of callbacks that can be installed by extensions
 	vector<unique_ptr<ExtensionCallback>> extension_callbacks;
 
@@ -249,9 +258,9 @@ public:
 	DUCKDB_API void AddExtensionOption(const string &name, string description, LogicalType parameter,
 	                                   const Value &default_value = Value(), set_option_callback_t function = nullptr);
 	//! Fetch an option by index. Returns a pointer to the option, or nullptr if out of range
-	DUCKDB_API static ConfigurationOption *GetOptionByIndex(idx_t index);
+	DUCKDB_API static optional_ptr<const ConfigurationOption> GetOptionByIndex(idx_t index);
 	//! Fetch an option by name. Returns a pointer to the option, or nullptr if none exists.
-	DUCKDB_API static ConfigurationOption *GetOptionByName(const string &name);
+	DUCKDB_API static optional_ptr<const ConfigurationOption> GetOptionByName(const string &name);
 	DUCKDB_API void SetOption(const ConfigurationOption &option, const Value &value);
 	DUCKDB_API void SetOption(DatabaseInstance *db, const ConfigurationOption &option, const Value &value);
 	DUCKDB_API void SetOptionByName(const string &name, const Value &value);

package/src/duckdb/src/include/duckdb/main/connection.hpp

@@ -32,7 +32,7 @@ class LogicalOperator;
 class SelectStatement;
 struct CSVReaderOptions;
 
-typedef void (*warning_callback)(std::string);
+typedef void (*warning_callback_t)(std::string);
 
 //! A connection to a database. This represents a (client) connection that can
 //! be used to query the database.
@@ -49,7 +49,7 @@ public:
 	DUCKDB_API ~Connection();
 
 	shared_ptr<ClientContext> context;
-	warning_callback warning_cb;
+	warning_callback_t warning_cb;
 
 public:
 	//! Returns query profiling information for the current query
@@ -63,8 +63,6 @@ public:
 	//! Disable query profiling
 	DUCKDB_API void DisableProfiling();
 
-	DUCKDB_API void SetWarningCallback(warning_callback);
-
 	//! Enable aggressive verification/testing of queries, should only be used in testing
 	DUCKDB_API void EnableQueryVerification();
 	DUCKDB_API void DisableQueryVerification();
@@ -83,8 +81,8 @@ public:
 	//! MaterializedQueryResult.
 	DUCKDB_API unique_ptr<MaterializedQueryResult> Query(unique_ptr<SQLStatement> statement);
 	// prepared statements
-	template <typename... Args>
-	unique_ptr<QueryResult> Query(const string &query, Args... args) {
+	template <typename... ARGS>
+	unique_ptr<QueryResult> Query(const string &query, ARGS... args) {
 		vector<Value> values;
 		return QueryParamsRecursive(query, values, args...);
 	}
@@ -167,28 +165,29 @@ public:
 	//! Fetch a list of table names that are required for a given query
 	DUCKDB_API unordered_set<string> GetTableNames(const string &query);
 
-	template <typename TR, typename... Args>
-	void CreateScalarFunction(const string &name, TR (*udf_func)(Args...)) {
-		scalar_function_t function = UDFWrapper::CreateScalarFunction<TR, Args...>(name, udf_func);
-		UDFWrapper::RegisterFunction<TR, Args...>(name, function, *context);
+	// NOLINTBEGIN
+	template <typename TR, typename... ARGS>
+	void CreateScalarFunction(const string &name, TR (*udf_func)(ARGS...)) {
+		scalar_function_t function = UDFWrapper::CreateScalarFunction<TR, ARGS...>(name, udf_func);
+		UDFWrapper::RegisterFunction<TR, ARGS...>(name, function, *context);
 	}
 
-	template <typename TR, typename... Args>
+	template <typename TR, typename... ARGS>
 	void CreateScalarFunction(const string &name, vector<LogicalType> args, LogicalType ret_type,
-	                          TR (*udf_func)(Args...)) {
-		scalar_function_t function = UDFWrapper::CreateScalarFunction<TR, Args...>(name, args, ret_type, udf_func);
+	                          TR (*udf_func)(ARGS...)) {
+		scalar_function_t function = UDFWrapper::CreateScalarFunction<TR, ARGS...>(name, args, ret_type, udf_func);
 		UDFWrapper::RegisterFunction(name, args, ret_type, function, *context);
 	}
 
-	template <typename TR, typename... Args>
+	template <typename TR, typename... ARGS>
 	void CreateVectorizedFunction(const string &name, scalar_function_t udf_func,
 	                              LogicalType varargs = LogicalType::INVALID) {
-		UDFWrapper::RegisterFunction<TR, Args...>(name, udf_func, *context, std::move(varargs));
+		UDFWrapper::RegisterFunction<TR, ARGS...>(name, udf_func, *context, std::move(varargs));
 	}
 
 	void CreateVectorizedFunction(const string &name, vector<LogicalType> args, LogicalType ret_type,
 	                              scalar_function_t udf_func, LogicalType varargs = LogicalType::INVALID) {
-		UDFWrapper::RegisterFunction(name, std::move(args), std::move(ret_type), udf_func, *context,
+		UDFWrapper::RegisterFunction(name, std::move(args), std::move(ret_type), std::move(udf_func), *context,
 		                             std::move(varargs));
 	}
 
@@ -206,23 +205,24 @@ public:
 	}
 
 	template <typename UDF_OP, typename STATE, typename TR, typename TA>
-	void CreateAggregateFunction(const string &name, LogicalType ret_type, LogicalType input_typeA) {
+	void CreateAggregateFunction(const string &name, LogicalType ret_type, LogicalType input_type_a) {
 		AggregateFunction function =
-		    UDFWrapper::CreateAggregateFunction<UDF_OP, STATE, TR, TA>(name, ret_type, input_typeA);
+		    UDFWrapper::CreateAggregateFunction<UDF_OP, STATE, TR, TA>(name, ret_type, input_type_a);
 		UDFWrapper::RegisterAggrFunction(function, *context);
 	}
 
 	template <typename UDF_OP, typename STATE, typename TR, typename TA, typename TB>
-	void CreateAggregateFunction(const string &name, LogicalType ret_type, LogicalType input_typeA,
-	                             LogicalType input_typeB) {
+	void CreateAggregateFunction(const string &name, LogicalType ret_type, LogicalType input_type_a,
+	                             LogicalType input_type_b) {
 		AggregateFunction function =
-		    UDFWrapper::CreateAggregateFunction<UDF_OP, STATE, TR, TA, TB>(name, ret_type, input_typeA, input_typeB);
+		    UDFWrapper::CreateAggregateFunction<UDF_OP, STATE, TR, TA, TB>(name, ret_type, input_type_a, input_type_b);
 		UDFWrapper::RegisterAggrFunction(function, *context);
 	}
 
-	void CreateAggregateFunction(const string &name, vector<LogicalType> arguments, LogicalType return_type,
-	                             aggregate_size_t state_size, aggregate_initialize_t initialize,
-	                             aggregate_update_t update, aggregate_combine_t combine, aggregate_finalize_t finalize,
+	void CreateAggregateFunction(const string &name, const vector<LogicalType> &arguments,
+	                             const LogicalType &return_type, aggregate_size_t state_size,
+	                             aggregate_initialize_t initialize, aggregate_update_t update,
+	                             aggregate_combine_t combine, aggregate_finalize_t finalize,
 	                             aggregate_simple_update_t simple_update = nullptr,
 	                             bind_aggregate_function_t bind = nullptr,
 	                             aggregate_destructor_t destructor = nullptr) {
@@ -231,12 +231,13 @@ public:
 		                                        finalize, simple_update, bind, destructor);
 		UDFWrapper::RegisterAggrFunction(function, *context);
 	}
+	// NOLINTEND
 
 private:
 	unique_ptr<QueryResult> QueryParamsRecursive(const string &query, vector<Value> &values);
 
-	template <typename T, typename... Args>
-	unique_ptr<QueryResult> QueryParamsRecursive(const string &query, vector<Value> &values, T value, Args... args) {
+	template <typename T, typename... ARGS>
+	unique_ptr<QueryResult> QueryParamsRecursive(const string &query, vector<Value> &values, T value, ARGS... args) {
 		values.push_back(Value::CreateValue<T>(value));
 		return QueryParamsRecursive(query, values, args...);
 	}