duckdb 0.8.2-dev1968.0 → 0.8.2-dev2044.0

package/src/duckdb/src/parser/result_modifier.cpp

@@ -179,19 +179,6 @@ void OrderByNode::Serialize(Serializer &serializer) const {
 	writer.Finalize();
 }
 
-void OrderByNode::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("type", type);
-	serializer.WriteProperty("null_order", null_order);
-	serializer.WriteProperty("expression", expression);
-}
-
-OrderByNode OrderByNode::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto type = deserializer.ReadProperty<OrderType>("type");
-	auto null_order = deserializer.ReadProperty<OrderByNullType>("null_order");
-	auto expression = deserializer.ReadProperty<unique_ptr<ParsedExpression>>("expression");
-	return OrderByNode(type, null_order, std::move(expression));
-}
-
 OrderByNode OrderByNode::Deserialize(Deserializer &source) {
 	FieldReader reader(source);
 	auto type = reader.ReadRequired<OrderType>();

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

@@ -17,22 +17,12 @@ void SelectStatement::Serialize(Serializer &serializer) const {
 	node->Serialize(serializer);
 }
 
-void SelectStatement::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("node", node);
-}
-
 unique_ptr<SelectStatement> SelectStatement::Deserialize(Deserializer &source) {
 	auto result = make_uniq<SelectStatement>();
 	result->node = QueryNode::Deserialize(source);
 	return result;
 }
 
