Update vendored DuckDB sources to f793ea27c6

src/duckdb/src/common/enum_util.cpp

@@ -3624,19 +3624,20 @@ const StringUtil::EnumStringLiteral *GetQueryNodeTypeValues() {
 		{ static_cast<uint32_t>(QueryNodeType::SET_OPERATION_NODE), "SET_OPERATION_NODE" },
 		{ static_cast<uint32_t>(QueryNodeType::BOUND_SUBQUERY_NODE), "BOUND_SUBQUERY_NODE" },
 		{ static_cast<uint32_t>(QueryNodeType::RECURSIVE_CTE_NODE), "RECURSIVE_CTE_NODE" },
-		{ static_cast<uint32_t>(QueryNodeType::CTE_NODE), "CTE_NODE" }
+		{ static_cast<uint32_t>(QueryNodeType::CTE_NODE), "CTE_NODE" },
+		{ static_cast<uint32_t>(QueryNodeType::STATEMENT_NODE), "STATEMENT_NODE" }
 	};
 	return values;
 }
 
 template<>
 const char* EnumUtil::ToChars<QueryNodeType>(QueryNodeType value) {
-	return StringUtil::EnumToString(GetQueryNodeTypeValues(), 5, "QueryNodeType", static_cast<uint32_t>(value));
+	return StringUtil::EnumToString(GetQueryNodeTypeValues(), 6, "QueryNodeType", static_cast<uint32_t>(value));
 }
 
 template<>
 QueryNodeType EnumUtil::FromString<QueryNodeType>(const char *value) {
-	return static_cast<QueryNodeType>(StringUtil::StringToEnum(GetQueryNodeTypeValues(), 5, "QueryNodeType", value));
+	return static_cast<QueryNodeType>(StringUtil::StringToEnum(GetQueryNodeTypeValues(), 6, "QueryNodeType", value));
 }
 
 const StringUtil::EnumStringLiteral *GetQueryResultTypeValues() {

src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,5 +1,5 @@
 #ifndef DUCKDB_PATCH_VERSION
-#define DUCKDB_PATCH_VERSION "0-dev722"
+#define DUCKDB_PATCH_VERSION "0-dev732"
 #endif
 #ifndef DUCKDB_MINOR_VERSION
 #define DUCKDB_MINOR_VERSION 5
@@ -8,10 +8,10 @@
 #define DUCKDB_MAJOR_VERSION 1
 #endif
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "v1.5.0-dev722"
+#define DUCKDB_VERSION "v1.5.0-dev732"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "b3c8acdc0e"
+#define DUCKDB_SOURCE_ID "f793ea27c6"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

src/duckdb/src/include/duckdb/common/insertion_order_preserving_map.hpp

@@ -95,6 +95,10 @@ class InsertionOrderPreservingMap {
 		map.resize(nz);
 	}
 
+	void clear() { // NOLINT: match stl API
+		map.clear();
+	}
+
 	void insert(const string &key, V &&value) { // NOLINT: match stl API
 		if (contains(key)) {
 			return;

src/duckdb/src/include/duckdb/parser/query_node.hpp

@@ -25,7 +25,8 @@ enum class QueryNodeType : uint8_t {
 	SET_OPERATION_NODE = 2,
 	BOUND_SUBQUERY_NODE = 3,
 	RECURSIVE_CTE_NODE = 4,
-	CTE_NODE = 5
+	CTE_NODE = 5,
+	STATEMENT_NODE = 6
 };
 
 struct CommonTableExpressionInfo;

src/duckdb/src/include/duckdb/parser/query_node/list.hpp

@@ -2,3 +2,4 @@
 #include "duckdb/parser/query_node/cte_node.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/query_node/set_operation_node.hpp"
+#include "duckdb/parser/query_node/statement_node.hpp"

src/duckdb/src/include/duckdb/parser/query_node/statement_node.hpp

@@ -0,0 +1,42 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/query_node/statement_node.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/parser/parsed_expression.hpp"
+#include "duckdb/parser/query_node.hpp"
+#include "duckdb/parser/sql_statement.hpp"
+
+namespace duckdb {
+
+class StatementNode : public QueryNode {
+public:
+	static constexpr const QueryNodeType TYPE = QueryNodeType::STATEMENT_NODE;
+
+public:
+	explicit StatementNode(SQLStatement &stmt_p);
+
+	SQLStatement &stmt;
+
+public:
+	const vector<unique_ptr<ParsedExpression>> &GetSelectList() const override;
+	//! Convert the query node to a string
+	string ToString() const override;
+
+	bool Equals(const QueryNode *other) const override;
+	//! Create a copy of this SelectNode
+	unique_ptr<QueryNode> Copy() const override;
+
+	//! Serializes a QueryNode to a stand-alone binary blob
+	//! Deserializes a blob back into a QueryNode
+
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<QueryNode> Deserialize(Deserializer &source);
+};
+
+} // namespace duckdb

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

@@ -53,6 +53,7 @@ class SelectNode;
 class SetOperationNode;
 class RecursiveCTENode;
 class CTENode;
+class StatementNode;
 
 //===--------------------------------------------------------------------===//
 // Expressions

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

@@ -23,7 +23,7 @@
 namespace duckdb {
 class Binder;
 class LogicalGet;
-class BoundQueryNode;
+struct BoundStatement;
 
 class StarExpression;
 
@@ -105,11 +105,11 @@ class BindContext {
 	                      const vector<LogicalType> &types, vector<ColumnIndex> &bound_column_ids,
 	                      optional_ptr<StandardEntry> entry, virtual_column_map_t virtual_columns);
 	//! 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, BoundStatement &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);
+	void AddSubquery(idx_t index, const string &alias, SubqueryRef &ref, BoundStatement &subquery);
 	//! Adds a subquery with a given alias to the BindContext.
-	void AddSubquery(idx_t index, const string &alias, TableFunctionRef &ref, BoundQueryNode &subquery);
+	void AddSubquery(idx_t index, const string &alias, TableFunctionRef &ref, BoundStatement &subquery);
 	//! Adds a binding to a catalog entry with a given alias to the BindContext.
 	void AddEntryBinding(idx_t index, const string &alias, const vector<string> &names,
 	                     const vector<LogicalType> &types, StandardEntry &entry);

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

@@ -69,6 +69,7 @@ struct PivotColumnEntry;
 struct UnpivotEntry;
 struct CopyInfo;
 struct CopyOption;
+struct BoundSetOpChild;
 
 template <class T, class INDEX_TYPE>
 class IndexVector;
@@ -403,23 +404,25 @@ class Binder : public enable_shared_from_this<Binder> {
 
 	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);
+	BoundStatement BindCTE(CTENode &statement);
 
-	unique_ptr<BoundQueryNode> BindNode(SelectNode &node);
-	unique_ptr<BoundQueryNode> BindNode(SetOperationNode &node);
-	unique_ptr<BoundQueryNode> BindNode(RecursiveCTENode &node);
-	unique_ptr<BoundQueryNode> BindNode(CTENode &node);
-	unique_ptr<BoundQueryNode> BindNode(QueryNode &node);
+	BoundStatement BindNode(SelectNode &node);
+	BoundStatement BindNode(SetOperationNode &node);
+	BoundStatement BindNode(RecursiveCTENode &node);
+	BoundStatement BindNode(CTENode &node);
+	BoundStatement BindNode(QueryNode &node);
+	BoundStatement BindNode(StatementNode &node);
 
 	unique_ptr<LogicalOperator> VisitQueryNode(BoundQueryNode &node, unique_ptr<LogicalOperator> root);
 	unique_ptr<LogicalOperator> CreatePlan(BoundRecursiveCTENode &node);
 	unique_ptr<LogicalOperator> CreatePlan(BoundCTENode &node);
-	unique_ptr<LogicalOperator> CreatePlan(BoundCTENode &node, unique_ptr<LogicalOperator> base);
 	unique_ptr<LogicalOperator> CreatePlan(BoundSelectNode &statement);
 	unique_ptr<LogicalOperator> CreatePlan(BoundSetOperationNode &node);
 	unique_ptr<LogicalOperator> CreatePlan(BoundQueryNode &node);
 
+	BoundSetOpChild BindSetOpChild(QueryNode &child);
+	unique_ptr<BoundSetOperationNode> BindSetOpNode(SetOperationNode &statement);
+
 	unique_ptr<BoundTableRef> BindJoin(Binder &parent, TableRef &ref);
 	unique_ptr<BoundTableRef> Bind(BaseTableRef &ref);
 	unique_ptr<BoundTableRef> Bind(BoundRefWrapper &ref);
@@ -489,8 +492,8 @@ class Binder : public enable_shared_from_this<Binder> {
 	                                            JoinType join_type = JoinType::INNER,
 	                                            unique_ptr<Expression> condition = nullptr);
 
-	unique_ptr<LogicalOperator> CastLogicalOperatorToTypes(vector<LogicalType> &source_types,
-	                                                       vector<LogicalType> &target_types,
+	unique_ptr<LogicalOperator> CastLogicalOperatorToTypes(const vector<LogicalType> &source_types,
+	                                                       const vector<LogicalType> &target_types,
 	                                                       unique_ptr<LogicalOperator> op);
 
 	BindingAlias FindBinding(const string &using_column, const string &join_side);
@@ -522,7 +525,9 @@ class Binder : public enable_shared_from_this<Binder> {
 
 	LogicalType BindLogicalTypeInternal(const LogicalType &type, optional_ptr<Catalog> catalog, const string &schema);
 
-	unique_ptr<BoundQueryNode> BindSelectNode(SelectNode &statement, unique_ptr<BoundTableRef> from_table);
+	BoundStatement BindSelectNode(SelectNode &statement, unique_ptr<BoundTableRef> from_table);
+	unique_ptr<BoundSelectNode> BindSelectNodeInternal(SelectNode &statement);
+	unique_ptr<BoundSelectNode> BindSelectNodeInternal(SelectNode &statement, unique_ptr<BoundTableRef> from_table);
 
 	unique_ptr<LogicalOperator> BindCopyDatabaseSchema(Catalog &source_catalog, const string &target_database_name);
 	unique_ptr<LogicalOperator> BindCopyDatabaseData(Catalog &source_catalog, const string &target_database_name);

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

@@ -29,7 +29,7 @@ class BoundSubqueryExpression : public Expression {
 	//! The binder used to bind the subquery node
 	shared_ptr<Binder> binder;
 	//! The bound subquery node
-	unique_ptr<BoundQueryNode> subquery;
+	BoundStatement subquery;
 	//! The subquery type
 	SubqueryType subquery_type;
 	//! the child expressions to compare with (in case of IN, ANY, ALL operators)

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

@@ -14,7 +14,6 @@
 #include <functional>
 
 namespace duckdb {
-class BoundQueryNode;
 class BoundTableRef;
 
 class ExpressionIterator {
@@ -47,18 +46,4 @@ class ExpressionIterator {
 	}
 };
 
-class BoundNodeVisitor {
-public:
-	virtual ~BoundNodeVisitor() = default;
-
-	virtual void VisitBoundQueryNode(BoundQueryNode &op);
-	virtual void VisitBoundTableRef(BoundTableRef &ref);
-	virtual void VisitExpression(unique_ptr<Expression> &expression);
-
-protected:
-	// The VisitExpressionChildren method is called at the end of every call to VisitExpression to recursively visit all
-	// expressions in an expression tree. It can be overloaded to prevent automatically visiting the entire tree.
-	virtual void VisitExpressionChildren(Expression &expression);
-};
-
 } // namespace duckdb

src/duckdb/src/include/duckdb/planner/logical_operator.hpp

@@ -45,6 +45,7 @@ class LogicalOperator {
 
 public:
 	virtual vector<ColumnBinding> GetColumnBindings();
+	virtual idx_t GetRootIndex();
 	static string ColumnBindingsToString(const vector<ColumnBinding> &bindings);
 	void PrintColumnBindings();
 	static vector<ColumnBinding> GenerateColumnBindings(idx_t table_idx, idx_t column_count);

src/duckdb/src/include/duckdb/planner/query_node/bound_cte_node.hpp

@@ -25,9 +25,9 @@ class BoundCTENode : public BoundQueryNode {
 	string ctename;
 
 	//! The cte node
-	unique_ptr<BoundQueryNode> query;
+	BoundStatement query;
 	//! The child node
-	unique_ptr<BoundQueryNode> child;
+	BoundStatement child;
 	//! Index used by the set operation
 	idx_t setop_index;
 	//! The binder used by the query side of the CTE
@@ -39,7 +39,7 @@ class BoundCTENode : public BoundQueryNode {
 
 public:
 	idx_t GetRootIndex() override {
-		return child->GetRootIndex();
+		return child.plan->GetRootIndex();
 	}
 };
 

src/duckdb/src/include/duckdb/planner/query_node/bound_recursive_cte_node.hpp

@@ -27,9 +27,9 @@ class BoundRecursiveCTENode : public BoundQueryNode {
 
 	bool union_all;
 	//! The left side of the set operation
-	unique_ptr<BoundQueryNode> left;
+	BoundStatement left;
 	//! The right side of the set operation
-	unique_ptr<BoundQueryNode> right;
+	BoundStatement right;
 	//! Target columns for the recursive key variant
 	vector<unique_ptr<Expression>> key_targets;
 

src/duckdb/src/include/duckdb/planner/query_node/bound_set_operation_node.hpp

@@ -13,13 +13,7 @@
 #include "duckdb/planner/bound_query_node.hpp"
 
 namespace duckdb {
-
-struct BoundSetOpChild {
-	unique_ptr<BoundQueryNode> node;
-	shared_ptr<Binder> binder;
-	//! Exprs used by the UNION BY NAME operations to add a new projection
-	vector<unique_ptr<Expression>> reorder_expressions;
-};
+struct BoundSetOpChild;
 
 //! Bound equivalent of SetOperationNode
 class BoundSetOperationNode : public BoundQueryNode {
@@ -29,6 +23,7 @@ class BoundSetOperationNode : public BoundQueryNode {
 public:
 	BoundSetOperationNode() : BoundQueryNode(QueryNodeType::SET_OPERATION_NODE) {
 	}
+	~BoundSetOperationNode() override;
 
 	//! The type of set operation
 	SetOperationType setop_type = SetOperationType::NONE;
@@ -46,4 +41,18 @@ class BoundSetOperationNode : public BoundQueryNode {
 	}
 };
 
+struct BoundSetOpChild {
+	unique_ptr<BoundSetOperationNode> bound_node;
+	BoundStatement node;
+	shared_ptr<Binder> binder;
+	//! Original select list (if this was a SELECT statement)
+	vector<unique_ptr<ParsedExpression>> select_list;
+	//! Exprs used by the UNION BY NAME operations to add a new projection
+	vector<unique_ptr<Expression>> reorder_expressions;
+
+	const vector<string> &GetNames();
+	const vector<LogicalType> &GetTypes();
+	idx_t GetRootIndex();
+};
+
 } // namespace duckdb

src/duckdb/src/include/duckdb/planner/tableref/bound_subqueryref.hpp

@@ -20,13 +20,13 @@ class BoundSubqueryRef : public BoundTableRef {
 	static constexpr const TableReferenceType TYPE = TableReferenceType::SUBQUERY;
 
 public:
-	BoundSubqueryRef(shared_ptr<Binder> binder_p, unique_ptr<BoundQueryNode> subquery)
+	BoundSubqueryRef(shared_ptr<Binder> binder_p, BoundStatement subquery)
 	    : BoundTableRef(TableReferenceType::SUBQUERY), binder(std::move(binder_p)), subquery(std::move(subquery)) {
 	}
 
 	//! The binder used to bind the subquery
 	shared_ptr<Binder> binder;
 	//! The bound subquery node (if any)
-	unique_ptr<BoundQueryNode> subquery;
+	BoundStatement subquery;
 };
 } // namespace duckdb

src/duckdb/src/parser/query_node/statement_node.cpp

@@ -0,0 +1,43 @@
+#include "duckdb/parser/query_node/statement_node.hpp"
+
+namespace duckdb {
+
+StatementNode::StatementNode(SQLStatement &stmt_p) : QueryNode(QueryNodeType::STATEMENT_NODE), stmt(stmt_p) {
+}
+
+const vector<unique_ptr<ParsedExpression>> &StatementNode::GetSelectList() const {
+	throw InternalException("StatementNode has no select list");
+}
+//! Convert the query node to a string
+string StatementNode::ToString() const {
+	return stmt.ToString();
+}
+
+bool StatementNode::Equals(const QueryNode *other_p) const {
+	if (!QueryNode::Equals(other_p)) {
+		return false;
+	}
+	if (this == other_p) {
+		return true;
+	}
+	auto &other = other_p->Cast<StatementNode>();
+	return RefersToSameObject(stmt, other.stmt);
+}
+
+//! Create a copy of this SelectNode
+unique_ptr<QueryNode> StatementNode::Copy() const {
+	return make_uniq<StatementNode>(stmt);
+}
+
+//! Serializes a QueryNode to a stand-alone binary blob
+//! Deserializes a blob back into a QueryNode
+
+void StatementNode::Serialize(Serializer &serializer) const {
+	throw InternalException("StatementNode cannot be serialized");
+}
+
+unique_ptr<QueryNode> StatementNode::Deserialize(Deserializer &source) {
+	throw InternalException("StatementNode cannot be deserialized");
+}
+
+} // namespace duckdb