duckdb 0.8.1-dev96.0 → 0.8.2-dev1.0

package/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp

@@ -87,6 +87,9 @@ unique_ptr<TableRef> Transformer::TransformPivot(duckdb_libpgquery::PGPivotExpr
 		result->unpivot_names = TransformStringList(root.unpivots);
 	}
 	result->pivots = TransformPivotList(*root.pivots);
+	if (!result->unpivot_names.empty() && result->pivots.size() > 1) {
+		throw ParserException("UNPIVOT requires a single pivot element");
+	}
 	if (root.groups) {
 		result->groups = TransformStringList(root.groups);
 	}

package/src/duckdb/src/parser/transformer.cpp

@@ -204,8 +204,6 @@ unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgque
 		return TransformDetach(PGCast<duckdb_libpgquery::PGDetachStmt>(stmt));
 	case duckdb_libpgquery::T_PGUseStmt:
 		return TransformUse(PGCast<duckdb_libpgquery::PGUseStmt>(stmt));
-	case duckdb_libpgquery::T_PGCreateDatabaseStmt:
-		return TransformCreateDatabase(PGCast<duckdb_libpgquery::PGCreateDatabaseStmt>(stmt));
 	default:
 		throw NotImplementedException(NodetypeToString(stmt.type));
 	}

package/src/duckdb/src/planner/bind_context.cpp

@@ -286,15 +286,14 @@ string BindContext::BindColumn(PositionalReferenceExpression &ref, string &table
 	return StringUtil::Format("Positional reference %d out of range (total %d columns)", ref.index, total_columns);
 }
 
