duckdb 1.3.4 → 1.4.0

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

@@ -20,19 +20,14 @@ public:
 	static constexpr const TableReferenceType TYPE = TableReferenceType::COLUMN_DATA;
 
 public:
-	explicit ColumnDataRef(shared_ptr<ColumnDataCollection> collection)
-	    : TableRef(TableReferenceType::COLUMN_DATA), collection(std::move(collection)) {
-	}
-	ColumnDataRef(shared_ptr<ColumnDataCollection> collection, vector<string> expected_names)
-	    : TableRef(TableReferenceType::COLUMN_DATA), expected_names(std::move(expected_names)),
-	      collection(std::move(collection)) {
-	}
+	explicit ColumnDataRef(optionally_owned_ptr<ColumnDataCollection> collection_p,
+	                       vector<string> expected_names = vector<string>());
 
 public:
 	//! The set of expected names
 	vector<string> expected_names;
-	//! The collection to scan
-	shared_ptr<ColumnDataCollection> collection;
+	//! (Optionally) the owned collection
+	optionally_owned_ptr<ColumnDataCollection> collection;
 
 public:
 	string ToString() const override;

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

@@ -43,6 +43,8 @@ public:
 	vector<unique_ptr<ParsedExpression>> duplicate_eliminated_columns;
 	//! If we have duplicate eliminated columns if the delim is flipped
 	bool delim_flipped = false;
+	//! Whether or not this is an implicit cross join
+	bool is_implicit = false;
 
 public:
 	string ToString() const override;

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

@@ -1,4 +1,5 @@
 #include "duckdb/parser/tableref/basetableref.hpp"
+#include "duckdb/parser/tableref/bound_ref_wrapper.hpp"
 #include "duckdb/parser/tableref/emptytableref.hpp"
 #include "duckdb/parser/tableref/expressionlistref.hpp"
 #include "duckdb/parser/tableref/column_data_ref.hpp"

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

