duckdb 0.7.2-dev3546.0 → 0.7.2-dev3710.0

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

@@ -16,7 +16,7 @@ namespace duckdb {
 struct UDFWrapper {
 public:
 	template <typename TR, typename... Args>
-	static scalar_function_t CreateScalarFunction(const string &name, TR (*udf_func)(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:
@@ -31,8 +31,8 @@ public:
 	}
 
 	template <typename TR, typename... Args>
-	static scalar_function_t CreateScalarFunction(const string &name, vector<LogicalType> args, LogicalType ret_type,
-	                                              TR (*udf_func)(Args...)) {
+	inline static scalar_function_t CreateScalarFunction(const string &name, vector<LogicalType> args,
+	                                                     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
@@ -56,8 +56,8 @@ public:
 	}
 
 	template <typename TR, typename... Args>
-	static void RegisterFunction(const string &name, scalar_function_t udf_function, ClientContext &context,
-	                             LogicalType varargs = LogicalType(LogicalTypeId::INVALID)) {
+	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);
 
@@ -66,23 +66,24 @@ public:
 		RegisterFunction(name, arguments, ret_type, udf_function, context, varargs);
 	}
 
-	DUCKDB_API static void RegisterFunction(string name, vector<LogicalType> args, LogicalType ret_type,
-	                                        scalar_function_t udf_function, ClientContext &context,
-	                                        LogicalType varargs = LogicalType(LogicalTypeId::INVALID));
+	static void RegisterFunction(string name, vector<LogicalType> args, LogicalType ret_type,
+	                             scalar_function_t udf_function, ClientContext &context,
+	                             LogicalType varargs = LogicalType(LogicalTypeId::INVALID));
 
 	//--------------------------------- Aggregate UDFs ------------------------------------//
 	template <typename UDF_OP, typename STATE, typename TR, typename TA>
-	static AggregateFunction CreateAggregateFunction(const string &name) {
+	inline static AggregateFunction CreateAggregateFunction(const string &name) {
 		return CreateUnaryAggregateFunction<UDF_OP, STATE, TR, TA>(name);
 	}
 
 	template <typename UDF_OP, typename STATE, typename TR, typename TA, typename TB>
-	static AggregateFunction CreateAggregateFunction(const string &name) {
+	inline static AggregateFunction CreateAggregateFunction(const string &name) {
 		return CreateBinaryAggregateFunction<UDF_OP, STATE, TR, TA, TB>(name);
 	}
 
 	template <typename UDF_OP, typename STATE, typename TR, typename TA>
-	static AggregateFunction CreateAggregateFunction(const string &name, LogicalType ret_type, LogicalType input_type) {
+	inline static AggregateFunction CreateAggregateFunction(const string &name, LogicalType ret_type,
+	                                                        LogicalType input_type) {
 		if (!TypesMatch<TR>(ret_type)) { // LCOV_EXCL_START
 			throw std::runtime_error("The return argument don't match!");
 		} // LCOV_EXCL_STOP
@@ -95,8 +96,8 @@ public:
 	}
 
 	template <typename UDF_OP, typename STATE, typename TR, typename TA, typename TB>
-	static AggregateFunction CreateAggregateFunction(const string &name, LogicalType ret_type, LogicalType input_typeA,
-	                                                 LogicalType input_typeB) {
+	inline static AggregateFunction CreateAggregateFunction(const string &name, LogicalType ret_type,
+	                                                        LogicalType input_typeA, LogicalType input_typeB) {
 		if (!TypesMatch<TR>(ret_type)) { // LCOV_EXCL_START
 			throw std::runtime_error("The return argument don't match!");
 		}
@@ -113,13 +114,12 @@ public:
 	}
 
 	//! A generic CreateAggregateFunction ---------------------------------------------------------------------------//
-	static AggregateFunction CreateAggregateFunction(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,
-	                                                 aggregate_simple_update_t simple_update = nullptr,
-	                                                 bind_aggregate_function_t bind = nullptr,
-	                                                 aggregate_destructor_t destructor = nullptr) {
+	inline static AggregateFunction
+	CreateAggregateFunction(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,
+	                        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);
@@ -127,8 +127,8 @@ public:
 		return aggr_function;
 	}
 
-	DUCKDB_API static void RegisterAggrFunction(AggregateFunction aggr_function, ClientContext &context,
-	                                            LogicalType varargs = LogicalType(LogicalTypeId::INVALID));
+	static void RegisterAggrFunction(AggregateFunction aggr_function, ClientContext &context,
+	                                 LogicalType varargs = LogicalType(LogicalTypeId::INVALID));
 
 private:
 	//-------------------------------- Templated functions --------------------------------//
@@ -142,7 +142,7 @@ private:
 	};
 
 	template <typename TR, typename TA>
-	static scalar_function_t CreateUnaryFunction(const string &name, TR (*udf_func)(TA)) {
+	inline static scalar_function_t CreateUnaryFunction(const string &name, TR (*udf_func)(TA)) {
 		scalar_function_t udf_function = [=](DataChunk &input, ExpressionState &state, Vector &result) -> void {
 			UnaryExecutor::GenericExecute<TA, TR, UnaryUDFExecutor>(input.data[0], result, input.size(),
 			                                                        (void *)udf_func);
@@ -151,7 +151,7 @@ private:
 	}
 
 	template <typename TR, typename TA, typename TB>
-	static scalar_function_t CreateBinaryFunction(const string &name, TR (*udf_func)(TA, TB)) {
+	inline static scalar_function_t CreateBinaryFunction(const string &name, TR (*udf_func)(TA, TB)) {
 		scalar_function_t udf_function = [=](DataChunk &input, ExpressionState &state, Vector &result) -> void {
 			BinaryExecutor::Execute<TA, TB, TR>(input.data[0], input.data[1], result, input.size(), udf_func);
 		};
@@ -159,7 +159,7 @@ private:
 	}
 
 	template <typename TR, typename TA, typename TB, typename TC>
-	static scalar_function_t CreateTernaryFunction(const string &name, TR (*udf_func)(TA, TB, TC)) {
+	inline static scalar_function_t CreateTernaryFunction(const string &name, TR (*udf_func)(TA, TB, TC)) {
 		scalar_function_t udf_function = [=](DataChunk &input, ExpressionState &state, Vector &result) -> void {
 			TernaryExecutor::Execute<TA, TB, TC, TR>(input.data[0], input.data[1], input.data[2], result, input.size(),
 			                                         udf_func);
@@ -168,22 +168,25 @@ private:
 	}
 
 	template <typename TR, typename... Args>
-	static scalar_function_t CreateUnaryFunction(const string &name, TR (*udf_func)(Args...)) { // LCOV_EXCL_START
+	inline static scalar_function_t CreateUnaryFunction(const string &name,
+	                                                    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>
-	static scalar_function_t CreateBinaryFunction(const string &name, TR (*udf_func)(Args...)) { // LCOV_EXCL_START
+	inline static scalar_function_t CreateBinaryFunction(const string &name,
+	                                                     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>
-	static scalar_function_t CreateTernaryFunction(const string &name, TR (*udf_func)(Args...)) { // LCOV_EXCL_START
+	inline static scalar_function_t CreateTernaryFunction(const string &name,
+	                                                      TR (*udf_func)(Args...)) { // LCOV_EXCL_START
 		throw std::runtime_error("Incorrect number of arguments for ternary function");
 	} // LCOV_EXCL_STOP
 
 	template <typename T>
-	static LogicalType GetArgumentType() {
+	inline static LogicalType GetArgumentType() {
 		if (std::is_same<T, bool>()) {
 			return LogicalType(LogicalTypeId::BOOLEAN);
 		} else if (std::is_same<T, int8_t>()) {
@@ -206,13 +209,13 @@ private:
 	}
 
 	template <typename TA, typename TB, typename... Args>
-	static void GetArgumentTypesRecursive(vector<LogicalType> &arguments) {
+	inline static void GetArgumentTypesRecursive(vector<LogicalType> &arguments) {
 		arguments.push_back(GetArgumentType<TA>());
 		GetArgumentTypesRecursive<TB, Args...>(arguments);
 	}
 
 	template <typename TA>
-	static void GetArgumentTypesRecursive(vector<LogicalType> &arguments) {
+	inline static void GetArgumentTypesRecursive(vector<LogicalType> &arguments) {
 		arguments.push_back(GetArgumentType<TA>());
 	}
 
@@ -220,14 +223,15 @@ private:
 	//-------------------------------- Argumented functions --------------------------------//
 
 	template <typename TR, typename... Args>
-	static scalar_function_t CreateUnaryFunction(const string &name, vector<LogicalType> args, LogicalType ret_type,
-	                                             TR (*udf_func)(Args...)) { // LCOV_EXCL_START
+	inline static scalar_function_t CreateUnaryFunction(const string &name, vector<LogicalType> args,
+	                                                    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>
-	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, vector<LogicalType> args,
+	                                                    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!");
 		}
@@ -243,14 +247,15 @@ private:
 	}
 
 	template <typename TR, typename... Args>
-	static scalar_function_t CreateBinaryFunction(const string &name, vector<LogicalType> args, LogicalType ret_type,
-	                                              TR (*udf_func)(Args...)) { // LCOV_EXCL_START
+	inline static scalar_function_t CreateBinaryFunction(const string &name, vector<LogicalType> args,
+	                                                     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>
-	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, vector<LogicalType> args,
+	                                                     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!");
 		}
@@ -268,14 +273,15 @@ private:
 	}
 
 	template <typename TR, typename... Args>
-	static scalar_function_t CreateTernaryFunction(const string &name, vector<LogicalType> args, LogicalType ret_type,
-	                                               TR (*udf_func)(Args...)) { // LCOV_EXCL_START
+	inline static scalar_function_t CreateTernaryFunction(const string &name, vector<LogicalType> args,
+	                                                      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>
-	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, vector<LogicalType> args,
+	                                                      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!");
 		}
@@ -297,7 +303,7 @@ private:
 	}
 
 	template <typename T>
-	static bool TypesMatch(const LogicalType &sql_type) {
+	inline static bool TypesMatch(const LogicalType &sql_type) {
 		switch (sql_type.id()) {
 		case LogicalTypeId::BOOLEAN:
 			return std::is_same<T, bool>();
@@ -336,15 +342,15 @@ private:
 private:
 	//-------------------------------- Aggregate functions --------------------------------//
 	template <typename UDF_OP, typename STATE, typename TR, typename TA>
-	static AggregateFunction CreateUnaryAggregateFunction(const string &name) {
+	inline static AggregateFunction CreateUnaryAggregateFunction(const string &name) {
 		LogicalType return_type = GetArgumentType<TR>();
 		LogicalType input_type = GetArgumentType<TA>();
 		return CreateUnaryAggregateFunction<UDF_OP, STATE, TR, TA>(name, return_type, input_type);
 	}
 
 	template <typename UDF_OP, typename STATE, typename TR, typename TA>
-	static AggregateFunction CreateUnaryAggregateFunction(const string &name, LogicalType ret_type,
-	                                                      LogicalType input_type) {
+	inline static AggregateFunction CreateUnaryAggregateFunction(const string &name, LogicalType ret_type,
+	                                                             LogicalType input_type) {
 		AggregateFunction aggr_function =
 		    AggregateFunction::UnaryAggregate<STATE, TR, TA, UDF_OP>(input_type, ret_type);
 		aggr_function.name = name;
@@ -352,7 +358,7 @@ private:
 	}
 
 	template <typename UDF_OP, typename STATE, typename TR, typename TA, typename TB>
-	static AggregateFunction CreateBinaryAggregateFunction(const string &name) {
+	inline static AggregateFunction CreateBinaryAggregateFunction(const string &name) {
 		LogicalType return_type = GetArgumentType<TR>();
 		LogicalType input_typeA = GetArgumentType<TA>();
 		LogicalType input_typeB = GetArgumentType<TB>();
@@ -360,8 +366,8 @@ private:
 	}
 
 	template <typename UDF_OP, typename STATE, typename TR, typename TA, typename TB>
-	static AggregateFunction CreateBinaryAggregateFunction(const string &name, LogicalType ret_type,
-	                                                       LogicalType input_typeA, LogicalType input_typeB) {
+	inline static AggregateFunction CreateBinaryAggregateFunction(const string &name, LogicalType ret_type,
+	                                                              LogicalType input_typeA, LogicalType input_typeB) {
 		AggregateFunction aggr_function =
 		    AggregateFunction::BinaryAggregate<STATE, TR, TA, TB, UDF_OP>(input_typeA, input_typeB, ret_type);
 		aggr_function.name = name;

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

@@ -77,10 +77,10 @@ public:
 	//! Flush the changes made by the appender and close it. The appender cannot be used after this point
 	DUCKDB_API void Close();
 
-	DUCKDB_API vector<LogicalType> &GetTypes() {
+	vector<LogicalType> &GetTypes() {
 		return types;
 	}
-	DUCKDB_API idx_t CurrentColumn() {
+	idx_t CurrentColumn() {
 		return column;
 	}
 	DUCKDB_API void AppendDataChunk(DataChunk &value);

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

@@ -86,7 +86,7 @@ public:
 	TransactionContext transaction;
 
 public:
-	DUCKDB_API MetaTransaction &ActiveTransaction() {
+	MetaTransaction &ActiveTransaction() {
 		return transaction.ActiveTransaction();
 	}
 
@@ -276,7 +276,7 @@ private:
 
 class ClientContextWrapper {
 public:
-	DUCKDB_API explicit ClientContextWrapper(const shared_ptr<ClientContext> &context)
+	explicit ClientContextWrapper(const shared_ptr<ClientContext> &context)
 	    : client_context(context) {
 
 	      };

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

@@ -63,7 +63,9 @@ struct ClientData {
 	string file_search_path;
 
 	//! The Max Line Length Size of Last Query Executed on a CSV File. (Only used for testing)
-	idx_t max_line_length = 0;
+	//! FIXME: this should not be done like this
+	bool debug_set_max_line_length = false;
+	idx_t debug_max_line_length = 0;
 
 public:
 	DUCKDB_API static ClientData &Get(ClientContext &context);

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

@@ -180,8 +180,8 @@ public:
 		UDFWrapper::RegisterFunction<TR, Args...>(name, udf_func, *context, std::move(varargs));
 	}
 
-	DUCKDB_API void CreateVectorizedFunction(const string &name, vector<LogicalType> args, LogicalType ret_type,
-	                                         scalar_function_t udf_func, LogicalType varargs = LogicalType::INVALID) {
+	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,
 		                             std::move(varargs));
 	}
@@ -214,13 +214,12 @@ public:
 		UDFWrapper::RegisterAggrFunction(function, *context);
 	}
 
-	DUCKDB_API 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,
-	                                        aggregate_simple_update_t simple_update = nullptr,
-	                                        bind_aggregate_function_t bind = nullptr,
-	                                        aggregate_destructor_t destructor = nullptr) {
+	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,
+	                             aggregate_simple_update_t simple_update = nullptr,
+	                             bind_aggregate_function_t bind = nullptr,
+	                             aggregate_destructor_t destructor = nullptr) {
 		AggregateFunction function =
 		    UDFWrapper::CreateAggregateFunction(name, arguments, return_type, state_size, initialize, update, combine,
 		                                        finalize, simple_update, bind, destructor);

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

@@ -70,6 +70,7 @@ static constexpr ExtensionEntry EXTENSION_FUNCTIONS[] = {
     {"read_json", "json"},
     {"read_json_auto", "json"},
     {"read_json_objects", "json"},
+    {"read_json_objects_auto", "json"},
     {"read_ndjson", "json"},
     {"read_ndjson_auto", "json"},
     {"read_ndjson_objects", "json"},

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

@@ -108,7 +108,7 @@ public:
 	//! Fetch() until both results are exhausted. The data in the results will be lost.
 	DUCKDB_API bool Equals(QueryResult &other);
 
-	DUCKDB_API bool TryFetch(unique_ptr<DataChunk> &result, PreservedError &error) {
+	bool TryFetch(unique_ptr<DataChunk> &result, PreservedError &error) {
 		try {
 			result = Fetch();
 			return success;
@@ -191,10 +191,10 @@ private:
 	};
 
 public:
-	DUCKDB_API QueryResultIterator begin() {
+	QueryResultIterator begin() {
 		return QueryResultIterator(this);
 	}
-	DUCKDB_API QueryResultIterator end() {
+	QueryResultIterator end() {
 		return QueryResultIterator(nullptr);
 	}
 

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

@@ -32,12 +32,11 @@ class TableRef;
 
 class Relation : public std::enable_shared_from_this<Relation> {
 public:
-	DUCKDB_API Relation(const std::shared_ptr<ClientContext> &context, RelationType type)
-	    : context(context), type(type) {
+	Relation(const std::shared_ptr<ClientContext> &context, RelationType type) : context(context), type(type) {
 	}
-	DUCKDB_API Relation(ClientContextWrapper &context, RelationType type) : context(context.GetContext()), type(type) {
+	Relation(ClientContextWrapper &context, RelationType type) : context(context.GetContext()), type(type) {
 	}
-	DUCKDB_API virtual ~Relation() {
+	virtual ~Relation() {
 	}
 
 	ClientContextWrapper context;
@@ -70,7 +69,7 @@ public:
 	DUCKDB_API unique_ptr<QueryResult> Explain(ExplainType type = ExplainType::EXPLAIN_STANDARD);
 
 	DUCKDB_API virtual unique_ptr<TableRef> GetTableRef();
-	DUCKDB_API virtual bool IsReadOnly() {
+	virtual bool IsReadOnly() {
 		return true;
 	}
 
@@ -154,10 +153,10 @@ public:
 
 public:
 	//! Whether or not the relation inherits column bindings from its child or not, only relevant for binding
-	DUCKDB_API virtual bool InheritsColumnBindings() {
+	virtual bool InheritsColumnBindings() {
 		return false;
 	}
-	DUCKDB_API virtual Relation *ChildRelation() {
+	virtual Relation *ChildRelation() {
 		return nullptr;
 	}
 	DUCKDB_API vector<shared_ptr<ExternalDependency>> GetAllDependencies();

package/src/duckdb/src/include/duckdb/optimizer/optimizer_extension.hpp

@@ -15,7 +15,7 @@ namespace duckdb {
 
 //! The OptimizerExtensionInfo holds static information relevant to the optimizer extension
 struct OptimizerExtensionInfo {
-	DUCKDB_API virtual ~OptimizerExtensionInfo() {
+	virtual ~OptimizerExtensionInfo() {
 	}
 };
 

package/src/duckdb/src/include/duckdb/parser/column_list.hpp

@@ -76,7 +76,7 @@ public:
 	// logical iterator
 	class ColumnListIterator {
 	public:
-		DUCKDB_API ColumnListIterator(const ColumnList &list, bool physical) : list(list), physical(physical) {
+		ColumnListIterator(const ColumnList &list, bool physical) : list(list), physical(physical) {
 		}
 
 	private:
@@ -86,7 +86,7 @@ public:
 	private:
 		class ColumnLogicalIteratorInternal {
 		public:
-			DUCKDB_API ColumnLogicalIteratorInternal(const ColumnList &list, bool physical, idx_t pos, idx_t end)
+			ColumnLogicalIteratorInternal(const ColumnList &list, bool physical, idx_t pos, idx_t end)
 			    : list(list), physical(physical), pos(pos), end(end) {
 			}
 
@@ -96,14 +96,14 @@ public:
 			idx_t end;
 
 		public:
-			DUCKDB_API ColumnLogicalIteratorInternal &operator++() {
+			ColumnLogicalIteratorInternal &operator++() {
 				pos++;
 				return *this;
 			}
-			DUCKDB_API bool operator!=(const ColumnLogicalIteratorInternal &other) const {
+			bool operator!=(const ColumnLogicalIteratorInternal &other) const {
 				return pos != other.pos || end != other.end || &list != &other.list;
 			}
-			DUCKDB_API const ColumnDefinition &operator*() const {
+			const ColumnDefinition &operator*() const {
 				if (physical) {
 					return list.GetColumn(PhysicalIndex(pos));
 				} else {
@@ -117,10 +117,10 @@ public:
 			return physical ? list.PhysicalColumnCount() : list.LogicalColumnCount();
 		}
 
-		DUCKDB_API ColumnLogicalIteratorInternal begin() {
+		ColumnLogicalIteratorInternal begin() {
 			return ColumnLogicalIteratorInternal(list, physical, 0, Size());
 		}
-		DUCKDB_API ColumnLogicalIteratorInternal end() {
+		ColumnLogicalIteratorInternal end() {
 			return ColumnLogicalIteratorInternal(list, physical, Size(), Size());
 		}
 	};

package/src/duckdb/src/include/duckdb/parser/expression/function_expression.hpp

@@ -92,7 +92,7 @@ public:
 		result += StringUtil::Join(entry.children, entry.children.size(), ", ", [&](const unique_ptr<BASE> &child) {
 			return child->alias.empty() || !add_alias
 			           ? child->ToString()
-			           : KeywordHelper::WriteOptionallyQuoted(child->alias) + " := " + child->ToString();
+			           : StringUtil::Format("%s := %s", SQLIdentifier(child->alias), child->ToString());
 		});
 		// ordered aggregate
 		if (order_bys && !order_bys->orders.empty()) {

package/src/duckdb/src/include/duckdb/parser/expression/operator_expression.hpp

@@ -96,8 +96,8 @@ public:
 			auto child_string = entry.children[1]->ToString();
 			D_ASSERT(child_string.size() >= 3);
 			D_ASSERT(child_string[0] == '\'' && child_string[child_string.size() - 1] == '\'');
-			return "(" + entry.children[0]->ToString() + ")." +
-			       KeywordHelper::WriteOptionallyQuoted(child_string.substr(1, child_string.size() - 2));
+			return StringUtil::Format("(%s).%s", entry.children[0]->ToString(),
+			                          SQLIdentifier(child_string.substr(1, child_string.size() - 2)));
 		}
 		case ExpressionType::ARRAY_CONSTRUCTOR: {
 			string result = "(ARRAY[";

package/src/duckdb/src/include/duckdb/parser/keyword_helper.hpp

@@ -17,9 +17,14 @@ public:
 	//! Returns true if the given text matches a keyword of the parser
 	static bool IsKeyword(const string &text);
 
+	static string EscapeQuotes(const string &text, char quote = '"');
+
 	//! Returns true if the given string needs to be quoted when written as an identifier
 	static bool RequiresQuotes(const string &text, bool allow_caps = true);
 
+	//! Writes a string that is quoted
+	static string WriteQuoted(const string &text, char quote = '\'');
+
 	//! Writes a string that is optionally quoted + escaped so it can be used as an identifier
 	static string WriteOptionallyQuoted(const string &text, char quote = '"', bool allow_caps = true);
 };

package/src/duckdb/src/include/duckdb/parser/parser_extension.hpp

@@ -17,7 +17,7 @@ namespace duckdb {
 //! The ParserExtensionInfo holds static information relevant to the parser extension
 //! It is made available in the parse_function, and will be kept alive as long as the database system is kept alive
 struct ParserExtensionInfo {
-	DUCKDB_API virtual ~ParserExtensionInfo() {
+	virtual ~ParserExtensionInfo() {
 	}
 };
 
@@ -29,7 +29,7 @@ enum class ParserExtensionResultType : uint8_t { PARSE_SUCCESSFUL, DISPLAY_ORIGI
 //! The ParserExtensionParseData holds the result of a successful parse step
 //! It will be passed along to the subsequent plan function
 struct ParserExtensionParseData {
-	DUCKDB_API virtual ~ParserExtensionParseData() {
+	virtual ~ParserExtensionParseData() {
 	}
 
 	virtual unique_ptr<ParserExtensionParseData> Copy() const = 0;

package/src/duckdb/src/include/duckdb/parser/sql_statement.hpp

@@ -41,7 +41,7 @@ protected:
 	SQLStatement(const SQLStatement &other) = default;
 
 public:
-	DUCKDB_API virtual string ToString() const {
+	virtual string ToString() const {
 		throw InternalException("ToString not supported for this type of SQLStatement: '%s'",
 		                        StatementTypeToString(type));
 	}

package/src/duckdb/src/include/duckdb/parser/statement/select_statement.hpp

@@ -26,7 +26,7 @@ public:
 	static constexpr const StatementType TYPE = StatementType::SELECT_STATEMENT;
 
 public:
-	DUCKDB_API SelectStatement() : SQLStatement(StatementType::SELECT_STATEMENT) {
+	SelectStatement() : SQLStatement(StatementType::SELECT_STATEMENT) {
 	}
 
 	//! The main query node

package/src/duckdb/src/include/duckdb/planner/operator_extension.hpp

@@ -16,7 +16,7 @@ namespace duckdb {
 
 //! The OperatorExtensionInfo holds static information relevant to the operator extension
 struct OperatorExtensionInfo {
-	DUCKDB_API virtual ~OperatorExtensionInfo() {
+	virtual ~OperatorExtensionInfo() {
 	}
 };
 
@@ -37,7 +37,7 @@ public:
 	virtual unique_ptr<LogicalExtensionOperator> Deserialize(LogicalDeserializationState &state,
 	                                                         FieldReader &reader) = 0;
 
-	DUCKDB_API virtual ~OperatorExtension() {
+	virtual ~OperatorExtension() {
 	}
 };
 

package/src/duckdb/src/include/duckdb/storage/storage_extension.hpp

@@ -20,7 +20,7 @@ class TransactionManager;
 
 //! The StorageExtensionInfo holds static information relevant to the storage extension
 struct StorageExtensionInfo {
-	DUCKDB_API virtual ~StorageExtensionInfo() {
+	virtual ~StorageExtensionInfo() {
 	}
 };
 
@@ -43,7 +43,7 @@ public:
 	//! Additional info passed to the various storage functions
 	shared_ptr<StorageExtensionInfo> storage_info;
 
-	DUCKDB_API virtual ~StorageExtension() {
+	virtual ~StorageExtension() {
 	}
 };
 

package/src/duckdb/src/main/db_instance_cache.cpp

@@ -1,8 +1,10 @@
 #include "duckdb/main/db_instance_cache.hpp"
 #include "duckdb/main/extension_helper.hpp"
+
 namespace duckdb {
 
-string GetDBAbsolutePath(const string &database) {
+string GetDBAbsolutePath(const string &database_p) {
+	auto database = FileSystem::ExpandPath(database_p, nullptr);
 	if (database.empty()) {
 		return ":memory:";
 	}
@@ -15,9 +17,9 @@ string GetDBAbsolutePath(const string &database) {
 		return database;
 	}
 	if (FileSystem::IsPathAbsolute(database)) {
-		return database;
+		return FileSystem::NormalizeAbsolutePath(database);
 	}
-	return FileSystem::JoinPath(FileSystem::GetWorkingDirectory(), database);
+	return FileSystem::NormalizeAbsolutePath(FileSystem::JoinPath(FileSystem::GetWorkingDirectory(), database));
 }
 
 shared_ptr<DuckDB> DBInstanceCache::GetInstanceInternal(const string &database, const DBConfig &config) {