-BindResult BindContext::BindColumn(PositionalReferenceExpression &ref, idx_t depth) {
+unique_ptr<ColumnRefExpression> BindContext::PositionToColumn(PositionalReferenceExpression &ref) {
 	string table_name, column_name;
 
 	string error = BindColumn(ref, table_name, column_name);
 	if (!error.empty()) {
-		return BindResult(error);
+		throw BinderException(error);
 	}
-	auto column_ref = make_uniq<ColumnRefExpression>(column_name, table_name);
-	return BindColumn(*column_ref, depth);
+	return make_uniq<ColumnRefExpression>(column_name, table_name);
 }
 
 bool BindContext::CheckExclusionList(StarExpression &expr, const string &column_name,

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

@@ -218,7 +218,6 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 			D_ASSERT(binding.names.size() == 1);
 			D_ASSERT(binding.types.size() == 1);
 
-			bound_function_expr.function.arguments.push_back(binding.types[0]);
 			auto bound_lambda_param =
 			    make_uniq<BoundReferenceExpression>(binding.names[0], binding.types[0], lambda_index);
 			bound_function_expr.children.push_back(std::move(bound_lambda_param));
@@ -227,7 +226,6 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 
 	// push back the captures into the children vector and the correct return types into the bound_function arguments
 	for (auto &capture : bound_lambda.captures) {
-		bound_function_expr.function.arguments.push_back(capture->return_type);
 		bound_function_expr.children.push_back(std::move(capture));
 	}
 

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

@@ -4,11 +4,16 @@
 
 namespace duckdb {
 
-BindResult ExpressionBinder::BindExpression(PositionalReferenceExpression &ref, idx_t depth) {
+BindResult ExpressionBinder::BindPositionalReference(unique_ptr<ParsedExpression> &expr, idx_t depth,
+                                                     bool root_expression) {
+	auto &ref = expr->Cast<PositionalReferenceExpression>();
 	if (depth != 0) {
-		return BindResult("Positional reference expression could not be bound");
+		throw InternalException("Positional reference expression could not be bound");
 	}
-	return binder.bind_context.BindColumn(ref, depth);
+	// replace the positional reference with a column
+	auto column = binder.bind_context.PositionToColumn(ref);
+	expr = std::move(column);
+	return BindExpression(expr, depth, root_expression);
 }
 
 } // namespace duckdb

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

@@ -288,6 +288,9 @@ void Binder::BindWhereStarExpression(unique_ptr<ParsedExpression> &expr) {
 	// expand the stars for this expression
 	vector<unique_ptr<ParsedExpression>> new_conditions;
 	ExpandStarExpression(std::move(expr), new_conditions);
+	if (new_conditions.empty()) {
+		throw ParserException("COLUMNS expansion resulted in empty set of columns");
+	}
 
 	// set up an AND conjunction between the expanded conditions
 	expr = std::move(new_conditions[0]);
@@ -401,14 +404,15 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 	}
 
 	// bind the QUALIFY clause, if any
+	unique_ptr<QualifyBinder> qualify_binder;
 	if (statement.qualify) {
 		if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
 			throw BinderException("Combining QUALIFY with GROUP BY ALL is not supported yet");
 		}
-		QualifyBinder qualify_binder(*this, context, *result, info, alias_map);
+		qualify_binder = make_uniq<QualifyBinder>(*this, context, *result, info, alias_map);
 		ExpressionBinder::QualifyColumnNames(*this, statement.qualify);
-		result->qualify = qualify_binder.Bind(statement.qualify);
-		if (qualify_binder.HasBoundColumns() && qualify_binder.BoundAggregates()) {
+		result->qualify = qualify_binder->Bind(statement.qualify);
+		if (qualify_binder->HasBoundColumns() && qualify_binder->BoundAggregates()) {
 			throw BinderException("Cannot mix aggregates with non-aggregated columns!");
 		}
 	}
@@ -487,19 +491,31 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 	    !result->groups.grouping_sets.empty()) {
 		if (statement.aggregate_handling == AggregateHandling::NO_AGGREGATES_ALLOWED) {
 			throw BinderException("Aggregates cannot be present in a Project relation!");
-		} else if (select_binder.HasBoundColumns()) {
-			auto &bound_columns = select_binder.GetBoundColumns();
-			string error;
-			error = "column \"%s\" must appear in the GROUP BY clause or must be part of an aggregate function.";
-			if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
-				error += "\nGROUP BY ALL will only group entries in the SELECT list. Add it to the SELECT list or "
-				         "GROUP BY this entry explicitly.";
-			} else {
-				error += "\nEither add it to the GROUP BY list, or use \"ANY_VALUE(%s)\" if the exact value of \"%s\" "
-				         "is not important.";
+		} else {
+			vector<reference<BaseSelectBinder>> to_check_binders;
+			to_check_binders.push_back(select_binder);
+			if (qualify_binder) {
+				to_check_binders.push_back(*qualify_binder);
+			}
+			for (auto &binder : to_check_binders) {
+				auto &sel_binder = binder.get();
+				if (!sel_binder.HasBoundColumns()) {
+					continue;
+				}
+				auto &bound_columns = sel_binder.GetBoundColumns();
+				string error;
+				error = "column \"%s\" must appear in the GROUP BY clause or must be part of an aggregate function.";
+				if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
+					error += "\nGROUP BY ALL will only group entries in the SELECT list. Add it to the SELECT list or "
+					         "GROUP BY this entry explicitly.";
+				} else {
+					error +=
+					    "\nEither add it to the GROUP BY list, or use \"ANY_VALUE(%s)\" if the exact value of \"%s\" "
+					    "is not important.";
+				}
+				throw BinderException(FormatError(bound_columns[0].query_location, error, bound_columns[0].name,
+				                                  bound_columns[0].name, bound_columns[0].name));
 			}
-			throw BinderException(FormatError(bound_columns[0].query_location, error, bound_columns[0].name,
-			                                  bound_columns[0].name, bound_columns[0].name));
 		}
 	}
 

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

@@ -13,7 +13,6 @@
 #include "duckdb/parser/parsed_data/create_index_info.hpp"
 #include "duckdb/parser/parsed_data/create_macro_info.hpp"
 #include "duckdb/parser/parsed_data/create_view_info.hpp"
-#include "duckdb/parser/parsed_data/create_database_info.hpp"
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/parser/statement/create_statement.hpp"
@@ -656,32 +655,6 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		}
 		break;
 	}
