duckdb 0.7.2-dev3515.0 → 0.7.2-dev3546.0

package/configure.py

@@ -63,6 +63,8 @@ elif 'DUCKDB_NODE_BINDIR' in os.environ:
             cflags += ['-g']
         if '-O0' in os.environ['DUCKDB_NODE_CFLAGS']:
             cflags += ['-O0']
+        if '-DNDEBUG' in os.environ['DUCKDB_NODE_CFLAGS']:
+            defines += ['NDEBUG']
 
     if 'DUCKDB_NODE_BUILD_CACHE' in os.environ:
         cache = {

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.7.2-dev3515.0",
+  "version": "0.7.2-dev3546.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/json/json_functions/read_json.cpp

@@ -276,6 +276,7 @@ static void ReadJSONFunction(ClientContext &context, TableFunctionInput &data_p,
 TableFunction JSONFunctions::GetReadJSONTableFunction(shared_ptr<JSONScanInfo> function_info) {
 	TableFunction table_function({LogicalType::VARCHAR}, ReadJSONFunction, ReadJSONBind,
 	                             JSONGlobalTableFunctionState::Init, JSONLocalTableFunctionState::Init);
+	table_function.name = "read_json";
 
 	JSONScan::TableFunctionDefaults(table_function);
 	table_function.named_parameters["columns"] = LogicalType::ANY;

package/src/duckdb/src/catalog/catalog_entry/macro_catalog_entry.cpp

@@ -0,0 +1,42 @@
+#include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_macro_catalog_entry.hpp"
+#include "duckdb/common/field_writer.hpp"
+#include "duckdb/function/scalar_macro_function.hpp"
+
+namespace duckdb {
+
+MacroCatalogEntry::MacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info)
+    : FunctionEntry(
+          (info.function->type == MacroType::SCALAR_MACRO ? CatalogType::MACRO_ENTRY : CatalogType::TABLE_MACRO_ENTRY),
+          catalog, schema, info),
+      function(std::move(info.function)) {
+	this->temporary = info.temporary;
+	this->internal = info.internal;
+}
+
+ScalarMacroCatalogEntry::ScalarMacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info)
+    : MacroCatalogEntry(catalog, schema, info) {
+}
+
+TableMacroCatalogEntry::TableMacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info)
+    : MacroCatalogEntry(catalog, schema, info) {
+}
+
+unique_ptr<CreateMacroInfo> MacroCatalogEntry::GetInfoForSerialization() const {
+	auto info = make_uniq<CreateMacroInfo>(type);
+	info->catalog = catalog.GetName();
+	info->schema = schema.name;
+	info->name = name;
+	info->function = function->Copy();
+	return info;
+}
+void MacroCatalogEntry::Serialize(Serializer &serializer) const {
+	auto info = GetInfoForSerialization();
+	info->Serialize(serializer);
+}
+
+unique_ptr<CreateMacroInfo> MacroCatalogEntry::Deserialize(Deserializer &main_source, ClientContext &context) {
+	return unique_ptr_cast<CreateInfo, CreateMacroInfo>(CreateInfo::Deserialize(main_source));
+}
+
+} // namespace duckdb

package/src/duckdb/src/catalog/catalog_search_path.cpp

@@ -145,6 +145,11 @@ void CatalogSearchPath::Set(vector<CatalogSearchEntry> new_paths, bool is_set_sc
 			                       is_set_schema ? "schema" : "search_path", path.ToString());
 		}
 	}
+	if (is_set_schema) {
+		if (new_paths[0].catalog == TEMP_CATALOG || new_paths[0].catalog == SYSTEM_CATALOG) {
+			throw CatalogException("SET schema cannot be set to internal schema \"%s\"", new_paths[0].catalog);
+		}
+	}
 	this->set_paths = std::move(new_paths);
 	SetPaths(set_paths);
 }

package/src/duckdb/src/catalog/catalog_set.cpp

