duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

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

@@ -1,23 +1,27 @@
 #include "duckdb/planner/binder.hpp"
 
+#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
+#include "duckdb/common/enum_util.hpp"
+#include "duckdb/common/helper.hpp"
 #include "duckdb/main/config.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
+#include "duckdb/parser/expression/subquery_expression.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
+#include "duckdb/parser/query_node/list.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/statement/list.hpp"
 #include "duckdb/parser/tableref/list.hpp"
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/planner/bound_query_node.hpp"
-#include "duckdb/planner/tableref/list.hpp"
-#include "duckdb/planner/query_node/list.hpp"
 #include "duckdb/planner/expression.hpp"
 #include "duckdb/planner/expression_binder/returning_binder.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/planner/operator/logical_sample.hpp"
-#include "duckdb/parser/query_node/list.hpp"
-#include "duckdb/common/helper.hpp"
-#include "duckdb/common/enum_util.hpp"
+#include "duckdb/planner/query_node/list.hpp"
+#include "duckdb/planner/tableref/list.hpp"
+#include "duckdb/main/database.hpp"
 
 #include <algorithm>
 
@@ -48,10 +52,10 @@ shared_ptr<Binder> Binder::CreateBinder(ClientContext &context, optional_ptr<Bin
 		                      "increase the maximum expression depth.",
 		                      context.config.max_expression_depth);
 	}
-	return make_shared_ptr<Binder>(true, context, parent ? parent->shared_from_this() : nullptr, binder_type);
+	return shared_ptr<Binder>(new Binder(context, parent ? parent->shared_from_this() : nullptr, binder_type));
 }
 
