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

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

@@ -4,18 +4,13 @@
 #include "duckdb/parser/parsed_data/create_schema_info.hpp"
 #include "duckdb/parser/parsed_data/create_table_info.hpp"
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
+#include "duckdb/parser/parsed_data/create_sequence_info.hpp"
 #include "duckdb/parser/parsed_data/create_database_info.hpp"
+#include "duckdb/parser/parsed_data/create_type_info.hpp"
 #include "duckdb/parser/parsed_data/alter_info.hpp"
+#include "duckdb/parser/parsed_data/create_macro_info.hpp"
 
 namespace duckdb {
-void CreateInfo::DeserializeBase(Deserializer &deserializer) {
-	this->catalog = deserializer.Read<string>();
-	this->schema = deserializer.Read<string>();
-	this->on_conflict = deserializer.Read<OnCreateConflict>();
-	this->temporary = deserializer.Read<bool>();
-	this->internal = deserializer.Read<bool>();
-	this->sql = deserializer.Read<string>();
-}
 
 void CreateInfo::Serialize(Serializer &serializer) const {
 	serializer.Write(type);
@@ -28,6 +23,15 @@ void CreateInfo::Serialize(Serializer &serializer) const {
 	SerializeInternal(serializer);
 }
 
+void CreateInfo::DeserializeBase(Deserializer &deserializer) {
+	this->catalog = deserializer.Read<string>();
+	this->schema = deserializer.Read<string>();
+	this->on_conflict = deserializer.Read<OnCreateConflict>();
+	this->temporary = deserializer.Read<bool>();
+	this->internal = deserializer.Read<bool>();
+	this->sql = deserializer.Read<string>();
+}
+
 unique_ptr<CreateInfo> CreateInfo::Deserialize(Deserializer &deserializer) {
 	auto type = deserializer.Read<CatalogType>();
 	switch (type) {
@@ -41,6 +45,13 @@ unique_ptr<CreateInfo> CreateInfo::Deserialize(Deserializer &deserializer) {
 		return CreateViewInfo::Deserialize(deserializer);
 	case CatalogType::DATABASE_ENTRY:
 		return CreateDatabaseInfo::Deserialize(deserializer);
+	case CatalogType::TYPE_ENTRY:
+		return CreateTypeInfo::Deserialize(deserializer);
+	case CatalogType::MACRO_ENTRY:
+	case CatalogType::TABLE_MACRO_ENTRY:
+		return CreateMacroInfo::Deserialize(deserializer);
+	case CatalogType::SEQUENCE_ENTRY:
+		return CreateSequenceInfo::Deserialize(deserializer);
 	default:
 		throw NotImplementedException("Cannot deserialize '%s'", CatalogTypeToString(type));
 	}

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

@@ -0,0 +1,46 @@
+#include "duckdb/parser/parsed_data/create_macro_info.hpp"
+#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/catalog/catalog.hpp"
+
+namespace duckdb {
+
+CreateMacroInfo::CreateMacroInfo() : CreateFunctionInfo(CatalogType::MACRO_ENTRY, INVALID_SCHEMA) {
+}
+
+CreateMacroInfo::CreateMacroInfo(CatalogType type) : CreateFunctionInfo(type, INVALID_SCHEMA) {
+}
+
+unique_ptr<CreateInfo> CreateMacroInfo::Copy() const {
+	auto result = make_uniq<CreateMacroInfo>();
+	result->function = function->Copy();
+	result->name = name;
+	CopyProperties(*result);
+	return std::move(result);
+}
+
+void CreateMacroInfo::SerializeInternal(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	writer.WriteString(name);
+	writer.WriteSerializable(*function);
+	writer.Finalize();
+}
+
+unique_ptr<CreateMacroInfo> CreateMacroInfo::Deserialize(Deserializer &deserializer) {
+	auto result = make_uniq<CreateMacroInfo>();
+	result->DeserializeBase(deserializer);
+
+	FieldReader reader(deserializer);
+	result->name = reader.ReadRequired<string>();
+	result->function = reader.ReadRequiredSerializable<MacroFunction>();
+	reader.Finalize();
+
+	if (result->function->type == MacroType::TABLE_MACRO) {
+		result->type = CatalogType::TABLE_MACRO_ENTRY;
+	} else {
+		result->type = CatalogType::MACRO_ENTRY;
+	}
+	return result;
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,56 @@
+#include "duckdb/parser/parsed_data/create_sequence_info.hpp"
+#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/catalog/catalog.hpp"
+
+namespace duckdb {
+
+CreateSequenceInfo::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) {
+}
+
+unique_ptr<CreateInfo> CreateSequenceInfo::Copy() const {
+	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);
+}
+
+void CreateSequenceInfo::SerializeInternal(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	writer.WriteString(name);
+	writer.WriteField(usage_count);
+	writer.WriteField(increment);
+	writer.WriteField(min_value);
+	writer.WriteField(max_value);
+	writer.WriteField(start_value);
+	writer.WriteField(cycle);
+	writer.Finalize();
+}
+
+unique_ptr<CreateSequenceInfo> CreateSequenceInfo::Deserialize(Deserializer &deserializer) {
+	auto result = make_uniq<CreateSequenceInfo>();
+	result->DeserializeBase(deserializer);
+
+	FieldReader reader(deserializer);
+	result->name = reader.ReadRequired<string>();
+	result->usage_count = reader.ReadRequired<uint64_t>();
+	result->increment = reader.ReadRequired<int64_t>();
+	result->min_value = reader.ReadRequired<int64_t>();
+	result->max_value = reader.ReadRequired<int64_t>();
+	result->start_value = reader.ReadRequired<int64_t>();
+	result->cycle = reader.ReadRequired<bool>();
+	reader.Finalize();
+
+	return result;
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,47 @@
+#include "duckdb/parser/parsed_data/create_type_info.hpp"
+#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/catalog/catalog.hpp"
+
+namespace duckdb {
+
+CreateTypeInfo::CreateTypeInfo() : CreateInfo(CatalogType::TYPE_ENTRY) {
+}
+CreateTypeInfo::CreateTypeInfo(string name_p, LogicalType type_p)
+    : CreateInfo(CatalogType::TYPE_ENTRY), name(std::move(name_p)), type(std::move(type_p)) {
+}
+
+unique_ptr<CreateInfo> CreateTypeInfo::Copy() const {
+	auto result = make_uniq<CreateTypeInfo>();
+	CopyProperties(*result);
+	result->name = name;
+	result->type = type;
+	if (query) {
+		result->query = query->Copy();
+	}
+	return std::move(result);
+}
+
+void CreateTypeInfo::SerializeInternal(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	writer.WriteString(name);
+	writer.WriteSerializable(type);
+	if (query) {
+		throw InternalException("Cannot serialize CreateTypeInfo with query");
+	}
+	writer.Finalize();
+}
+
+unique_ptr<CreateTypeInfo> CreateTypeInfo::Deserialize(Deserializer &deserializer) {
+	auto result = make_uniq<CreateTypeInfo>();
+	result->DeserializeBase(deserializer);
+
+	FieldReader reader(deserializer);
+	result->name = reader.ReadRequired<string>();
+	result->type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
+	reader.Finalize();
+
+	return result;
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,34 @@
+#include "duckdb/parser/parsed_data/detach_info.hpp"
+#include "duckdb/common/field_writer.hpp"
+
+namespace duckdb {
+
+DetachInfo::DetachInfo() {
+}
+
+unique_ptr<DetachInfo> DetachInfo::Copy() const {
+	auto result = make_uniq<DetachInfo>();
+	result->name = name;
+	result->if_not_found = if_not_found;
+	return result;
+}
+
+void DetachInfo::Serialize(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	writer.WriteString(name);
+	writer.WriteField(if_not_found);
+	writer.Finalize();
+}
+
+unique_ptr<ParseInfo> DetachInfo::Deserialize(Deserializer &deserializer) {
+	auto result = make_uniq<DetachInfo>();
+
+	FieldReader reader(deserializer);
+	result->name = reader.ReadRequired<string>();
+	result->if_not_found = reader.ReadRequired<OnEntryNotFound>();
+	reader.Finalize();
+
+	return std::move(result);
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,46 @@
+#include "duckdb/parser/parsed_data/drop_info.hpp"
+
+namespace duckdb {
+
+DropInfo::DropInfo() : catalog(INVALID_CATALOG), schema(INVALID_SCHEMA), cascade(false) {
+}
+
+unique_ptr<DropInfo> 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;
+}
+
+void DropInfo::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();
+}
+
+unique_ptr<ParseInfo> DropInfo::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);
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,24 @@
+#include "duckdb/parser/parsed_data/transaction_info.hpp"
+#include "duckdb/common/field_writer.hpp"
+
+namespace duckdb {
+
+TransactionInfo::TransactionInfo(TransactionType type) : type(type) {
+}
+
+void TransactionInfo::Serialize(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	writer.WriteField(type);
+	writer.Finalize();
+}
+
+unique_ptr<ParseInfo> TransactionInfo::Deserialize(Deserializer &deserializer) {
+	FieldReader reader(deserializer);
+	auto transaction_type = reader.ReadRequired<TransactionType>();
+	reader.Finalize();
+
+	auto transaction_info = make_uniq<TransactionInfo>(transaction_type);
+	return std::move(transaction_info);
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,37 @@
+#include "duckdb/parser/parsed_data/vacuum_info.hpp"
+#include "duckdb/common/field_writer.hpp"
+
+namespace duckdb {
+
+VacuumInfo::VacuumInfo(VacuumOptions options) : options(options), has_table(false) {
+}
+
+unique_ptr<VacuumInfo> VacuumInfo::Copy() {
+	auto result = make_uniq<VacuumInfo>(options);
+	result->has_table = has_table;
+	if (has_table) {
+		result->ref = ref->Copy();
+	}
+	return result;
+}
+
+void VacuumInfo::Serialize(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	writer.WriteField(options.analyze);
+	writer.WriteField(options.vacuum);
+	writer.Finalize();
+}
+
+unique_ptr<ParseInfo> VacuumInfo::Deserialize(Deserializer &deserializer) {
+
+	VacuumOptions options;
+	FieldReader reader(deserializer);
+	options.analyze = reader.ReadRequired<bool>();
+	options.vacuum = reader.ReadRequired<bool>();
+	reader.Finalize();
+
+	auto vacuum_info = make_uniq<VacuumInfo>(options);
+	return std::move(vacuum_info);
+}
+
+} // namespace duckdb

package/src/duckdb/src/parser/statement/insert_statement.cpp

@@ -30,7 +30,7 @@ InsertStatement::InsertStatement(const InsertStatement &other)
     : SQLStatement(other), select_statement(unique_ptr_cast<SQLStatement, SelectStatement>(
                                other.select_statement ? other.select_statement->Copy() : nullptr)),
       columns(other.columns), table(other.table), schema(other.schema), catalog(other.catalog),
-      default_values(other.default_values) {
+      default_values(other.default_values), column_order(other.column_order) {
 	cte_map = other.cte_map.Copy();
 	for (auto &expr : other.returning_list) {
 		returning_list.emplace_back(expr->Copy());
@@ -81,6 +81,9 @@ string InsertStatement::ToString() const {
 	if (table_ref && !table_ref->alias.empty()) {
 		result += StringUtil::Format(" AS %s", KeywordHelper::WriteOptionallyQuoted(table_ref->alias));
 	}
+	if (column_order == InsertColumnOrder::INSERT_BY_NAME) {
+		result += " BY NAME";
+	}
 	if (!columns.empty()) {
 		result += " (";
 		for (idx_t i = 0; i < columns.size(); i++) {

package/src/duckdb/src/parser/transform/statement/transform_insert.cpp

@@ -67,6 +67,16 @@ unique_ptr<InsertStatement> Transformer::TransformInsert(duckdb_libpgquery::PGNo
 		result->on_conflict_info = DummyOnConflictClause(stmt->onConflictAlias, result->schema);
 		result->table_ref = TransformRangeVar(stmt->relation);
 	}
+	switch (stmt->insert_column_order) {
+	case duckdb_libpgquery::PG_INSERT_BY_POSITION:
+		result->column_order = InsertColumnOrder::INSERT_BY_POSITION;
+		break;
+	case duckdb_libpgquery::PG_INSERT_BY_NAME:
+		result->column_order = InsertColumnOrder::INSERT_BY_NAME;
+		break;
+	default:
+		throw InternalException("Unrecognized insert column order in TransformInsert");
+	}
 	result->catalog = qname.catalog;
 	return result;
 }

package/src/duckdb/src/planner/binder/expression/bind_star_expression.cpp

@@ -8,6 +8,15 @@
 
 namespace duckdb {
 
+string GetColumnsStringValue(ParsedExpression &expr) {
+	if (expr.type == ExpressionType::COLUMN_REF) {
+		auto &colref = expr.Cast<ColumnRefExpression>();
+		return colref.GetColumnName();
+	} else {
+		return expr.ToString();
+	}
+}
+
 bool Binder::FindStarExpression(unique_ptr<ParsedExpression> &expr, StarExpression **star, bool is_root,
                                 bool in_columns) {
 	bool has_star = false;
@@ -33,7 +42,7 @@ bool Binder::FindStarExpression(unique_ptr<ParsedExpression> &expr, StarExpressi
 			vector<Value> values;
 			values.reserve(star_list.size());
 			for (auto &expr : star_list) {
-				values.emplace_back(expr->ToString());
+				values.emplace_back(GetColumnsStringValue(*expr));
 			}
 			D_ASSERT(!values.empty());
 
@@ -139,17 +148,26 @@ void Binder::ExpandStarExpression(unique_ptr<ParsedExpression> expr,
 			}
 			auto &children = ListValue::GetChildren(val);
 			vector<unique_ptr<ParsedExpression>> new_list;
+			// scan the list for all selected columns and construct a lookup table
+			case_insensitive_map_t<bool> selected_set;
 			for (auto &child : children) {
-				auto qname = QualifiedName::Parse(StringValue::Get(child));
-				vector<string> names;
-				if (!qname.catalog.empty()) {
-					names.push_back(qname.catalog);
+				selected_set.insert(make_pair(StringValue::Get(child), false));
+			}
+			// now check the list of all possible expressions and select which ones make it in
+			for (auto &expr : star_list) {
+				auto str = GetColumnsStringValue(*expr);
+				auto entry = selected_set.find(str);
+				if (entry != selected_set.end()) {
+					new_list.push_back(std::move(expr));
+					entry->second = true;
 				}
-				if (!qname.schema.empty()) {
-					names.push_back(qname.schema);
+			}
+			// check if all expressions found a match
+			for (auto &entry : selected_set) {
+				if (!entry.second) {
+					throw BinderException("Column \"%s\" was selected but was not found in the FROM clause",
+					                      entry.first);
 				}
-				names.push_back(qname.name);
-				new_list.push_back(make_uniq<ColumnRefExpression>(std::move(names)));
 			}
 			star_list = std::move(new_list);
 		} else {

package/src/duckdb/src/planner/binder/statement/bind_create.cpp

@@ -455,7 +455,7 @@ static bool AnyConstraintReferencesGeneratedColumn(CreateTableInfo &table_info)
 unique_ptr<LogicalOperator> DuckCatalog::BindCreateIndex(Binder &binder, CreateStatement &stmt,
                                                          TableCatalogEntry &table, unique_ptr<LogicalOperator> plan) {
 	D_ASSERT(plan->type == LogicalOperatorType::LOGICAL_GET);
-	auto &base = (CreateIndexInfo &)*stmt.info;
+	auto &base = stmt.info->Cast<CreateIndexInfo>();
 
 	auto &get = plan->Cast<LogicalGet>();
 	// bind the index expressions
@@ -614,6 +614,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 			// CREATE TYPE mood AS ENUM (SELECT 'happy')
 			auto query_obj = Bind(*create_type_info.query);
 			auto query = std::move(query_obj.plan);
+			create_type_info.query.reset();
 
 			auto &sql_types = query_obj.types;
 			if (sql_types.size() != 1) {

package/src/duckdb/src/planner/binder/statement/bind_create_table.cpp

@@ -256,6 +256,7 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 	if (base.query) {
 		// construct the result object
 		auto query_obj = Bind(*base.query);
+		base.query.reset();
 		result->query = std::move(query_obj.plan);
 
 		// construct the set of columns based on the names and types of the query

package/src/duckdb/src/planner/binder/statement/bind_insert.cpp

@@ -406,6 +406,26 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	// Add CTEs as bindable
 	AddCTEMap(stmt.cte_map);
 
+	auto values_list = stmt.GetValuesList();
+
+	// bind the root select node (if any)
+	BoundStatement root_select;
+	if (stmt.column_order == InsertColumnOrder::INSERT_BY_NAME) {
+		if (values_list) {
+			throw BinderException("INSERT BY NAME can only be used when inserting from a SELECT statement");
+		}
+		if (!stmt.columns.empty()) {
+			throw BinderException("INSERT BY NAME cannot be combined with an explicit column list");
+		}
+		D_ASSERT(stmt.select_statement);
+		// INSERT BY NAME - generate the columns from the names of the SELECT statement
+		auto select_binder = Binder::CreateBinder(context, this);
+		root_select = select_binder->Bind(*stmt.select_statement);
+		MoveCorrelatedExpressions(*select_binder);
+
+		stmt.columns = root_select.names;
+	}
+
 	vector<LogicalIndex> named_column_map;
 	if (!stmt.columns.empty() || stmt.default_values) {
 		// insertion statement specifies column list
@@ -413,6 +433,10 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 		// create a mapping of (list index) -> (column index)
 		case_insensitive_map_t<idx_t> column_name_map;
 		for (idx_t i = 0; i < stmt.columns.size(); i++) {
+			auto entry = column_name_map.insert(make_pair(stmt.columns[i], i));
+			if (!entry.second) {
+				throw BinderException("Duplicate column name \"%s\" in INSERT", stmt.columns[i]);
+			}
 			column_name_map[stmt.columns[i]] = i;
 			auto column_index = table.GetColumnIndex(stmt.columns[i]);
 			if (column_index.index == COLUMN_IDENTIFIER_ROW_ID) {
@@ -436,8 +460,8 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 			}
 		}
 	} else {
-		// No columns specified, assume insertion into all columns
-		// Intentionally don't populate 'column_index_map' as an indication of this
+		// insert by position and no columns specified - insertion into all columns of the table
+		// intentionally don't populate 'column_index_map' as an indication of this
 		for (auto &col : table.GetColumns().Physical()) {
 			named_column_map.push_back(col.Logical());
 			insert->expected_types.push_back(col.Type());
@@ -454,7 +478,6 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	idx_t expected_columns = stmt.columns.empty() ? table.GetColumns().PhysicalColumnCount() : stmt.columns.size();
 
 	// special case: check if we are inserting from a VALUES statement
-	auto values_list = stmt.GetValuesList();
 	if (values_list) {
 		auto &expr_list = values_list->Cast<ExpressionListRef>();
 		expr_list.expected_types.resize(expected_columns);
@@ -487,10 +510,12 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	// parse select statement and add to logical plan
 	unique_ptr<LogicalOperator> root;
 	if (stmt.select_statement) {
-		auto select_binder = Binder::CreateBinder(context, this);
-		auto root_select = select_binder->Bind(*stmt.select_statement);
-		MoveCorrelatedExpressions(*select_binder);
-
+		if (stmt.column_order == InsertColumnOrder::INSERT_BY_POSITION) {
+			auto select_binder = Binder::CreateBinder(context, this);
+			root_select = select_binder->Bind(*stmt.select_statement);
+			MoveCorrelatedExpressions(*select_binder);
+		}
+		// inserting from a select - check if the column count matches
 		CheckInsertColumnCountMismatch(expected_columns, root_select.types.size(), !stmt.columns.empty(),
 		                               table.name.c_str());
 

package/src/duckdb/src/planner/logical_operator.cpp

@@ -344,10 +344,9 @@ unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deseriali
 	case LogicalOperatorType::LOGICAL_ATTACH:
 	case LogicalOperatorType::LOGICAL_TRANSACTION:
 	case LogicalOperatorType::LOGICAL_DROP:
+	case LogicalOperatorType::LOGICAL_DETACH:
 		result = LogicalSimple::Deserialize(state, reader);
 		break;
-	case LogicalOperatorType::LOGICAL_DETACH:
-		throw SerializationException("Logical Detach does not support serialization");
 	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:
 		result = LogicalExtensionOperator::Deserialize(state, reader);
 		break;

package/src/duckdb/src/planner/operator/logical_create_index.cpp

@@ -7,43 +7,34 @@
 namespace duckdb {
 
 void LogicalCreateIndex::Serialize(FieldWriter &writer) const {
-
 	writer.WriteOptional(info);
-	table.Serialize(writer.GetSerializer());
+	writer.WriteString(table.catalog.GetName());
+	writer.WriteString(table.schema.name);
+	writer.WriteString(table.name);
 	FunctionSerializer::SerializeBase<TableFunction>(writer, function, bind_data.get());
 	writer.WriteSerializableList(unbound_expressions);
-
-	writer.Finalize();
 }
 
 unique_ptr<LogicalOperator> LogicalCreateIndex::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-
 	auto &context = state.gstate.context;
-	auto catalog_info = TableCatalogEntry::Deserialize(reader.GetSource(), context);
-
-	auto &table =
-	    Catalog::GetEntry<TableCatalogEntry>(context, catalog_info->catalog, catalog_info->schema, catalog_info->table);
-	auto unbound_expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-
-	auto create_info = reader.ReadOptional<CreateInfo>(nullptr);
-	if (create_info->type != CatalogType::INDEX_ENTRY) {
-		throw InternalException("Unexpected type: '%s', expected '%s'", CatalogTypeToString(create_info->type),
-		                        CatalogTypeToString(CatalogType::INDEX_ENTRY));
-	}
-
-	CreateInfo *raw_create_info_ptr = create_info.release();
-	CreateIndexInfo *raw_create_index_info_ptr = static_cast<CreateIndexInfo *>(raw_create_info_ptr);
-	unique_ptr<CreateIndexInfo> uptr_create_index_info = unique_ptr<CreateIndexInfo> {raw_create_index_info_ptr};
-	auto info = unique_ptr<CreateIndexInfo> {static_cast<CreateIndexInfo *>(create_info.release())};
 
+	auto info = reader.ReadOptional<CreateInfo>(nullptr);
+	auto catalog = reader.ReadRequired<string>();
+	auto schema = reader.ReadRequired<string>();
+	auto table_name = reader.ReadRequired<string>();
 	unique_ptr<FunctionData> bind_data;
 	bool has_deserialize;
 	auto function = FunctionSerializer::DeserializeBaseInternal<TableFunction, TableFunctionCatalogEntry>(
 	    reader, state.gstate, CatalogType::TABLE_FUNCTION_ENTRY, bind_data, has_deserialize);
-
-	reader.Finalize();
-	return make_uniq<LogicalCreateIndex>(std::move(bind_data), std::move(info), std::move(unbound_expressions), table,
-	                                     std::move(function));
+	auto unbound_expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
+	if (info->type != CatalogType::INDEX_ENTRY) {
+		throw InternalException("Unexpected type: '%s', expected '%s'", CatalogTypeToString(info->type),
+		                        CatalogTypeToString(CatalogType::INDEX_ENTRY));
+	}
+	auto index_info = unique_ptr_cast<CreateInfo, CreateIndexInfo>(std::move(info));
+	auto &table = Catalog::GetEntry<TableCatalogEntry>(context, catalog, schema, table_name);
+	return make_uniq<LogicalCreateIndex>(std::move(bind_data), std::move(index_info), std::move(unbound_expressions),
+	                                     table, std::move(function));
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_insert.cpp

@@ -25,6 +25,16 @@ void LogicalInsert::Serialize(FieldWriter &writer) const {
 	writer.WriteField(return_chunk);
 	writer.WriteSerializableList(bound_defaults);
 	writer.WriteField(action_type);
+	writer.WriteRegularSerializableList(expected_set_types);
+	writer.WriteList<column_t>(on_conflict_filter);
+	writer.WriteOptional(on_conflict_condition);
+	writer.WriteOptional(do_update_condition);
+	writer.WriteIndexList(set_columns);
+	writer.WriteRegularSerializableList(set_types);
+	writer.WriteField(excluded_table_index);
+	writer.WriteList<column_t>(columns_to_fetch);
+	writer.WriteList<column_t>(source_columns);
+	writer.WriteSerializableList<Expression>(expressions);
 }
 
 unique_ptr<LogicalOperator> LogicalInsert::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
@@ -42,6 +52,16 @@ unique_ptr<LogicalOperator> LogicalInsert::Deserialize(LogicalDeserializationSta
 	auto return_chunk = reader.ReadRequired<bool>();
 	auto bound_defaults = reader.ReadRequiredSerializableList<Expression>(state.gstate);
 	auto action_type = reader.ReadRequired<OnConflictAction>();
+	auto expected_set_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
+	auto on_conflict_filter = reader.ReadRequiredSet<column_t, unordered_set<column_t>>();
+	auto on_conflict_condition = reader.ReadOptional<Expression>(nullptr, state.gstate);
+	auto do_update_condition = reader.ReadOptional<Expression>(nullptr, state.gstate);
+	auto set_columns = reader.ReadRequiredIndexList<PhysicalIndex>();
+	auto set_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
+	auto excluded_table_index = reader.ReadRequired<idx_t>();
+	auto columns_to_fetch = reader.ReadRequiredList<column_t>();
+	auto source_columns = reader.ReadRequiredList<column_t>();
+	auto expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
 
 	auto &catalog = Catalog::GetCatalog(context, info->catalog);
 
@@ -54,6 +74,16 @@ unique_ptr<LogicalOperator> LogicalInsert::Deserialize(LogicalDeserializationSta
 	result->expected_types = expected_types;
 	result->bound_defaults = std::move(bound_defaults);
 	result->action_type = action_type;
+	result->expected_set_types = std::move(expected_set_types);
+	result->on_conflict_filter = std::move(on_conflict_filter);
+	result->on_conflict_condition = std::move(on_conflict_condition);
+	result->do_update_condition = std::move(do_update_condition);
+	result->set_columns = std::move(set_columns);
+	result->set_types = std::move(set_types);
+	result->excluded_table_index = excluded_table_index;
+	result->columns_to_fetch = std::move(columns_to_fetch);
+	result->source_columns = std::move(source_columns);
+	result->expressions = std::move(expressions);
 	return std::move(result);
 }