-	case CatalogType::DATABASE_ENTRY: {
-		// not supported in DuckDB yet but allow extensions to intercept and implement this functionality
-		auto &base = stmt.info->Cast<CreateDatabaseInfo>();
-		string database_name = base.name;
-		string source_path = base.path;
-
-		auto &config = DBConfig::GetConfig(context);
-
-		if (config.storage_extensions.empty()) {
-			throw NotImplementedException("CREATE DATABASE not supported in DuckDB yet");
-		}
-		// for now assume only one storage extension provides the custom create_database impl
-		for (auto &extension_entry : config.storage_extensions) {
-			if (extension_entry.second->create_database != nullptr) {
-				auto &storage_extension = extension_entry.second;
-				auto create_database_function_ref = storage_extension->create_database(
-				    storage_extension->storage_info.get(), context, database_name, source_path);
-				if (create_database_function_ref) {
-					auto bound_create_database_func = Bind(*create_database_function_ref);
-					result.plan = CreatePlan(*bound_create_database_func);
-					break;
-				}
-			}
-		}
-		break;
-	}
 	default:
 		throw Exception("Unrecognized type!");
 	}

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

@@ -294,9 +294,26 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 		BindLogicalType(context, column.TypeMutable(), &result->schema.catalog);
 		// We add a catalog dependency
 		auto type_dependency = EnumType::GetCatalog(column.Type());
+
 		if (type_dependency) {
 			// Only if the USER comes from a create type
-			result->dependencies.AddDependency(*type_dependency);
+			if (!schema.catalog.IsTemporaryCatalog()) {
+				// If it is not a TEMP table we add a dependency
+				result->dependencies.AddDependency(*type_dependency);
+			} else {
+				auto enum_type = type_dependency->user_type;
+				auto &enum_entries = EnumType::GetValuesInsertOrder(enum_type);
+				auto enum_size = EnumType::GetSize(enum_type);
+				Vector copy_enum_entries_vec(LogicalType::VARCHAR, enum_size);
+				auto copy_enum_entries_ptr = FlatVector::GetData<string_t>(copy_enum_entries_vec);
+				auto enum_entries_ptr = FlatVector::GetData<string_t>(enum_entries);
+				for (idx_t enum_idx = 0; enum_idx < enum_size; enum_idx++) {
+					copy_enum_entries_ptr[enum_idx] =
+					    StringVector::AddStringOrBlob(copy_enum_entries_vec, enum_entries_ptr[enum_idx]);
+				}
+				auto copy_type = LogicalType::ENUM(EnumType::GetTypeName(enum_type), copy_enum_entries_vec, enum_size);
+				column.SetType(copy_type);
+			}
 		}
 	}
 	result->dependencies.VerifyDependencies(schema.catalog, result->Base().table);

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

@@ -47,31 +47,6 @@ BoundStatement Binder::Bind(DropStatement &stmt) {
 		stmt.info->schema = entry->ParentSchema().name;
 		break;
 	}
-	case CatalogType::DATABASE_ENTRY: {
-		auto &base = (DropInfo &)*stmt.info;
-		string database_name = base.name;
-
-		auto &config = DBConfig::GetConfig(context);
-		// for now assume only one storage extension provides the custom drop_database impl
-		for (auto &extension_entry : config.storage_extensions) {
-			if (extension_entry.second->drop_database == nullptr) {
-				continue;
-			}
-			auto &storage_extension = extension_entry.second;
-			auto drop_database_function_ref =
-			    storage_extension->drop_database(storage_extension->storage_info.get(), context, database_name);
-			if (drop_database_function_ref) {
-				auto bound_drop_database_func = Bind(*drop_database_function_ref);
-				result.plan = CreatePlan(*bound_drop_database_func);
-				result.names = {"Success"};
-				result.types = {LogicalType::BIGINT};
-				properties.allow_stream_result = false;
-				properties.return_type = StatementReturnType::NOTHING;
-				return result;
-			}
-		}
-		throw BinderException("Drop is not supported for this database!");
-	}
 	default:
 		throw BinderException("Unknown catalog type for drop statement!");
 	}

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