@@ -16,7 +16,7 @@
 
 namespace duckdb {
 
-enum class ShowType : uint8_t { SUMMARY, DESCRIBE };
+enum class ShowType : uint8_t { SUMMARY, DESCRIBE, SHOW_FROM };
 
 //! Represents a SHOW/DESCRIBE/SUMMARIZE statement
 class ShowRef : public TableRef {
@@ -28,6 +28,10 @@ public:
 
 	//! The table name (if any)
 	string table_name;
+	//! The catalog name (if any)
+	string catalog_name;
+	//! The schema name (if any)
+	string schema_name;
 	//! The QueryNode of select query (if any)
 	unique_ptr<QueryNode> query;
 	//! Whether or not we are requesting a summary or a describe

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

@@ -12,6 +12,7 @@
 #include "duckdb/parser/tableref.hpp"
 #include "duckdb/common/vector.hpp"
 #include "duckdb/parser/statement/select_statement.hpp"
+#include "duckdb/common/enums/ordinality_request_type.hpp"
 
 namespace duckdb {
 //! Represents a Table producing function
@@ -27,6 +28,9 @@ public:
 	// if the function takes a subquery as argument its in here
 	unique_ptr<SelectStatement> subquery;
 
+	//! Whether or not WITH ORDINALITY has been invoked
+	OrdinalityType with_ordinality = OrdinalityType::WITHOUT_ORDINALITY;
+
 public:
 	string ToString() const override;
 

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

@@ -43,6 +43,7 @@ class LoadStatement;
 class LogicalPlanStatement;
 class MultiStatement;
 class CopyDatabaseStatement;
+class MergeIntoStatement;
 
 //===--------------------------------------------------------------------===//
 // Query Node
@@ -92,6 +93,7 @@ class ForeignKeyConstraint;
 class TableRef;
 
 class BaseTableRef;
+class BoundRefWrapper;
 class JoinRef;
 class SubqueryRef;
 class TableFunctionRef;
@@ -105,5 +107,6 @@ class ShowRef;
 // Other
 //===--------------------------------------------------------------------===//
 class SampleOptions;
+class MergeIntoAction;
 
 } // namespace duckdb

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

@@ -142,6 +142,9 @@ private:
 	unique_ptr<SQLStatement> TransformDrop(duckdb_libpgquery::PGDropStmt &stmt);
 	//! Transform a Postgres duckdb_libpgquery::T_PGInsertStmt node into a InsertStatement
 	unique_ptr<InsertStatement> TransformInsert(duckdb_libpgquery::PGInsertStmt &stmt);
+	InsertColumnOrder TransformColumnOrder(duckdb_libpgquery::PGInsertColumnOrder insert_column_order);
+
+	vector<string> TransformInsertColumns(duckdb_libpgquery::PGList &cols);
 
 	//! Transform a Postgres duckdb_libpgquery::T_PGOnConflictClause node into a OnConflictInfo
 	unique_ptr<OnConflictInfo> TransformOnConflictClause(duckdb_libpgquery::PGOnConflictClause *node,
@@ -191,6 +194,9 @@ private:
 	static bool TransformPivotInList(unique_ptr<ParsedExpression> &expr, PivotColumnEntry &entry,
 	                                 bool root_entry = true);
 
+	unique_ptr<SQLStatement> TransformMergeInto(duckdb_libpgquery::PGMergeIntoStmt &stmt);
+	unique_ptr<MergeIntoAction> TransformMergeIntoAction(duckdb_libpgquery::PGMatchAction &action);
+
 	//===--------------------------------------------------------------------===//
 	// SetStatement Transform
 	//===--------------------------------------------------------------------===//
@@ -322,6 +328,9 @@ private:
 	//! Transform a VALUES list into a set of expressions
 	unique_ptr<TableRef> TransformValuesList(duckdb_libpgquery::PGList *list);
 
+	//! Transform using clause
+	vector<string> TransformUsingClause(duckdb_libpgquery::PGList &usingClause);
+
 	//! Transform a range var into a (schema) qualified name
 	QualifiedName TransformQualifiedName(duckdb_libpgquery::PGRangeVar &root);
 
@@ -367,8 +376,6 @@ private:
 
 	unique_ptr<MacroFunction> TransformMacroFunction(duckdb_libpgquery::PGFunctionDefinition &function);
 
-	void ParseGenericOptionListEntry(case_insensitive_map_t<vector<Value>> &result_options, string &name,
-	                                 duckdb_libpgquery::PGNode *arg);
 	vector<string> TransformNameList(duckdb_libpgquery::PGList &list);
 
 public:

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

@@ -97,6 +97,9 @@ public:
 	                  vector<ColumnIndex> &bound_column_ids, TableCatalogEntry &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);
+	void AddBaseTable(idx_t index, const string &alias, const vector<string> &names, const vector<LogicalType> &types,
+	                  vector<ColumnIndex> &bound_column_ids, TableCatalogEntry &entry,
+	                  virtual_column_map_t virtual_columns);
 	//! 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<ColumnIndex> &bound_column_ids,
@@ -119,6 +122,8 @@ public:
 	void AddCTEBinding(idx_t index, const string &alias, const vector<string> &names, const vector<LogicalType> &types,
 	                   bool using_key = false);
 
+	void RemoveCTEBinding(const string &alias);
+
 	//! Add an implicit join condition (e.g. USING (x))
 	void AddUsingBinding(const string &column_name, UsingColumnSet &set);
 

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

@@ -28,6 +28,7 @@
 #include "duckdb/planner/bound_constraint.hpp"
 #include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/planner/tableref/bound_delimgetref.hpp"
+#include "duckdb/common/enums/copy_option_mode.hpp"
 
 //! fwd declare
 namespace duckdb_re2 {
@@ -58,6 +59,7 @@ class BoundAtClause;
 
 struct CreateInfo;
 struct BoundCreateTableInfo;
+struct BoundOnConflictInfo;
 struct CommonTableExpressionInfo;
 struct BoundParameterMap;
 struct BoundPragmaInfo;
@@ -65,6 +67,11 @@ struct BoundLimitNode;
 struct EntryLookupInfo;
 struct PivotColumnEntry;
 struct UnpivotEntry;
+struct CopyInfo;
+struct CopyOption;
+
+template <class T, class INDEX_TYPE>
+class IndexVector;
 
 enum class BindingMode : uint8_t {
 	STANDARD_BINDING,
@@ -157,6 +164,7 @@ public:
 
 	void SetCatalogLookupCallback(catalog_entry_callback_t callback);
 	void BindCreateViewInfo(CreateViewInfo &base);
+	void SearchSchema(CreateInfo &info);
 	SchemaCatalogEntry &BindSchema(CreateInfo &info);
 	SchemaCatalogEntry &BindCreateFunctionInfo(CreateInfo &info);
 
@@ -199,9 +207,10 @@ public:
 	unique_ptr<LogicalOperator> BindUpdateSet(LogicalOperator &op, unique_ptr<LogicalOperator> root,
 	                                          UpdateSetInfo &set_info, TableCatalogEntry &table,
 	                                          vector<PhysicalIndex> &columns);
-	void BindDoUpdateSetExpressions(const string &table_alias, LogicalInsert &insert, UpdateSetInfo &set_info,
-	                                TableCatalogEntry &table, TableStorageInfo &storage_info);
-	void BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &table, InsertStatement &stmt);
+	void BindUpdateSet(idx_t proj_index, unique_ptr<LogicalOperator> &root, UpdateSetInfo &set_info,
+	                   TableCatalogEntry &table, vector<PhysicalIndex> &columns,
+	                   vector<unique_ptr<Expression>> &update_expressions,
+	                   vector<unique_ptr<Expression>> &projection_expressions);
 
 	void BindVacuumTable(LogicalVacuum &vacuum, unique_ptr<LogicalOperator> &root);
 
@@ -271,12 +280,18 @@ private:
 	idx_t unnamed_subquery_index = 1;
 	//! Statement properties
 	StatementProperties prop;
+	//! Root binder
+	Binder &root_binder;
+	//! Binder depth
+	idx_t depth;
 
 private:
 	//! Get the root binder (binder with no parent)
 	Binder &GetRootBinder();
 	//! Determine the depth of the binder
 	idx_t GetBinderDepth() const;
+	//! Increase the depth of the binder
+	void IncreaseDepth();
 	//! Bind the expressions of generated columns to check for errors
 	void BindGeneratedColumns(BoundCreateTableInfo &info);
 	//! Bind the default values of the columns of a table
@@ -321,18 +336,18 @@ private:
 	BoundStatement Bind(DetachStatement &stmt);
 	BoundStatement Bind(CopyDatabaseStatement &stmt);
 	BoundStatement Bind(UpdateExtensionsStatement &stmt);
+	BoundStatement Bind(MergeIntoStatement &stmt);
 
 	void BindRowIdColumns(TableCatalogEntry &table, LogicalGet &get, vector<unique_ptr<Expression>> &expressions);
 	BoundStatement BindReturning(vector<unique_ptr<ParsedExpression>> returning_list, TableCatalogEntry &table,
 	                             const string &alias, idx_t update_table_index,
-	                             unique_ptr<LogicalOperator> child_operator, BoundStatement result);
+	                             unique_ptr<LogicalOperator> child_operator,
+	                             virtual_column_map_t virtual_columns = virtual_column_map_t());
 
 	unique_ptr<QueryNode> BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry &macro_func, idx_t depth);
 
 	unique_ptr<BoundCTENode> BindMaterializedCTE(CommonTableExpressionMap &cte_map);
 	unique_ptr<BoundCTENode> BindCTE(CTENode &statement);
-	//! Materializes CTEs if this is expected to improve performance
-	bool OptimizeCTEs(QueryNode &node);
 
 	unique_ptr<BoundQueryNode> BindNode(SelectNode &node);
 	unique_ptr<BoundQueryNode> BindNode(SetOperationNode &node);
@@ -350,6 +365,7 @@ private:
 
 	unique_ptr<BoundTableRef> BindJoin(Binder &parent, TableRef &ref);
 	unique_ptr<BoundTableRef> Bind(BaseTableRef &ref);
+	unique_ptr<BoundTableRef> Bind(BoundRefWrapper &ref);
 	unique_ptr<BoundTableRef> Bind(JoinRef &ref);
 	unique_ptr<BoundTableRef> Bind(SubqueryRef &ref, optional_ptr<CommonTableExpressionInfo> cte = nullptr);
 	unique_ptr<BoundTableRef> Bind(TableFunctionRef &ref);
@@ -394,8 +410,10 @@ private:
 	unique_ptr<LogicalOperator> CreatePlan(BoundPivotRef &ref);
 	unique_ptr<LogicalOperator> CreatePlan(BoundDelimGetRef &ref);
 
-	BoundStatement BindCopyTo(CopyStatement &stmt, CopyToType copy_to_type);
-	BoundStatement BindCopyFrom(CopyStatement &stmt);
+	BoundStatement BindCopyTo(CopyStatement &stmt, const CopyFunction &function, CopyToType copy_to_type);
+	BoundStatement BindCopyFrom(CopyStatement &stmt, const CopyFunction &function);
+	void BindCopyOptions(CopyInfo &info);
+	case_insensitive_map_t<CopyOption> GetFullCopyOptionsList(const CopyFunction &function, CopyOptionMode mode);
 
 	void PrepareModifiers(OrderBinder &order_binder, QueryNode &statement, BoundQueryNode &result);
 	void BindModifiers(BoundQueryNode &result, idx_t table_index, const vector<string> &names,
@@ -456,6 +474,25 @@ private:
 	unique_ptr<BoundTableRef> BindShowTable(ShowRef &ref);
 	unique_ptr<BoundTableRef> BindSummarize(ShowRef &ref);
 
+	void BindInsertColumnList(TableCatalogEntry &table, vector<string> &columns, bool default_values,
+	                          vector<LogicalIndex> &named_column_map, vector<LogicalType> &expected_types,
+	                          IndexVector<idx_t, PhysicalIndex> &column_index_map);
+	void TryReplaceDefaultExpression(unique_ptr<ParsedExpression> &expr, const ColumnDefinition &column);
+	void ExpandDefaultInValuesList(InsertStatement &stmt, TableCatalogEntry &table,
+	                               optional_ptr<ExpressionListRef> values_list,
+	                               const vector<LogicalIndex> &named_column_map);
+	unique_ptr<BoundMergeIntoAction> BindMergeAction(LogicalMergeInto &merge_into, TableCatalogEntry &table,
+	                                                 LogicalGet &get, idx_t proj_index,
+	                                                 vector<unique_ptr<Expression>> &expressions,
+	                                                 unique_ptr<LogicalOperator> &root, MergeIntoAction &action,
+	                                                 const vector<BindingAlias> &source_aliases,
+	                                                 const vector<string> &source_names);
+
+	unique_ptr<MergeIntoStatement> GenerateMergeInto(InsertStatement &stmt, TableCatalogEntry &table);
+
+	static void CheckInsertColumnCountMismatch(idx_t expected_columns, idx_t result_columns, bool columns_provided,
+	                                           const string &tname);
+
 private:
 	Binder(ClientContext &context, shared_ptr<Binder> parent, BinderType binder_type);
 };

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

@@ -38,5 +38,7 @@ public:
 		}
 		return reinterpret_cast<const TARGET &>(*this);
 	}