@@ -84,7 +84,7 @@ bool CatalogSet::CreateEntry(CatalogTransaction transaction, const string &name,
 			throw InternalException("Attempting to create temporary entry \"%s\" in non-temporary catalog", name);
 		}
 		if (!value->temporary && catalog.IsTemporaryCatalog() && name != DEFAULT_SCHEMA) {
-			throw InternalException("Attempting to create non-temporary entry \"%s\" in temporary catalog", name);
+			throw InvalidInputException("Cannot create non-temporary entry \"%s\" in temporary catalog", name);
 		}
 	}
 	// lock the catalog for writing

package/src/duckdb/src/common/constants.cpp

@@ -2,6 +2,7 @@
 
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/vector_size.hpp"
+#include "duckdb/common/serializer.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/common/types/vector.cpp

@@ -1868,7 +1868,7 @@ idx_t ListVector::GetListSize(const Vector &vec) {
 		return ListVector::GetListSize(child);
 	}
 	D_ASSERT(vec.auxiliary);
-	return ((VectorListBuffer &)*vec.auxiliary).size;
+	return ((VectorListBuffer &)*vec.auxiliary).GetSize();
 }
 
 idx_t ListVector::GetListCapacity(const Vector &vec) {
@@ -1877,7 +1877,7 @@ idx_t ListVector::GetListCapacity(const Vector &vec) {
 		return ListVector::GetListSize(child);
 	}
 	D_ASSERT(vec.auxiliary);
-	return ((VectorListBuffer &)*vec.auxiliary).capacity;
+	return ((VectorListBuffer &)*vec.auxiliary).GetCapacity();
 }
 
 void ListVector::ReferenceEntry(Vector &vector, Vector &other) {
@@ -1894,7 +1894,7 @@ void ListVector::SetListSize(Vector &vec, idx_t size) {
 		auto &child = DictionaryVector::Child(vec);
 		ListVector::SetListSize(child, size);
 	}
-	((VectorListBuffer &)*vec.auxiliary).size = size;
+	((VectorListBuffer &)*vec.auxiliary).SetSize(size);
 }
 
 void ListVector::Append(Vector &target, const Vector &source, idx_t source_size, idx_t source_offset) {

package/src/duckdb/src/common/types/vector_buffer.cpp

@@ -58,12 +58,12 @@ VectorStructBuffer::~VectorStructBuffer() {
 }
 
 VectorListBuffer::VectorListBuffer(unique_ptr<Vector> vector, idx_t initial_capacity)
-    : VectorBuffer(VectorBufferType::LIST_BUFFER), capacity(initial_capacity), child(std::move(vector)) {
+    : VectorBuffer(VectorBufferType::LIST_BUFFER), child(std::move(vector)), capacity(initial_capacity) {
 }
 
 VectorListBuffer::VectorListBuffer(const LogicalType &list_type, idx_t initial_capacity)
-    : VectorBuffer(VectorBufferType::LIST_BUFFER), capacity(initial_capacity),
-      child(make_uniq<Vector>(ListType::GetChildType(list_type), initial_capacity)) {
+    : VectorBuffer(VectorBufferType::LIST_BUFFER),
+      child(make_uniq<Vector>(ListType::GetChildType(list_type), initial_capacity)), capacity(initial_capacity) {
 }
 
 void VectorListBuffer::Reserve(idx_t to_reserve) {
@@ -96,6 +96,14 @@ void VectorListBuffer::PushBack(const Value &insert) {
 	child->SetValue(size++, insert);
 }
 
+void VectorListBuffer::SetCapacity(idx_t new_capacity) {
+	this->capacity = new_capacity;
+}
+
+void VectorListBuffer::SetSize(idx_t new_size) {
+	this->size = new_size;
+}
+
 VectorListBuffer::~VectorListBuffer() {
 }
 

package/src/duckdb/src/common/types/vector_cache.cpp

@@ -16,7 +16,7 @@ public:
 			owned_data = allocator.Allocate(capacity * GetTypeIdSize(internal_type));
 			// child data of the list
 			auto &child_type = ListType::GetChildType(type);
-			child_caches.push_back(make_buffer<VectorCacheBuffer>(allocator, child_type));
+			child_caches.push_back(make_buffer<VectorCacheBuffer>(allocator, child_type, capacity));
 			auto child_vector = make_uniq<Vector>(child_type, false, false);
 			auxiliary = make_shared<VectorListBuffer>(std::move(child_vector));
 			break;
@@ -24,7 +24,7 @@ public:
 		case PhysicalType::STRUCT: {
 			auto &child_types = StructType::GetChildTypes(type);
 			for (auto &child_type : child_types) {
-				child_caches.push_back(make_buffer<VectorCacheBuffer>(allocator, child_type.second));
+				child_caches.push_back(make_buffer<VectorCacheBuffer>(allocator, child_type.second, capacity));
 			}
 			auto struct_buffer = make_shared<VectorStructBuffer>(type);
 			auxiliary = std::move(struct_buffer);
@@ -48,13 +48,13 @@ public:
 			// reinitialize the VectorListBuffer
 			AssignSharedPointer(result.auxiliary, auxiliary);
 			// propagate through child
+			auto &child_cache = (VectorCacheBuffer &)*child_caches[0];
 			auto &list_buffer = (VectorListBuffer &)*result.auxiliary;
-			list_buffer.capacity = capacity;
-			list_buffer.size = 0;
+			list_buffer.SetCapacity(child_cache.capacity);
+			list_buffer.SetSize(0);
 			list_buffer.SetAuxiliaryData(nullptr);
 
 			auto &list_child = list_buffer.GetChild();
-			auto &child_cache = (VectorCacheBuffer &)*child_caches[0];
 			child_cache.ResetFromCache(list_child, child_caches[0]);
 			break;
 		}

package/src/duckdb/src/execution/operator/schema/physical_create_type.cpp

@@ -7,9 +7,9 @@
 
 namespace duckdb {
 
-PhysicalCreateType::PhysicalCreateType(unique_ptr<CreateTypeInfo> info, idx_t estimated_cardinality)
+PhysicalCreateType::PhysicalCreateType(unique_ptr<CreateTypeInfo> info_p, idx_t estimated_cardinality)
     : PhysicalOperator(PhysicalOperatorType::CREATE_TYPE, {LogicalType::BIGINT}, estimated_cardinality),
-      info(std::move(info)) {
+      info(std::move(info_p)) {
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/function/macro_function.cpp

@@ -5,6 +5,7 @@
 #include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/function/scalar_macro_function.hpp"
+#include "duckdb/function/table_macro_function.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/parser/expression/comparison_expression.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
@@ -91,4 +92,46 @@ string MacroFunction::ToSQL(const string &schema, const string &name) const {
 	return StringUtil::Format("CREATE MACRO %s.%s(%s) AS ", schema, name, StringUtil::Join(param_strings, ", "));
 }
 
+void MacroFunction::Serialize(Serializer &main_serializer) const {
+	FieldWriter writer(main_serializer);
+	writer.WriteField(type);
+	writer.WriteSerializableList(parameters);
+	writer.WriteField<uint32_t>((uint32_t)default_parameters.size());
+	auto &serializer = writer.GetSerializer();
+	for (auto &kv : default_parameters) {
+		serializer.WriteString(kv.first);
+		kv.second->Serialize(serializer);
+	}
+	SerializeInternal(writer);
+	writer.Finalize();
+}
+
+unique_ptr<MacroFunction> MacroFunction::Deserialize(Deserializer &main_source) {
+	FieldReader reader(main_source);
+	auto type = reader.ReadRequired<MacroType>();
+	auto parameters = reader.ReadRequiredSerializableList<ParsedExpression>();
+	auto default_param_count = reader.ReadRequired<uint32_t>();
+	unordered_map<string, unique_ptr<ParsedExpression>> default_parameters;
+	auto &source = reader.GetSource();
+	for (idx_t i = 0; i < default_param_count; i++) {
+		auto name = source.Read<string>();
+		default_parameters[name] = ParsedExpression::Deserialize(source);
+	}
+	unique_ptr<MacroFunction> result;
+	switch (type) {
+	case MacroType::SCALAR_MACRO:
+		result = ScalarMacroFunction::Deserialize(reader);
+		break;
+	case MacroType::TABLE_MACRO:
+		result = TableMacroFunction::Deserialize(reader);
+		break;
+	default:
+		throw InternalException("Cannot deserialize macro type");
+	}
+	result->parameters = std::move(parameters);
+	result->default_parameters = std::move(default_parameters);
+	reader.Finalize();
+	return result;
+}
+
 } // namespace duckdb

package/src/duckdb/src/function/scalar/strftime_format.cpp

@@ -417,6 +417,7 @@ string StrTimeFormat::ParseFormatSpecifier(const string &format_string, StrTimeF
 	if (format_string.empty()) {
 		return "Empty format string";
 	}
+	format.format_specifier = format_string;
 	format.specifiers.clear();
 	format.literals.clear();
 	format.numeric_width.clear();

package/src/duckdb/src/function/scalar_macro_function.cpp

@@ -49,4 +49,14 @@ string ScalarMacroFunction::ToSQL(const string &schema, const string &name) cons
 	return MacroFunction::ToSQL(schema, name) + StringUtil::Format("(%s);", expression_copy->ToString());
 }
 
+void ScalarMacroFunction::SerializeInternal(FieldWriter &writer) const {
+	writer.WriteSerializable(*expression);
+}
+
+unique_ptr<MacroFunction> ScalarMacroFunction::Deserialize(FieldReader &reader) {
+	auto result = make_uniq<ScalarMacroFunction>();
+	result->expression = reader.ReadRequiredSerializable<ParsedExpression>();
+	return std::move(result);
+}
+
 } // namespace duckdb

package/src/duckdb/src/function/table/copy_csv.cpp

@@ -324,15 +324,11 @@ static void WriteCSVChunkInternal(ClientContext &context, FunctionData &bind_dat
 			csv_data.options.write_date_format[LogicalTypeId::DATE].ConvertDateVector(
 			    input.data[col_idx], cast_chunk.data[col_idx], input.size());
 		} else if (options.has_format[LogicalTypeId::TIMESTAMP] &&
-		           csv_data.sql_types[col_idx].id() == LogicalTypeId::TIMESTAMP) {
+		           (csv_data.sql_types[col_idx].id() == LogicalTypeId::TIMESTAMP ||
+		            csv_data.sql_types[col_idx].id() == LogicalTypeId::TIMESTAMP_TZ)) {
 			// use the timestamp format to cast the chunk
 			csv_data.options.write_date_format[LogicalTypeId::TIMESTAMP].ConvertTimestampVector(
 			    input.data[col_idx], cast_chunk.data[col_idx], input.size());
-		} else if (options.has_format[LogicalTypeId::TIMESTAMP_TZ] &&
-		           csv_data.sql_types[col_idx].id() == LogicalTypeId::TIMESTAMP_TZ) {
-			// use the timestamp format to cast the chunk
-			csv_data.options.write_date_format[LogicalTypeId::TIMESTAMP_TZ].ConvertTimestampVector(
-			    input.data[col_idx], cast_chunk.data[col_idx], input.size());
 		} else {
 			// non varchar column, perform the cast
 			VectorOperations::Cast(context, input.data[col_idx], cast_chunk.data[col_idx], input.size());

package/src/duckdb/src/function/table/read_csv.cpp

@@ -1055,6 +1055,12 @@ void BufferedCSVReaderOptions::Serialize(FieldWriter &writer) const {
 	writer.WriteSerializable(file_options);
 	// write options
 	writer.WriteListNoReference<bool>(force_quote);
+	// FIXME: serialize date_format / has_format
+	vector<string> csv_formats;
+	for (auto &format : date_format) {
+		csv_formats.push_back(format.second.format_specifier);
+	}
+	writer.WriteList<string>(csv_formats);
 }
 
 void BufferedCSVReaderOptions::Deserialize(FieldReader &reader) {
@@ -1091,6 +1097,17 @@ void BufferedCSVReaderOptions::Deserialize(FieldReader &reader) {
 	file_options = reader.ReadRequiredSerializable<MultiFileReaderOptions, MultiFileReaderOptions>();
 	// write options
 	force_quote = reader.ReadRequiredList<bool>();
+	auto formats = reader.ReadRequiredList<string>();
+	vector<LogicalTypeId> format_types {LogicalTypeId::DATE, LogicalTypeId::TIMESTAMP};
+	for (idx_t f_idx = 0; f_idx < formats.size(); f_idx++) {
+		auto &format = formats[f_idx];
+		auto &type = format_types[f_idx];
+		if (format.empty()) {
+			continue;
+		}
+		has_format[type] = true;
+		StrTimeFormat::ParseFormatSpecifier(format, date_format[type]);
+	}
 }
 
 static void CSVReaderSerialize(FieldWriter &writer, const FunctionData *bind_data_p, const TableFunction &function) {

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev3515"
+#define DUCKDB_VERSION "0.7.2-dev3546"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "12638bd156"
+#define DUCKDB_SOURCE_ID "bd8adef6d1"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/function/table_macro_function.cpp

@@ -31,4 +31,14 @@ string TableMacroFunction::ToSQL(const string &schema, const string &name) const
 	return MacroFunction::ToSQL(schema, name) + StringUtil::Format("TABLE (%s);", query_node->ToString());
 }
 
+void TableMacroFunction::SerializeInternal(FieldWriter &writer) const {
+	writer.WriteSerializable(*query_node);
+}
+
+unique_ptr<MacroFunction> TableMacroFunction::Deserialize(FieldReader &reader) {
+	auto result = make_uniq<TableMacroFunction>();
+	result->query_node = reader.ReadRequiredSerializable<QueryNode>();
+	return std::move(result);
+}
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/macro_catalog_entry.hpp

@@ -24,8 +24,10 @@ public:
 	unique_ptr<MacroFunction> function;
 
 public:
+	virtual unique_ptr<CreateMacroInfo> GetInfoForSerialization() const;
 	//! Serialize the meta information
-	virtual void Serialize(Serializer &serializer) const = 0;
+	virtual void Serialize(Serializer &serializer) const;
+	static unique_ptr<CreateMacroInfo> Deserialize(Deserializer &main_source, ClientContext &context);
 
 	string ToSQL() const override {
 		return function->ToSQL(schema.name, name);

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp

@@ -23,11 +23,5 @@ public:
 
 public:
 	ScalarMacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info);
-
-public:
-	//! Serialize the meta information of the ScalarMacroCatalogEntry
-	void Serialize(Serializer &serializer) const override;
-	//! Deserializes to a CreateMacroInfo
-	static unique_ptr<CreateMacroInfo> Deserialize(Deserializer &source, ClientContext &context);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_macro_catalog_entry.hpp

@@ -22,12 +22,6 @@ public:
 
 public:
 	TableMacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info);
-
-public:
-	//! Serialize the meta information of the ScalarMacroCatalogEntry
-	void Serialize(Serializer &serializer) const override;
-	//! Deserializes to a CreateMacroInfo
-	static unique_ptr<CreateMacroInfo> Deserialize(Deserializer &source, ClientContext &context);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/constants.hpp

@@ -15,6 +15,8 @@
 #include "duckdb/common/typedefs.hpp"
 
 namespace duckdb {
+class Serializer;
+class Deserializer;
 
 //! inline std directives that we use frequently
 #ifndef DUCKDB_DEBUG_MOVE

package/src/duckdb/src/include/duckdb/common/field_writer.hpp

@@ -263,15 +263,15 @@ public:
 		return ReadRequiredGenericList<T, idx_t, IndexReadOperation>();
 	}
 
-	template <class T>
-	set<T> ReadRequiredSet() {
+	template <class T, class CONTAINER_TYPE = set<T>>
+	CONTAINER_TYPE ReadRequiredSet() {
 		if (field_count >= max_field_count) {
 			// field is not there, throw an exception
 			throw SerializationException("Attempting to read a required field, but field is missing");
 		}
 		AddField();
 		auto result_count = source.Read<uint32_t>();
-		set<T> result;
+		CONTAINER_TYPE result;
 		for (idx_t i = 0; i < result_count; i++) {
 			result.insert(source.Read<T>());
 		}

package/src/duckdb/src/include/duckdb/common/types/vector_buffer.hpp

@@ -241,12 +241,22 @@ public:
 
 	void PushBack(const Value &insert);
 
-	idx_t capacity = 0;
-	idx_t size = 0;
+	idx_t GetSize() {
+		return size;
+	}
+
+	idx_t GetCapacity() {
+		return capacity;
+	}
+
+	void SetCapacity(idx_t new_capacity);
+	void SetSize(idx_t new_size);
 
 private:
 	//! child vectors used for nested data
 	unique_ptr<Vector> child;
+	idx_t capacity = 0;
+	idx_t size = 0;
 };
 
 //! The ManagedVectorBuffer holds a buffer handle

package/src/duckdb/src/include/duckdb/execution/operator/persistent/csv_reader_options.hpp

@@ -130,8 +130,7 @@ struct BufferedCSVReaderOptions {
 	std::map<LogicalTypeId, StrfTimeFormat> write_date_format = {{LogicalTypeId::DATE, {}},
 	                                                             {LogicalTypeId::TIMESTAMP, {}}};
 	//! Whether or not a type format is specified
-	std::map<LogicalTypeId, bool> has_format = {
-	    {LogicalTypeId::DATE, false}, {LogicalTypeId::TIMESTAMP, false}, {LogicalTypeId::TIMESTAMP_TZ, false}};
+	std::map<LogicalTypeId, bool> has_format = {{LogicalTypeId::DATE, false}, {LogicalTypeId::TIMESTAMP, false}};
 
 	void Serialize(FieldWriter &writer) const;
 	void Deserialize(FieldReader &reader);

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_create_type.hpp

@@ -38,7 +38,7 @@ public:
 	SinkResultType Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const override;
 
 	bool IsSink() const override {
-		return info->query != nullptr;
+		return !children.empty();
 	}
 
 	bool ParallelSink() const override {

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

@@ -21,7 +21,7 @@ enum class MacroType : uint8_t { VOID_MACRO = 0, TABLE_MACRO = 1, SCALAR_MACRO =
 
 class MacroFunction {
 public:
-	MacroFunction(MacroType type);
+	explicit MacroFunction(MacroType type);
 
 	//! The type
 	MacroType type;
@@ -45,6 +45,12 @@ public:
 
 	virtual string ToSQL(const string &schema, const string &name) const;
 
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<MacroFunction> Deserialize(Deserializer &deserializer);
+
+protected:
+	virtual void SerializeInternal(FieldWriter &writer) const = 0;
+
 public:
 	template <class TARGET>
 	TARGET &Cast() {

package/src/duckdb/src/include/duckdb/function/scalar/strftime_format.hpp

@@ -66,6 +66,9 @@ public:
 		return std::find(specifiers.begin(), specifiers.end(), s) != specifiers.end();
 	}
 
+	//! The full format specifier, for error messages
+	string format_specifier;
+
 protected:
 	//! The format specifiers
 	vector<StrTimeSpecifier> specifiers;
@@ -134,10 +137,6 @@ public:
 		DUCKDB_API string FormatError(string_t input, const string &format_specifier);
 	};
 
-public:
-	//! The full format specifier, for error messages
-	string format_specifier;
-
 public:
 	DUCKDB_API static ParseResult Parse(const string &format, const string &text);
 

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

@@ -23,9 +23,9 @@ public:
 	static constexpr const MacroType TYPE = MacroType::SCALAR_MACRO;
 
 public:
-	ScalarMacroFunction(unique_ptr<ParsedExpression> expression);
-
+	explicit ScalarMacroFunction(unique_ptr<ParsedExpression> expression);
 	ScalarMacroFunction(void);
+
 	//! The macro expression
 	unique_ptr<ParsedExpression> expression;
 
@@ -33,6 +33,11 @@ public:
 	unique_ptr<MacroFunction> Copy() const override;
 
 	string ToSQL(const string &schema, const string &name) const override;
+
+	static unique_ptr<MacroFunction> Deserialize(FieldReader &reader);
+
+protected:
+	void SerializeInternal(FieldWriter &writer) const override;
 };
 
 } // namespace duckdb

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

@@ -33,6 +33,11 @@ public:
 	unique_ptr<MacroFunction> Copy() const override;
 
 	string ToSQL(const string &schema, const string &name) const override;
+
+	static unique_ptr<MacroFunction> Deserialize(FieldReader &reader);
+
+protected:
+	void SerializeInternal(FieldWriter &writer) const override;
 };
 
 } // namespace duckdb

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