duckdb 0.10.3-dev3.0 → 0.10.3-dev8.0

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

@@ -16,6 +16,8 @@
 #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 <algorithm>
 
@@ -39,26 +41,27 @@ idx_t Binder::GetBinderDepth() const {
 	return depth;
 }
 
-shared_ptr<Binder> Binder::CreateBinder(ClientContext &context, optional_ptr<Binder> parent, bool inherit_ctes) {
+shared_ptr<Binder> Binder::CreateBinder(ClientContext &context, optional_ptr<Binder> parent, BinderType binder_type) {
 	auto depth = parent ? parent->GetBinderDepth() : 0;
 	if (depth > context.config.max_expression_depth) {
 		throw BinderException("Max expression depth limit of %lld exceeded. Use \"SET max_expression_depth TO x\" to "
 		                      "increase the maximum expression depth.",
 		                      context.config.max_expression_depth);
 	}
-	return make_shared<Binder>(true, context, parent ? parent->shared_from_this() : nullptr, inherit_ctes);
+	return make_shared_ptr<Binder>(true, context, parent ? parent->shared_from_this() : nullptr, binder_type);
 }
 
-Binder::Binder(bool, ClientContext &context, shared_ptr<Binder> parent_p, bool inherit_ctes_p)
-    : context(context), bind_context(*this), parent(std::move(parent_p)), bound_tables(0),
-      inherit_ctes(inherit_ctes_p) {
+Binder::Binder(bool, 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) {
+		entry_retriever.SetCallback(parent->entry_retriever.GetCallback());
 
 		// We have to inherit macro and lambda parameter bindings and from the parent binder, if there is a parent.
 		macro_binding = parent->macro_binding;
 		lambda_bindings = parent->lambda_bindings;
 
-		if (inherit_ctes) {
+		if (binder_type == BinderType::REGULAR_BINDER) {
 			// We have to inherit CTE bindings from the parent bind_context, if there is a parent.
 			bind_context.SetCTEBindings(parent->bind_context.GetCTEBindings());
 			bind_context.cte_references = parent->bind_context.cte_references;
@@ -110,22 +113,22 @@ BoundStatement Binder::BindWithCTE(T &statement) {
 	BoundStatement bound_statement;
 	auto bound_cte = BindMaterializedCTE(statement.template Cast<T>().cte_map);
 	if (bound_cte) {
-		BoundCTENode *tail = bound_cte.get();
+		reference<BoundCTENode> tail_ref = *bound_cte;
 
-		while (tail->child && tail->child->type == QueryNodeType::CTE_NODE) {
-			tail = &tail->child->Cast<BoundCTENode>();
+		while (tail_ref.get().child && tail_ref.get().child->type == QueryNodeType::CTE_NODE) {
+			tail_ref = tail_ref.get().child->Cast<BoundCTENode>();
 		}
 
-		bound_statement = tail->child_binder->Bind(statement.template Cast<T>());
+		auto &tail = tail_ref.get();
+		bound_statement = tail.child_binder->Bind(statement.template Cast<T>());
 
-		tail->types = bound_statement.types;
-		tail->names = bound_statement.names;
+		tail.types = bound_statement.types;
+		tail.names = bound_statement.names;
 
-		for (auto &c : tail->query_binder->correlated_columns) {
-			tail->child_binder->AddCorrelatedColumn(c);
+		for (auto &c : tail.query_binder->correlated_columns) {
+			tail.child_binder->AddCorrelatedColumn(c);
 		}
-
-		MoveCorrelatedExpressions(*tail->child_binder);
+		MoveCorrelatedExpressions(*tail.child_binder);
 
 		// extract operator below root operation
 		auto plan = std::move(bound_statement.plan->children[0]);
@@ -188,6 +191,8 @@ BoundStatement Binder::Bind(SQLStatement &statement) {
 		return Bind(statement.Cast<DetachStatement>());
 	case StatementType::COPY_DATABASE_STATEMENT:
 		return Bind(statement.Cast<CopyDatabaseStatement>());
+	case StatementType::UPDATE_EXTENSIONS_STATEMENT:
+		return Bind(statement.Cast<UpdateExtensionsStatement>());
 	default: // LCOV_EXCL_START
 		throw NotImplementedException("Unimplemented statement type \"%s\" for Bind",
 		                              StatementTypeToString(statement.type));
@@ -271,6 +276,9 @@ unique_ptr<BoundTableRef> Binder::Bind(TableRef &ref) {
 	case TableReferenceType::EXPRESSION_LIST:
 		result = Bind(ref.Cast<ExpressionListRef>());
 		break;
+	case TableReferenceType::COLUMN_DATA:
+		result = Bind(ref.Cast<ColumnDataRef>());
+		break;
 	case TableReferenceType::PIVOT:
 		result = Bind(ref.Cast<PivotRef>());
 		break;
@@ -280,7 +288,7 @@ unique_ptr<BoundTableRef> Binder::Bind(TableRef &ref) {
 	case TableReferenceType::CTE:
 	case TableReferenceType::INVALID:
 	default:
-		throw InternalException("Unknown table ref type");
+		throw InternalException("Unknown table ref type (%s)", EnumUtil::ToString(ref.type));
 	}
 	result->sample = std::move(ref.sample);
 	return result;
@@ -307,6 +315,9 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableRef &ref) {
 	case TableReferenceType::EXPRESSION_LIST:
 		root = CreatePlan(ref.Cast<BoundExpressionListRef>());
 		break;
+	case TableReferenceType::COLUMN_DATA:
+		root = CreatePlan(ref.Cast<BoundColumnDataRef>());
+		break;
 	case TableReferenceType::CTE:
 		root = CreatePlan(ref.Cast<BoundCTERef>());
 		break;
@@ -315,7 +326,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableRef &ref) {
 		break;
 	case TableReferenceType::INVALID:
 	default:
-		throw InternalException("Unsupported bound table ref type");
+		throw InternalException("Unsupported bound table ref type (%s)", EnumUtil::ToString(ref.type));
 	}
 	// plan the sample clause
 	if (ref.sample) {
@@ -341,7 +352,7 @@ vector<reference<CommonTableExpressionInfo>> Binder::FindCTE(const string &name,
 			ctes.push_back(entry->second);
 		}
 	}
-	if (parent && inherit_ctes) {
+	if (parent && binder_type == BinderType::REGULAR_BINDER) {
 		auto parent_ctes = parent->FindCTE(name, name == alias);
 		ctes.insert(ctes.end(), parent_ctes.begin(), parent_ctes.end());
 	}
@@ -352,7 +363,7 @@ bool Binder::CTEIsAlreadyBound(CommonTableExpressionInfo &cte) {
 	if (bound_ctes.find(cte) != bound_ctes.end()) {
 		return true;
 	}
-	if (parent && inherit_ctes) {
+	if (parent && binder_type == BinderType::REGULAR_BINDER) {
 		return parent->CTEIsAlreadyBound(cte);
 	}
 	return false;
@@ -375,6 +386,11 @@ idx_t Binder::GenerateTableIndex() {
 	return root_binder.bound_tables++;
 }
 
+StatementProperties &Binder::GetStatementProperties() {
+	auto &root_binder = GetRootBinder();
+	return root_binder.prop;
+}
+
 void Binder::PushExpressionBinder(ExpressionBinder &binder) {
 	GetActiveBinders().push_back(binder);
 }
@@ -398,7 +414,11 @@ bool Binder::HasActiveBinder() {
 }
 
 vector<reference<ExpressionBinder>> &Binder::GetActiveBinders() {
-	auto &root_binder = GetRootBinder();
+	reference<Binder> root = *this;
+	while (root.get().parent && root.get().binder_type == BinderType::REGULAR_BINDER) {
+		root = *root.get().parent;
+	}
+	auto &root_binder = root.get();
 	return root_binder.active_binders;
 }
 
@@ -487,15 +507,8 @@ void Binder::SetCanContainNulls(bool can_contain_nulls_p) {
 }
 
 void Binder::SetAlwaysRequireRebind() {
-	reference<Binder> current_binder = *this;
-	while (true) {
-		auto &current = current_binder.get();
-		current.properties.always_require_rebind = true;
-		if (!current.parent) {
-			break;
-		}
-		current_binder = *current.parent;
-	}
+	auto &properties = GetStatementProperties();
+	properties.always_require_rebind = true;
 }
 
 void Binder::AddTableName(string table_name) {
@@ -571,9 +584,16 @@ BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> return
 	// where the data modification doesn't take place until the streamed result is exhausted. Once a row is
 	// returned, it should be guaranteed that the row has been inserted.
 	// see https://github.com/duckdb/duckdb/issues/8310
+	auto &properties = GetStatementProperties();
 	properties.allow_stream_result = false;
 	properties.return_type = StatementReturnType::QUERY_RESULT;
 	return result;
 }
 
+optional_ptr<CatalogEntry> Binder::GetCatalogEntry(CatalogType type, const string &catalog, const string &schema,
+                                                   const string &name, OnEntryNotFound on_entry_not_found,
+                                                   QueryErrorContext &error_context) {
+	return entry_retriever.GetEntry(type, catalog, schema, name, on_entry_not_found, error_context);
+}
+
 } // namespace duckdb

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

@@ -33,7 +33,7 @@ shared_ptr<BoundParameterData> BoundParameterMap::CreateOrGetData(const string &
 	auto entry = parameters.find(identifier);
 	if (entry == parameters.end()) {
 		// no entry yet: create a new one
-		auto data = make_shared<BoundParameterData>();
+		auto data = make_shared_ptr<BoundParameterData>();
 		data->return_type = GetReturnType(identifier);
 
 		CreateNewParameter(identifier, data);

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

@@ -126,7 +126,7 @@ BoundLimitNode::BoundLimitNode() : type(LimitNodeType::UNSET) {
 }
 
 BoundLimitNode::BoundLimitNode(int64_t constant_value)
-    : type(LimitNodeType::CONSTANT_VALUE), constant_integer(constant_value) {
+    : type(LimitNodeType::CONSTANT_VALUE), constant_integer(NumericCast<idx_t>(constant_value)) {
 }
 
 BoundLimitNode::BoundLimitNode(double percentage_value)

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

@@ -1,4 +1,5 @@
 #include "duckdb/parser/expression/bound_expression.hpp"
+#include "duckdb/common/enum_util.hpp"
 
 namespace duckdb {
 
@@ -30,11 +31,11 @@ hash_t BoundExpression::Hash() const {
 }
 
 unique_ptr<ParsedExpression> BoundExpression::Copy() const {
-	throw SerializationException("Cannot copy or serialize bound expression");
+	throw SerializationException("Cannot copy bound expression");
 }
 
 void BoundExpression::Serialize(Serializer &serializer) const {
-	throw SerializationException("Cannot copy or serialize bound expression");
+	throw SerializationException("Cannot serialize bound expression");
 }
 
 } // namespace duckdb

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

@@ -1,8 +1,9 @@
 #include "duckdb/planner/expression_binder/alter_binder.hpp"
 
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/planner/table_binding.hpp"
 
 namespace duckdb {
 
@@ -12,6 +13,12 @@ AlterBinder::AlterBinder(Binder &binder, ClientContext &context, TableCatalogEnt
 	this->target_type = std::move(target_type);
 }
 
+BindResult AlterBinder::BindLambdaReference(LambdaRefExpression &expr, idx_t depth) {
+	D_ASSERT(lambda_bindings && expr.lambda_idx < lambda_bindings->size());
+	auto &lambda_ref = expr.Cast<LambdaRefExpression>();
+	return (*lambda_bindings)[expr.lambda_idx].Bind(lambda_ref, depth);
+}
+
 BindResult AlterBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
 	auto &expr = *expr_ptr;
 	switch (expr.GetExpressionClass()) {
@@ -20,7 +27,7 @@ BindResult AlterBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, i
 	case ExpressionClass::SUBQUERY:
 		return BindResult("cannot use subquery in alter statement");
 	case ExpressionClass::COLUMN_REF:
-		return BindColumn(expr.Cast<ColumnRefExpression>());
+		return BindColumnReference(expr.Cast<ColumnRefExpression>(), depth);
 	default:
 		return ExpressionBinder::BindExpression(expr_ptr, depth);
 	}
@@ -30,14 +37,24 @@ string AlterBinder::UnsupportedAggregateMessage() {
 	return "aggregate functions are not allowed in alter statement";
 }
 
-BindResult AlterBinder::BindColumn(ColumnRefExpression &colref) {
-	if (colref.column_names.size() > 1) {
-		return BindQualifiedColumnName(colref, table.name);
+BindResult AlterBinder::BindColumnReference(ColumnRefExpression &col_ref, idx_t depth) {
+
+	// try binding as a lambda parameter
+	if (!col_ref.IsQualified()) {
+		auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, col_ref.GetName());
+		if (lambda_ref) {
+			return BindLambdaReference(lambda_ref->Cast<LambdaRefExpression>(), depth);
+		}
+	}
+
+	if (col_ref.column_names.size() > 1) {
+		return BindQualifiedColumnName(col_ref, table.name);
 	}
-	auto idx = table.GetColumnIndex(colref.column_names[0], true);
+
+	auto idx = table.GetColumnIndex(col_ref.column_names[0], true);
 	if (!idx.IsValid()) {
 		throw BinderException("Table does not contain column %s referenced in alter statement!",
-		                      colref.column_names[0]);
+		                      col_ref.column_names[0]);
 	}
 	if (table.GetColumn(idx).Generated()) {
 		throw BinderException("Using generated columns in alter statement not supported");

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

@@ -3,9 +3,12 @@
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/parser/expression/operator_expression.hpp"
+#include "duckdb/planner/expression/bound_operator_expression.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/parser/expression/window_expression.hpp"
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
+#include "duckdb/planner/expression/bound_case_expression.hpp"
 #include "duckdb/planner/expression_binder/aggregate_binder.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
 #include "duckdb/planner/expression_binder/select_bind_state.hpp"
@@ -98,8 +101,30 @@ BindResult BaseSelectBinder::BindGroup(ParsedExpression &expr, idx_t depth, idx_
 	if (it != info.collated_groups.end()) {
 		// This is an implicitly collated group, so we need to refer to the first() aggregate
 		const auto &aggr_index = it->second;
-		return BindResult(make_uniq<BoundColumnRefExpression>(expr.GetName(), node.aggregates[aggr_index]->return_type,
-		                                                      ColumnBinding(node.aggregate_index, aggr_index), depth));
+		auto uncollated_first_expression =
+		    make_uniq<BoundColumnRefExpression>(expr.GetName(), node.aggregates[aggr_index]->return_type,
+		                                        ColumnBinding(node.aggregate_index, aggr_index), depth);
+
+		if (node.groups.grouping_sets.size() <= 1) {
+			// if there are no more than two grouping sets, you can return the uncollated first expression.
+			// "first" meaning the aggreagte function.
+			return BindResult(std::move(uncollated_first_expression));
+		}
+
+		// otherwise we insert a case statement to return NULL when the collated group expression is NULL
+		// otherwise you can return the "first" of the uncollated expression.
+		auto &group = node.groups.group_expressions[group_index];
+		auto collated_group_expression = make_uniq<BoundColumnRefExpression>(
+		    expr.GetName(), group->return_type, ColumnBinding(node.group_index, group_index), depth);
+
+		auto sql_null = make_uniq<BoundConstantExpression>(Value(LogicalType::VARCHAR));
+		auto when_expr = make_uniq<BoundOperatorExpression>(ExpressionType::OPERATOR_IS_NULL, LogicalType::BOOLEAN);
+		when_expr->children.push_back(std::move(collated_group_expression));
+		auto then_expr = make_uniq<BoundConstantExpression>(Value(LogicalType::VARCHAR));
+		auto else_expr = std::move(uncollated_first_expression);
+		auto case_expr =
+		    make_uniq<BoundCaseExpression>(std::move(when_expr), std::move(then_expr), std::move(else_expr));
+		return BindResult(std::move(case_expr));
 	} else {
 		auto &group = node.groups.group_expressions[group_index];
 		return BindResult(make_uniq<BoundColumnRefExpression>(expr.GetName(), group->return_type,

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

@@ -15,14 +15,29 @@ HavingBinder::HavingBinder(Binder &binder, ClientContext &context, BoundSelectNo
 	target_type = LogicalType(LogicalTypeId::BOOLEAN);
 }
 
+BindResult HavingBinder::BindLambdaReference(LambdaRefExpression &expr, idx_t depth) {
+	D_ASSERT(lambda_bindings && expr.lambda_idx < lambda_bindings->size());
+	auto &lambda_ref = expr.Cast<LambdaRefExpression>();
+	return (*lambda_bindings)[expr.lambda_idx].Bind(lambda_ref, depth);
+}
+
 BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
+
 	// Keep the original column name to return a meaningful error message.
-	auto column_name = expr_ptr->Cast<ColumnRefExpression>().GetColumnName();
+	auto col_ref = expr_ptr->Cast<ColumnRefExpression>();
+	const auto &column_name = col_ref.GetColumnName();
+
+	// Try binding as a lambda parameter
+	if (!col_ref.IsQualified()) {
+		auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, col_ref.GetName());
+		if (lambda_ref) {
+			return BindLambdaReference(lambda_ref->Cast<LambdaRefExpression>(), depth);
+		}
+	}
 
 	// Bind the alias.
 	BindResult alias_result;
 	auto found_alias = column_alias_binder.BindAlias(*this, expr_ptr, depth, root_expression, alias_result);
-
 	if (found_alias) {
 		if (depth > 0) {
 			throw BinderException("Having clause cannot reference alias \"%s\" in correlated subquery", column_name);
@@ -30,27 +45,27 @@ BindResult HavingBinder::BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, i
 		return alias_result;
 	}
 
-	if (aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
-		if (depth > 0) {
-			throw BinderException(
-			    "Having clause cannot reference column \"%s\" in correlated subquery and group by all", column_name);
-		}
+	if (aggregate_handling != AggregateHandling::FORCE_AGGREGATES) {
+		return BindResult(StringUtil::Format(
+		    "column %s must appear in the GROUP BY clause or be used in an aggregate function", column_name));
+	}
 
-		auto expr = duckdb::BaseSelectBinder::BindColumnRef(expr_ptr, depth, root_expression);
-		if (expr.HasError()) {
-			return expr;
-		}
+	if (depth > 0) {
+		throw BinderException("Having clause cannot reference column \"%s\" in correlated subquery and group by all",
+		                      column_name);
+	}
 
-		// Return a GROUP BY column reference expression.
-		auto return_type = expr.expression->return_type;
-		auto column_binding = ColumnBinding(node.group_index, node.groups.group_expressions.size());
-		auto group_ref = make_uniq<BoundColumnRefExpression>(return_type, column_binding);
-		node.groups.group_expressions.push_back(std::move(expr.expression));
-		return BindResult(std::move(group_ref));
+	auto expr = duckdb::BaseSelectBinder::BindColumnRef(expr_ptr, depth, root_expression);
+	if (expr.HasError()) {
+		return expr;
 	}
 
-	return BindResult(StringUtil::Format(
-	    "column %s must appear in the GROUP BY clause or be used in an aggregate function", column_name));
+	// Return a GROUP BY column reference expression.
+	auto return_type = expr.expression->return_type;
+	auto column_binding = ColumnBinding(node.group_index, node.groups.group_expressions.size());
+	auto group_ref = make_uniq<BoundColumnRefExpression>(return_type, column_binding);
+	node.groups.group_expressions.push_back(std::move(expr.expression));
+	return BindResult(std::move(group_ref));
 }
 
 BindResult HavingBinder::BindWindow(WindowExpression &expr, idx_t depth) {

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

@@ -4,6 +4,10 @@
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/column_binding.hpp"
+#include "duckdb/execution/index/bound_index.hpp"
+#include "duckdb/execution/index/unbound_index.hpp"
+#include "duckdb/main/config.hpp"
+#include "duckdb/main/database.hpp"
 
 namespace duckdb {
 
@@ -12,6 +16,35 @@ IndexBinder::IndexBinder(Binder &binder, ClientContext &context, optional_ptr<Ta
     : ExpressionBinder(binder, context), table(table), info(info) {
 }
 
+unique_ptr<BoundIndex> IndexBinder::BindIndex(const UnboundIndex &unbound_index) {
+	auto &index_type_name = unbound_index.GetIndexType();
+	// Do we know the type of this index now?
+	auto index_type = context.db->config.GetIndexTypes().FindByName(index_type_name);
+	if (!index_type) {
+		throw MissingExtensionException("Cannot bind index '%s', unknown index type '%s'. You need to load the "
+		                                "extension that provides this index type before table '%s' can be modified.",
+		                                unbound_index.GetTableName(), index_type_name, unbound_index.GetTableName());
+	}
+
+	auto &create_info = unbound_index.GetCreateInfo();
+	auto &storage_info = unbound_index.GetStorageInfo();
+	auto &parsed_expressions = unbound_index.GetParsedExpressions();
+
+	// bind the parsed expressions to create unbound expressions
+	vector<unique_ptr<Expression>> unbound_expressions;
+	unbound_expressions.reserve(parsed_expressions.size());
+	for (auto &expr : parsed_expressions) {
+		auto copy = expr->Copy();
+		unbound_expressions.push_back(Bind(copy));
+	}
+
+	CreateIndexInput input(unbound_index.table_io_manager, unbound_index.db, create_info.constraint_type,
+	                       create_info.index_name, create_info.column_ids, unbound_expressions, storage_info,
+	                       create_info.options);
+
+	return index_type->create_instance(input);
+}
+
 BindResult IndexBinder::BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) {
 	auto &expr = *expr_ptr;
 	switch (expr.expression_class) {

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

@@ -108,7 +108,16 @@ unique_ptr<Expression> OrderBinder::Bind(unique_ptr<ParsedExpression> expr) {
 		auto &collation = expr->Cast<CollateExpression>();
 		if (collation.child->expression_class == ExpressionClass::CONSTANT) {
 			auto &constant = collation.child->Cast<ConstantExpression>();
-			auto index = NumericCast<idx_t>(constant.value.GetValue<idx_t>()) - 1;
+
+			// non-integral expression, we just leave the constant here.
+			// ORDER BY <constant> has no effect
+			// CONTROVERSIAL: maybe we should throw an error
+			if (!constant.value.type().IsIntegral()) {
+				return nullptr;
+			}
+
+			D_ASSERT(constant.value.GetValue<idx_t>() > 0);
+			auto index = constant.value.GetValue<idx_t>() - 1;
 			child_list_t<Value> values;
 			values.push_back(make_pair("index", Value::UBIGINT(index)));
 			values.push_back(make_pair("collation", Value(std::move(collation.collation))));

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

@@ -9,6 +9,10 @@
 
 namespace duckdb {
 
+void ExpressionBinder::SetCatalogLookupCallback(catalog_entry_callback_t callback) {
+	binder.SetCatalogLookupCallback(std::move(callback));
+}
+
 ExpressionBinder::ExpressionBinder(Binder &binder, ClientContext &context, bool replace_binder)
     : binder(binder), context(context) {
 	InitializeStackCheck();

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

@@ -7,6 +7,7 @@
 #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"
+#include "duckdb/common/enum_util.hpp"
 
 namespace duckdb {
 
@@ -269,7 +270,8 @@ void BoundNodeVisitor::VisitBoundTableRef(BoundTableRef &ref) {
 	case TableReferenceType::CTE:
 		break;
 	default:
-		throw NotImplementedException("Unimplemented table reference type in ExpressionIterator");
+		throw NotImplementedException("Unimplemented table reference type (%s) in ExpressionIterator",
+		                              EnumUtil::ToString(ref.type));
 	}
 }
 

package/src/duckdb/src/planner/filter/constant_filter.cpp

@@ -32,7 +32,7 @@ FilterPropagateResult ConstantFilter::CheckStatistics(BaseStatistics &stats) {
 }
 
 string ConstantFilter::ToString(const string &column_name) {
-	return column_name + ExpressionTypeToOperator(comparison_type) + constant.ToString();
+	return column_name + ExpressionTypeToOperator(comparison_type) + constant.ToSQLString();
 }
 
 bool ConstantFilter::Equals(const TableFilter &other_p) const {

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

@@ -6,9 +6,23 @@
 namespace duckdb {
 
 LogicalColumnDataGet::LogicalColumnDataGet(idx_t table_index, vector<LogicalType> types,
-                                           unique_ptr<ColumnDataCollection> collection)
+                                           unique_ptr<ColumnDataCollection> collection_p)
     : LogicalOperator(LogicalOperatorType::LOGICAL_CHUNK_GET), table_index(table_index),
-      collection(std::move(collection)) {
+      collection(std::move(collection_p)) {
+	D_ASSERT(types.size() > 0);
+	chunk_types = std::move(types);
+}
+
+LogicalColumnDataGet::LogicalColumnDataGet(idx_t table_index, vector<LogicalType> types, ColumnDataCollection &to_scan)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_CHUNK_GET), table_index(table_index), collection(to_scan) {
+	D_ASSERT(types.size() > 0);
+	chunk_types = std::move(types);
+}
+
+LogicalColumnDataGet::LogicalColumnDataGet(idx_t table_index, vector<LogicalType> types,
+                                           optionally_owned_ptr<ColumnDataCollection> collection_p)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_CHUNK_GET), table_index(table_index),
+      collection(std::move(collection_p)) {
 	D_ASSERT(types.size() > 0);
 	chunk_types = std::move(types);
 }

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

@@ -15,6 +15,8 @@ LogicalDelete::LogicalDelete(ClientContext &context, const unique_ptr<CreateInfo
     : LogicalOperator(LogicalOperatorType::LOGICAL_DELETE),
       table(Catalog::GetEntry<TableCatalogEntry>(context, table_info->catalog, table_info->schema,
                                                  table_info->Cast<CreateTableInfo>().table)) {
+	auto binder = Binder::CreateBinder(context);
+	bound_constraints = binder->BindConstraints(table);
 }
 
 idx_t LogicalDelete::EstimateCardinality(ClientContext &context) {

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

@@ -9,6 +9,7 @@
 #include "duckdb/storage/data_table.hpp"
 #include "duckdb/common/serializer/serializer.hpp"
 #include "duckdb/common/serializer/deserializer.hpp"
+#include "duckdb/parser/tableref/table_function_ref.hpp"
 
 namespace duckdb {
 
@@ -164,8 +165,10 @@ unique_ptr<LogicalOperator> LogicalGet::Deserialize(Deserializer &deserializer)
 		deserializer.ReadProperty(207, "named_parameters", result->named_parameters);
 		deserializer.ReadProperty(208, "input_table_types", result->input_table_types);
 		deserializer.ReadProperty(209, "input_table_names", result->input_table_names);
+		TableFunctionRef empty_ref;
 		TableFunctionBindInput input(result->parameters, result->named_parameters, result->input_table_types,
-		                             result->input_table_names, function.function_info.get(), nullptr);
+		                             result->input_table_names, function.function_info.get(), nullptr, result->function,
+		                             empty_ref);
 
 		vector<LogicalType> bind_return_types;
 		vector<string> bind_names;

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

@@ -15,6 +15,8 @@ LogicalInsert::LogicalInsert(ClientContext &context, const unique_ptr<CreateInfo
     : LogicalOperator(LogicalOperatorType::LOGICAL_INSERT),
       table(Catalog::GetEntry<TableCatalogEntry>(context, table_info->catalog, table_info->schema,
                                                  table_info->Cast<CreateTableInfo>().table)) {
+	auto binder = Binder::CreateBinder(context);
+	bound_constraints = binder->BindConstraints(table);
 }
 
 idx_t LogicalInsert::EstimateCardinality(ClientContext &context) {

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

@@ -4,7 +4,7 @@ namespace duckdb {
 
 idx_t LogicalTopN::EstimateCardinality(ClientContext &context) {
 	auto child_cardinality = LogicalOperator::EstimateCardinality(context);
-	if (limit >= 0 && child_cardinality < idx_t(limit)) {
+	if (child_cardinality < limit) {
 		return limit;
 	}
 	return child_cardinality;

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

@@ -13,6 +13,8 @@ LogicalUpdate::LogicalUpdate(ClientContext &context, const unique_ptr<CreateInfo
     : LogicalOperator(LogicalOperatorType::LOGICAL_UPDATE),
       table(Catalog::GetEntry<TableCatalogEntry>(context, table_info->catalog, table_info->schema,
                                                  table_info->Cast<CreateTableInfo>().table)) {
+	auto binder = Binder::CreateBinder(context);
+	bound_constraints = binder->BindConstraints(table);
 }
 
 idx_t LogicalUpdate::EstimateCardinality(ClientContext &context) {