duckdb 0.7.2-dev3441.0 → 0.7.2-dev3546.0

package/src/duckdb/src/include/duckdb/function/table/read_csv.hpp

@@ -55,7 +55,7 @@ struct WriteCSVData : public BaseCSVData {
 	//! The size of the CSV file (in bytes) that we buffer before we flush it to disk
 	idx_t flush_size = 4096 * 8;
 	//! For each byte whether or not the CSV file requires quotes when containing the byte
-	unique_ptr<bool[]> requires_quotes;
+	unsafe_array_ptr<bool> requires_quotes;
 };
 
 struct ColumnInfo {
@@ -65,7 +65,7 @@ struct ColumnInfo {
 		names = std::move(names_p);
 		types = std::move(types_p);
 	}
-	void Serialize(FieldWriter &writer) {
+	void Serialize(FieldWriter &writer) const {
 		writer.WriteList<string>(names);
 		writer.WriteRegularSerializableList<LogicalType>(types);
 	}
@@ -99,8 +99,6 @@ struct ReadCSVData : public BaseCSVData {
 	bool single_threaded = false;
 	//! Reader bind data
 	MultiFileReaderBindData reader_bind;
-	//! If any file is a pipe
-	bool is_pipe = false;
 	vector<ColumnInfo> column_info;
 
 	void Initialize(unique_ptr<BufferedCSVReader> &reader) {

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/optimizer/join_order/join_relation.hpp

@@ -27,12 +27,12 @@ struct SingleJoinRelation {
 
 //! Set of relations, used in the join graph.
 struct JoinRelationSet {
-	JoinRelationSet(unique_ptr<idx_t[]> relations, idx_t count) : relations(std::move(relations)), count(count) {
+	JoinRelationSet(unsafe_array_ptr<idx_t> relations, idx_t count) : relations(std::move(relations)), count(count) {
 	}
 
 	string ToString() const;
 
-	unique_ptr<idx_t[]> relations;
+	unsafe_array_ptr<idx_t> relations;
 	idx_t count;
 
 	static bool IsSubset(JoinRelationSet &super, JoinRelationSet &sub);
@@ -55,7 +55,7 @@ public:
 	//! Create or get a JoinRelationSet from a set of relation bindings
 	JoinRelationSet &GetJoinRelation(unordered_set<idx_t> &bindings);
 	//! Create or get a JoinRelationSet from a (sorted, duplicate-free!) list of relations
-	JoinRelationSet &GetJoinRelation(unique_ptr<idx_t[]> relations, idx_t count);
+	JoinRelationSet &GetJoinRelation(unsafe_array_ptr<idx_t> relations, idx_t count);
 	//! Union two sets of relations together and create a new relation set
 	JoinRelationSet &Union(JoinRelationSet &left, JoinRelationSet &right);
 	// //! Create the set difference of left \ right (i.e. all elements in left that are not in right)

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

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

@@ -15,8 +15,7 @@
 namespace duckdb {
 
 struct DropInfo : public ParseInfo {
-	DropInfo() : catalog(INVALID_CATALOG), schema(INVALID_SCHEMA), cascade(false) {
-	}
+	DropInfo();
 
 	//! The catalog type to drop
 	CatalogType type;
@@ -35,43 +34,10 @@ struct DropInfo : public ParseInfo {
 	bool allow_drop_internal = false;
 
 public:
-	unique_ptr<DropInfo> Copy() const {
-		auto result = make_uniq<DropInfo>();
-		result->type = type;
-		result->catalog = catalog;
-		result->schema = schema;
-		result->name = name;
-		result->if_not_found = if_not_found;
-		result->cascade = cascade;
-		result->allow_drop_internal = allow_drop_internal;
-		return result;
-	}
+	unique_ptr<DropInfo> Copy() const;
 
-	void Serialize(Serializer &serializer) const {
-		FieldWriter writer(serializer);
-		writer.WriteField<CatalogType>(type);
-		writer.WriteString(catalog);
-		writer.WriteString(schema);
-		writer.WriteString(name);
-		writer.WriteField(if_not_found);
-		writer.WriteField(cascade);
-		writer.WriteField(allow_drop_internal);
-		writer.Finalize();
-	}
-
-	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer) {
-		FieldReader reader(deserializer);
-		auto drop_info = make_uniq<DropInfo>();
-		drop_info->type = reader.ReadRequired<CatalogType>();
-		drop_info->catalog = reader.ReadRequired<string>();
-		drop_info->schema = reader.ReadRequired<string>();
-		drop_info->name = reader.ReadRequired<string>();
-		drop_info->if_not_found = reader.ReadRequired<OnEntryNotFound>();
-		drop_info->cascade = reader.ReadRequired<bool>();
-		drop_info->allow_drop_internal = reader.ReadRequired<bool>();
-		reader.Finalize();
-		return std::move(drop_info);
-	}
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
 };
 
 } // namespace duckdb

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

@@ -15,11 +15,14 @@ namespace duckdb {
 enum class TransactionType : uint8_t { INVALID, BEGIN_TRANSACTION, COMMIT, ROLLBACK };
 
 struct TransactionInfo : public ParseInfo {
-	explicit TransactionInfo(TransactionType type) : type(type) {
-	}
+	explicit TransactionInfo(TransactionType type);
 
 	//! The type of transaction statement
 	TransactionType type;
+
+public:
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
 };
 
 } // namespace duckdb

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

@@ -17,22 +17,16 @@
 namespace duckdb {
 
 struct VacuumOptions {
+	VacuumOptions() : vacuum(false), analyze(false) {
+	}
+
 	bool vacuum;
 	bool analyze;
 };
 
 struct VacuumInfo : public ParseInfo {
 public:
-	explicit VacuumInfo(VacuumOptions options) : options(options), has_table(false) {};
-
-	unique_ptr<VacuumInfo> Copy() {
-		auto result = make_uniq<VacuumInfo>(options);
-		result->has_table = has_table;
-		if (has_table) {
-			result->ref = ref->Copy();
-		}
-		return result;
-	}
+	explicit VacuumInfo(VacuumOptions options);
 
 	const VacuumOptions options;
 
@@ -42,6 +36,12 @@ public:
 	optional_ptr<TableCatalogEntry> table;
 	unordered_map<idx_t, idx_t> column_id_map;
 	vector<string> columns;
+
+public:
+	unique_ptr<VacuumInfo> Copy();
+
+	void Serialize(Serializer &serializer) const;
+	static unique_ptr<ParseInfo> Deserialize(Deserializer &deserializer);
 };
 
 } // namespace duckdb

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

@@ -24,6 +24,8 @@ enum class OnConflictAction : uint8_t {
 	REPLACE // Only used in transform/bind step, changed to UPDATE later
 };
 
+enum class InsertColumnOrder : uint8_t { INSERT_BY_POSITION = 0, INSERT_BY_NAME = 1 };
+
 class OnConflictInfo {
 public:
 	OnConflictInfo();
@@ -75,6 +77,9 @@ public:
 	//! Whether or not this a DEFAULT VALUES
 	bool default_values = false;
 
+	//! INSERT BY POSITION or INSERT BY NAME
+	InsertColumnOrder column_order = InsertColumnOrder::INSERT_BY_POSITION;
+
 protected:
 	InsertStatement(const InsertStatement &other);
 

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

@@ -20,7 +20,7 @@ struct ArenaChunk {
 	AllocatedData data;
 	idx_t current_position;
 	idx_t maximum_size;
-	unique_ptr<ArenaChunk> next;
+	unsafe_unique_ptr<ArenaChunk> next;
 	ArenaChunk *prev;
 };
 
@@ -56,7 +56,7 @@ private:
 	//! Internal allocator that is used by the arena allocator
 	Allocator &allocator;
 	idx_t current_capacity;
-	unique_ptr<ArenaChunk> head;
+	unsafe_unique_ptr<ArenaChunk> head;
 	ArenaChunk *tail;
 	//! An allocator wrapper using this arena allocator
 	Allocator arena_allocator;

package/src/duckdb/src/include/duckdb/storage/buffer/buffer_handle.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/storage/storage_info.hpp"
+#include "duckdb/common/file_buffer.hpp"
 
 namespace duckdb {
 class BlockHandle;
@@ -30,9 +31,15 @@ public:
 	//! Returns whether or not the BufferHandle is valid.
 	DUCKDB_API bool IsValid() const;
 	//! Returns a pointer to the buffer data. Handle must be valid.
-	DUCKDB_API data_ptr_t Ptr() const;
+	inline data_ptr_t Ptr() const {
+		D_ASSERT(IsValid());
+		return node->buffer;
+	}
 	//! Returns a pointer to the buffer data. Handle must be valid.
-	DUCKDB_API data_ptr_t Ptr();
+	inline data_ptr_t Ptr() {
+		D_ASSERT(IsValid());
+		return node->buffer;
+	}
 	//! Gets the underlying file buffer. Handle must be valid.
 	DUCKDB_API FileBuffer &GetFileBuffer();
 	//! Destroys the buffer handle

package/src/duckdb/src/include/duckdb/storage/statistics/base_statistics.hpp

@@ -138,7 +138,7 @@ private:
 		StringStatsData string_data;
 	} stats_union;
 	//! Child stats (for LIST and STRUCT)
-	unique_ptr<BaseStatistics[]> child_stats;
+	unsafe_array_ptr<BaseStatistics> child_stats;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/table/append_state.hpp

@@ -44,7 +44,7 @@ struct RowGroupAppendState {
 	//! The current row_group we are appending to
 	RowGroup *row_group;
 	//! The column append states
-	unique_ptr<ColumnAppendState[]> states;
+	unsafe_array_ptr<ColumnAppendState> states;
 	//! Offset within the row_group
 	idx_t offset_in_row_group;
 };

package/src/duckdb/src/include/duckdb/storage/table/scan_state.hpp

@@ -99,7 +99,7 @@ public:
 	//! The maximum row within the row group
 	idx_t max_row_group_row;
 	//! Child column scans
-	unique_ptr<ColumnScanState[]> column_scans;
+	unsafe_array_ptr<ColumnScanState> column_scans;
 	//! Row group segment tree
 	RowGroupSegmentTree *row_groups;
 	//! The total maximum row index

package/src/duckdb/src/include/duckdb/storage/table/update_segment.hpp

@@ -96,8 +96,8 @@ private:
 
 struct UpdateNodeData {
 	unique_ptr<UpdateInfo> info;
-	unique_ptr<sel_t[]> tuples;
-	unique_ptr<data_t[]> tuple_data;
+	unsafe_array_ptr<sel_t> tuples;
+	unsafe_array_ptr<data_t> tuple_data;
 };
 
 struct UpdateNode {

package/src/duckdb/src/optimizer/join_order/join_relation_set.cpp

@@ -35,7 +35,7 @@ bool JoinRelationSet::IsSubset(JoinRelationSet &super, JoinRelationSet &sub) {
 	return false;
 }
 
-JoinRelationSet &JoinRelationSetManager::GetJoinRelation(unique_ptr<idx_t[]> relations, idx_t count) {
+JoinRelationSet &JoinRelationSetManager::GetJoinRelation(unsafe_array_ptr<idx_t> relations, idx_t count) {
 	// now look it up in the tree
 	reference<JoinRelationTreeNode> info(root);
 	for (idx_t i = 0; i < count; i++) {
@@ -59,7 +59,7 @@ JoinRelationSet &JoinRelationSetManager::GetJoinRelation(unique_ptr<idx_t[]> rel
 //! Create or get a JoinRelationSet from a single node with the given index
 JoinRelationSet &JoinRelationSetManager::GetJoinRelation(idx_t index) {
 	// create a sorted vector of the relations
-	auto relations = unique_ptr<idx_t[]>(new idx_t[1]);
+	auto relations = make_unsafe_array<idx_t>(1);
 	relations[0] = index;
 	idx_t count = 1;
 	return GetJoinRelation(std::move(relations), count);
@@ -67,7 +67,7 @@ JoinRelationSet &JoinRelationSetManager::GetJoinRelation(idx_t index) {
 
 JoinRelationSet &JoinRelationSetManager::GetJoinRelation(unordered_set<idx_t> &bindings) {
 	// create a sorted vector of the relations
-	unique_ptr<idx_t[]> relations = bindings.empty() ? nullptr : unique_ptr<idx_t[]>(new idx_t[bindings.size()]);
+	unsafe_array_ptr<idx_t> relations = bindings.empty() ? nullptr : make_unsafe_array<idx_t>(bindings.size());
 	idx_t count = 0;
 	for (auto &entry : bindings) {
 		relations[count++] = entry;
@@ -77,7 +77,7 @@ JoinRelationSet &JoinRelationSetManager::GetJoinRelation(unordered_set<idx_t> &b
 }
 
 JoinRelationSet &JoinRelationSetManager::Union(JoinRelationSet &left, JoinRelationSet &right) {
-	auto relations = unique_ptr<idx_t[]>(new idx_t[left.count + right.count]);
+	auto relations = make_unsafe_array<idx_t>(left.count + right.count);
 	idx_t count = 0;
 	// move through the left and right relations, eliminating duplicates
 	idx_t i = 0, j = 0;
@@ -113,7 +113,7 @@ JoinRelationSet &JoinRelationSetManager::Union(JoinRelationSet &left, JoinRelati
 }
 
 // JoinRelationSet *JoinRelationSetManager::Difference(JoinRelationSet *left, JoinRelationSet *right) {
-// 	auto relations = unique_ptr<idx_t[]>(new idx_t[left->count]);
+// 	auto relations = unsafe_array_ptr<idx_t>(new idx_t[left->count]);
 // 	idx_t count = 0;
 // 	// move through the left and right relations
 // 	idx_t i = 0, j = 0;

package/src/duckdb/src/optimizer/unnest_rewriter.cpp

@@ -195,18 +195,24 @@ void UnnestRewriter::UpdateRHSBindings(unique_ptr<LogicalOperator> *plan_ptr, un
 		updater.replace_bindings.push_back(replace_binding);
 	}
 
-	// temporarily remove the BOUND_UNNEST and the child of the LOGICAL_UNNEST from the plan
+	// temporarily remove the BOUND_UNNESTs and the child of the LOGICAL_UNNEST from the plan
 	D_ASSERT(curr_op->get()->type == LogicalOperatorType::LOGICAL_UNNEST);
 	auto &unnest = curr_op->get()->Cast<LogicalUnnest>();
-	auto temp_bound_unnest = std::move(unnest.expressions[0]);
+	vector<unique_ptr<Expression>> temp_bound_unnests;
+	for (auto &temp_bound_unnest : unnest.expressions) {
+		temp_bound_unnests.push_back(std::move(temp_bound_unnest));
+	}
+	D_ASSERT(unnest.children.size() == 1);
 	auto temp_unnest_child = std::move(unnest.children[0]);
 	unnest.expressions.clear();
 	unnest.children.clear();
 	// update the bindings of the plan
 	updater.VisitOperator(*plan_ptr->get());
 	updater.replace_bindings.clear();
-	// add the child again
-	unnest.expressions.push_back(std::move(temp_bound_unnest));
+	// add the children again
+	for (auto &temp_bound_unnest : temp_bound_unnests) {
+		unnest.expressions.push_back(std::move(temp_bound_unnest));
+	}
 	unnest.children.push_back(std::move(temp_unnest_child));
 
 	// add the LHS expressions to each LOGICAL_PROJECTION
@@ -256,6 +262,7 @@ void UnnestRewriter::UpdateBoundUnnestBindings(UnnestRewriterPlanUpdater &update
 	D_ASSERT(curr_op->get()->type == LogicalOperatorType::LOGICAL_UNNEST);
 	auto &unnest = curr_op->get()->Cast<LogicalUnnest>();
 
+	D_ASSERT(unnest.children.size() == 1);
 	auto unnest_child_cols = unnest.children[0]->GetColumnBindings();
 	for (idx_t delim_col_idx = 0; delim_col_idx < delim_columns.size(); delim_col_idx++) {
 		for (idx_t child_col_idx = 0; child_col_idx < unnest_child_cols.size(); child_col_idx++) {
@@ -268,8 +275,9 @@ void UnnestRewriter::UpdateBoundUnnestBindings(UnnestRewriterPlanUpdater &update
 	}
 
 	// update bindings
-	D_ASSERT(unnest.expressions.size() == 1);
-	updater.VisitExpression(&unnest.expressions[0]);
+	for (auto &unnest_expr : unnest.expressions) {
+		updater.VisitExpression(&unnest_expr);
+	}
 	updater.replace_bindings.clear();
 }
 

package/src/duckdb/src/parser/parsed_data/attach_info.cpp

@@ -0,0 +1,42 @@
+#include "duckdb/parser/parsed_data/attach_info.hpp"
+#include "duckdb/common/field_writer.hpp"
+
+namespace duckdb {
+
+unique_ptr<AttachInfo> AttachInfo::Copy() const {
+	auto result = make_uniq<AttachInfo>();
+	result->name = name;
+	result->path = path;
+	result->options = options;
+	return result;
+}
+
+void AttachInfo::Serialize(Serializer &main_serializer) const {
+	FieldWriter writer(main_serializer);
+	writer.WriteString(name);
+	writer.WriteString(path);
+	writer.WriteField<uint32_t>(options.size());
+	auto &serializer = writer.GetSerializer();
+	for (auto &kv : options) {
+		serializer.WriteString(kv.first);
+		kv.second.Serialize(serializer);
+	}
+	writer.Finalize();
+}
+
+unique_ptr<ParseInfo> AttachInfo::Deserialize(Deserializer &deserializer) {
+	FieldReader reader(deserializer);
+	auto attach_info = make_uniq<AttachInfo>();
+	attach_info->name = reader.ReadRequired<string>();
+	attach_info->path = reader.ReadRequired<string>();
+	auto default_attach_count = reader.ReadRequired<uint32_t>();
+	auto &source = reader.GetSource();
+	for (idx_t i = 0; i < default_attach_count; i++) {
+		auto name = source.Read<string>();
+		attach_info->options[name] = Value::Deserialize(source);
+	}
+	reader.Finalize();
+	return std::move(attach_info);
+}
+
+} // namespace duckdb

package/src/duckdb/src/parser/parsed_data/create_index_info.cpp

@@ -5,7 +5,6 @@
 namespace duckdb {
 
 unique_ptr<CreateInfo> CreateIndexInfo::Copy() const {
-
 	auto result = make_uniq<CreateIndexInfo>();
 	CopyProperties(*result);
 
@@ -27,24 +26,20 @@ unique_ptr<CreateInfo> CreateIndexInfo::Copy() const {
 }
 
 void CreateIndexInfo::SerializeInternal(Serializer &serializer) const {
-
 	FieldWriter writer(serializer);
 	writer.WriteField(index_type);
 	writer.WriteString(index_name);
 	writer.WriteField(constraint_type);
 
-	writer.WriteSerializableList<ParsedExpression>(expressions);
 	writer.WriteSerializableList<ParsedExpression>(parsed_expressions);
 
 	writer.WriteRegularSerializableList(scan_types);
 	writer.WriteList<string>(names);
 	writer.WriteList<column_t>(column_ids);
-
 	writer.Finalize();
 }
 
 unique_ptr<CreateIndexInfo> CreateIndexInfo::Deserialize(Deserializer &deserializer) {
-
 	auto result = make_uniq<CreateIndexInfo>();
 	result->DeserializeBase(deserializer);
 
@@ -53,13 +48,11 @@ unique_ptr<CreateIndexInfo> CreateIndexInfo::Deserialize(Deserializer &deseriali
 	result->index_name = reader.ReadRequired<string>();
 	result->constraint_type = reader.ReadRequired<IndexConstraintType>();
 
-	result->expressions = reader.ReadRequiredSerializableList<ParsedExpression>();
 	result->parsed_expressions = reader.ReadRequiredSerializableList<ParsedExpression>();
 
 	result->scan_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
 	result->names = reader.ReadRequiredList<string>();
 	result->column_ids = reader.ReadRequiredList<column_t>();
-
 	reader.Finalize();
 	return result;
 }