-Binder::Binder(bool, ClientContext &context, shared_ptr<Binder> parent_p, BinderType binder_type)
+Binder::Binder(ClientContext &context, shared_ptr<Binder> parent_p, BinderType binder_type)
     : context(context), bind_context(*this), parent(std::move(parent_p)), bound_tables(0), binder_type(binder_type),
       entry_retriever(context) {
 	if (parent) {
@@ -146,9 +150,9 @@ BoundStatement Binder::Bind(SQLStatement &statement) {
 	case StatementType::SELECT_STATEMENT:
 		return Bind(statement.Cast<SelectStatement>());
 	case StatementType::INSERT_STATEMENT:
-		return Bind(statement.Cast<InsertStatement>());
+		return BindWithCTE(statement.Cast<InsertStatement>());
 	case StatementType::COPY_STATEMENT:
-		return Bind(statement.Cast<CopyStatement>());
+		return Bind(statement.Cast<CopyStatement>(), CopyToType::COPY_TO_FILE);
 	case StatementType::DELETE_STATEMENT:
 		return BindWithCTE(statement.Cast<DeleteStatement>());
 	case StatementType::UPDATE_STATEMENT:
@@ -205,6 +209,116 @@ void Binder::AddCTEMap(CommonTableExpressionMap &cte_map) {
 	}
 }
 
+static void GetTableRefCountsNode(case_insensitive_map_t<idx_t> &cte_ref_counts, QueryNode &node);
+
+static void GetTableRefCountsExpr(case_insensitive_map_t<idx_t> &cte_ref_counts, ParsedExpression &expr) {
+	if (expr.type == ExpressionType::SUBQUERY) {
+		auto &subquery = expr.Cast<SubqueryExpression>();
+		GetTableRefCountsNode(cte_ref_counts, *subquery.subquery->node);
+	} else {
+		ParsedExpressionIterator::EnumerateChildren(
+		    expr, [&](ParsedExpression &expr) { GetTableRefCountsExpr(cte_ref_counts, expr); });
+	}
+}
+
+static void GetTableRefCountsNode(case_insensitive_map_t<idx_t> &cte_ref_counts, QueryNode &node) {
+	ParsedExpressionIterator::EnumerateQueryNodeChildren(
+	    node, [&](unique_ptr<ParsedExpression> &child) { GetTableRefCountsExpr(cte_ref_counts, *child); },
+	    [&](TableRef &ref) {
+		    if (ref.type != TableReferenceType::BASE_TABLE) {
+			    return;
+		    }
+		    auto cte_ref_counts_it = cte_ref_counts.find(ref.Cast<BaseTableRef>().table_name);
+		    if (cte_ref_counts_it != cte_ref_counts.end()) {
+			    cte_ref_counts_it->second++;
+		    }
+	    });
+}
+
+static bool ParsedExpressionIsAggregate(Binder &binder, const ParsedExpression &expr) {
+	if (expr.GetExpressionClass() == ExpressionClass::FUNCTION) {
+		auto &function = expr.Cast<FunctionExpression>();
+		QueryErrorContext error_context;
+		auto entry = binder.GetCatalogEntry(CatalogType::SCALAR_FUNCTION_ENTRY, function.catalog, function.schema,
+		                                    function.function_name, OnEntryNotFound::RETURN_NULL, error_context);
+		if (entry && entry->type == CatalogType::AGGREGATE_FUNCTION_ENTRY) {
+			return true;
+		}
+	}
+	bool is_aggregate = false;
+	ParsedExpressionIterator::EnumerateChildren(
+	    expr, [&](const ParsedExpression &child) { is_aggregate |= ParsedExpressionIsAggregate(binder, child); });
+	return is_aggregate;
+}
+
+bool Binder::OptimizeCTEs(QueryNode &node) {
+	D_ASSERT(context.config.enable_optimizer);
+
+	// only applies to nodes that have at least one CTE
+	auto &cte_map = node.cte_map.map;
+	if (cte_map.empty()) {
+		return false;
+	}
+
+	// initialize counts with the CTE names
+	case_insensitive_map_t<idx_t> cte_ref_counts;
+	for (auto &cte : cte_map) {
+		cte_ref_counts[cte.first];
+	}
+
+	// count the references of each CTE
+	GetTableRefCountsNode(cte_ref_counts, node);
+
+	// determine for each CTE whether it should be materialized
+	bool result = false;
+	for (auto &cte : cte_map) {
+		if (cte.second->materialized != CTEMaterialize::CTE_MATERIALIZE_DEFAULT) {
+			continue; // only triggers when nothing is specified
+		}
+		if (bind_context.GetCTEBinding(cte.first)) {
+			continue; // there's a CTE in the bind context with an overlapping name, we can't also materialize this
+		}
+
+		auto cte_ref_counts_it = cte_ref_counts.find(cte.first);
+		D_ASSERT(cte_ref_counts_it != cte_ref_counts.end());
+
+		// only applies to CTEs that are referenced more than once
+		if (cte_ref_counts_it->second <= 1) {
+			continue;
+		}
+
+		// if the cte is a SELECT node
+		if (cte.second->query->node->type != QueryNodeType::SELECT_NODE) {
+			continue;
+		}
+
+		// we materialize if the CTE ends in an aggregation
+		auto &cte_node = cte.second->query->node->Cast<SelectNode>();
+		bool materialize = !cte_node.groups.group_expressions.empty() || !cte_node.groups.grouping_sets.empty();
+		// or has a distinct modifier
+		for (auto &modifier : cte_node.modifiers) {
+			if (materialize) {
+				break;
+			}
+			if (modifier->type == ResultModifierType::DISTINCT_MODIFIER) {
+				materialize = true;
+			}
+		}
+		for (auto &sel : cte_node.select_list) {
+			if (materialize) {
+				break;
+			}
+			materialize |= ParsedExpressionIsAggregate(*this, *sel);
+		}
+
+		if (materialize) {
+			cte.second->materialized = CTEMaterialize::CTE_MATERIALIZE_ALWAYS;
+			result = true;
+		}
+	}
+	return result;
+}
+
 unique_ptr<BoundQueryNode> Binder::BindNode(QueryNode &node) {
 	// first we visit the set of CTEs and add them to the bind context
 	AddCTEMap(node.cte_map);
@@ -229,14 +343,34 @@ unique_ptr<BoundQueryNode> Binder::BindNode(QueryNode &node) {
 }
 
 BoundStatement Binder::Bind(QueryNode &node) {
-	auto bound_node = BindNode(node);
-
 	BoundStatement result;
-	result.names = bound_node->names;
-	result.types = bound_node->types;
+	if (context.db->config.options.disabled_optimizers.find(OptimizerType::MATERIALIZED_CTE) ==
+	        context.db->config.options.disabled_optimizers.end() &&
+	    context.config.enable_optimizer && OptimizeCTEs(node)) {
+		switch (node.type) {
+		case QueryNodeType::SELECT_NODE:
+			result = BindWithCTE(node.Cast<SelectNode>());
+			break;
+		case QueryNodeType::RECURSIVE_CTE_NODE:
+			result = BindWithCTE(node.Cast<RecursiveCTENode>());
+			break;
+		case QueryNodeType::CTE_NODE:
+			result = BindWithCTE(node.Cast<CTENode>());
+			break;
+		default:
+			D_ASSERT(node.type == QueryNodeType::SET_OPERATION_NODE);
+			result = BindWithCTE(node.Cast<SetOperationNode>());
+			break;
+		}
+	} else {
+		auto bound_node = BindNode(node);
 
-	// and plan it
-	result.plan = CreatePlan(*bound_node);
+		result.names = bound_node->names;
+		result.types = bound_node->types;
+
+		// and plan it
+		result.plan = CreatePlan(*bound_node);
+	}
 	return result;
 }
 
@@ -285,6 +419,9 @@ unique_ptr<BoundTableRef> Binder::Bind(TableRef &ref) {
 	case TableReferenceType::SHOW_REF:
 		result = Bind(ref.Cast<ShowRef>());
 		break;
+	case TableReferenceType::DELIM_GET:
+		result = Bind(ref.Cast<DelimGetRef>());
+		break;
 	case TableReferenceType::CTE:
 	case TableReferenceType::INVALID:
 	default:
@@ -324,6 +461,9 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableRef &ref) {
 	case TableReferenceType::PIVOT:
 		root = CreatePlan(ref.Cast<BoundPivotRef>());
 		break;
+	case TableReferenceType::DELIM_GET:
+		root = CreatePlan(ref.Cast<BoundDelimGetRef>());
+		break;
 	case TableReferenceType::INVALID:
 	default:
 		throw InternalException("Unsupported bound table ref type (%s)", EnumUtil::ToString(ref.type));
@@ -516,11 +656,28 @@ void Binder::AddTableName(string table_name) {
 	root_binder.table_names.insert(std::move(table_name));
 }
 
+void Binder::AddReplacementScan(const string &table_name, unique_ptr<TableRef> replacement) {
+	auto &root_binder = GetRootBinder();
+	auto it = root_binder.replacement_scans.find(table_name);
+	replacement->column_name_alias.clear();
+	replacement->alias.clear();
+	if (it == root_binder.replacement_scans.end()) {
+		root_binder.replacement_scans[table_name] = std::move(replacement);
+	} else {
+		// A replacement scan by this name was previously registered, we can just use it
+	}
+}
+
 const unordered_set<string> &Binder::GetTableNames() {
 	auto &root_binder = GetRootBinder();
 	return root_binder.table_names;
 }
 
+case_insensitive_map_t<unique_ptr<TableRef>> &Binder::GetReplacementScans() {
+	auto &root_binder = GetRootBinder();
+	return root_binder.replacement_scans;
+}
+
 // FIXME: this is extremely naive
 void VerifyNotExcluded(ParsedExpression &expr) {
 	if (expr.type == ExpressionType::COLUMN_REF) {

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

@@ -0,0 +1,99 @@
+#include "duckdb/planner/collation_binding.hpp"
+#include "duckdb/catalog/catalog_entry/collate_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/main/config.hpp"
+#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/function/function_binder.hpp"
+
+namespace duckdb {
+
+bool PushVarcharCollation(ClientContext &context, unique_ptr<Expression> &source, const LogicalType &sql_type) {
+	if (sql_type.id() != LogicalTypeId::VARCHAR) {
+		// only VARCHAR columns require collation
+		return false;
+	}
+	// replace default collation with system collation
+	auto str_collation = StringType::GetCollation(sql_type);
+	string collation;
+	if (str_collation.empty()) {
+		collation = DBConfig::GetConfig(context).options.collation;
+	} else {
+		collation = str_collation;
+	}
+	collation = StringUtil::Lower(collation);
+	// bind the collation
+	if (collation.empty() || collation == "binary" || collation == "c" || collation == "posix") {
+		// no collation or binary collation: skip
+		return false;
+	}
+	auto &catalog = Catalog::GetSystemCatalog(context);
+	auto splits = StringUtil::Split(StringUtil::Lower(collation), ".");
+	vector<reference<CollateCatalogEntry>> entries;
+	for (auto &collation_argument : splits) {
+		auto &collation_entry = catalog.GetEntry<CollateCatalogEntry>(context, DEFAULT_SCHEMA, collation_argument);
+		if (collation_entry.combinable) {
+			entries.insert(entries.begin(), collation_entry);
+		} else {
+			if (!entries.empty() && !entries.back().get().combinable) {
+				throw BinderException("Cannot combine collation types \"%s\" and \"%s\"", entries.back().get().name,
+				                      collation_entry.name);
+			}
+			entries.push_back(collation_entry);
+		}
+	}
+	for (auto &entry : entries) {
+		auto &collation_entry = entry.get();
+		vector<unique_ptr<Expression>> children;
+		children.push_back(std::move(source));
+
+		FunctionBinder function_binder(context);
+		auto function = function_binder.BindScalarFunction(collation_entry.function, std::move(children));
+		source = std::move(function);
+	}
+	return true;
+}
+
+bool PushTimeTZCollation(ClientContext &context, unique_ptr<Expression> &source, const LogicalType &sql_type) {
+	if (sql_type.id() != LogicalTypeId::TIME_TZ) {
+		return false;
+	}
+
+	auto &catalog = Catalog::GetSystemCatalog(context);
+	auto &function_entry =
+	    catalog.GetEntry<ScalarFunctionCatalogEntry>(context, DEFAULT_SCHEMA, "timetz_byte_comparable");
+	if (function_entry.functions.Size() != 1) {
+		throw InternalException("timetz_byte_comparable should only have a single overload");
+	}
+	auto &scalar_function = function_entry.functions.GetFunctionReferenceByOffset(0);
+	vector<unique_ptr<Expression>> children;
+	children.push_back(std::move(source));
+
+	FunctionBinder function_binder(context);
+	auto function = function_binder.BindScalarFunction(scalar_function, std::move(children));
+	source = std::move(function);
+	return true;
+}
+
+// timetz_byte_comparable
+CollationBinding::CollationBinding() {
+	RegisterCollation(CollationCallback(PushVarcharCollation));
+	RegisterCollation(CollationCallback(PushTimeTZCollation));
+}
+
+void CollationBinding::RegisterCollation(CollationCallback callback) {
+	collations.push_back(callback);
+}
+
+bool CollationBinding::PushCollation(ClientContext &context, unique_ptr<Expression> &source,
+                                     const LogicalType &sql_type) const {
+	for (auto &collation : collations) {
+		if (collation.try_push_collation(context, source, sql_type)) {
+			// successfully pushed a collation
+			return true;
+		}
+	}
+	return false;
+}
+
+} // namespace duckdb

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

@@ -65,7 +65,7 @@ bool BoundAggregateExpression::PropagatesNullValues() const {
 	                                                                        : Expression::PropagatesNullValues();
 }
 
-unique_ptr<Expression> BoundAggregateExpression::Copy() {
+unique_ptr<Expression> BoundAggregateExpression::Copy() const {
 	vector<unique_ptr<Expression>> new_children;
 	new_children.reserve(children.size());
 	for (auto &child : children) {
@@ -94,12 +94,18 @@ unique_ptr<Expression> BoundAggregateExpression::Deserialize(Deserializer &deser
 	auto return_type = deserializer.ReadProperty<LogicalType>(200, "return_type");
 	auto children = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "children");
 	auto entry = FunctionSerializer::Deserialize<AggregateFunction, AggregateFunctionCatalogEntry>(
-	    deserializer, CatalogType::AGGREGATE_FUNCTION_ENTRY, children, std::move(return_type));
+	    deserializer, CatalogType::AGGREGATE_FUNCTION_ENTRY, children, return_type);
 	auto aggregate_type = deserializer.ReadProperty<AggregateType>(203, "aggregate_type");
-	auto filter = deserializer.ReadPropertyWithDefault<unique_ptr<Expression>>(204, "filter", unique_ptr<Expression>());
+	auto filter =
+	    deserializer.ReadPropertyWithExplicitDefault<unique_ptr<Expression>>(204, "filter", unique_ptr<Expression>());
 	auto result = make_uniq<BoundAggregateExpression>(std::move(entry.first), std::move(children), std::move(filter),
 	                                                  std::move(entry.second), aggregate_type);
-	deserializer.ReadPropertyWithDefault(205, "order_bys", result->order_bys, unique_ptr<BoundOrderModifier>());
+	if (result->return_type != return_type) {
+		// return type mismatch - push a cast
+		auto &context = deserializer.Get<ClientContext &>();
+		return BoundCastExpression::AddCastToType(context, std::move(result), return_type);
+	}
+	deserializer.ReadPropertyWithExplicitDefault(205, "order_bys", result->order_bys, unique_ptr<BoundOrderModifier>());
 	return std::move(result);
 }
 

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

@@ -35,7 +35,7 @@ bool BoundBetweenExpression::Equals(const BaseExpression &other_p) const {
 	return lower_inclusive == other.lower_inclusive && upper_inclusive == other.upper_inclusive;
 }
 
-unique_ptr<Expression> BoundBetweenExpression::Copy() {
+unique_ptr<Expression> BoundBetweenExpression::Copy() const {
 	auto copy = make_uniq<BoundBetweenExpression>(input->Copy(), lower->Copy(), upper->Copy(), lower_inclusive,
 	                                              upper_inclusive);
 	copy->CopyProperties(*this);

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

@@ -43,7 +43,7 @@ bool BoundCaseExpression::Equals(const BaseExpression &other_p) const {
 	return true;
 }
 
-unique_ptr<Expression> BoundCaseExpression::Copy() {
+unique_ptr<Expression> BoundCaseExpression::Copy() const {
 	auto new_case = make_uniq<BoundCaseExpression>(return_type);
 	for (auto &check : case_checks) {
 		BoundCaseCheck new_check;

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

@@ -149,26 +149,28 @@ bool BoundCastExpression::CastIsInvertible(const LogicalType &source_type, const
 	case LogicalTypeId::TIMESTAMP_MS:
 	case LogicalTypeId::TIMESTAMP_NS:
 		switch (target_type.id()) {
+			// see types.hpp to see timestamp ranking
+		case LogicalTypeId::TIMESTAMP:
+			return source_type.id() <= LogicalTypeId::TIMESTAMP;
+		case LogicalTypeId::TIMESTAMP_SEC:
+			return source_type.id() <= LogicalTypeId::TIMESTAMP_SEC;
+		case LogicalTypeId::TIMESTAMP_MS:
+			return source_type.id() <= LogicalTypeId::TIMESTAMP_MS;
+		case LogicalTypeId::TIMESTAMP_NS:
+			return source_type.id() <= LogicalTypeId::TIMESTAMP_NS;
 		case LogicalTypeId::DATE:
 		case LogicalTypeId::TIME:
 		case LogicalTypeId::TIME_TZ:
 			return false;
+		case LogicalTypeId::TIMESTAMP_TZ:
+			return source_type.id() == LogicalTypeId::TIMESTAMP_TZ;
 		default:
 			break;
 		}
 		break;
 	case LogicalTypeId::VARCHAR:
-		switch (target_type.id()) {
-		case LogicalTypeId::TIMESTAMP:
-		case LogicalTypeId::TIMESTAMP_NS:
-		case LogicalTypeId::TIMESTAMP_MS:
-		case LogicalTypeId::TIMESTAMP_SEC:
-		case LogicalTypeId::TIMESTAMP_TZ:
-			return true;
-		default:
-			return false;
-		}
-		break;
+	case LogicalTypeId::BIT:
+		return false;
 	default:
 		break;
 	}
@@ -208,7 +210,7 @@ bool BoundCastExpression::Equals(const BaseExpression &other_p) const {
 	return true;
 }
 
-unique_ptr<Expression> BoundCastExpression::Copy() {
+unique_ptr<Expression> BoundCastExpression::Copy() const {
 	auto copy = make_uniq<BoundCastExpression>(child->Copy(), return_type, bound_cast.Copy(), try_cast);
 	copy->CopyProperties(*this);
 	return std::move(copy);

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

@@ -15,7 +15,7 @@ BoundColumnRefExpression::BoundColumnRefExpression(LogicalType type, ColumnBindi
     : BoundColumnRefExpression(string(), std::move(type), binding, depth) {
 }
 
-unique_ptr<Expression> BoundColumnRefExpression::Copy() {
+unique_ptr<Expression> BoundColumnRefExpression::Copy() const {
 	return make_uniq<BoundColumnRefExpression>(alias, return_type, binding, depth);
 }
 

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

@@ -27,7 +27,7 @@ bool BoundComparisonExpression::Equals(const BaseExpression &other_p) const {
 	return true;
 }
 
-unique_ptr<Expression> BoundComparisonExpression::Copy() {
+unique_ptr<Expression> BoundComparisonExpression::Copy() const {
 	auto copy = make_uniq<BoundComparisonExpression>(type, left->Copy(), right->Copy());
 	copy->CopyProperties(*this);
 	return std::move(copy);

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

@@ -31,7 +31,7 @@ bool BoundConjunctionExpression::PropagatesNullValues() const {
 	return false;
 }
 
-unique_ptr<Expression> BoundConjunctionExpression::Copy() {
+unique_ptr<Expression> BoundConjunctionExpression::Copy() const {
 	auto copy = make_uniq<BoundConjunctionExpression>(type);
 	for (auto &expr : children) {
 		copy->children.push_back(expr->Copy());

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

@@ -26,7 +26,7 @@ hash_t BoundConstantExpression::Hash() const {
 	return CombineHash(value.Hash(), result);
 }
 
-unique_ptr<Expression> BoundConstantExpression::Copy() {
+unique_ptr<Expression> BoundConstantExpression::Copy() const {
 	auto copy = make_uniq<BoundConstantExpression>(value);
 	copy->CopyProperties(*this);
 	return std::move(copy);

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

@@ -15,7 +15,7 @@ bool BoundExpandedExpression::Equals(const BaseExpression &other_p) const {
 	return false;
 }
 
-unique_ptr<Expression> BoundExpandedExpression::Copy() {
+unique_ptr<Expression> BoundExpandedExpression::Copy() const {
 	throw SerializationException("Cannot copy BoundExpandedExpression");
 }
 

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

@@ -73,7 +73,7 @@ bool BoundFunctionExpression::Equals(const BaseExpression &other_p) const {
 	return true;
 }
 
-unique_ptr<Expression> BoundFunctionExpression::Copy() {
+unique_ptr<Expression> BoundFunctionExpression::Copy() const {
 	vector<unique_ptr<Expression>> new_children;
 	new_children.reserve(children.size());
 	for (auto &child : children) {
@@ -104,9 +104,15 @@ unique_ptr<Expression> BoundFunctionExpression::Deserialize(Deserializer &deseri
 	auto children = deserializer.ReadProperty<vector<unique_ptr<Expression>>>(201, "children");
 	auto entry = FunctionSerializer::Deserialize<ScalarFunction, ScalarFunctionCatalogEntry>(
 	    deserializer, CatalogType::SCALAR_FUNCTION_ENTRY, children, return_type);
-	auto result = make_uniq<BoundFunctionExpression>(std::move(return_type), std::move(entry.first),
+	auto function_return_type = entry.first.return_type;
+	auto result = make_uniq<BoundFunctionExpression>(std::move(function_return_type), std::move(entry.first),
 	                                                 std::move(children), std::move(entry.second));
 	deserializer.ReadProperty(202, "is_operator", result->is_operator);
+	if (result->return_type != return_type) {
+		// return type mismatch - push a cast
+		auto &context = deserializer.Get<ClientContext &>();
+		return BoundCastExpression::AddCastToType(context, std::move(result), return_type);
+	}
 	return std::move(result);
 }
 

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

@@ -30,7 +30,7 @@ bool BoundLambdaExpression::Equals(const BaseExpression &other_p) const {
 	return true;
 }
 
-unique_ptr<Expression> BoundLambdaExpression::Copy() {
+unique_ptr<Expression> BoundLambdaExpression::Copy() const {
 	auto copy = make_uniq<BoundLambdaExpression>(type, return_type, lambda_expr->Copy(), parameter_count);
 	for (auto &capture : captures) {
 		copy->captures.push_back(capture->Copy());

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

@@ -17,7 +17,7 @@ BoundLambdaRefExpression::BoundLambdaRefExpression(LogicalType type, ColumnBindi
     : BoundLambdaRefExpression(string(), std::move(type), binding, lambda_idx, depth) {
 }
 
-unique_ptr<Expression> BoundLambdaRefExpression::Copy() {
+unique_ptr<Expression> BoundLambdaRefExpression::Copy() const {
 	return make_uniq<BoundLambdaRefExpression>(alias, return_type, binding, lambda_idx, depth);
 }
 

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

@@ -23,7 +23,7 @@ bool BoundOperatorExpression::Equals(const BaseExpression &other_p) const {
 	return true;
 }
 
-unique_ptr<Expression> BoundOperatorExpression::Copy() {
+unique_ptr<Expression> BoundOperatorExpression::Copy() const {
 	auto copy = make_uniq<BoundOperatorExpression>(type, return_type);
 	copy->CopyProperties(*this);
 	for (auto &child : children) {

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

@@ -73,7 +73,7 @@ hash_t BoundParameterExpression::Hash() const {
 	return result;
 }
 
-unique_ptr<Expression> BoundParameterExpression::Copy() {
+unique_ptr<Expression> BoundParameterExpression::Copy() const {
 	auto result = make_uniq<BoundParameterExpression>(identifier);
 	result->parameter_data = parameter_data;
 	result->return_type = return_type;

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

@@ -38,7 +38,7 @@ hash_t BoundReferenceExpression::Hash() const {
 	return CombineHash(Expression::Hash(), duckdb::Hash<idx_t>(index));
 }
 
-unique_ptr<Expression> BoundReferenceExpression::Copy() {
+unique_ptr<Expression> BoundReferenceExpression::Copy() const {
 	return make_uniq<BoundReferenceExpression>(alias, return_type, index);
 }
 

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

@@ -17,7 +17,7 @@ bool BoundSubqueryExpression::Equals(const BaseExpression &other_p) const {
 	return false;
 }
 
-unique_ptr<Expression> BoundSubqueryExpression::Copy() {
+unique_ptr<Expression> BoundSubqueryExpression::Copy() const {
 	throw SerializationException("Cannot copy BoundSubqueryExpression");
 }
 

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

@@ -33,7 +33,7 @@ bool BoundUnnestExpression::Equals(const BaseExpression &other_p) const {
 	return true;
 }
 
-unique_ptr<Expression> BoundUnnestExpression::Copy() {
+unique_ptr<Expression> BoundUnnestExpression::Copy() const {
 	auto copy = make_uniq<BoundUnnestExpression>(return_type);
 	copy->child = child->Copy();
 	return std::move(copy);

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

@@ -120,7 +120,7 @@ bool BoundWindowExpression::KeysAreCompatible(const BoundWindowExpression &other
 	return true;
 }
 
-unique_ptr<Expression> BoundWindowExpression::Copy() {
+unique_ptr<Expression> BoundWindowExpression::Copy() const {
 	auto new_window = make_uniq<BoundWindowExpression>(type, return_type, nullptr, nullptr);
 	new_window->CopyProperties(*this);
 
@@ -208,14 +208,14 @@ unique_ptr<Expression> BoundWindowExpression::Deserialize(Deserializer &deserial
 	result->children = std::move(children);
 	deserializer.ReadProperty(202, "partitions", result->partitions);
 	deserializer.ReadProperty(203, "orders", result->orders);
-	deserializer.ReadPropertyWithDefault(204, "filters", result->filter_expr, unique_ptr<Expression>());
+	deserializer.ReadPropertyWithExplicitDefault(204, "filters", result->filter_expr, unique_ptr<Expression>());
 	deserializer.ReadProperty(205, "ignore_nulls", result->ignore_nulls);
 	deserializer.ReadProperty(206, "start", result->start);
 	deserializer.ReadProperty(207, "end", result->end);
-	deserializer.ReadPropertyWithDefault(208, "start_expr", result->start_expr, unique_ptr<Expression>());
-	deserializer.ReadPropertyWithDefault(209, "end_expr", result->end_expr, unique_ptr<Expression>());
-	deserializer.ReadPropertyWithDefault(210, "offset_expr", result->offset_expr, unique_ptr<Expression>());
-	deserializer.ReadPropertyWithDefault(211, "default_expr", result->default_expr, unique_ptr<Expression>());
+	deserializer.ReadPropertyWithExplicitDefault(208, "start_expr", result->start_expr, unique_ptr<Expression>());
+	deserializer.ReadPropertyWithExplicitDefault(209, "end_expr", result->end_expr, unique_ptr<Expression>());
+	deserializer.ReadPropertyWithExplicitDefault(210, "offset_expr", result->offset_expr, unique_ptr<Expression>());
+	deserializer.ReadPropertyWithExplicitDefault(211, "default_expr", result->default_expr, unique_ptr<Expression>());
 	deserializer.ReadProperty(212, "exclude_clause", result->exclude_clause);
 	deserializer.ReadProperty(213, "distinct", result->distinct);
 	return std::move(result);

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

@@ -11,7 +11,7 @@ BindResult AggregateBinder::BindExpression(unique_ptr<ParsedExpression> &expr_pt
 	auto &expr = *expr_ptr;
 	switch (expr.expression_class) {
 	case ExpressionClass::WINDOW:
-		throw ParserException("aggregate function calls cannot contain window function calls");
+		throw BinderException::Unsupported(expr, "aggregate function calls cannot contain window function calls");
 	default:
 		return ExpressionBinder::BindExpression(expr_ptr, depth);
 	}