duckdb 0.7.2-dev3515.0 → 0.7.2-dev3666.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/parsed_data/attach_info.hpp

@@ -27,13 +27,10 @@ struct AttachInfo : public ParseInfo {
 	unordered_map<string, Value> options;
 
 public:
-	unique_ptr<AttachInfo> Copy() const {
-		auto result = make_uniq<AttachInfo>();
-		result->name = name;
-		result->path = path;
-		result->options = options;
-		return result;
-	}
+	unique_ptr<AttachInfo> Copy() const;
+
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_macro_info.hpp

@@ -14,22 +14,18 @@
 namespace duckdb {
 
 struct CreateMacroInfo : public CreateFunctionInfo {
-	CreateMacroInfo() : CreateFunctionInfo(CatalogType::MACRO_ENTRY, INVALID_SCHEMA) {
-	}
-
-	CreateMacroInfo(CatalogType type) : CreateFunctionInfo(type, INVALID_SCHEMA) {
-	}
+	CreateMacroInfo();
+	CreateMacroInfo(CatalogType type);
 
 	unique_ptr<MacroFunction> function;
 
 public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_uniq<CreateMacroInfo>();
-		result->function = function->Copy();
-		result->name = name;
-		CopyProperties(*result);
-		return std::move(result);
-	}
+	unique_ptr<CreateInfo> Copy() const override;
+
+	DUCKDB_API static unique_ptr<CreateMacroInfo> Deserialize(Deserializer &deserializer);
+
+protected:
+	void SerializeInternal(Serializer &) const override;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_sequence_info.hpp

@@ -29,10 +29,7 @@ enum class SequenceInfo : uint8_t {
 };
 
 struct CreateSequenceInfo : public CreateInfo {
-	CreateSequenceInfo()
-	    : CreateInfo(CatalogType::SEQUENCE_ENTRY, INVALID_SCHEMA), name(string()), usage_count(0), increment(1),
-	      min_value(1), max_value(NumericLimits<int64_t>::Maximum()), start_value(1), cycle(false) {
-	}
+	CreateSequenceInfo();
 
 	//! Sequence name to create
 	string name;
@@ -50,24 +47,13 @@ struct CreateSequenceInfo : public CreateInfo {
 	bool cycle;
 
 public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_uniq<CreateSequenceInfo>();
-		CopyProperties(*result);
-		result->name = name;
-		result->schema = schema;
-		result->usage_count = usage_count;
-		result->increment = increment;
-		result->min_value = min_value;
-		result->max_value = max_value;
-		result->start_value = start_value;
-		result->cycle = cycle;
-		return std::move(result);
-	}
+	unique_ptr<CreateInfo> Copy() const override;
+
+public:
+	DUCKDB_API static unique_ptr<CreateSequenceInfo> Deserialize(Deserializer &deserializer);
 
 protected:
-	void SerializeInternal(Serializer &) const override {
-		throw NotImplementedException("Cannot serialize '%s'", CatalogTypeToString(type));
-	}
+	void SerializeInternal(Serializer &) const override;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_type_info.hpp

@@ -16,11 +16,8 @@
 namespace duckdb {
 
 struct CreateTypeInfo : public CreateInfo {
-	CreateTypeInfo() : CreateInfo(CatalogType::TYPE_ENTRY) {
-	}
-	CreateTypeInfo(string name_p, LogicalType type_p)
-	    : CreateInfo(CatalogType::TYPE_ENTRY), name(std::move(name_p)), type(std::move(type_p)) {
-	}
+	CreateTypeInfo();
+	CreateTypeInfo(string name_p, LogicalType type_p);
 
 	//! Name of the Type
 	string name;
@@ -30,21 +27,12 @@ struct CreateTypeInfo : public CreateInfo {
 	unique_ptr<SQLStatement> query;
 
 public:
-	unique_ptr<CreateInfo> Copy() const override {
-		auto result = make_uniq<CreateTypeInfo>();
-		CopyProperties(*result);
-		result->name = name;
-		result->type = type;
-		if (query) {
-			result->query = query->Copy();
-		}
-		return std::move(result);
-	}
+	unique_ptr<CreateInfo> Copy() const override;
+
+	DUCKDB_API static unique_ptr<CreateTypeInfo> Deserialize(Deserializer &deserializer);
 
 protected:
-	void SerializeInternal(Serializer &) const override {
-		throw NotImplementedException("Cannot serialize '%s'", CatalogTypeToString(CreateInfo::type));
-	}
+	void SerializeInternal(Serializer &) const override;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/detach_info.hpp

@@ -14,8 +14,7 @@
 namespace duckdb {
 
 struct DetachInfo : public ParseInfo {
-	DetachInfo() {
-	}
+	DetachInfo();
 
 	//! The alias of the attached database
 	string name;
@@ -23,11 +22,8 @@ struct DetachInfo : public ParseInfo {
 	OnEntryNotFound if_not_found;
 
 public:
-	unique_ptr<DetachInfo> Copy() const {
-		auto result = make_uniq<DetachInfo>();
-		result->name = name;
-		result->if_not_found = if_not_found;
-		return result;
-	}
+	unique_ptr<DetachInfo> Copy() const;
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
 };
 } // namespace duckdb