duckdb 0.8.2-dev33.0 → 0.8.2-dev3334.0

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) {
@@ -135,12 +142,10 @@ bool BoundCastExpression::CastIsInvertible(const LogicalType &source_type, const
 	}
 	if (source_type.id() == LogicalTypeId::VARCHAR) {
 		switch (target_type.id()) {
-		case LogicalTypeId::TIME:
 		case LogicalTypeId::TIMESTAMP:
 		case LogicalTypeId::TIMESTAMP_NS:
 		case LogicalTypeId::TIMESTAMP_MS:
 		case LogicalTypeId::TIMESTAMP_SEC:
-		case LogicalTypeId::TIME_TZ:
 		case LogicalTypeId::TIMESTAMP_TZ:
 			return true;
 		default:

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

@@ -3,6 +3,8 @@
 #include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
 #include "duckdb/common/types/hash.hpp"
 #include "duckdb/function/function_serialization.hpp"
+#include "duckdb/common/serializer/format_serializer.hpp"
+#include "duckdb/common/serializer/format_deserializer.hpp"
 
 namespace duckdb {
 
@@ -92,4 +94,24 @@ unique_ptr<Expression> BoundFunctionExpression::Deserialize(ExpressionDeserializ
 	return make_uniq<BoundFunctionExpression>(std::move(return_type), std::move(function), std::move(children),
 	                                          std::move(bind_info), is_operator);
 }
+
+void BoundFunctionExpression::FormatSerialize(FormatSerializer &serializer) const {
+	Expression::FormatSerialize(serializer);
+	serializer.WriteProperty(200, "return_type", return_type);
+	serializer.WriteProperty(201, "children", children);
+	FunctionSerializer::FormatSerialize(serializer, function, bind_info.get());
+	serializer.WriteProperty(202, "is_operator", is_operator);
+}
+
+unique_ptr<Expression> BoundFunctionExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
+	auto children = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "children");
+	auto entry = FunctionSerializer::FormatDeserialize<ScalarFunction, ScalarFunctionCatalogEntry>(
+	    deserializer, CatalogType::SCALAR_FUNCTION_ENTRY, children);
+	auto result = make_uniq<BoundFunctionExpression>(std::move(return_type), std::move(entry.first),
+	                                                 std::move(children), std::move(entry.second));
+	deserializer.ReadProperty(202, "is_operator", result->is_operator);
+	return std::move(result);
+}
+
 } // namespace duckdb

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

@@ -6,10 +6,27 @@
 
 namespace duckdb {
 
-BoundParameterExpression::BoundParameterExpression(idx_t parameter_nr)
+BoundParameterExpression::BoundParameterExpression(const string &identifier)
     : Expression(ExpressionType::VALUE_PARAMETER, ExpressionClass::BOUND_PARAMETER,
                  LogicalType(LogicalTypeId::UNKNOWN)),
-      parameter_nr(parameter_nr) {
+      identifier(identifier) {
+}
+
+BoundParameterExpression::BoundParameterExpression(bound_parameter_map_t &global_parameter_set, string identifier,
+                                                   LogicalType return_type,
+                                                   shared_ptr<BoundParameterData> parameter_data)
+    : Expression(ExpressionType::VALUE_PARAMETER, ExpressionClass::BOUND_PARAMETER, std::move(return_type)),
+      identifier(std::move(identifier)) {
+	// check if we have already deserialized a parameter with this number
+	auto entry = global_parameter_set.find(this->identifier);
+	if (entry == global_parameter_set.end()) {
+		// we have not - store the entry we deserialized from this parameter expression
+		global_parameter_set[this->identifier] = 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) {
@@ -40,7 +57,7 @@ bool BoundParameterExpression::IsFoldable() const {
 }
 
 string BoundParameterExpression::ToString() const {
-	return "$" + to_string(parameter_nr);
+	return "$" + identifier;
 }
 
 bool BoundParameterExpression::Equals(const BaseExpression &other_p) const {
@@ -48,17 +65,17 @@ bool BoundParameterExpression::Equals(const BaseExpression &other_p) const {
 		return false;
 	}
 	auto &other = other_p.Cast<BoundParameterExpression>();
-	return parameter_nr == other.parameter_nr;
+	return StringUtil::CIEquals(identifier, other.identifier);
 }
 
 hash_t BoundParameterExpression::Hash() const {
 	hash_t result = Expression::Hash();
-	result = CombineHash(duckdb::Hash(parameter_nr), result);
+	result = CombineHash(duckdb::Hash(identifier.c_str(), identifier.size()), result);
 	return result;
 }
 
 unique_ptr<Expression> BoundParameterExpression::Copy() {
-	auto result = make_uniq<BoundParameterExpression>(parameter_nr);
+	auto result = make_uniq<BoundParameterExpression>(identifier);
 	result->parameter_data = parameter_data;
 	result->return_type = return_type;
 	result->CopyProperties(*this);
@@ -66,7 +83,7 @@ unique_ptr<Expression> BoundParameterExpression::Copy() {
 }
 
 void BoundParameterExpression::Serialize(FieldWriter &writer) const {
-	writer.WriteField(parameter_nr);
+	writer.WriteString(identifier);
 	writer.WriteSerializable(return_type);
 	writer.WriteSerializable(*parameter_data);
 }
@@ -74,20 +91,11 @@ void BoundParameterExpression::Serialize(FieldWriter &writer) const {
 unique_ptr<Expression> BoundParameterExpression::Deserialize(ExpressionDeserializationState &state,
                                                              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 identifier = reader.ReadRequired<string>();
+	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, std::move(identifier), std::move(return_type), std::move(parameter_data)));
 	return std::move(result);
 }
 

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

@@ -61,10 +61,7 @@ bool BoundWindowExpression::KeysAreCompatible(const BoundWindowExpression &other
 		return false;
 	}
 	for (idx_t i = 0; i < orders.size(); i++) {
-		if (orders[i].type != other.orders[i].type) {
-			return false;
-		}
-		if (!Expression::Equals(*orders[i].expression, *other.orders[i].expression)) {
+		if (!orders[i].Equals(other.orders[i])) {
 			return false;
 		}
 	}
@@ -165,4 +162,51 @@ unique_ptr<Expression> BoundWindowExpression::Deserialize(ExpressionDeserializat
 	return std::move(result);
 }
 
+void BoundWindowExpression::FormatSerialize(FormatSerializer &serializer) const {
+	Expression::FormatSerialize(serializer);
+	serializer.WriteProperty(200, "return_type", return_type);
+	serializer.WriteProperty(201, "children", children);
+	if (type == ExpressionType::WINDOW_AGGREGATE) {
+		D_ASSERT(aggregate);
+		FunctionSerializer::FormatSerialize(serializer, *aggregate, bind_info.get());
+	}
+	serializer.WriteProperty(202, "partitions", partitions);
+	serializer.WriteProperty(203, "orders", orders);
+	serializer.WriteOptionalProperty(204, "filters", filter_expr);
+	serializer.WriteProperty(205, "ignore_nulls", ignore_nulls);
+	serializer.WriteProperty(206, "start", start);
+	serializer.WriteProperty(207, "end", end);
+	serializer.WriteOptionalProperty(208, "start_expr", start_expr);
+	serializer.WriteOptionalProperty(209, "end_expr", end_expr);
+	serializer.WriteOptionalProperty(210, "offset_expr", offset_expr);
+	serializer.WriteOptionalProperty(211, "default_expr", default_expr);
+}
+
+unique_ptr<Expression> BoundWindowExpression::FormatDeserialize(FormatDeserializer &deserializer) {
+	auto expression_type = deserializer.Get<ExpressionType>();
+	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
+	auto children = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "children");
+	unique_ptr<AggregateFunction> aggregate;
+	unique_ptr<FunctionData> bind_info;
+	if (expression_type == ExpressionType::WINDOW_AGGREGATE) {
+		auto entry = FunctionSerializer::FormatDeserialize<AggregateFunction, AggregateFunctionCatalogEntry>(
+		    deserializer, CatalogType::AGGREGATE_FUNCTION_ENTRY, children);
+		aggregate = make_uniq<AggregateFunction>(std::move(entry.first));
+		bind_info = std::move(entry.second);
+	}
+	auto result =
+	    make_uniq<BoundWindowExpression>(expression_type, return_type, std::move(aggregate), std::move(bind_info));
+	deserializer.ReadProperty(202, "partitions", result->partitions);
+	deserializer.ReadProperty(203, "orders", result->orders);
+	deserializer.ReadOptionalProperty(204, "filters", result->filter_expr);
+	deserializer.ReadProperty(205, "ignore_nulls", result->ignore_nulls);
+	deserializer.ReadProperty(206, "start", result->start);
+	deserializer.ReadProperty(207, "end", result->end);
+	deserializer.ReadOptionalProperty(208, "start_expr", result->start_expr);
+	deserializer.ReadOptionalProperty(209, "end_expr", result->end_expr);
+	deserializer.ReadOptionalProperty(210, "offset_expr", result->offset_expr);
+	deserializer.ReadOptionalProperty(211, "default_expr", result->default_expr);
+	return std::move(result);
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/expression_binder/lateral_binder.cpp

@@ -31,41 +31,10 @@ BindResult LateralBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr,
 	if (result.HasError()) {
 		return result;
 	}
-	if (depth > 1) {
-		throw BinderException("Nested lateral joins are not supported yet");
-	}
 	ExtractCorrelatedColumns(*result.expression);
 	return result;
 }
 
-vector<CorrelatedColumnInfo> LateralBinder::ExtractCorrelatedColumns(Binder &binder) {
-
-	if (correlated_columns.empty()) {
-		return binder.correlated_columns;
-	}
-
-	// clear outer
-	correlated_columns.clear();
-	auto all_correlated_columns = binder.correlated_columns;
-
-	// remove outer from inner
-	for (auto &corr_column : correlated_columns) {
-		auto entry = std::find(binder.correlated_columns.begin(), binder.correlated_columns.end(), corr_column);
-		if (entry != binder.correlated_columns.end()) {
-			binder.correlated_columns.erase(entry);
-		}
-	}
-
-	// add inner to outer
-	for (auto &corr_column : binder.correlated_columns) {
-		correlated_columns.push_back(corr_column);
-	}
-
-	// clear inner
-	binder.correlated_columns.clear();
-	return all_correlated_columns;
-}
-
 BindResult LateralBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
 	auto &expr = *expr_ptr;
 	switch (expr.GetExpressionClass()) {
@@ -125,7 +94,11 @@ protected:
 			ReduceColumnRefDepth(expr.Cast<BoundColumnRefExpression>());
 		}
 		if (expr.GetExpressionClass() == ExpressionClass::BOUND_SUBQUERY) {
+			auto &subquery_ref = expr.Cast<BoundSubqueryExpression>();
 			ReduceExpressionSubquery(expr.Cast<BoundSubqueryExpression>());
+			// Recursively update the depth in the bindings of the children nodes
+			ExpressionIterator::EnumerateQueryNodeChildren(
+			    *subquery_ref.subquery, [&](Expression &child_expr) { ReduceExpressionDepth(child_expr); });
 		}
 	}
 

package/src/duckdb/src/planner/expression_binder.cpp

@@ -10,6 +10,7 @@ namespace duckdb {
 
 ExpressionBinder::ExpressionBinder(Binder &binder, ClientContext &context, bool replace_binder)
     : binder(binder), context(context) {
+	InitializeStackCheck();
 	if (replace_binder) {
 		stored_binder = &binder.GetActiveBinder();
 		binder.SetActiveBinder(*this);
@@ -28,7 +29,26 @@ ExpressionBinder::~ExpressionBinder() {
 	}
 }
 
+void ExpressionBinder::InitializeStackCheck() {
+	if (binder.HasActiveBinder()) {
+		stack_depth = binder.GetActiveBinder().stack_depth;
+	} else {
+		stack_depth = 0;
+	}
+}
+
+StackChecker<ExpressionBinder> ExpressionBinder::StackCheck(const ParsedExpression &expr, idx_t extra_stack) {
+	D_ASSERT(stack_depth != DConstants::INVALID_INDEX);
+	if (stack_depth + extra_stack >= MAXIMUM_STACK_DEPTH) {
+		throw BinderException("Maximum recursion depth exceeded (Maximum: %llu) while binding \"%s\"",
+		                      MAXIMUM_STACK_DEPTH, expr.ToString());
+	}
+	return StackChecker<ExpressionBinder>(*this, extra_stack);
+}
+
 BindResult ExpressionBinder::BindExpression(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression) {
+	auto stack_checker = StackCheck(*expr);
+
 	auto &expr_ref = *expr;
 	switch (expr_ref.expression_class) {
 	case ExpressionClass::BETWEEN:
@@ -79,9 +99,12 @@ bool ExpressionBinder::BindCorrelatedColumns(unique_ptr<ParsedExpression> &expr)
 	auto &active_binders = binder.GetActiveBinders();
 	// make a copy of the set of binders, so we can restore it later
 	auto binders = active_binders;
+
+	// we already failed with the current binder
 	active_binders.pop_back();
 	idx_t depth = 1;
 	bool success = false;
+
 	while (!active_binders.empty()) {
 		auto &next_binder = active_binders.back().get();
 		ExpressionBinder::QualifyColumnNames(next_binder.binder, expr);

package/src/duckdb/src/planner/expression_iterator.cpp

@@ -5,6 +5,7 @@
 #include "duckdb/planner/query_node/bound_select_node.hpp"
 #include "duckdb/planner/query_node/bound_set_operation_node.hpp"
 #include "duckdb/planner/query_node/bound_recursive_cte_node.hpp"
+#include "duckdb/planner/query_node/bound_cte_node.hpp"
 #include "duckdb/planner/tableref/list.hpp"
 
 namespace duckdb {
@@ -198,6 +199,11 @@ void ExpressionIterator::EnumerateQueryNodeChildren(BoundQueryNode &node,
 		EnumerateQueryNodeChildren(*cte_node.right, callback);
 		break;
 	}
+	case QueryNodeType::CTE_NODE: {
+		auto &cte_node = node.Cast<BoundCTENode>();
+		EnumerateQueryNodeChildren(*cte_node.child, callback);
+		break;
+	}
 	case QueryNodeType::SELECT_NODE: {
 		auto &bound_select = node.Cast<BoundSelectNode>();
 		for (auto &expr : bound_select.select_list) {

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

@@ -8,6 +8,9 @@
 #include "duckdb/parser/parser.hpp"
 #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 {
 
@@ -128,12 +131,11 @@ void LogicalOperator::Verify(ClientContext &context) {
 		}
 		BufferedSerializer serializer;
 		// We are serializing a query plan
-		serializer.is_query_plan = true;
 		try {
 			expressions[expr_idx]->Serialize(serializer);
 		} catch (NotImplementedException &ex) {
 			// ignore for now (FIXME)
-			return;
+			continue;
 		}
 
 		auto data = serializer.GetData();
@@ -141,6 +143,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));
@@ -253,12 +265,8 @@ unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deseriali
 		break;
 	case LogicalOperatorType::LOGICAL_JOIN:
 		throw InternalException("LogicalJoin deserialize not supported");
-	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-		result = LogicalDelimJoin::Deserialize(state, reader);
-		break;
 	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-		result = LogicalAsOfJoin::Deserialize(state, reader);
-		break;
+	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 		result = LogicalComparisonJoin::Deserialize(state, reader);
 		break;
@@ -283,6 +291,9 @@ unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deseriali
 	case LogicalOperatorType::LOGICAL_RECURSIVE_CTE:
 		result = LogicalRecursiveCTE::Deserialize(state, reader);
 		break;
+	case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE:
+		result = LogicalMaterializedCTE::Deserialize(state, reader);
+		break;
 	case LogicalOperatorType::LOGICAL_INSERT:
 		result = LogicalInsert::Deserialize(state, reader);
 		break;
@@ -352,6 +363,7 @@ unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deseriali
 	case LogicalOperatorType::LOGICAL_PIVOT:
 		result = LogicalPivot::Deserialize(state, reader);
 		break;
+	case LogicalOperatorType::LOGICAL_DEPENDENT_JOIN:
 	case LogicalOperatorType::LOGICAL_INVALID:
 		/* no default here to trigger a warning if we forget to implement deserialize for a new operator */
 		throw SerializationException("Invalid type for operator deserialization");

package/src/duckdb/src/planner/logical_operator_visitor.cpp

@@ -19,6 +19,7 @@ void LogicalOperatorVisitor::VisitOperatorChildren(LogicalOperator &op) {
 
 void LogicalOperatorVisitor::EnumerateExpressions(LogicalOperator &op,
                                                   const std::function<void(unique_ptr<Expression> *child)> &callback) {
+
 	switch (op.type) {
 	case LogicalOperatorType::LOGICAL_EXPRESSION_GET: {
 		auto &get = op.Cast<LogicalExpressionGet>();
@@ -67,14 +68,12 @@ void LogicalOperatorVisitor::EnumerateExpressions(LogicalOperator &op,
 	}
 	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
+	case LogicalOperatorType::LOGICAL_DEPENDENT_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
-		if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-			auto &delim_join = op.Cast<LogicalDelimJoin>();
-			for (auto &expr : delim_join.duplicate_eliminated_columns) {
-				callback(&expr);
-			}
-		}
 		auto &join = op.Cast<LogicalComparisonJoin>();
+		for (auto &expr : join.duplicate_eliminated_columns) {
+			callback(&expr);
+		}
 		for (auto &cond : join.conditions) {
 			callback(&cond.left);
 			callback(&cond.right);

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

@@ -23,15 +23,17 @@ string LogicalComparisonJoin::ParamsToString() const {
 
 void LogicalComparisonJoin::Serialize(FieldWriter &writer) const {
 	LogicalJoin::Serialize(writer);
+	writer.WriteRegularSerializableList(mark_types);
 	writer.WriteRegularSerializableList(conditions);
-	writer.WriteRegularSerializableList(delim_types);
+	writer.WriteSerializableList(duplicate_eliminated_columns);
 }
 
 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>();
+	comparison_join.duplicate_eliminated_columns = reader.ReadRequiredSerializableList<Expression>(state.gstate);
 }
 
 unique_ptr<LogicalOperator> LogicalComparisonJoin::Deserialize(LogicalDeserializationState &state,

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

@@ -59,6 +59,14 @@ unique_ptr<LogicalOperator> LogicalCopyToFile::Deserialize(LogicalDeserializatio
 	return std::move(result);
 }
 
+void LogicalCopyToFile::FormatSerialize(FormatSerializer &serializer) const {
+	throw SerializationException("LogicalCopyToFile not implemented yet");
+}
+
+unique_ptr<LogicalOperator> LogicalCopyToFile::FormatDeserialize(FormatDeserializer &deserializer) {
+	throw SerializationException("LogicalCopyToFile not implemented yet");
+}
+
 idx_t LogicalCopyToFile::EstimateCardinality(ClientContext &context) {
 	return 1;
 }

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,12 +6,35 @@
 
 namespace duckdb {
 
+LogicalCreateIndex::LogicalCreateIndex(unique_ptr<CreateIndexInfo> info_p, vector<unique_ptr<Expression>> expressions_p,
+                                       TableCatalogEntry &table_p)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_INDEX), info(std::move(info_p)), table(table_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!");
+	}
+}
+
+LogicalCreateIndex::LogicalCreateIndex(ClientContext &context, unique_ptr<CreateInfo> info_p,
+                                       vector<unique_ptr<Expression>> expressions_p)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_INDEX),
+      info(unique_ptr_cast<CreateInfo, CreateIndexInfo>(std::move(info_p))), table(BindTable(context, *info)) {
+	for (auto &expr : expressions_p) {
+		this->unbound_expressions.push_back(expr->Copy());
+	}
+	this->expressions = std::move(expressions_p);
+}
+
 void LogicalCreateIndex::Serialize(FieldWriter &writer) const {
 	writer.WriteOptional(info);
 	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);
 }
 
@@ -22,10 +45,6 @@ unique_ptr<LogicalOperator> LogicalCreateIndex::Deserialize(LogicalDeserializati
 	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);
 	auto unbound_expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
 	if (info->type != CatalogType::INDEX_ENTRY) {
 		throw InternalException("Unexpected type: '%s', expected '%s'", CatalogTypeToString(info->type),
@@ -33,8 +52,18 @@ unique_ptr<LogicalOperator> LogicalCreateIndex::Deserialize(LogicalDeserializati
 	}
 	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));
+	return make_uniq<LogicalCreateIndex>(std::move(index_info), std::move(unbound_expressions), table);
+}
+
+void LogicalCreateIndex::ResolveTypes() {
+	types.emplace_back(LogicalType::BIGINT);
+}
+
+TableCatalogEntry &LogicalCreateIndex::BindTable(ClientContext &context, CreateIndexInfo &info) {
+	auto &catalog = info.catalog;
+	auto &schema = info.schema;
+	auto &table_name = info.table;
+	return Catalog::GetEntry<TableCatalogEntry>(context, catalog, schema, table_name);
 }
 
 } // 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_cteref.cpp

@@ -10,6 +10,7 @@ void LogicalCTERef::Serialize(FieldWriter &writer) const {
 	writer.WriteField(cte_index);
 	writer.WriteRegularSerializableList(chunk_types);
 	writer.WriteList<string>(bound_columns);
+	writer.WriteField(materialized_cte);
 }
 
 unique_ptr<LogicalOperator> LogicalCTERef::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
@@ -17,7 +18,8 @@ unique_ptr<LogicalOperator> LogicalCTERef::Deserialize(LogicalDeserializationSta
 	auto cte_index = reader.ReadRequired<idx_t>();
 	auto chunk_types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
 	auto bound_columns = reader.ReadRequiredList<string>();
-	return make_uniq<LogicalCTERef>(table_index, cte_index, chunk_types, bound_columns);
+	auto materialized_cte = reader.ReadField<CTEMaterialize>(CTEMaterialize::CTE_MATERIALIZE_DEFAULT);
+	return make_uniq<LogicalCTERef>(table_index, cte_index, chunk_types, bound_columns, materialized_cte);
 }
 
 vector<idx_t> LogicalCTERef::GetTableIndex() const {