+
+	virtual unique_ptr<BoundConstraint> Copy() const = 0;
 };
 } // namespace duckdb

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

@@ -59,6 +59,7 @@ public:
 public:
 	BoundOrderByNode Copy() const;
 	bool Equals(const BoundOrderByNode &other) const;
+	string GetOrderModifier() const;
 	string ToString() const;
 
 	void Serialize(Serializer &serializer) const;

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

@@ -34,6 +34,7 @@ class BoundConjunctionExpression;
 class BoundConstantExpression;
 class BoundDefaultExpression;
 class BoundFunctionExpression;
+class BoundLambdaRefExpression;
 class BoundOperatorExpression;
 class BoundParameterExpression;
 class BoundReferenceExpression;
@@ -56,4 +57,6 @@ class BoundColumnDataRef;
 class BoundCTERef;
 class BoundPivotRef;
 
+class BoundMergeIntoAction;
+
 } // namespace duckdb

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

@@ -29,6 +29,14 @@ public:
 	unique_ptr<Expression> expression;
 	//! The columns used by the CHECK constraint
 	physical_index_set_t bound_columns;
+
+public:
+	unique_ptr<BoundConstraint> Copy() const override {
+		auto result = make_uniq<BoundCheckConstraint>();
+		result->expression = expression->Copy();
+		result->bound_columns = bound_columns;
+		return std::move(result);
+	}
 };
 
 } // namespace duckdb

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