@@ -20,119 +20,6 @@
 
 namespace duckdb {
 
-static void BindExtraColumns(TableCatalogEntry &table, LogicalGet &get, LogicalProjection &proj, LogicalUpdate &update,
-                             physical_index_set_t &bound_columns) {
-	if (bound_columns.size() <= 1) {
-		return;
-	}
-	idx_t found_column_count = 0;
-	physical_index_set_t found_columns;
-	for (idx_t i = 0; i < update.columns.size(); i++) {
-		if (bound_columns.find(update.columns[i]) != bound_columns.end()) {
-			// this column is referenced in the CHECK constraint
-			found_column_count++;
-			found_columns.insert(update.columns[i]);
-		}
-	}
-	if (found_column_count > 0 && found_column_count != bound_columns.size()) {
-		// columns in this CHECK constraint were referenced, but not all were part of the UPDATE
-		// add them to the scan and update set
-		for (auto &check_column_id : bound_columns) {
-			if (found_columns.find(check_column_id) != found_columns.end()) {
-				// column is already projected
-				continue;
-			}
-			// column is not projected yet: project it by adding the clause "i=i" to the set of updated columns
-			auto &column = table.GetColumns().GetColumn(check_column_id);
-			update.expressions.push_back(make_uniq<BoundColumnRefExpression>(
-			    column.Type(), ColumnBinding(proj.table_index, proj.expressions.size())));
-			proj.expressions.push_back(make_uniq<BoundColumnRefExpression>(
-			    column.Type(), ColumnBinding(get.table_index, get.column_ids.size())));
-			get.column_ids.push_back(check_column_id.index);
-			update.columns.push_back(check_column_id);
-		}
-	}
-}
-
-static bool TypeSupportsRegularUpdate(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::LIST:
-	case LogicalTypeId::MAP:
-	case LogicalTypeId::UNION:
-		// lists and maps and unions don't support updates directly
-		return false;
-	case LogicalTypeId::STRUCT: {
-		auto &child_types = StructType::GetChildTypes(type);
-		for (auto &entry : child_types) {
-			if (!TypeSupportsRegularUpdate(entry.second)) {
-				return false;
-			}
-		}
-		return true;
-	}
-	default:
-		return true;
-	}
-}
-
-static void BindUpdateConstraints(TableCatalogEntry &table, LogicalGet &get, LogicalProjection &proj,
-                                  LogicalUpdate &update) {
-	if (!table.IsDuckTable()) {
-		return;
-	}
-	// check the constraints and indexes of the table to see if we need to project any additional columns
-	// we do this for indexes with multiple columns and CHECK constraints in the UPDATE clause
-	// suppose we have a constraint CHECK(i + j < 10); now we need both i and j to check the constraint
-	// if we are only updating one of the two columns we add the other one to the UPDATE set
-	// with a "useless" update (i.e. i=i) so we can verify that the CHECK constraint is not violated
-	for (auto &constraint : table.GetBoundConstraints()) {
-		if (constraint->type == ConstraintType::CHECK) {
-			auto &check = constraint->Cast<BoundCheckConstraint>();
-			// check constraint! check if we need to add any extra columns to the UPDATE clause
-			BindExtraColumns(table, get, proj, update, check.bound_columns);
-		}
-	}
-	auto &storage = table.GetStorage();
-	if (update.return_chunk) {
-		physical_index_set_t all_columns;
-		for (idx_t i = 0; i < storage.column_definitions.size(); i++) {
-			all_columns.insert(PhysicalIndex(i));
-		}
-		BindExtraColumns(table, get, proj, update, all_columns);
-	}
-	// for index updates we always turn any update into an insert and a delete
-	// we thus need all the columns to be available, hence we check if the update touches any index columns
-	// If the returning keyword is used, we need access to the whole row in case the user requests it.
-	// Therefore switch the update to a delete and insert.
-	update.update_is_del_and_insert = false;
-	storage.info->indexes.Scan([&](Index &index) {
-		if (index.IndexIsUpdated(update.columns)) {
-			update.update_is_del_and_insert = true;
-			return true;
-		}
-		return false;
-	});
-
-	// we also convert any updates on LIST columns into delete + insert
-	for (auto &col_index : update.columns) {
-		auto &column = table.GetColumns().GetColumn(col_index);
-		if (!TypeSupportsRegularUpdate(column.Type())) {
-			update.update_is_del_and_insert = true;
-			break;
-		}
-	}
-
-	if (update.update_is_del_and_insert) {
-		// the update updates a column required by an index or requires returning the updated rows,
-		// push projections for all columns
-		physical_index_set_t all_columns;
-		for (idx_t i = 0; i < storage.column_definitions.size(); i++) {
-			all_columns.insert(PhysicalIndex(i));
-		}
-		BindExtraColumns(table, get, proj, update, all_columns);
-	}
-}
-
 // This creates a LogicalProjection and moves 'root' into it as a child
 // unless there are no expressions to project, in which case it just returns 'root'
 unique_ptr<LogicalOperator> Binder::BindUpdateSet(LogicalOperator &op, unique_ptr<LogicalOperator> root,
@@ -239,7 +126,8 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	auto proj = unique_ptr_cast<LogicalOperator, LogicalProjection>(std::move(proj_tmp));
 
 	// bind any extra columns necessary for CHECK constraints or indexes
-	BindUpdateConstraints(table, *get, *proj, *update);
+	table.BindUpdateConstraints(*get, *proj, *update, context);
+
 	// finally add the row id column to the projection list
 	proj->expressions.push_back(make_uniq<BoundColumnRefExpression>(
 	    LogicalType::ROW_TYPE, ColumnBinding(get->table_index, get->column_ids.size())));

package/src/duckdb/src/planner/binder/tableref/bind_pivot.cpp

@@ -250,7 +250,9 @@ unique_ptr<BoundTableRef> Binder::BindBoundPivot(PivotRef &ref) {
 	auto &aggregates = result->bound_pivot.aggregates;
 	ExtractPivotAggregates(*result->child, aggregates);
 	if (aggregates.size() != ref.bound_aggregate_names.size()) {
-		throw InternalException("Pivot - aggregate count mismatch");
+		throw BinderException("Pivot aggregate count mismatch. Expected %llu aggregates but found %llu. Are all pivot "
+		                      "expressions aggregate functions?",
+		                      ref.bound_aggregate_names.size(), aggregates.size());
 	}
 
 	vector<string> child_names;
@@ -544,6 +546,9 @@ unique_ptr<BoundTableRef> Binder::Bind(PivotRef &ref) {
 
 	// bind the source of the pivot
 	// we need to do this to be able to expand star expressions
+	if (ref.source->type == TableReferenceType::SUBQUERY && ref.source->alias.empty()) {
+		ref.source->alias = "__internal_pivot_alias_" + to_string(GenerateTableIndex());
+	}
 	auto copied_source = ref.source->Copy();
 	auto star_binder = Binder::CreateBinder(context, this);
 	star_binder->Bind(*copied_source);

package/src/duckdb/src/planner/binder/tableref/bind_table_function.cpp

@@ -97,6 +97,8 @@ bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_functi
 			subquery = make_uniq<BoundSubqueryRef>(std::move(binder), std::move(node));
 			seen_subquery = true;
 			arguments.emplace_back(LogicalTypeId::TABLE);
+			parameters.emplace_back(
+			    Value(LogicalType::INVALID)); // this is a dummy value so the lengths of arguments and parameter match
 			continue;
 		}
 
@@ -161,6 +163,9 @@ Binder::BindTableFunctionInternal(TableFunction &table_function, const string &f
 				table_function.extra_info = "(Multi-Threaded)";
 			}
 		}
+	} else {
+		throw InvalidInputException("Cannot call function \"%s\" directly - it has no bind function",
+		                            table_function.name);
 	}
 	if (return_types.size() != return_names.size()) {
 		throw InternalException("Failed to bind \"%s\": return_types/names must have same size", table_function.name);

package/src/duckdb/src/planner/bound_result_modifier.cpp

@@ -16,6 +16,20 @@ BoundOrderByNode::BoundOrderByNode(OrderType type, OrderByNullType null_order, u
                                    unique_ptr<BaseStatistics> stats)
     : type(type), null_order(null_order), expression(std::move(expression)), stats(std::move(stats)) {
 }
+void BoundOrderModifier::Serialize(Serializer &serializer) const {
+	FieldWriter writer(serializer);
+	writer.WriteRegularSerializableList(orders);
+	writer.Finalize();
+}
+unique_ptr<BoundOrderModifier> BoundOrderModifier::Deserialize(Deserializer &source, PlanDeserializationState &state) {
+	auto x = make_uniq<BoundOrderModifier>();
+
+	FieldReader reader(source);
+	x->orders = reader.ReadRequiredSerializableList<BoundOrderByNode, BoundOrderByNode>(state);
+	reader.Finalize();
+
+	return x;
+}
 
 BoundOrderByNode BoundOrderByNode::Copy() const {
 	if (stats) {

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

@@ -84,9 +84,7 @@ unique_ptr<Expression> BoundAggregateExpression::Copy() {
 void BoundAggregateExpression::Serialize(FieldWriter &writer) const {
 	writer.WriteField(IsDistinct());
 	writer.WriteOptional(filter);
-	if (order_bys) {
-		throw NotImplementedException("Serialization of ORDER BY aggregate not yet supported");
-	}
+	writer.WriteOptional(order_bys);
 	FunctionSerializer::Serialize<AggregateFunction>(writer, function, return_type, children, bind_info.get());
 }
 
@@ -94,13 +92,16 @@ unique_ptr<Expression> BoundAggregateExpression::Deserialize(ExpressionDeseriali
                                                              FieldReader &reader) {
 	auto distinct = reader.ReadRequired<bool>();
 	auto filter = reader.ReadOptional<Expression>(nullptr, state.gstate);
+	auto order_bys = reader.ReadOptional<BoundOrderModifier>(nullptr, state.gstate);
 	vector<unique_ptr<Expression>> children;
 	unique_ptr<FunctionData> bind_info;
 	auto function = FunctionSerializer::Deserialize<AggregateFunction, AggregateFunctionCatalogEntry>(
 	    reader, state, CatalogType::AGGREGATE_FUNCTION_ENTRY, children, bind_info);
 
-	return make_uniq<BoundAggregateExpression>(function, std::move(children), std::move(filter), std::move(bind_info),
-	                                           distinct ? AggregateType::DISTINCT : AggregateType::NON_DISTINCT);
+	auto x = make_uniq<BoundAggregateExpression>(function, std::move(children), std::move(filter), std::move(bind_info),
+	                                             distinct ? AggregateType::DISTINCT : AggregateType::NON_DISTINCT);
+	x->order_bys = std::move(order_bys);
+	return std::move(x);
 }
 
 } // namespace duckdb

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

@@ -1,10 +1,16 @@
 #include "duckdb/planner/expression/bound_default_expression.hpp"
 #include "duckdb/common/exception.hpp"
+#include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
 
 void BoundDefaultExpression::Serialize(FieldWriter &writer) const {
-	throw NotImplementedException(ExpressionTypeToString(type));
+	writer.WriteSerializable(return_type);
+}
+
+unique_ptr<Expression> BoundDefaultExpression::Deserialize(ExpressionDeserializationState &state, FieldReader &reader) {
+	auto return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
+	return make_uniq<BoundDefaultExpression>(return_type);
 }
 
 } // namespace duckdb

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

@@ -130,6 +130,9 @@ unique_ptr<Expression> Expression::Deserialize(Deserializer &source, PlanDeseria
 	case ExpressionClass::BOUND_CONSTANT:
 		result = BoundConstantExpression::Deserialize(state, reader);
 		break;
+	case ExpressionClass::BOUND_DEFAULT:
+		result = BoundDefaultExpression::Deserialize(state, reader);
+		break;
 	case ExpressionClass::BOUND_FUNCTION:
 		result = BoundFunctionExpression::Deserialize(state, reader);
 		break;

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

@@ -64,8 +64,9 @@ BindResult ExpressionBinder::BindExpression(unique_ptr<ParsedExpression> &expr,
 		return BindExpression(expr_ref.Cast<SubqueryExpression>(), depth);
 	case ExpressionClass::PARAMETER:
 		return BindExpression(expr_ref.Cast<ParameterExpression>(), depth);
-	case ExpressionClass::POSITIONAL_REFERENCE:
-		return BindExpression(expr_ref.Cast<PositionalReferenceExpression>(), depth);
+	case ExpressionClass::POSITIONAL_REFERENCE: {
+		return BindPositionalReference(expr, depth, root_expression);
+	}
 	case ExpressionClass::STAR:
 		return BindResult(binder.FormatError(expr_ref, "STAR expression is not supported here"));
 	default:

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

@@ -16,15 +16,16 @@ string LogicalDistinct::ParamsToString() const {
 void LogicalDistinct::Serialize(FieldWriter &writer) const {
 	writer.WriteField<DistinctType>(distinct_type);
 	writer.WriteSerializableList(distinct_targets);
-	if (order_by) {
-		throw NotImplementedException("Serializing ORDER BY not yet supported");
-	}
+	writer.WriteOptional(order_by);
 }
 
 unique_ptr<LogicalOperator> LogicalDistinct::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
 	auto distinct_type = reader.ReadRequired<DistinctType>();
 	auto distinct_targets = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	return make_uniq<LogicalDistinct>(std::move(distinct_targets), distinct_type);
+	auto order_by = reader.ReadOptional<BoundOrderModifier>(nullptr, state.gstate);
+	auto ret = make_uniq<LogicalDistinct>(std::move(distinct_targets), distinct_type);
+	ret->order_by = std::move(order_by);
+	return std::move(ret);
 }
 
 } // namespace duckdb

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

@@ -19,11 +19,23 @@ vector<ColumnBinding> LogicalPivot::GetColumnBindings() {
 }
 
 void LogicalPivot::Serialize(FieldWriter &writer) const {
-	throw NotImplementedException("Serializing pivot is not supported yet");
+	writer.WriteField(pivot_index);
+	writer.WriteOptional<LogicalOperator>(children.back());
+	writer.WriteField(bound_pivot.group_count);
+	writer.WriteRegularSerializableList<LogicalType>(bound_pivot.types);
+	writer.WriteList<string>(bound_pivot.pivot_values);
+	writer.WriteSerializableList<Expression>(bound_pivot.aggregates);
 }
 
 unique_ptr<LogicalOperator> LogicalPivot::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
-	throw NotImplementedException("Deserializing pivot is not supported yet");
+	auto pivot_index = reader.ReadRequired<idx_t>();
+	auto plan = reader.ReadOptional<LogicalOperator>(nullptr, state.gstate);
+	BoundPivotInfo info;
+	info.group_count = reader.ReadRequired<idx_t>();
+	info.types = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
+	info.pivot_values = reader.ReadRequiredList<string>();
+	info.aggregates = reader.ReadRequiredSerializableList<Expression>(state.gstate);
+	return make_uniq<LogicalPivot>(pivot_index, std::move(plan), std::move(info));
 }
 
 vector<idx_t> LogicalPivot::GetTableIndex() const {

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

@@ -1,14 +1,15 @@
 #include "duckdb/planner/planner.hpp"
-#include "duckdb/main/query_profiler.hpp"
+
 #include "duckdb/common/serializer.hpp"
+#include "duckdb/common/serializer/buffered_deserializer.hpp"
+#include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/client_data.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/main/prepared_statement_data.hpp"
+#include "duckdb/main/query_profiler.hpp"
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/common/serializer/buffered_deserializer.hpp"
 #include "duckdb/transaction/meta_transaction.hpp"
 
 namespace duckdb {
@@ -142,23 +143,12 @@ void Planner::CreatePlan(unique_ptr<SQLStatement> statement) {
 }
 
 static bool OperatorSupportsSerialization(LogicalOperator &op) {
-	switch (op.type) {
-	case LogicalOperatorType::LOGICAL_PREPARE:
-	case LogicalOperatorType::LOGICAL_EXECUTE:
-	case LogicalOperatorType::LOGICAL_PRAGMA:
-	case LogicalOperatorType::LOGICAL_EXPLAIN:
-	case LogicalOperatorType::LOGICAL_COPY_TO_FILE:
-		// unsupported (for now)
-		return false;
-	default:
-		break;
-	}
 	for (auto &child : op.children) {
 		if (!OperatorSupportsSerialization(*child)) {
 			return false;
 		}
 	}
-	return true;
+	return op.SupportSerialization();
 }
 
 void Planner::VerifyPlan(ClientContext &context, unique_ptr<LogicalOperator> &op, bound_parameter_map_t *map) {