duckdb 0.8.2-dev2809.0 → 0.8.2-dev2850.0

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

@@ -999,14 +999,14 @@ void Vector::FormatSerialize(FormatSerializer &serializer, idx_t count) {
 	ToUnifiedFormat(count, vdata);
 
 	const bool all_valid = (count > 0) && !vdata.validity.AllValid();
-	serializer.WriteProperty("all_valid", all_valid);
+	serializer.WriteProperty(100, "all_valid", all_valid);
 	if (all_valid) {
 		ValidityMask flat_mask(count);
 		for (idx_t i = 0; i < count; ++i) {
 			auto row_idx = vdata.sel->get_index(i);
 			flat_mask.Set(i, vdata.validity.RowIsValid(row_idx));
 		}
-		serializer.WriteProperty("validity", const_data_ptr_cast(flat_mask.GetData()),
+		serializer.WriteProperty(101, "validity", const_data_ptr_cast(flat_mask.GetData()),
 		                         flat_mask.ValidityMaskSize(count));
 	}
 	if (TypeIsConstantSize(logical_type.InternalType())) {
@@ -1014,14 +1014,14 @@ void Vector::FormatSerialize(FormatSerializer &serializer, idx_t count) {
 		idx_t write_size = GetTypeIdSize(logical_type.InternalType()) * count;
 		auto ptr = make_unsafe_uniq_array<data_t>(write_size);
 		VectorOperations::WriteToStorage(*this, count, ptr.get());
-		serializer.WriteProperty("data", ptr.get(), write_size);
+		serializer.WriteProperty(102, "data", ptr.get(), write_size);
 	} else {
 		switch (logical_type.InternalType()) {
 		case PhysicalType::VARCHAR: {
 			auto strings = UnifiedVectorFormat::GetData<string_t>(vdata);
 
 			// Serialize data as a list
-			serializer.SetTag("data");
+			serializer.SetTag(102, "data");
 			serializer.OnListBegin(count);
 			for (idx_t i = 0; i < count; i++) {
 				auto idx = vdata.sel->get_index(i);
@@ -1036,7 +1036,7 @@ void Vector::FormatSerialize(FormatSerializer &serializer, idx_t count) {
 			auto &entries = StructVector::GetEntries(*this);
 
 			// Serialize entries as a list
-			serializer.SetTag("children");
+			serializer.SetTag(103, "children");
 			serializer.OnListBegin(entries.size());
 			for (auto &entry : entries) {
 				serializer.OnObjectBegin();
@@ -1059,17 +1059,17 @@ void Vector::FormatSerialize(FormatSerializer &serializer, idx_t count) {
 				entries[i].offset = source.offset;
 				entries[i].length = source.length;
 			}
-			serializer.WriteProperty("list_size", list_size);
-			serializer.SetTag("entries");
+			serializer.WriteProperty(104, "list_size", list_size);
+			serializer.SetTag(105, "entries");
 			serializer.OnListBegin(count);
 			for (idx_t i = 0; i < count; i++) {
 				serializer.OnObjectBegin();
-				serializer.WriteProperty("offset", entries[i].offset);
-				serializer.WriteProperty("length", entries[i].length);
+				serializer.WriteProperty(100, "offset", entries[i].offset);
+				serializer.WriteProperty(101, "length", entries[i].length);
 				serializer.OnObjectEnd();
 			}
 			serializer.OnListEnd(count);
-			serializer.SetTag("child");
+			serializer.SetTag(106, "child");
 			serializer.OnObjectBegin();
 			child.FormatSerialize(serializer, list_size);
 			serializer.OnObjectEnd();
@@ -1086,24 +1086,24 @@ void Vector::FormatDeserialize(FormatDeserializer &deserializer, idx_t count) {
 
 	auto &validity = FlatVector::Validity(*this);
 	validity.Reset();
-	const auto has_validity = deserializer.ReadProperty<bool>("all_valid");
+	const auto has_validity = deserializer.ReadProperty<bool>(100, "all_valid");
 	if (has_validity) {
 		validity.Initialize(count);
-		deserializer.ReadProperty("validity", data_ptr_cast(validity.GetData()), validity.ValidityMaskSize(count));
+		deserializer.ReadProperty(101, "validity", data_ptr_cast(validity.GetData()), validity.ValidityMaskSize(count));
 	}
 
 	if (TypeIsConstantSize(logical_type.InternalType())) {
 		// constant size type: read fixed amount of data
 		auto column_size = GetTypeIdSize(logical_type.InternalType()) * count;
 		auto ptr = make_unsafe_uniq_array<data_t>(column_size);
-		deserializer.ReadProperty("data", ptr.get(), column_size);
+		deserializer.ReadProperty(102, "data", ptr.get(), column_size);
 
 		VectorOperations::ReadFromStorage(ptr.get(), count, *this);
 	} else {
 		switch (logical_type.InternalType()) {
 		case PhysicalType::VARCHAR: {
 			auto strings = FlatVector::GetData<string_t>(*this);
-			deserializer.SetTag("data");
+			deserializer.SetTag(102, "data");
 			auto read_count = deserializer.OnListBegin();
 			D_ASSERT(read_count == count);
 			(void)read_count; // otherwise unused variable error in release mode
@@ -1122,7 +1122,7 @@ void Vector::FormatDeserialize(FormatDeserializer &deserializer, idx_t count) {
 		case PhysicalType::STRUCT: {
 			auto &entries = StructVector::GetEntries(*this);
 			// Deserialize entries as a list
-			deserializer.SetTag("children");
+			deserializer.SetTag(103, "children");
 			auto read_size = deserializer.OnListBegin();
 			D_ASSERT(read_size == entries.size());
 			(void)read_size;
@@ -1136,26 +1136,26 @@ void Vector::FormatDeserialize(FormatDeserializer &deserializer, idx_t count) {
 		}
 		case PhysicalType::LIST: {
 			// Read the list size
-			auto list_size = deserializer.ReadProperty<uint64_t>("list_size");
+			auto list_size = deserializer.ReadProperty<uint64_t>(104, "list_size");
 			ListVector::Reserve(*this, list_size);
 			ListVector::SetListSize(*this, list_size);
 
 			// Read the entries
 			auto list_entries = FlatVector::GetData<list_entry_t>(*this);
-			deserializer.SetTag("entries");
+			deserializer.SetTag(105, "entries");
 			auto entries_count = deserializer.OnListBegin();
 			D_ASSERT(entries_count == count);
 			(void)entries_count;
 			for (idx_t i = 0; i < count; i++) {
 				deserializer.OnObjectBegin();
-				deserializer.ReadProperty("offset", list_entries[i].offset);
-				deserializer.ReadProperty("length", list_entries[i].length);
+				deserializer.ReadProperty(100, "offset", list_entries[i].offset);
+				deserializer.ReadProperty(101, "length", list_entries[i].length);
 				deserializer.OnObjectEnd();
 			}
 			deserializer.OnListEnd();
 
 			// Read the child vector
-			deserializer.SetTag("child");
+			deserializer.SetTag(106, "child");
 			auto &child = ListVector::GetEntry(*this);
 			deserializer.OnObjectBegin();
 			child.FormatDeserialize(deserializer, list_size);

package/src/duckdb/src/core_functions/aggregate/holistic/approximate_quantile.cpp

@@ -55,12 +55,12 @@ struct ApproximateQuantileBindData : public FunctionData {
 	static void FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
 	                            const AggregateFunction &function) {
 		auto &bind_data = bind_data_p->Cast<ApproximateQuantileBindData>();
-		serializer.WriteProperty("quantiles", bind_data.quantiles);
+		serializer.WriteProperty(100, "quantiles", bind_data.quantiles);
 	}
 
 	static unique_ptr<FunctionData> FormatDeserialize(FormatDeserializer &deserializer, AggregateFunction &function) {
 		auto result = make_uniq<ApproximateQuantileBindData>();
-		deserializer.ReadProperty("quantiles", result->quantiles);
+		deserializer.ReadProperty(100, "quantiles", result->quantiles);
 		return std::move(result);
 	}
 

package/src/duckdb/src/core_functions/aggregate/holistic/quantile.cpp

@@ -461,16 +461,16 @@ struct QuantileBindData : public FunctionData {
 	static void FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
 	                            const AggregateFunction &function) {
 		auto &bind_data = bind_data_p->Cast<QuantileBindData>();
-		serializer.WriteProperty("quantiles", bind_data.quantiles);
-		serializer.WriteProperty("order", bind_data.order);
-		serializer.WriteProperty("desc", bind_data.desc);
+		serializer.WriteProperty(100, "quantiles", bind_data.quantiles);
+		serializer.WriteProperty(101, "order", bind_data.order);
+		serializer.WriteProperty(102, "desc", bind_data.desc);
 	}
 
 	static unique_ptr<FunctionData> FormatDeserialize(FormatDeserializer &deserializer, AggregateFunction &function) {
 		auto result = make_uniq<QuantileBindData>();
-		deserializer.ReadProperty("quantiles", result->quantiles);
-		deserializer.ReadProperty("order", result->order);
-		deserializer.ReadProperty("desc", result->desc);
+		deserializer.ReadProperty(100, "quantiles", result->quantiles);
+		deserializer.ReadProperty(101, "order", result->order);
+		deserializer.ReadProperty(102, "desc", result->desc);
 		return std::move(result);
 	}
 

package/src/duckdb/src/core_functions/aggregate/holistic/reservoir_quantile.cpp

@@ -87,14 +87,14 @@ struct ReservoirQuantileBindData : public FunctionData {
 	static void FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
 	                            const AggregateFunction &function) {
 		auto &bind_data = bind_data_p->Cast<ReservoirQuantileBindData>();
-		serializer.WriteProperty("quantiles", bind_data.quantiles);
-		serializer.WriteProperty("sample_size", bind_data.sample_size);
+		serializer.WriteProperty(100, "quantiles", bind_data.quantiles);
+		serializer.WriteProperty(101, "sample_size", bind_data.sample_size);
 	}
 
 	static unique_ptr<FunctionData> FormatDeserialize(FormatDeserializer &deserializer, AggregateFunction &function) {
 		auto result = make_uniq<ReservoirQuantileBindData>();
-		deserializer.ReadProperty("quantiles", result->quantiles);
-		deserializer.ReadProperty("sample_size", result->sample_size);
+		deserializer.ReadProperty(100, "quantiles", result->quantiles);
+		deserializer.ReadProperty(101, "sample_size", result->sample_size);
 		return std::move(result);
 	}
 

package/src/duckdb/src/core_functions/scalar/list/list_lambdas.cpp

@@ -34,13 +34,13 @@ public:
 	static void FormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
 	                            const ScalarFunction &function) {
 		auto &bind_data = bind_data_p->Cast<ListLambdaBindData>();
-		serializer.WriteProperty("stype", bind_data.stype);
-		serializer.WriteOptionalProperty("lambda_expr", bind_data.lambda_expr);
+		serializer.WriteProperty(100, "stype", bind_data.stype);
+		serializer.WriteOptionalProperty(101, "lambda_expr", bind_data.lambda_expr);
 	}
 
 	static unique_ptr<FunctionData> FormatDeserialize(FormatDeserializer &deserializer, ScalarFunction &function) {
-		auto stype = deserializer.ReadProperty<LogicalType>("stype");
-		auto lambda_expr = deserializer.ReadOptionalProperty<unique_ptr<Expression>>("lambda_expr");
+		auto stype = deserializer.ReadProperty<LogicalType>(100, "stype");
+		auto lambda_expr = deserializer.ReadOptionalProperty<unique_ptr<Expression>>(101, "lambda_expr");
 		return make_uniq<ListLambdaBindData>(stype, std::move(lambda_expr));
 	}
 };

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

@@ -1240,14 +1240,14 @@ static unique_ptr<FunctionData> CSVReaderDeserialize(PlanDeserializationState &s
 static void CSVReaderFormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
                                      const TableFunction &function) {
 	auto &bind_data = bind_data_p->Cast<ReadCSVData>();
-	serializer.WriteProperty("extra_info", function.extra_info);
-	serializer.WriteProperty("csv_data", bind_data);
+	serializer.WriteProperty(100, "extra_info", function.extra_info);
+	serializer.WriteProperty(101, "csv_data", bind_data);
 }
 
 static unique_ptr<FunctionData> CSVReaderFormatDeserialize(FormatDeserializer &deserializer, TableFunction &function) {
 	unique_ptr<ReadCSVData> result;
-	deserializer.ReadProperty("extra_info", function.extra_info);
-	deserializer.ReadProperty("csv_data", result);
+	deserializer.ReadProperty(100, "extra_info", function.extra_info);
+	deserializer.ReadProperty(101, "csv_data", result);
 	return std::move(result);
 }
 

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

@@ -452,29 +452,29 @@ static unique_ptr<FunctionData> TableScanDeserialize(PlanDeserializationState &s
 static void TableScanFormatSerialize(FormatSerializer &serializer, const optional_ptr<FunctionData> bind_data_p,
                                      const TableFunction &function) {
 	auto &bind_data = bind_data_p->Cast<TableScanBindData>();
-	serializer.WriteProperty("catalog", bind_data.table.schema.catalog.GetName());
-	serializer.WriteProperty("schema", bind_data.table.schema.name);
-	serializer.WriteProperty("table", bind_data.table.name);
-	serializer.WriteProperty("is_index_scan", bind_data.is_index_scan);
-	serializer.WriteProperty("is_create_index", bind_data.is_create_index);
-	serializer.WriteProperty("result_ids", bind_data.result_ids);
-	serializer.WriteProperty("result_ids", bind_data.result_ids);
+	serializer.WriteProperty(100, "catalog", bind_data.table.schema.catalog.GetName());
+	serializer.WriteProperty(101, "schema", bind_data.table.schema.name);
+	serializer.WriteProperty(102, "table", bind_data.table.name);
+	serializer.WriteProperty(103, "is_index_scan", bind_data.is_index_scan);
+	serializer.WriteProperty(104, "is_create_index", bind_data.is_create_index);
+	serializer.WriteProperty(105, "result_ids", bind_data.result_ids);
+	serializer.WriteProperty(106, "result_ids", bind_data.result_ids);
 }
 
 static unique_ptr<FunctionData> TableScanFormatDeserialize(FormatDeserializer &deserializer, TableFunction &function) {
-	auto catalog = deserializer.ReadProperty<string>("catalog");
-	auto schema = deserializer.ReadProperty<string>("schema");
-	auto table = deserializer.ReadProperty<string>("table");
+	auto catalog = deserializer.ReadProperty<string>(100, "catalog");
+	auto schema = deserializer.ReadProperty<string>(101, "schema");
+	auto table = deserializer.ReadProperty<string>(102, "table");
 	auto &catalog_entry =
 	    Catalog::GetEntry<TableCatalogEntry>(deserializer.Get<ClientContext &>(), catalog, schema, table);
 	if (catalog_entry.type != CatalogType::TABLE_ENTRY) {
 		throw SerializationException("Cant find table for %s.%s", schema, table);
 	}
 	auto result = make_uniq<TableScanBindData>(catalog_entry.Cast<DuckTableEntry>());
-	deserializer.ReadProperty("is_index_scan", result->is_index_scan);
-	deserializer.ReadProperty("is_create_index", result->is_create_index);
-	deserializer.ReadProperty("result_ids", result->result_ids);
-	deserializer.ReadProperty("result_ids", result->result_ids);
+	deserializer.ReadProperty(103, "is_index_scan", result->is_index_scan);
+	deserializer.ReadProperty(104, "is_create_index", result->is_create_index);
+	deserializer.ReadProperty(105, "result_ids", result->result_ids);
+	deserializer.ReadProperty(106, "result_ids", result->result_ids);
 	return std::move(result);
 }
 

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev2809"
+#define DUCKDB_VERSION "0.8.2-dev2850"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "a8ce02cc2e"
+#define DUCKDB_SOURCE_ID "e2128946cc"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

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

@@ -62,12 +62,12 @@ public:
 	}
 
 	void FormatSerialize(FormatSerializer &serializer) const {
-		serializer.WriteProperty("internal_vector", internal_vector);
+		serializer.WriteProperty(100, "internal_vector", internal_vector);
 	}
 
 	static IndexVector<T, INDEX_TYPE> FormatDeserialize(FormatDeserializer &deserializer) {
 		IndexVector<T, INDEX_TYPE> result;
-		deserializer.ReadProperty("internal_vector", result.internal_vector);
+		deserializer.ReadProperty(100, "internal_vector", result.internal_vector);
 		return result;
 	}
 

package/src/duckdb/src/include/duckdb/common/serializer/binary_deserializer.hpp

@@ -45,13 +45,17 @@ private:
 	struct State {
 		uint32_t expected_field_count;
 		idx_t expected_size;
+		field_id_t expected_field_id;
 		uint32_t read_field_count;
-		State(uint32_t expected_field_count, idx_t expected_size)
-		    : expected_field_count(expected_field_count), expected_size(expected_size), read_field_count(0) {
+
+		State(uint32_t expected_field_count, idx_t expected_size, field_id_t expected_field_id)
+		    : expected_field_count(expected_field_count), expected_size(expected_size),
+		      expected_field_id(expected_field_id), read_field_count(0) {
 		}
 	};
 
 	const char *current_tag = nullptr;
+	field_id_t current_field_id = 0;
 	data_ptr_t ptr;
 	data_ptr_t end_ptr;
 	vector<State> stack;
@@ -72,7 +76,7 @@ private:
 	}
 
 	// Set the 'tag' of the property to read
-	void SetTag(const char *tag) final;
+	void SetTag(const field_id_t field_id, const char *tag) final;
 
 	//===--------------------------------------------------------------------===//
 	// Nested Types Hooks

package/src/duckdb/src/include/duckdb/common/serializer/binary_serializer.hpp

@@ -24,6 +24,7 @@ private:
 	};
 
 	const char *current_tag;
+	field_id_t current_field_id = 0;
 
 	vector<data_t> data;
 	vector<State> stack;
@@ -55,7 +56,7 @@ public:
 		return std::move(serializer.data);
 	}
 
-	void SetTag(const char *tag) final;
+	void SetTag(const field_id_t field_id, const char *tag) final;
 
 	//===--------------------------------------------------------------------===//
 	// Nested Types Hooks

package/src/duckdb/src/include/duckdb/common/serializer/format_deserializer.hpp

@@ -30,22 +30,22 @@ protected:
 public:
 	// Read into an existing value
 	template <typename T>
-	inline void ReadProperty(const char *tag, T &ret) {
-		SetTag(tag);
+	inline void ReadProperty(const field_id_t field_id, const char *tag, T &ret) {
+		SetTag(field_id, tag);
 		ret = Read<T>();
 	}
 
 	// Read and return a value
 	template <typename T>
-	inline T ReadProperty(const char *tag) {
-		SetTag(tag);
+	inline T ReadProperty(const field_id_t field_id, const char *tag) {
+		SetTag(field_id, tag);
 		return Read<T>();
 	}
 
 	// Read optional property and return a value, or forward a default value
 	template <typename T>
-	inline T ReadOptionalPropertyOrDefault(const char *tag, T &&default_value) {
-		SetTag(tag);
+	inline T ReadOptionalPropertyOrDefault(const field_id_t field_id, const char *tag, T &&default_value) {
+		SetTag(field_id, tag);
 		auto present = OnOptionalBegin();
 		if (present) {
 			auto item = Read<T>();
@@ -59,8 +59,8 @@ public:
 
 	// Read optional property into an existing value, or use a default value
 	template <typename T>
-	inline void ReadOptionalPropertyOrDefault(const char *tag, T &ret, T &&default_value) {
-		SetTag(tag);
+	inline void ReadOptionalPropertyOrDefault(const field_id_t field_id, const char *tag, T &ret, T &&default_value) {
+		SetTag(field_id, tag);
 		auto present = OnOptionalBegin();
 		if (present) {
 			ret = Read<T>();
@@ -74,8 +74,8 @@ public:
 	// Read optional property and return a value, or default construct it
 	template <typename T>
 	inline typename std::enable_if<std::is_default_constructible<T>::value, T>::type
-	ReadOptionalProperty(const char *tag) {
-		SetTag(tag);
+	ReadOptionalProperty(const field_id_t field_id, const char *tag) {
+		SetTag(field_id, tag);
 		auto present = OnOptionalBegin();
 		if (present) {
 			auto item = Read<T>();
@@ -90,8 +90,8 @@ public:
 	// Read optional property into an existing value, or default construct it
 	template <typename T>
 	inline typename std::enable_if<std::is_default_constructible<T>::value, void>::type
-	ReadOptionalProperty(const char *tag, T &ret) {
-		SetTag(tag);
+	ReadOptionalProperty(const field_id_t field_id, const char *tag, T &ret) {
+		SetTag(field_id, tag);
 		auto present = OnOptionalBegin();
 		if (present) {
 			ret = Read<T>();
@@ -104,8 +104,8 @@ public:
 
 	// Special case:
 	// Read into an existing data_ptr_t
-	inline void ReadProperty(const char *tag, data_ptr_t ret, idx_t count) {
-		SetTag(tag);
+	inline void ReadProperty(const field_id_t field_id, const char *tag, data_ptr_t ret, idx_t count) {
+		SetTag(field_id, tag);
 		ReadDataPtr(ret, count);
 	}
 
@@ -128,8 +128,8 @@ public:
 	}
 
 	// Manually begin an object - should be followed by EndObject
-	void BeginObject(const char *tag) {
-		SetTag(tag);
+	void BeginObject(const field_id_t field_id, const char *tag) {
+		SetTag(field_id, tag);
 		OnObjectBegin();
 	}
 
@@ -392,7 +392,8 @@ private:
 	}
 
 protected:
-	virtual void SetTag(const char *tag) {
+	virtual void SetTag(const field_id_t field_id, const char *tag) {
+		(void)field_id;
 		(void)tag;
 	}
 

package/src/duckdb/src/include/duckdb/common/serializer/format_serializer.hpp

@@ -28,15 +28,15 @@ protected:
 public:
 	// Serialize a value
 	template <class T>
-	void WriteProperty(const char *tag, const T &value) {
-		SetTag(tag);
+	void WriteProperty(const field_id_t field_id, const char *tag, const T &value) {
+		SetTag(field_id, tag);
 		WriteValue(value);
 	}
 
 	// Optional pointer
 	template <class POINTER>
-	void WriteOptionalProperty(const char *tag, POINTER &&ptr) {
-		SetTag(tag);
+	void WriteOptionalProperty(const field_id_t field_id, const char *tag, POINTER &&ptr) {
+		SetTag(field_id, tag);
 		if (ptr == nullptr) {
 			OnOptionalBegin(false);
 			OnOptionalEnd(false);
@@ -48,14 +48,14 @@ public:
 	}
 
 	// Special case: data_ptr_T
-	void WriteProperty(const char *tag, const_data_ptr_t ptr, idx_t count) {
-		SetTag(tag);
+	void WriteProperty(const field_id_t field_id, const char *tag, const_data_ptr_t ptr, idx_t count) {
+		SetTag(field_id, tag);
 		WriteDataPtr(ptr, count);
 	}
 
 	// Manually begin an object - should be followed by EndObject
-	void BeginObject(const char *tag) {
-		SetTag(tag);
+	void BeginObject(const field_id_t field_id, const char *tag) {
+		SetTag(field_id, tag);
 		OnObjectBegin();
 	}
 
@@ -196,7 +196,8 @@ protected:
 	}
 
 	// Handle setting a "tag" (optional)
-	virtual void SetTag(const char *tag) {
+	virtual void SetTag(const field_id_t field_id, const char *tag) {
+		(void)field_id;
 		(void)tag;
 	}
 

package/src/duckdb/src/include/duckdb/common/serializer/serialization_traits.hpp

@@ -1,5 +1,7 @@
 #pragma once
 #include <type_traits>
+#include <cstdint>
+
 #include "duckdb/common/vector.hpp"
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/common/unordered_set.hpp"
@@ -10,6 +12,8 @@ namespace duckdb {
 class FormatSerializer;   // Forward declare
 class FormatDeserializer; // Forward declare
 
+typedef uint32_t field_id_t;
+
 // Backport to c++11
 template <class...>
 using void_t = void;

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

@@ -104,13 +104,13 @@ public:
 	static void FormatSerialize(FormatSerializer &serializer, const FUNC &function,
 	                            optional_ptr<FunctionData> bind_info) {
 		D_ASSERT(!function.name.empty());
-		serializer.WriteProperty("name", function.name);
-		serializer.WriteProperty("arguments", function.arguments);
-		serializer.WriteProperty("original_arguments", function.original_arguments);
+		serializer.WriteProperty(500, "name", function.name);
+		serializer.WriteProperty(501, "arguments", function.arguments);
+		serializer.WriteProperty(502, "original_arguments", function.original_arguments);
 		bool has_serialize = function.format_serialize;
-		serializer.WriteProperty("has_serialize", has_serialize);
+		serializer.WriteProperty(503, "has_serialize", has_serialize);
 		if (has_serialize) {
-			serializer.BeginObject("function_data");
+			serializer.BeginObject(504, "function_data");
 			function.format_serialize(serializer, bind_info, function);
 			serializer.EndObject();
 			D_ASSERT(function.format_deserialize);
@@ -135,12 +135,12 @@ public:
 	template <class FUNC, class CATALOG_ENTRY>
 	static pair<FUNC, bool> FormatDeserializeBase(FormatDeserializer &deserializer, CatalogType catalog_type) {
 		auto &context = deserializer.Get<ClientContext &>();
-		auto name = deserializer.ReadProperty<string>("name");
-		auto arguments = deserializer.ReadProperty<vector<LogicalType>>("arguments");
-		auto original_arguments = deserializer.ReadProperty<vector<LogicalType>>("original_arguments");
+		auto name = deserializer.ReadProperty<string>(500, "name");
+		auto arguments = deserializer.ReadProperty<vector<LogicalType>>(501, "arguments");
+		auto original_arguments = deserializer.ReadProperty<vector<LogicalType>>(502, "original_arguments");
 		auto function = DeserializeFunction<FUNC, CATALOG_ENTRY>(context, catalog_type, name, std::move(arguments),
 		                                                         std::move(original_arguments));
-		auto has_serialize = deserializer.ReadProperty<bool>("has_serialize");
+		auto has_serialize = deserializer.ReadProperty<bool>(503, "has_serialize");
 		return make_pair(std::move(function), has_serialize);
 	}
 
@@ -150,7 +150,7 @@ public:
 			throw SerializationException("Function requires deserialization but no deserialization function for %s",
 			                             function.name);
 		}
-		deserializer.BeginObject("function_data");
+		deserializer.BeginObject(504, "function_data");
 		auto result = function.format_deserialize(deserializer, function);
 		deserializer.EndObject();
 		return result;

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

@@ -10,17 +10,20 @@
 
 #include "duckdb/main/relation.hpp"
 #include "duckdb/parser/parsed_expression.hpp"
+#include "duckdb/parser/group_by_node.hpp"
 
 namespace duckdb {
 
 class AggregateRelation : public Relation {
 public:
 	DUCKDB_API AggregateRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions);
+	DUCKDB_API AggregateRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions,
+	                             GroupByNode groups);
 	DUCKDB_API AggregateRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions,
 	                             vector<unique_ptr<ParsedExpression>> groups);
 
 	vector<unique_ptr<ParsedExpression>> expressions;
-	vector<unique_ptr<ParsedExpression>> groups;
+	GroupByNode groups;
 	vector<ColumnDefinition> columns;
 	shared_ptr<Relation> child;
 

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

@@ -22,6 +22,17 @@ public:
 	vector<unique_ptr<ParsedExpression>> group_expressions;
 	//! The different grouping sets as they map to the group expressions
 	vector<GroupingSet> grouping_sets;
+
+public:
+	GroupByNode Copy() {
+		GroupByNode node;
+		node.group_expressions.reserve(group_expressions.size());
+		for (auto &expr : group_expressions) {
+			node.group_expressions.push_back(expr->Copy());
+		}
+		node.grouping_sets = grouping_sets;
+		return node;
+	}
 };
 
 } // namespace duckdb

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

@@ -22,6 +22,8 @@ struct PGList;
 
 namespace duckdb {
 
+class GroupByNode;
+
 //! The parser is responsible for parsing the query and converting it into a set
 //! of parsed statements. The parsed statements can then be converted into a
 //! plan and executed.
@@ -50,6 +52,8 @@ public:
 	//! Parses a list of expressions (i.e. the list found in a SELECT clause)
 	DUCKDB_API static vector<unique_ptr<ParsedExpression>> ParseExpressionList(const string &select_list,
 	                                                                           ParserOptions options = ParserOptions());
+	//! Parses a list of GROUP BY expressions
+	static GroupByNode ParseGroupByList(const string &group_by, ParserOptions options = ParserOptions());
 	//! Parses a list as found in an ORDER BY expression (i.e. including optional ASCENDING/DESCENDING modifiers)
 	static vector<OrderByNode> ParseOrderList(const string &select_list, ParserOptions options = ParserOptions());
 	//! Parses an update list (i.e. the list found in the SET clause of an UPDATE statement)