@@ -40,6 +40,10 @@ public:
 	physical_index_set_t pk_key_set;
 	//! The same keys but stored as an unordered set
 	physical_index_set_t fk_key_set;
+
+	unique_ptr<BoundConstraint> Copy() const override {
+		return make_uniq<BoundForeignKeyConstraint>(info, pk_key_set, fk_key_set);
+	}
 };
 
 } // namespace duckdb

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

@@ -22,6 +22,10 @@ public:
 
 	//! Column index this constraint pertains to
 	PhysicalIndex index;
+
+	unique_ptr<BoundConstraint> Copy() const override {
+		return make_uniq<BoundNotNullConstraint>(index);
+	}
 };
 
 } // namespace duckdb

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

@@ -37,6 +37,11 @@ public:
 	physical_index_set_t key_set;
 	//! Whether this is a PRIMARY KEY constraint, or a UNIQUE constraint.
 	bool is_primary_key;
+
+public:
+	unique_ptr<BoundConstraint> Copy() const override {
+		return make_uniq<BoundUniqueConstraint>(keys, key_set, is_primary_key);
+	}
 };
 
 } // namespace duckdb

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

@@ -37,10 +37,10 @@ public:
 	static unique_ptr<Expression> Deserialize(Deserializer &deserializer);
 
 public:
-	ExpressionType LowerComparisonType() {
+	ExpressionType LowerComparisonType() const {
 		return lower_inclusive ? ExpressionType::COMPARE_GREATERTHANOREQUALTO : ExpressionType::COMPARE_GREATERTHAN;
 	}
-	ExpressionType UpperComparisonType() {
+	ExpressionType UpperComparisonType() const {
 		return upper_inclusive ? ExpressionType::COMPARE_LESSTHANOREQUALTO : ExpressionType::COMPARE_LESSTHAN;
 	}
 

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

@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/expression_binder/projection_binder.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/planner/expression_binder.hpp"
+
+namespace duckdb {
+
+class ColumnAliasBinder;
+
+//! The Projection binder
+class ProjectionBinder : public ExpressionBinder {
+public:
+	ProjectionBinder(Binder &binder, ClientContext &context, idx_t proj_index,
+	                 vector<unique_ptr<Expression>> &proj_expressions, string clause);
+
+protected:
+	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
+	                          bool root_expression = false) override;
+
+	string UnsupportedAggregateMessage() override;
+
+	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression);
+
+private:
+	idx_t proj_index;
+	vector<unique_ptr<Expression>> &proj_expressions;
+	string clause;
+};
+
+} // namespace duckdb

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

@@ -15,7 +15,8 @@ namespace duckdb {
 //! The table function binder can bind standard table function parameters (i.e., non-table-in-out functions)
 class TableFunctionBinder : public ExpressionBinder {
 public:
-	TableFunctionBinder(Binder &binder, ClientContext &context, string table_function_name = string());
+	TableFunctionBinder(Binder &binder, ClientContext &context, string table_function_name = string(),
+	                    string clause = "Table function");
 
 protected:
 	BindResult BindLambdaReference(LambdaRefExpression &expr, idx_t depth);
@@ -26,6 +27,7 @@ protected:
 
 private:
 	string table_function_name;
+	string clause;
 };
 
 } // namespace duckdb

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

@@ -147,13 +147,6 @@ public:
 	//! Enables special-handling of lambda parameters during macro replacement by tracking them in the lambda_params
 	//! vector.
 	void ReplaceMacroParametersInLambda(FunctionExpression &function, vector<unordered_set<string>> &lambda_params);