-unique_ptr<SelectStatement> SelectStatement::FormatDeserialize(FormatDeserializer &deserializer) {
-	auto result = make_uniq<SelectStatement>();
-	deserializer.ReadProperty("node", result->node);
-	return result;
-}
-
 bool SelectStatement::Equals(const SQLStatement &other_p) const {
 	if (type != other_p.type) {
 		return false;

package/src/duckdb/src/parser/tableref/pivotref.cpp

@@ -130,13 +130,6 @@ void PivotColumn::Serialize(Serializer &serializer) const {
 	writer.Finalize();
 }
 
-void PivotColumn::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("pivot_expressions", pivot_expressions);
-	serializer.WriteProperty("unpivot_names", unpivot_names);
-	serializer.WriteProperty("entries", entries);
-	serializer.WriteProperty("pivot_enum", pivot_enum);
-}
-
 PivotColumn PivotColumn::Deserialize(Deserializer &source) {
 	PivotColumn result;
 	FieldReader reader(source);
@@ -148,15 +141,6 @@ PivotColumn PivotColumn::Deserialize(Deserializer &source) {
 	return result;
 }
 
-PivotColumn PivotColumn::FormatDeserialize(FormatDeserializer &source) {
-	PivotColumn result;
-	source.ReadProperty("pivot_expressions", result.pivot_expressions);
-	source.ReadProperty("unpivot_names", result.unpivot_names);
-	source.ReadProperty("entries", result.entries);
-	source.ReadProperty("pivot_enum", result.pivot_enum);
-	return result;
-}
-
 //===--------------------------------------------------------------------===//
 // PivotColumnEntry
 //===--------------------------------------------------------------------===//

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

@@ -57,12 +57,13 @@ unique_ptr<CreateStatement> Transformer::TransformCreateIndex(duckdb_libpgquery:
 	info->expressions = TransformIndexParameters(*stmt.indexParams, stmt.relation->relname);
 
 	info->index_type = StringToIndexType(string(stmt.accessMethod));
-	auto tableref = make_uniq<BaseTableRef>();
-	tableref->table_name = stmt.relation->relname;
 	if (stmt.relation->schemaname) {
-		tableref->schema_name = stmt.relation->schemaname;
+		info->schema = stmt.relation->schemaname;
 	}
-	info->table = std::move(tableref);
+	if (stmt.relation->catalogname) {
+		info->catalog = stmt.relation->catalogname;
+	}
+	info->table = stmt.relation->relname;
 	if (stmt.idxname) {
 		info->index_name = stmt.idxname;
 	} else {

package/src/duckdb/src/planner/binder/query_node/plan_subquery.cpp

@@ -160,7 +160,7 @@ CreateDuplicateEliminatedJoin(const vector<CorrelatedColumnInfo> &correlated_col
 	for (idx_t i = 0; i < correlated_columns.size(); i++) {
 		auto &col = correlated_columns[i];
 		delim_join->duplicate_eliminated_columns.push_back(make_uniq<BoundColumnRefExpression>(col.type, col.binding));
-		delim_join->delim_types.push_back(col.type);
+		delim_join->mark_types.push_back(col.type);
 	}
 	return delim_join;
 }

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

@@ -529,7 +529,12 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		auto &base = stmt.info->Cast<CreateIndexInfo>();
 
 		// visit the table reference
-		auto bound_table = Bind(*base.table);
+		auto table_ref = make_uniq<BaseTableRef>();
+		table_ref->catalog_name = base.catalog;
+		table_ref->schema_name = base.schema;
+		table_ref->table_name = base.table;
+
+		auto bound_table = Bind(*table_ref);
 		if (bound_table->type != TableReferenceType::BASE_TABLE) {
 			throw BinderException("Can only create an index over a base table!");
 		}

package/src/duckdb/src/planner/expression/bound_between_expression.cpp

@@ -4,6 +4,10 @@
 
 namespace duckdb {
 
+BoundBetweenExpression::BoundBetweenExpression()
+    : Expression(ExpressionType::COMPARE_BETWEEN, ExpressionClass::BOUND_BETWEEN, LogicalType::BOOLEAN) {
+}
+
 BoundBetweenExpression::BoundBetweenExpression(unique_ptr<Expression> input, unique_ptr<Expression> lower,
                                                unique_ptr<Expression> upper, bool lower_inclusive, bool upper_inclusive)
     : Expression(ExpressionType::COMPARE_BETWEEN, ExpressionClass::BOUND_BETWEEN, LogicalType::BOOLEAN),

package/src/duckdb/src/planner/expression/bound_cast_expression.cpp

@@ -8,12 +8,25 @@
 
 namespace duckdb {
 
+static BoundCastInfo BindCastFunction(ClientContext &context, const LogicalType &source, const LogicalType &target) {
+	auto &cast_functions = DBConfig::GetConfig(context).GetCastFunctions();
+	GetCastFunctionInput input(context);
+	return cast_functions.GetCastFunction(source, target, input);
+}
+
 BoundCastExpression::BoundCastExpression(unique_ptr<Expression> child_p, LogicalType target_type_p,
                                          BoundCastInfo bound_cast_p, bool try_cast_p)
     : Expression(ExpressionType::OPERATOR_CAST, ExpressionClass::BOUND_CAST, std::move(target_type_p)),
       child(std::move(child_p)), try_cast(try_cast_p), bound_cast(std::move(bound_cast_p)) {
 }
 
+BoundCastExpression::BoundCastExpression(ClientContext &context, unique_ptr<Expression> child_p,
+                                         LogicalType target_type_p)
+    : Expression(ExpressionType::OPERATOR_CAST, ExpressionClass::BOUND_CAST, std::move(target_type_p)),
+      child(std::move(child_p)), try_cast(false),
+      bound_cast(BindCastFunction(context, child->return_type, return_type)) {
+}
+
 unique_ptr<Expression> AddCastExpressionInternal(unique_ptr<Expression> expr, const LogicalType &target_type,
                                                  BoundCastInfo bound_cast, bool try_cast) {
 	if (expr->return_type == target_type) {
@@ -30,12 +43,6 @@ unique_ptr<Expression> AddCastExpressionInternal(unique_ptr<Expression> expr, co
 	return make_uniq<BoundCastExpression>(std::move(expr), target_type, std::move(bound_cast), try_cast);
 }
 
-static BoundCastInfo BindCastFunction(ClientContext &context, const LogicalType &source, const LogicalType &target) {
-	auto &cast_functions = DBConfig::GetConfig(context).GetCastFunctions();
-	GetCastFunctionInput input(context);
-	return cast_functions.GetCastFunction(source, target, input);
-}
-
 unique_ptr<Expression> AddCastToTypeInternal(unique_ptr<Expression> expr, const LogicalType &target_type,
                                              CastFunctionSet &cast_functions, GetCastFunctionInput &get_input,
                                              bool try_cast) {

package/src/duckdb/src/planner/expression/bound_parameter_expression.cpp

@@ -12,6 +12,23 @@ BoundParameterExpression::BoundParameterExpression(idx_t parameter_nr)
       parameter_nr(parameter_nr) {
 }
 
+BoundParameterExpression::BoundParameterExpression(bound_parameter_map_t &global_parameter_set, idx_t parameter_nr,
+                                                   LogicalType return_type,
+                                                   shared_ptr<BoundParameterData> parameter_data)
+    : Expression(ExpressionType::VALUE_PARAMETER, ExpressionClass::BOUND_PARAMETER, std::move(return_type)),
+      parameter_nr(parameter_nr) {
+	// check if we have already deserialized a parameter with this number
+	auto entry = global_parameter_set.find(parameter_nr);
+	if (entry == global_parameter_set.end()) {
+		// we have not - store the entry we deserialized from this parameter expression
+		global_parameter_set[parameter_nr] = parameter_data;
+	} else {
+		// we have! use the previously deserialized entry
+		parameter_data = entry->second;
+	}
+	this->parameter_data = std::move(parameter_data);
+}
+
 void BoundParameterExpression::Invalidate(Expression &expr) {
 	if (expr.type != ExpressionType::VALUE_PARAMETER) {
 		throw InternalException("BoundParameterExpression::Invalidate requires a parameter as input");
@@ -75,19 +92,10 @@ unique_ptr<Expression> BoundParameterExpression::Deserialize(ExpressionDeseriali
                                                              FieldReader &reader) {
 	auto &global_parameter_set = state.gstate.parameter_data;
 	auto parameter_nr = reader.ReadRequired<idx_t>();
-	auto result = make_uniq<BoundParameterExpression>(parameter_nr);
-	result->return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
+	auto return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
 	auto parameter_data = reader.ReadRequiredSerializable<BoundParameterData, shared_ptr<BoundParameterData>>();
-	// check if we have already deserialized a parameter with this number
-	auto entry = global_parameter_set.find(parameter_nr);
-	if (entry == global_parameter_set.end()) {
-		// we have not - store the entry we deserialized from this parameter expression
-		global_parameter_set[parameter_nr] = parameter_data;
-	} else {
-		// we have! use the previously deserialized entry
-		parameter_data = entry->second;
-	}
-	result->parameter_data = std::move(parameter_data);
+	auto result = unique_ptr<BoundParameterExpression>(new BoundParameterExpression(
+	    global_parameter_set, parameter_nr, std::move(return_type), std::move(parameter_data)));
 	return std::move(result);
 }
 

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

@@ -9,6 +9,8 @@
 #include "duckdb/planner/operator/list.hpp"
 #include "duckdb/planner/operator/logical_extension_operator.hpp"
 #include "duckdb/planner/operator/logical_dependent_join.hpp"
+#include "duckdb/common/serializer/binary_serializer.hpp"
+#include "duckdb/common/serializer/binary_deserializer.hpp"
 
 namespace duckdb {
 
@@ -134,7 +136,7 @@ void LogicalOperator::Verify(ClientContext &context) {
 			expressions[expr_idx]->Serialize(serializer);
 		} catch (NotImplementedException &ex) {
 			// ignore for now (FIXME)
-			return;
+			continue;
 		}
 
 		auto data = serializer.GetData();
@@ -142,6 +144,16 @@ void LogicalOperator::Verify(ClientContext &context) {
 
 		PlanDeserializationState state(context);
 		auto deserialized_expression = Expression::Deserialize(deserializer, state);
+
+		// format (de)serialization of expressions
+		try {
+			auto blob = BinarySerializer::Serialize(*expressions[expr_idx]);
+			bound_parameter_map_t parameters;
+			auto result = BinaryDeserializer::Deserialize<Expression>(context, parameters, blob.data(), blob.size());
+			result->Hash();
+		} catch (SerializationException &ex) {
+			// pass
+		}
 		// FIXME: expressions might not be equal yet because of statistics propagation
 		continue;
 		D_ASSERT(Expression::Equals(expressions[expr_idx], deserialized_expression));

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

@@ -1,6 +1,7 @@
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
+#include "duckdb/planner/operator/logical_delim_join.hpp"
 #include "duckdb/planner/expression/bound_comparison_expression.hpp"
 #include "duckdb/common/enum_util.hpp"
 namespace duckdb {
@@ -23,15 +24,15 @@ string LogicalComparisonJoin::ParamsToString() const {
 
 void LogicalComparisonJoin::Serialize(FieldWriter &writer) const {
 	LogicalJoin::Serialize(writer);
+	writer.WriteRegularSerializableList(mark_types);
 	writer.WriteRegularSerializableList(conditions);
-	writer.WriteRegularSerializableList(delim_types);
 }
 
 void LogicalComparisonJoin::Deserialize(LogicalComparisonJoin &comparison_join, LogicalDeserializationState &state,
                                         FieldReader &reader) {
 	LogicalJoin::Deserialize(comparison_join, state, reader);
+	comparison_join.mark_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
 	comparison_join.conditions = reader.ReadRequiredSerializableList<JoinCondition, JoinCondition>(state.gstate);
-	comparison_join.delim_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
 }
 
 unique_ptr<LogicalOperator> LogicalComparisonJoin::Deserialize(LogicalDeserializationState &state,
@@ -41,4 +42,17 @@ unique_ptr<LogicalOperator> LogicalComparisonJoin::Deserialize(LogicalDeserializ
 	return std::move(result);
 }
 
+unique_ptr<LogicalOperator> LogicalComparisonJoin::FromDelimJoin(LogicalDelimJoin &delim_join) {
+	auto new_join = make_uniq<LogicalComparisonJoin>(delim_join.join_type);
+	new_join->children = std::move(delim_join.children);
+	new_join->conditions = std::move(delim_join.conditions);
+	new_join->types = std::move(delim_join.types);
+	new_join->mark_types = std::move(delim_join.mark_types);
+	new_join->mark_index = delim_join.mark_index;
+	new_join->left_projection_map = std::move(delim_join.left_projection_map);
+	new_join->right_projection_map = std::move(delim_join.right_projection_map);
+	new_join->join_stats = std::move(delim_join.join_stats);
+	return std::move(new_join);
+}
+
 } // namespace duckdb

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

@@ -2,6 +2,16 @@
 
 namespace duckdb {
 
+LogicalCreate::LogicalCreate(LogicalOperatorType type, unique_ptr<CreateInfo> info,
+                             optional_ptr<SchemaCatalogEntry> schema)
+    : LogicalOperator(type), schema(schema), info(std::move(info)) {
+}
+
+LogicalCreate::LogicalCreate(LogicalOperatorType type, ClientContext &context, unique_ptr<CreateInfo> info_p)
+    : LogicalOperator(type), info(std::move(info_p)) {
+	this->schema = Catalog::GetSchema(context, info->catalog, info->schema, OnEntryNotFound::RETURN_NULL);
+}
+
 void LogicalCreate::Serialize(FieldWriter &writer) const {
 	info->Serialize(writer.GetSerializer());
 }
@@ -18,4 +28,8 @@ idx_t LogicalCreate::EstimateCardinality(ClientContext &context) {
 	return 1;
 }
 
+void LogicalCreate::ResolveTypes() {
+	types.emplace_back(LogicalType::BIGINT);
+}
+
 } // namespace duckdb

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

@@ -6,6 +6,22 @@
 
 namespace duckdb {
 
+LogicalCreateIndex::LogicalCreateIndex(unique_ptr<FunctionData> bind_data_p, unique_ptr<CreateIndexInfo> info_p,
+                                       vector<unique_ptr<Expression>> expressions_p, TableCatalogEntry &table_p,
+                                       TableFunction function_p)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_INDEX), bind_data(std::move(bind_data_p)),
+      info(std::move(info_p)), table(table_p), function(std::move(function_p)) {
+
+	for (auto &expr : expressions_p) {
+		this->unbound_expressions.push_back(expr->Copy());
+	}
+	this->expressions = std::move(expressions_p);
+
+	if (info->column_ids.empty()) {
+		throw BinderException("CREATE INDEX does not refer to any columns in the base table!");
+	}
+}
+
 void LogicalCreateIndex::Serialize(FieldWriter &writer) const {
 	writer.WriteOptional(info);
 	writer.WriteString(table.catalog.GetName());
@@ -37,4 +53,8 @@ unique_ptr<LogicalOperator> LogicalCreateIndex::Deserialize(LogicalDeserializati
 	                                     table, std::move(function));
 }
 
+void LogicalCreateIndex::ResolveTypes() {
+	types.emplace_back(LogicalType::BIGINT);
+}
+
 } // namespace duckdb

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

@@ -2,6 +2,18 @@
 
 namespace duckdb {
 
+LogicalCreateTable::LogicalCreateTable(SchemaCatalogEntry &schema, unique_ptr<BoundCreateTableInfo> info)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_TABLE), schema(schema), info(std::move(info)) {
+}
+
+LogicalCreateTable::LogicalCreateTable(ClientContext &context, const string &catalog, const string &schema,
+                                       unique_ptr<CreateInfo> unbound_info)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_TABLE), schema(Catalog::GetSchema(context, catalog, schema)) {
+	D_ASSERT(unbound_info->type == CatalogType::TABLE_ENTRY);
+	auto binder = Binder::CreateBinder(context);
+	info = binder->BindCreateTableInfo(unique_ptr_cast<CreateInfo, CreateTableInfo>(std::move(unbound_info)));
+}
+
 void LogicalCreateTable::Serialize(FieldWriter &writer) const {
 	writer.WriteSerializable(*info);
 }
@@ -16,4 +28,8 @@ idx_t LogicalCreateTable::EstimateCardinality(ClientContext &context) {
 	return 1;
 }
 
+void LogicalCreateTable::ResolveTypes() {
+	types.emplace_back(LogicalType::BIGINT);
+}
+
 } // namespace duckdb

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

@@ -11,6 +11,11 @@ LogicalDelete::LogicalDelete(TableCatalogEntry &table, idx_t table_index)
       return_chunk(false) {
 }
 
+LogicalDelete::LogicalDelete(ClientContext &context, const string &catalog, const string &schema, const string &table)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_DELETE),
+      table(Catalog::GetEntry<TableCatalogEntry>(context, catalog, schema, table)) {
+}
+
 void LogicalDelete::Serialize(FieldWriter &writer) const {
 	table.Serialize(writer.GetSerializer());
 	writer.WriteField(table_index);
@@ -20,9 +25,11 @@ void LogicalDelete::Serialize(FieldWriter &writer) const {
 
 unique_ptr<LogicalOperator> LogicalDelete::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
 	auto &context = state.gstate.context;
-	auto info = TableCatalogEntry::Deserialize(reader.GetSource(), context);
+	auto info = TableCatalogEntry::Deserialize(reader.GetSource());
+	auto &table_info = info->Cast<CreateTableInfo>();
 
-	auto &table_catalog_entry = Catalog::GetEntry<TableCatalogEntry>(context, info->catalog, info->schema, info->table);
+	auto &table_catalog_entry =
+	    Catalog::GetEntry<TableCatalogEntry>(context, info->catalog, info->schema, table_info.table);
 
 	auto table_index = reader.ReadRequired<idx_t>();
 	auto result = make_uniq<LogicalDelete>(table_catalog_entry, table_index);

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

@@ -9,10 +9,8 @@ LogicalDelimJoin::LogicalDelimJoin(JoinType type)
 
 void LogicalDelimJoin::Serialize(FieldWriter &writer) const {
 	LogicalComparisonJoin::Serialize(writer);
-	if (type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
-		D_ASSERT(duplicate_eliminated_columns.empty());
-		// if the delim join has no delim columns anymore it is turned into a regular comparison join
-		return;
+	if (type != LogicalOperatorType::LOGICAL_DELIM_JOIN) {
+		throw InternalException("LogicalDelimJoin needs to have type LOGICAL_DELIM_JOIN");
 	}
 	writer.WriteSerializableList(duplicate_eliminated_columns);
 }

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

@@ -4,6 +4,14 @@
 
 namespace duckdb {
 
+LogicalDistinct::LogicalDistinct(DistinctType distinct_type)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_DISTINCT), distinct_type(distinct_type) {
+}
+LogicalDistinct::LogicalDistinct(vector<unique_ptr<Expression>> targets, DistinctType distinct_type)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_DISTINCT), distinct_type(distinct_type),
+      distinct_targets(std::move(targets)) {
+}
+
 string LogicalDistinct::ParamsToString() const {
 	string result = LogicalOperator::ParamsToString();
 	if (!distinct_targets.empty()) {
@@ -13,6 +21,7 @@ string LogicalDistinct::ParamsToString() const {
 
 	return result;
 }
+
 void LogicalDistinct::Serialize(FieldWriter &writer) const {
 	writer.WriteField<DistinctType>(distinct_type);
 	writer.WriteSerializableList(distinct_targets);
@@ -28,4 +37,8 @@ unique_ptr<LogicalOperator> LogicalDistinct::Deserialize(LogicalDeserializationS
 	return std::move(ret);
 }
 
+void LogicalDistinct::ResolveTypes() {
+	types = children[0]->types;
+}
+
 } // namespace duckdb

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

@@ -12,11 +12,11 @@ void LogicalExplain::Serialize(FieldWriter &writer) const {
 
 unique_ptr<LogicalOperator> LogicalExplain::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
 	auto explain_type = reader.ReadRequired<ExplainType>();
-	// TODO(stephwang) review if unique_ptr<LogicalOperator> plan is needed
 	auto result = unique_ptr<LogicalExplain>(new LogicalExplain(explain_type));
 	result->physical_plan = reader.ReadRequired<string>();
 	result->logical_plan_unopt = reader.ReadRequired<string>();
 	result->logical_plan_opt = reader.ReadRequired<string>();
 	return std::move(result);
 }
+
 } // namespace duckdb

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

@@ -12,6 +12,11 @@ LogicalInsert::LogicalInsert(TableCatalogEntry &table, idx_t table_index)
       action_type(OnConflictAction::THROW) {
 }
 
+LogicalInsert::LogicalInsert(ClientContext &context, const string &catalog, const string &schema, const string &table)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_INSERT),
+      table(Catalog::GetEntry<TableCatalogEntry>(context, catalog, schema, table)) {
+}
+
 void LogicalInsert::Serialize(FieldWriter &writer) const {
 	writer.WriteField<idx_t>(insert_values.size());
 	for (auto &entry : insert_values) {
@@ -47,7 +52,7 @@ unique_ptr<LogicalOperator> LogicalInsert::Deserialize(LogicalDeserializationSta
 
 	auto column_index_map = reader.ReadRequiredList<idx_t, physical_index_vector_t<idx_t>>();
 	auto expected_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
-	auto info = TableCatalogEntry::Deserialize(reader.GetSource(), context);
+	auto info = TableCatalogEntry::Deserialize(reader.GetSource());
 	auto table_index = reader.ReadRequired<idx_t>();
 	auto return_chunk = reader.ReadRequired<bool>();
 	auto bound_defaults = reader.ReadRequiredSerializableList<Expression>(state.gstate);
@@ -65,7 +70,8 @@ unique_ptr<LogicalOperator> LogicalInsert::Deserialize(LogicalDeserializationSta
 
 	auto &catalog = Catalog::GetCatalog(context, info->catalog);
 
-	auto &table_catalog_entry = catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->table);
+	auto &table_catalog_entry =
+	    catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->Cast<CreateTableInfo>().table);
 	auto result = make_uniq<LogicalInsert>(table_catalog_entry, table_index);
 	result->type = state.type;
 	result->return_chunk = return_chunk;

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

@@ -10,8 +10,9 @@ void LogicalMaterializedCTE::Serialize(FieldWriter &writer) const {
 
 unique_ptr<LogicalOperator> LogicalMaterializedCTE::Deserialize(LogicalDeserializationState &state,
                                                                 FieldReader &reader) {
-	auto table_index = reader.ReadRequired<idx_t>();
-	return unique_ptr<LogicalMaterializedCTE>(new LogicalMaterializedCTE(table_index));
+	auto result = unique_ptr<LogicalMaterializedCTE>(new LogicalMaterializedCTE());
+	result->table_index = reader.ReadRequired<idx_t>();
+	return std::move(result);
 }
 
 vector<idx_t> LogicalMaterializedCTE::GetTableIndex() const {

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

@@ -4,6 +4,45 @@
 
 namespace duckdb {
 
+LogicalOrder::LogicalOrder(vector<BoundOrderByNode> orders)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_ORDER_BY), orders(std::move(orders)) {
+}
+
+vector<ColumnBinding> LogicalOrder::GetColumnBindings() {
+	auto child_bindings = children[0]->GetColumnBindings();
+	if (projections.empty()) {
+		return child_bindings;
+	}
+
+	vector<ColumnBinding> result;
+	for (auto &col_idx : projections) {
+		result.push_back(child_bindings[col_idx]);
+	}
+	return result;
+}
+
+string LogicalOrder::ParamsToString() const {
+	string result = "ORDERS:\n";
+	for (idx_t i = 0; i < orders.size(); i++) {
+		if (i > 0) {
+			result += "\n";
+		}
+		result += orders[i].expression->GetName();
+	}
+	return result;
+}
+
+void LogicalOrder::ResolveTypes() {
+	const auto child_types = children[0]->types;
+	if (projections.empty()) {
+		types = child_types;
+	} else {
+		for (auto &col_idx : projections) {
+			types.push_back(child_types[col_idx]);
+		}
+	}
+}
+
 void LogicalOrder::Serialize(FieldWriter &writer) const {
 	writer.WriteRegularSerializableList(orders);
 	writer.WriteList<idx_t>(projections);

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

@@ -4,6 +4,9 @@
 
 namespace duckdb {
 
+LogicalPivot::LogicalPivot() : LogicalOperator(LogicalOperatorType::LOGICAL_PIVOT) {
+}
+
 LogicalPivot::LogicalPivot(idx_t pivot_idx, unique_ptr<LogicalOperator> plan, BoundPivotInfo info_p)
     : LogicalOperator(LogicalOperatorType::LOGICAL_PIVOT), pivot_index(pivot_idx), bound_pivot(std::move(info_p)) {
 	D_ASSERT(plan);

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

@@ -12,11 +12,11 @@ void LogicalRecursiveCTE::Serialize(FieldWriter &writer) const {
 }
 
 unique_ptr<LogicalOperator> LogicalRecursiveCTE::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	auto table_index = reader.ReadRequired<idx_t>();
-	auto column_count = reader.ReadRequired<idx_t>();
-	auto union_all = reader.ReadRequired<bool>();
-	// TODO(stephwang): review if unique_ptr<LogicalOperator> plan is needed
-	return unique_ptr<LogicalRecursiveCTE>(new LogicalRecursiveCTE(table_index, column_count, union_all));
+	auto result = unique_ptr<LogicalRecursiveCTE>(new LogicalRecursiveCTE());
+	result->table_index = reader.ReadRequired<idx_t>();
+	result->column_count = reader.ReadRequired<idx_t>();
+	result->union_all = reader.ReadRequired<bool>();
+	return std::move(result);
 }
 
 vector<idx_t> LogicalRecursiveCTE::GetTableIndex() const {

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

@@ -3,6 +3,9 @@
 
 namespace duckdb {
 
+LogicalSample::LogicalSample() : LogicalOperator(LogicalOperatorType::LOGICAL_SAMPLE) {
+}
+
 LogicalSample::LogicalSample(unique_ptr<SampleOptions> sample_options_p, unique_ptr<LogicalOperator> child)
     : LogicalOperator(LogicalOperatorType::LOGICAL_SAMPLE), sample_options(std::move(sample_options_p)) {
 	children.push_back(std::move(child));

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

@@ -10,6 +10,11 @@ LogicalUpdate::LogicalUpdate(TableCatalogEntry &table)
     : LogicalOperator(LogicalOperatorType::LOGICAL_UPDATE), table(table), table_index(0), return_chunk(false) {
 }
 
+LogicalUpdate::LogicalUpdate(ClientContext &context, const string &catalog, const string &schema, const string &table)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_UPDATE),
+      table(Catalog::GetEntry<TableCatalogEntry>(context, catalog, schema, table)) {
+}
+
 void LogicalUpdate::Serialize(FieldWriter &writer) const {
 	table.Serialize(writer.GetSerializer());
 	writer.WriteField(table_index);
@@ -22,10 +27,11 @@ void LogicalUpdate::Serialize(FieldWriter &writer) const {
 
 unique_ptr<LogicalOperator> LogicalUpdate::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
 	auto &context = state.gstate.context;
-	auto info = TableCatalogEntry::Deserialize(reader.GetSource(), context);
+	auto info = TableCatalogEntry::Deserialize(reader.GetSource());
 	auto &catalog = Catalog::GetCatalog(context, info->catalog);
 
-	auto &table_catalog_entry = catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->table);
+	auto &table_catalog_entry =
+	    catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->Cast<CreateTableInfo>().table);
 	auto result = make_uniq<LogicalUpdate>(table_catalog_entry);
 	result->table_index = reader.ReadRequired<idx_t>();
 	result->return_chunk = reader.ReadRequired<bool>();

package/src/duckdb/src/planner/parsed_data/bound_create_table_info.cpp

@@ -2,8 +2,11 @@
 #include "duckdb/parser/parsed_data/create_schema_info.hpp"
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/common/field_writer.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
+
 void BoundCreateTableInfo::Serialize(Serializer &serializer) const {
 	serializer.WriteOptional(base);
 }
@@ -11,10 +14,9 @@ void BoundCreateTableInfo::Serialize(Serializer &serializer) const {
 unique_ptr<BoundCreateTableInfo> BoundCreateTableInfo::Deserialize(Deserializer &source,
                                                                    PlanDeserializationState &state) {
 	auto info = source.ReadOptional<CreateInfo>();
-	auto schema_name = info->schema;
-	auto catalog = info->catalog;
 	auto binder = Binder::CreateBinder(state.context);
 	auto bound_info = binder->BindCreateTableInfo(std::move(info));
 	return bound_info;
 }
+
 } // namespace duckdb