duckdb 1.1.2-dev6.0 → 1.1.4-dev11.0

package/src/duckdb/src/include/duckdb/parser/qualified_name.hpp

@@ -12,6 +12,7 @@
 #include "duckdb/common/exception/parser_exception.hpp"
 #include "duckdb/parser/keyword_helper.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/planner/binding_alias.hpp"
 
 namespace duckdb {
 
@@ -22,70 +23,29 @@ struct QualifiedName {
 
 	//! Parse the (optional) schema and a name from a string in the format of e.g. "schema"."table"; if there is no dot
 	//! the schema will be set to INVALID_SCHEMA
-	static QualifiedName Parse(const string &input) {
-		string catalog;
-		string schema;
-		string name;
-		idx_t idx = 0;
-		vector<string> entries;
-		string entry;
-	normal:
-		//! quote
-		for (; idx < input.size(); idx++) {
-			if (input[idx] == '"') {
-				idx++;
-				goto quoted;
-			} else if (input[idx] == '.') {
-				goto separator;
-			}
-			entry += input[idx];
-		}
-		goto end;
-	separator:
-		entries.push_back(entry);
-		entry = "";
-		idx++;
-		goto normal;
-	quoted:
-		//! look for another quote
-		for (; idx < input.size(); idx++) {
-			if (input[idx] == '"') {
-				//! unquote
-				idx++;
-				goto normal;
-			}
-			entry += input[idx];
-		}
-		throw ParserException("Unterminated quote in qualified name!");
-	end:
-		if (entries.empty()) {
-			catalog = INVALID_CATALOG;
-			schema = INVALID_SCHEMA;
-			name = entry;
-		} else if (entries.size() == 1) {
-			catalog = INVALID_CATALOG;
-			schema = entries[0];
-			name = entry;
-		} else if (entries.size() == 2) {
-			catalog = entries[0];
-			schema = entries[1];
-			name = entry;
-		} else {
-			throw ParserException("Expected catalog.entry, schema.entry or entry: too many entries found");
-		}
-		return QualifiedName {catalog, schema, name};
-	}
+	static QualifiedName Parse(const string &input);
+	string ToString() const;
 };
 
 struct QualifiedColumnName {
-	QualifiedColumnName() {
-	}
-	QualifiedColumnName(string table_p, string column_p) : table(std::move(table_p)), column(std::move(column_p)) {
-	}
+	QualifiedColumnName();
+	QualifiedColumnName(string column_p); // NOLINT: allow implicit conversion from string to column name
+	QualifiedColumnName(string table_p, string column_p);
+	QualifiedColumnName(const BindingAlias &alias, string column_p);
 
+	string catalog;
 	string schema;
 	string table;
 	string column;
+
+	string ToString() const;
+
+	void Serialize(Serializer &serializer) const;
+	static QualifiedColumnName Deserialize(Deserializer &deserializer);
+
+	bool IsQualified() const;
+
+	bool operator==(const QualifiedColumnName &rhs) const;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/qualified_name_set.hpp

@@ -16,17 +16,33 @@ namespace duckdb {
 
 struct QualifiedColumnHashFunction {
 	uint64_t operator()(const QualifiedColumnName &a) const {
-		std::hash<std::string> str_hasher;
-		return str_hasher(a.schema) ^ str_hasher(a.table) ^ str_hasher(a.column);
+		// hash only on the column name - since we match based on the shortest possible match
+		return StringUtil::CIHash(a.column);
 	}
 };
 
 struct QualifiedColumnEquality {
 	bool operator()(const QualifiedColumnName &a, const QualifiedColumnName &b) const {
-		return a.schema == b.schema && a.table == b.table && a.column == b.column;
+		// qualified column names follow a prefix comparison
+		// so "tbl.i"  and "i" are equivalent, as are "schema.tbl.i" and "i"
+		// but "tbl.i" and "tbl2.i" are not equivalent
+		if (!a.catalog.empty() && !b.catalog.empty() && !StringUtil::CIEquals(a.catalog, b.catalog)) {
+			return false;
+		}
+		if (!a.schema.empty() && !b.schema.empty() && !StringUtil::CIEquals(a.schema, b.schema)) {
+			return false;
+		}
+		if (!a.table.empty() && !b.table.empty() && !StringUtil::CIEquals(a.table, b.table)) {
+			return false;
+		}
+		return StringUtil::CIEquals(a.column, b.column);
 	}
 };
 
 using qualified_column_set_t = unordered_set<QualifiedColumnName, QualifiedColumnHashFunction, QualifiedColumnEquality>;
 
+template <class T>
+using qualified_column_map_t =
+    unordered_map<QualifiedColumnName, T, QualifiedColumnHashFunction, QualifiedColumnEquality>;
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/simplified_token.hpp

@@ -20,7 +20,8 @@ enum class SimplifiedTokenType : uint8_t {
 	SIMPLIFIED_TOKEN_STRING_CONSTANT,
 	SIMPLIFIED_TOKEN_OPERATOR,
 	SIMPLIFIED_TOKEN_KEYWORD,
-	SIMPLIFIED_TOKEN_COMMENT
+	SIMPLIFIED_TOKEN_COMMENT,
+	SIMPLIFIED_TOKEN_ERROR
 };
 
 struct SimplifiedToken {

package/src/duckdb/src/include/duckdb/parser/tableref/basetableref.hpp

@@ -8,11 +8,13 @@
 
 #pragma once
 
-#include "duckdb/parser/tableref.hpp"
 #include "duckdb/common/vector.hpp"
+#include "duckdb/main/table_description.hpp"
+#include "duckdb/parser/tableref.hpp"
 
 namespace duckdb {
-//! Represents a TableReference to a base table in the schema
+
+//! Represents a TableReference to a base table in a catalog and schema.
 class BaseTableRef : public TableRef {
 public:
 	static constexpr const TableReferenceType TYPE = TableReferenceType::BASE_TABLE;
@@ -21,23 +23,24 @@ public:
 	BaseTableRef()
 	    : TableRef(TableReferenceType::BASE_TABLE), catalog_name(INVALID_CATALOG), schema_name(INVALID_SCHEMA) {
 	}
+	explicit BaseTableRef(const TableDescription &description)
+	    : TableRef(TableReferenceType::BASE_TABLE), catalog_name(description.database), schema_name(description.schema),
+	      table_name(description.table) {
+	}
 
-	//! The catalog name
+	//! The catalog name.
 	string catalog_name;
-	//! Schema name
+	//! The schema name.
 	string schema_name;
-	//! Table name
+	//! The table name.
 	string table_name;
 
 public:
 	string ToString() const override;
 	bool Equals(const TableRef &other_p) const override;
-
 	unique_ptr<TableRef> Copy() override;
-
-	//! Deserializes a blob back into a BaseTableRef
 	void Serialize(Serializer &serializer) const override;
-
 	static unique_ptr<TableRef> Deserialize(Deserializer &source);
 };
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tokens.hpp

@@ -104,6 +104,6 @@ class ShowRef;
 //===--------------------------------------------------------------------===//
 // Other
 //===--------------------------------------------------------------------===//
-struct SampleOptions;
+class SampleOptions;
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/transformer.hpp

@@ -261,8 +261,8 @@ private:
 	//===--------------------------------------------------------------------===//
 	// Constraints transform
 	//===--------------------------------------------------------------------===//
-	unique_ptr<Constraint> TransformConstraint(duckdb_libpgquery::PGListCell &cell);
-	unique_ptr<Constraint> TransformConstraint(duckdb_libpgquery::PGListCell &cell, ColumnDefinition &column,
+	unique_ptr<Constraint> TransformConstraint(duckdb_libpgquery::PGConstraint &constraint);
+	unique_ptr<Constraint> TransformConstraint(duckdb_libpgquery::PGConstraint &constraint, ColumnDefinition &column,
 	                                           idx_t index);
 
 	//===--------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/planner/bind_context.hpp

@@ -10,6 +10,7 @@
 
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
+#include "duckdb/common/column_index.hpp"
 #include "duckdb/common/reference_map.hpp"
 #include "duckdb/common/exception/binder_exception.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
@@ -30,10 +31,12 @@ class TableCatalogEntry;
 class TableFunctionCatalogEntry;
 
 struct UsingColumnSet {
-	string primary_binding;
-	unordered_set<string> bindings;
+	BindingAlias primary_binding;
+	vector<BindingAlias> bindings;
 };
 
+enum class ColumnBindType { EXPAND_GENERATED_COLUMNS, DO_NOT_EXPAND_GENERATED_COLUMNS };
+
 //! The BindContext object keeps track of all the tables and columns that are
 //! encountered during the binding process.
 class BindContext {
@@ -46,10 +49,10 @@ public:
 public:
 	//! Given a column name, find the matching table it belongs to. Throws an
 	//! exception if no table has a column of the given name.
-	string GetMatchingBinding(const string &column_name);
+	optional_ptr<Binding> GetMatchingBinding(const string &column_name);
 	//! Like GetMatchingBinding, but instead of throwing an error if multiple tables have the same binding it will
 	//! return a list of all the matching ones
-	unordered_set<string> GetMatchingBindings(const string &column_name);
+	vector<reference<Binding>> GetMatchingBindings(const string &column_name);
 	//! Like GetMatchingBindings, but returns the top 3 most similar bindings (in levenshtein distance) instead of the
 	//! matching ones
 	vector<string> GetSimilarBindings(const string &column_name);
@@ -61,38 +64,45 @@ public:
 	string BindColumn(PositionalReferenceExpression &ref, string &table_name, string &column_name);
 	unique_ptr<ColumnRefExpression> PositionToColumn(PositionalReferenceExpression &ref);
 
-	unique_ptr<ParsedExpression> ExpandGeneratedColumn(const string &table_name, const string &column_name);
-
-	unique_ptr<ParsedExpression> CreateColumnReference(const string &table_name, const string &column_name);
-	unique_ptr<ParsedExpression> CreateColumnReference(const string &schema_name, const string &table_name,
-	                                                   const string &column_name);
-	unique_ptr<ParsedExpression> CreateColumnReference(const string &catalog_name, const string &schema_name,
-	                                                   const string &table_name, const string &column_name);
+	unique_ptr<ParsedExpression> ExpandGeneratedColumn(TableBinding &table_binding, const string &column_name);
+
+	unique_ptr<ParsedExpression>
+	CreateColumnReference(const string &table_name, const string &column_name,
+	                      ColumnBindType bind_type = ColumnBindType::EXPAND_GENERATED_COLUMNS);
+	unique_ptr<ParsedExpression>
+	CreateColumnReference(const string &schema_name, const string &table_name, const string &column_name,
+	                      ColumnBindType bind_type = ColumnBindType::EXPAND_GENERATED_COLUMNS);
+	unique_ptr<ParsedExpression>
+	CreateColumnReference(const string &catalog_name, const string &schema_name, const string &table_name,
+	                      const string &column_name,
+	                      ColumnBindType bind_type = ColumnBindType::EXPAND_GENERATED_COLUMNS);
+	unique_ptr<ParsedExpression>
+	CreateColumnReference(const BindingAlias &table_alias, const string &column_name,
+	                      ColumnBindType bind_type = ColumnBindType::EXPAND_GENERATED_COLUMNS);
 
 	//! Generate column expressions for all columns that are present in the
 	//! referenced tables. This is used to resolve the * expression in a
 	//! selection list.
 	void GenerateAllColumnExpressions(StarExpression &expr, vector<unique_ptr<ParsedExpression>> &new_select_list);
-	//! Check if the given (binding, column_name) is in the exclusion/replacement lists.
-	//! Returns true if it is in one of these lists, and should therefore be skipped.
-	bool CheckExclusionList(StarExpression &expr, const string &column_name,
-	                        vector<unique_ptr<ParsedExpression>> &new_select_list,
-	                        case_insensitive_set_t &excluded_columns);
 
-	const vector<reference<Binding>> &GetBindingsList() {
+	const vector<unique_ptr<Binding>> &GetBindingsList() {
 		return bindings_list;
 	}
+	vector<BindingAlias> GetBindingAliases();
 
 	void GetTypesAndNames(vector<string> &result_names, vector<LogicalType> &result_types);
 
 	//! Adds a base table with the given alias to the BindContext.
 	void AddBaseTable(idx_t index, const string &alias, const vector<string> &names, const vector<LogicalType> &types,
-	                  vector<column_t> &bound_column_ids, StandardEntry *entry, bool add_row_id = true);
+	                  vector<ColumnIndex> &bound_column_ids, StandardEntry &entry, bool add_row_id = true);
+	void AddBaseTable(idx_t index, const string &alias, const vector<string> &names, const vector<LogicalType> &types,
+	                  vector<ColumnIndex> &bound_column_ids, const string &table_name);
 	//! Adds a call to a table function with the given alias to the BindContext.
 	void AddTableFunction(idx_t index, const string &alias, const vector<string> &names,
-	                      const vector<LogicalType> &types, vector<column_t> &bound_column_ids, StandardEntry *entry);
+	                      const vector<LogicalType> &types, vector<ColumnIndex> &bound_column_ids,
+	                      optional_ptr<StandardEntry> entry);
 	//! Adds a table view with a given alias to the BindContext.
-	void AddView(idx_t index, const string &alias, SubqueryRef &ref, BoundQueryNode &subquery, ViewCatalogEntry *view);
+	void AddView(idx_t index, const string &alias, SubqueryRef &ref, BoundQueryNode &subquery, ViewCatalogEntry &view);
 	//! Adds a subquery with a given alias to the BindContext.
 	void AddSubquery(idx_t index, const string &alias, SubqueryRef &ref, BoundQueryNode &subquery);
 	//! Adds a subquery with a given alias to the BindContext.
@@ -117,17 +127,18 @@ public:
 	//! column sets with the same name) throw an exception.
 	optional_ptr<UsingColumnSet> GetUsingBinding(const string &column_name);
 	//! Returns any using column set for the given column name, or nullptr if there is none
-	optional_ptr<UsingColumnSet> GetUsingBinding(const string &column_name, const string &binding_name);
+	optional_ptr<UsingColumnSet> GetUsingBinding(const string &column_name, const BindingAlias &binding);
 	//! Erase a using binding from the set of using bindings
 	void RemoveUsingBinding(const string &column_name, UsingColumnSet &set);
 	//! Transfer a using binding from one bind context to this bind context
 	void TransferUsingBinding(BindContext &current_context, optional_ptr<UsingColumnSet> current_set,
-	                          UsingColumnSet &new_set, const string &binding, const string &using_column);
+	                          UsingColumnSet &new_set, const string &using_column);
 
 	//! Fetch the actual column name from the given binding, or throws if none exists
 	//! This can be different from "column_name" because of case insensitivity
 	//! (e.g. "column_name" might return "COLUMN_NAME")
-	string GetActualColumnName(const string &binding, const string &column_name);
+	string GetActualColumnName(const BindingAlias &binding_alias, const string &column_name);
+	string GetActualColumnName(Binding &binding, const string &column_name);
 
 	case_insensitive_map_t<shared_ptr<Binding>> GetCTEBindings() {
 		return cte_bindings;
@@ -144,21 +155,27 @@ public:
 	//! Add all the bindings from a BindContext to this BindContext. The other BindContext is destroyed in the process.
 	void AddContext(BindContext other);
 	//! For semi and anti joins we remove the binding context of the right table after binding the condition.
-	void RemoveContext(vector<reference<Binding>> &other_bindings_list);
+	void RemoveContext(const vector<BindingAlias> &aliases);
 
 	//! Gets a binding of the specified name. Returns a nullptr and sets the out_error if the binding could not be
 	//! found.
 	optional_ptr<Binding> GetBinding(const string &name, ErrorData &out_error);
 
+	optional_ptr<Binding> GetBinding(const BindingAlias &alias, ErrorData &out_error);
+
+	optional_ptr<Binding> GetBinding(const BindingAlias &alias, const string &column_name, ErrorData &out_error);
+
+	//! Get all bindings that match a specific binding alias - returns an error if none match
+	vector<reference<Binding>> GetBindings(const BindingAlias &alias, ErrorData &out_error);
+
 private:
-	void AddBinding(const string &alias, unique_ptr<Binding> binding);
+	void AddBinding(unique_ptr<Binding> binding);
+	static string AmbiguityException(const BindingAlias &alias, const vector<reference<Binding>> &bindings);
 
 private:
 	Binder &binder;
-	//! The set of bindings
-	case_insensitive_map_t<unique_ptr<Binding>> bindings;
 	//! The list of bindings in insertion order
-	vector<reference<Binding>> bindings_list;
+	vector<unique_ptr<Binding>> bindings_list;
 	//! The set of columns used in USING join conditions
 	case_insensitive_map_t<reference_set_t<UsingColumnSet>> using_columns;
 	//! Using column sets

package/src/duckdb/src/include/duckdb/planner/binder.hpp

@@ -24,6 +24,7 @@
 #include "duckdb/planner/bound_tokens.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/joinside.hpp"
+#include "duckdb/planner/bound_constraint.hpp"
 #include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/planner/tableref/bound_delimgetref.hpp"
 
@@ -49,7 +50,6 @@ class BoundConstraint;
 
 struct CreateInfo;
 struct BoundCreateTableInfo;
-struct BoundCreateFunctionInfo;
 struct CommonTableExpressionInfo;
 struct BoundParameterMap;
 struct BoundPragmaInfo;
@@ -125,6 +125,7 @@ public:
 	                                                     vector<unique_ptr<Expression>> &bound_defaults);
 	static unique_ptr<BoundCreateTableInfo> BindCreateTableCheckpoint(unique_ptr<CreateInfo> info,
 	                                                                  SchemaCatalogEntry &schema);
+
 	static vector<unique_ptr<BoundConstraint>> BindConstraints(ClientContext &context,
 	                                                           const vector<unique_ptr<Constraint>> &constraints,
 	                                                           const string &table_name, const ColumnList &columns);
@@ -133,6 +134,11 @@ public:
 	vector<unique_ptr<BoundConstraint>> BindConstraints(const TableCatalogEntry &table);
 	vector<unique_ptr<BoundConstraint>> BindNewConstraints(vector<unique_ptr<Constraint>> &constraints,
 	                                                       const string &table_name, const ColumnList &columns);
+	unique_ptr<BoundConstraint> BindConstraint(Constraint &constraint, const string &table, const ColumnList &columns);
+	unique_ptr<BoundConstraint> BindUniqueConstraint(Constraint &constraint, const string &table,
+	                                                 const ColumnList &columns);
+
+	BoundStatement BindAlterAddIndex(BoundStatement &result, CatalogEntry &entry, unique_ptr<AlterInfo> alter_info);
 
 	void SetCatalogLookupCallback(catalog_entry_callback_t callback);
 	void BindCreateViewInfo(CreateViewInfo &base);
@@ -189,11 +195,11 @@ public:
 	void BindLogicalType(LogicalType &type, optional_ptr<Catalog> catalog = nullptr,
 	                     const string &schema = INVALID_SCHEMA);
 
-	bool HasMatchingBinding(const string &table_name, const string &column_name, ErrorData &error);
-	bool HasMatchingBinding(const string &schema_name, const string &table_name, const string &column_name,
-	                        ErrorData &error);
-	bool HasMatchingBinding(const string &catalog_name, const string &schema_name, const string &table_name,
-	                        const string &column_name, ErrorData &error);
+	optional_ptr<Binding> GetMatchingBinding(const string &table_name, const string &column_name, ErrorData &error);
+	optional_ptr<Binding> GetMatchingBinding(const string &schema_name, const string &table_name,
+	                                         const string &column_name, ErrorData &error);
+	optional_ptr<Binding> GetMatchingBinding(const string &catalog_name, const string &schema_name,
+	                                         const string &table_name, const string &column_name, ErrorData &error);
 
 	void SetBindingMode(BindingMode mode);
 	BindingMode GetBindingMode();
@@ -204,6 +210,11 @@ public:
 	optional_ptr<SQLStatement> GetRootStatement() {
 		return root_statement;
 	}
+	CatalogEntryRetriever &EntryRetriever() {
+		return entry_retriever;
+	}
+	//! Returns a ColumnRefExpression after it was resolved (i.e. past the STAR expression/USING clauses)
+	static optional_ptr<ParsedExpression> GetResolvedColumnExpression(ParsedExpression &root_expr);
 
 	void SetCanContainNulls(bool can_contain_nulls);
 	void SetAlwaysRequireRebind();
@@ -250,7 +261,8 @@ private:
 	//! Bind the expressions of generated columns to check for errors
 	void BindGeneratedColumns(BoundCreateTableInfo &info);
 	//! Bind the default values of the columns of a table
-	void BindDefaultValues(const ColumnList &columns, vector<unique_ptr<Expression>> &bound_defaults);
+	void BindDefaultValues(const ColumnList &columns, vector<unique_ptr<Expression>> &bound_defaults,
+	                       const string &catalog = "", const string &schema = "");
 	//! Bind a limit value (LIMIT or OFFSET)
 	BoundLimitNode BindLimitValue(OrderBinder &order_binder, unique_ptr<ParsedExpression> limit_val, bool is_percentage,
 	                              bool is_offset);
@@ -384,12 +396,12 @@ private:
 	                                                       vector<LogicalType> &target_types,
 	                                                       unique_ptr<LogicalOperator> op);
 
-	string FindBinding(const string &using_column, const string &join_side);
-	bool TryFindBinding(const string &using_column, const string &join_side, string &result);
+	BindingAlias FindBinding(const string &using_column, const string &join_side);
+	bool TryFindBinding(const string &using_column, const string &join_side, BindingAlias &result);
 
 	void AddUsingBindingSet(unique_ptr<UsingColumnSet> set);
-	string RetrieveUsingBinding(Binder &current_binder, optional_ptr<UsingColumnSet> current_set,
-	                            const string &column_name, const string &join_side);
+	BindingAlias RetrieveUsingBinding(Binder &current_binder, optional_ptr<UsingColumnSet> current_set,
+	                                  const string &column_name, const string &join_side);
 
 	void AddCTEMap(CommonTableExpressionMap &cte_map);
 

package/src/duckdb/src/include/duckdb/planner/binding_alias.hpp

@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/binding_alias.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
+
+namespace duckdb {
+class StandardEntry;
+
+struct BindingAlias {
+	BindingAlias();
+	explicit BindingAlias(string alias);
+	BindingAlias(string schema, string alias);
+	BindingAlias(string catalog, string schema, string alias);
+	explicit BindingAlias(const StandardEntry &entry);
+
+	bool IsSet() const;
+	const string &GetAlias() const;
+
+	const string &GetCatalog() const {
+		return catalog;
+	}
+	const string &GetSchema() const {
+		return schema;
+	}
+
+	bool Matches(const BindingAlias &other) const;
+	bool operator==(const BindingAlias &other) const;
+	string ToString() const;
+
+private:
+	string catalog;
+	string schema;
+	string alias;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/bound_result_modifier.hpp

@@ -154,6 +154,7 @@ public:
 
 	//! Remove unneeded/duplicate order elements.
 	//! Returns true of orders is not empty.
+	static bool Simplify(vector<BoundOrderByNode> &orders, const vector<unique_ptr<Expression>> &groups);
 	bool Simplify(const vector<unique_ptr<Expression>> &groups);
 };
 

package/src/duckdb/src/include/duckdb/planner/collation_binding.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/function/cast/default_casts.hpp"
+#include "duckdb/common/enums/collation_type.hpp"
 
 namespace duckdb {
 struct MapCastInfo;
@@ -16,7 +17,7 @@ struct MapCastNode;
 struct DBConfig;
 
 typedef bool (*try_push_collation_t)(ClientContext &context, unique_ptr<Expression> &source,
-                                     const LogicalType &sql_type);
+                                     const LogicalType &sql_type, CollationType type);
 
 struct CollationCallback {
 	explicit CollationCallback(try_push_collation_t try_push_collation_p) : try_push_collation(try_push_collation_p) {
@@ -34,8 +35,8 @@ public:
 	DUCKDB_API static CollationBinding &Get(DatabaseInstance &db);
 
 	DUCKDB_API void RegisterCollation(CollationCallback callback);
-	DUCKDB_API bool PushCollation(ClientContext &context, unique_ptr<Expression> &source,
-	                              const LogicalType &sql_type) const;
+	DUCKDB_API bool PushCollation(ClientContext &context, unique_ptr<Expression> &source, const LogicalType &sql_type,
+	                              CollationType type) const;
 
 private:
 	vector<CollationCallback> collations;

package/src/duckdb/src/include/duckdb/planner/constraints/bound_unique_constraint.hpp

@@ -19,22 +19,23 @@ public:
 	static constexpr const ConstraintType TYPE = ConstraintType::UNIQUE;
 
 public:
-	BoundUniqueConstraint(vector<LogicalIndex> keys, logical_index_set_t key_set, bool is_primary_key)
-	    : BoundConstraint(ConstraintType::UNIQUE), keys(std::move(keys)), key_set(std::move(key_set)),
+	BoundUniqueConstraint(vector<PhysicalIndex> keys_p, physical_index_set_t key_set_p, const bool is_primary_key)
+	    : BoundConstraint(ConstraintType::UNIQUE), keys(std::move(keys_p)), key_set(std::move(key_set_p)),
 	      is_primary_key(is_primary_key) {
+
 #ifdef DEBUG
-		D_ASSERT(this->keys.size() == this->key_set.size());
-		for (auto &key : this->keys) {
-			D_ASSERT(this->key_set.find(key) != this->key_set.end());
+		D_ASSERT(keys.size() == key_set.size());
+		for (auto &key : keys) {
+			D_ASSERT(key_set.find(key) != key_set.end());
 		}
 #endif
 	}
 
-	//! The keys that define the unique constraint
-	vector<LogicalIndex> keys;
-	//! The same keys but stored as an unordered set
-	logical_index_set_t key_set;
-	//! Whether or not the unique constraint is a primary key
+	//! The keys that define the unique constraint.
+	vector<PhysicalIndex> keys;
+	//! The same keys but stored as an unordered set.
+	physical_index_set_t key_set;
+	//! Whether this is a PRIMARY KEY constraint, or a UNIQUE constraint.
 	bool is_primary_key;
 };
 

package/src/duckdb/src/include/duckdb/planner/expression/bound_cast_expression.hpp

@@ -54,6 +54,8 @@ public:
 
 	unique_ptr<Expression> Copy() const override;
 
+	bool CanThrow() const override;
+
 	void Serialize(Serializer &serializer) const override;
 	static unique_ptr<Expression> Deserialize(Deserializer &deserializer);
 

package/src/duckdb/src/include/duckdb/planner/expression/bound_function_expression.hpp

@@ -37,6 +37,7 @@ public:
 	bool IsVolatile() const override;
 	bool IsConsistent() const override;
 	bool IsFoldable() const override;
+	bool CanThrow() const override;
 	string ToString() const override;
 	bool PropagatesNullValues() const override;
 	hash_t Hash() const override;

package/src/duckdb/src/include/duckdb/planner/expression/bound_subquery_expression.hpp

@@ -32,12 +32,12 @@ public:
 	unique_ptr<BoundQueryNode> subquery;
 	//! The subquery type
 	SubqueryType subquery_type;
-	//! the child expression to compare with (in case of IN, ANY, ALL operators)
-	unique_ptr<Expression> child;
+	//! the child expressions to compare with (in case of IN, ANY, ALL operators)
+	vector<unique_ptr<Expression>> children;
 	//! The comparison type of the child expression with the subquery (in case of ANY, ALL operators)
 	ExpressionType comparison_type;
-	//! The LogicalType of the subquery result. Only used for ANY expressions.
-	LogicalType child_type;
+	//! The LogicalTypes of the subquery result. Only used for ANY expressions.
+	vector<LogicalType> child_types;
 	//! The target LogicalType of the subquery result (i.e. to which type it should be casted, if child_type <>
 	//! child_target). Only used for ANY expressions.
 	LogicalType child_target;

package/src/duckdb/src/include/duckdb/planner/expression/bound_window_expression.hpp

@@ -54,6 +54,11 @@ public:
 	unique_ptr<Expression> offset_expr;
 	unique_ptr<Expression> default_expr;
 
+	//! The set of argument ordering clauses
+	//! These are distinct from the frame ordering clauses e.g., the "x" in
+	//! FIRST_VALUE(a ORDER BY x) OVER (PARTITION BY p ORDER BY s)
+	vector<BoundOrderByNode> arg_orders;
+
 	//! Statistics belonging to the other expressions (start, end, offset, default)
 	vector<unique_ptr<BaseStatistics>> expr_stats;
 
@@ -68,6 +73,7 @@ public:
 	string ToString() const override;
 
 	//! The number of ordering clauses the functions share
+	static idx_t GetSharedOrders(const vector<BoundOrderByNode> &lhs, const vector<BoundOrderByNode> &rhs);
 	idx_t GetSharedOrders(const BoundWindowExpression &other) const;
 
 	bool PartitionsAreEquivalent(const BoundWindowExpression &other) const;

package/src/duckdb/src/include/duckdb/planner/expression.hpp

@@ -32,10 +32,12 @@ public:
 	bool HasSubquery() const override;
 	bool IsScalar() const override;
 	bool HasParameter() const override;
+
 	virtual bool IsVolatile() const;
 	virtual bool IsConsistent() const;
 	virtual bool PropagatesNullValues() const;
 	virtual bool IsFoldable() const;
+	virtual bool CanThrow() const;
 
 	hash_t Hash() const override;
 

package/src/duckdb/src/include/duckdb/planner/expression_binder/having_binder.hpp

@@ -25,6 +25,8 @@ protected:
 	BindResult BindWindow(WindowExpression &expr, idx_t depth) override;
 	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) override;
 
+	unique_ptr<ParsedExpression> QualifyColumnName(ColumnRefExpression &col_ref, ErrorData &error) override;
+
 private:
 	ColumnAliasBinder column_alias_binder;
 	AggregateHandling aggregate_handling;