-	//! Recursively qualifies column references in ON CONFLICT DO UPDATE SET expressions.
-	void DoUpdateSetQualify(unique_ptr<ParsedExpression> &expr, const string &table_name,
-	                        vector<unordered_set<string>> &lambda_params);
-	//! Enables special-handling of lambda parameters during ON CONFLICT TO UPDATE SET qualification by tracking them in
-	//! the lambda_params vector.
-	void DoUpdateSetQualifyInLambda(FunctionExpression &function, const string &table_name,
-	                                vector<unordered_set<string>> &lambda_params);
 
 	static LogicalType GetExpressionReturnType(const Expression &expr);
 
@@ -200,6 +193,8 @@ protected:
 
 	BindResult BindUnsupportedExpression(ParsedExpression &expr, idx_t depth, const string &message);
 
+	optional_ptr<CatalogEntry> BindAndQualifyFunction(FunctionExpression &function, bool allow_throw);
+
 protected:
 	virtual BindResult BindGroupingFunction(OperatorExpression &op, idx_t depth);
 	virtual BindResult BindFunction(FunctionExpression &expr, ScalarFunctionCatalogEntry &function, idx_t depth);
@@ -209,7 +204,7 @@ protected:
 	virtual BindResult BindMacro(FunctionExpression &expr, ScalarMacroCatalogEntry &macro, idx_t depth,
 	                             unique_ptr<ParsedExpression> &expr_ptr);
 	void UnfoldMacroExpression(FunctionExpression &function, ScalarMacroCatalogEntry &macro_func,
-	                           unique_ptr<ParsedExpression> &expr);
+	                           unique_ptr<ParsedExpression> &expr, idx_t depth);
 
 	virtual string UnsupportedAggregateMessage();
 	virtual string UnsupportedUnnestMessage();

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

@@ -27,6 +27,24 @@ public:
 
 	static void EnumerateExpression(unique_ptr<Expression> &expr,
 	                                const std::function<void(Expression &child)> &callback);
+	static void EnumerateExpression(unique_ptr<Expression> &expr,
+	                                const std::function<void(unique_ptr<Expression> &child)> &callback);
+
+	static void VisitExpressionClass(const Expression &expr, ExpressionClass expr_class,
+	                                 const std::function<void(const Expression &child)> &callback);
+	static void VisitExpressionClassMutable(unique_ptr<Expression> &expr, ExpressionClass expr_class,
+	                                        const std::function<void(unique_ptr<Expression> &child)> &callback);
+
+	template <class T>
+	static void VisitExpressionMutable(unique_ptr<Expression> &expr,
+	                                   const std::function<void(T &child, unique_ptr<Expression> &)> &callback) {
+		VisitExpressionClassMutable(expr, T::TYPE,
+		                            [&](unique_ptr<Expression> &child) { callback(child->Cast<T>(), child); });
+	}
+	template <class T>
+	static void VisitExpression(const Expression &expr, const std::function<void(const T &child)> &callback) {
+		VisitExpressionClass(expr, T::TYPE, [&](const Expression &child) { callback(child.Cast<T>()); });
+	}
 };
 
 class BoundNodeVisitor {

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

@@ -11,7 +11,9 @@
 #include "duckdb/common/common.hpp"
 
 namespace duckdb {
+class ClientContext;
 class DatabaseInstance;
+class ErrorData;
 
 class ExtensionCallback {
 public:
@@ -24,9 +26,15 @@ public:
 	//! Called when a connection is closed
 	virtual void OnConnectionClosed(ClientContext &context) {
 	}
+	//! Called before an extension starts loading
+	virtual void OnBeginExtensionLoad(DatabaseInstance &db, const string &name) {
+	}
 	//! Called after an extension is finished loading
 	virtual void OnExtensionLoaded(DatabaseInstance &db, const string &name) {
 	}
+	//! Called after an extension fails to load loading
+	virtual void OnExtensionLoadFail(DatabaseInstance &db, const string &name, const ErrorData &error) {
+	}
 };
 
 } // namespace duckdb

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

@@ -0,0 +1,67 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/logical_operator_deep_copy.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/planner/bound_tokens.hpp"
+#include "duckdb/planner/logical_tokens.hpp"
+
+#include "duckdb/planner/logical_operator_visitor.hpp"
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/bound_parameter_map.hpp"
+
+namespace duckdb {
+
+//! While it is possible to copy a logical plan using `Copy()`, both, the original and the copy
+//! are—by design—identical. This includes any table_idx values etc. This is bad, when we try
+//! to use part of a logical plan multiple times in the same plan.
+//! The LogicalOperatorDeepCopy first copies a LogicalOperator, but then traverses the entire plan
+//! and replaces all table indexes. We store a map from the original table index to the new index,
+//! which we use in the TableBindingReplacer to correct all column accesses.
+class LogicalOperatorDeepCopy : public LogicalOperatorVisitor {
+public:
+	LogicalOperatorDeepCopy(Binder &binder, optional_ptr<bound_parameter_map_t> parameter_data);
+
+	unique_ptr<LogicalOperator> DeepCopy(unique_ptr<LogicalOperator> &op);
+
+private:
+	void VisitOperator(LogicalOperator &op) override;
+
+private:
+	// Single-field version
+	template <typename T>
+	void ReplaceTableIndex(LogicalOperator &op);
+	// Multi-field version
+	template <typename T>
+	void ReplaceTableIndexMulti(LogicalOperator &op);
+
+private:
+	Binder &binder;
+	std::unordered_map<idx_t, idx_t> table_idx_replacements;
+	optional_ptr<bound_parameter_map_t> parameter_data;
+};
+
+//! The TableBindingReplacer updates table bindings, utility for optimizers
+class TableBindingReplacer : LogicalOperatorVisitor {
+public:
+	TableBindingReplacer(std::unordered_map<idx_t, idx_t> &table_idx_replacements,
+	                     optional_ptr<bound_parameter_map_t> parameter_data);
+
+public:
+	//! Update each operator of the plan
+	void VisitOperator(LogicalOperator &op) override;
+	//! Visit an expression and update its column bindings
+	void VisitExpression(unique_ptr<Expression> *expression) override;
+
+public:
+	//! Contains all bindings that need to be updated
+	const std::unordered_map<idx_t, idx_t> &table_idx_replacements;
+	optional_ptr<bound_parameter_map_t> parameter_data;
+};
+} // namespace duckdb

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

@@ -39,6 +39,7 @@ class LogicalGet;
 class LogicalInsert;
 class LogicalJoin;
 class LogicalLimit;
+class LogicalMergeInto;
 class LogicalOrder;
 class LogicalPivot;
 class LogicalPositionalJoin;

package/src/duckdb/src/include/duckdb/planner/operator/list.hpp

@@ -28,6 +28,7 @@
 #include "duckdb/planner/operator/logical_join.hpp"
 #include "duckdb/planner/operator/logical_limit.hpp"
 #include "duckdb/planner/operator/logical_materialized_cte.hpp"
+#include "duckdb/planner/operator/logical_merge_into.hpp"
 #include "duckdb/planner/operator/logical_order.hpp"
 #include "duckdb/planner/operator/logical_pivot.hpp"
 #include "duckdb/planner/operator/logical_positional_join.hpp"

package/src/duckdb/src/include/duckdb/planner/operator/logical_aggregate.hpp

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include "duckdb/common/enums/tuple_data_layout_enums.hpp"
 #include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/planner/column_binding.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
@@ -38,6 +39,8 @@ public:
 	vector<unsafe_vector<idx_t>> grouping_functions;
 	//! Group statistics (optional)
 	vector<unique_ptr<BaseStatistics>> group_stats;
+	//! Whether the inputs to all expression are non-NULL
+	TupleDataValidityType distinct_validity;
 
 public:
 	InsertionOrderPreservingMap<string> ParamsToString() const override;

package/src/duckdb/src/include/duckdb/planner/operator/logical_cteref.hpp

@@ -23,7 +23,7 @@ public:
 	              CTEMaterialize materialized_cte, bool is_recurring = false)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_CTE_REF), table_index(table_index), cte_index(cte_index),
 	      correlated_columns(0), materialized_cte(materialized_cte), is_recurring(is_recurring) {
-		D_ASSERT(types.size() > 0);
+		D_ASSERT(!types.empty());
 		chunk_types = std::move(types);
 		bound_columns = std::move(colnames);
 	}