duckdb 0.6.2-dev971.0 → 0.7.1-dev2.0

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

@@ -0,0 +1,54 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/expression/bound_lambdaref_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/planner/column_binding.hpp"
+#include "duckdb/planner/expression.hpp"
+
+namespace duckdb {
+
+class FieldReader;
+class FieldWriter;
+
+//! A BoundLambdaRef expression represents a LambdaRef expression that was bound to an lambda parameter
+//! in the lambda bindings vector. When capturing lambdas the BoundLambdaRef becomes a
+//! BoundReferenceExpresssion, indexing the corresponding lambda parameter in the lambda bindings vector,
+//! which refers to the physical chunk of the lambda parameter during execution.
+class BoundLambdaRefExpression : public Expression {
+public:
+	BoundLambdaRefExpression(LogicalType type, ColumnBinding binding, idx_t lambda_index, idx_t depth = 0);
+	BoundLambdaRefExpression(string alias, LogicalType type, ColumnBinding binding, idx_t lambda_index,
+	                         idx_t depth = 0);
+	//! Column index set by the binder, used to generate the final BoundExpression
+	ColumnBinding binding;
+	//! The index of the lambda parameter in the lambda bindings vector
+	idx_t lambda_index;
+	//! The subquery depth (i.e. depth 0 = current query, depth 1 = parent query, depth 2 = parent of parent, etc...).
+	//! This is only non-zero for correlated expressions inside subqueries.
+	idx_t depth;
+
+public:
+	bool IsScalar() const override {
+		return false;
+	}
+	bool IsFoldable() const override {
+		return false;
+	}
+
+	string ToString() const override;
+
+	bool Equals(const BaseExpression *other) const override;
+	hash_t Hash() const override;
+
+	unique_ptr<Expression> Copy() override;
+
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+};
+} // namespace duckdb

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

@@ -17,7 +17,7 @@ namespace duckdb {
 struct BoundParameterData {
 	BoundParameterData() {
 	}
-	BoundParameterData(Value val) : value(move(val)), return_type(value.type()) {
+	BoundParameterData(Value val) : value(std::move(val)), return_type(value.type()) {
 	}
 
 	Value value;
@@ -34,7 +34,7 @@ public:
 	static shared_ptr<BoundParameterData> Deserialize(Deserializer &source) {
 		FieldReader reader(source);
 		auto value = Value::Deserialize(reader.GetSource());
-		auto result = make_shared<BoundParameterData>(move(value));
+		auto result = make_shared<BoundParameterData>(std::move(value));
 		result->return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
 		reader.Finalize();
 		return result;

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

@@ -27,7 +27,7 @@ public:
 private:
 	BoundSelectNode &node;
 	const case_insensitive_map_t<idx_t> &alias_map;
-	bool in_alias;
+	unordered_set<idx_t> visited_select_indexes;
 };
 
 } // namespace duckdb

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

@@ -20,10 +20,6 @@ public:
 protected:
 	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
 	                          bool root_expression = false) override;
-
-	// check certain column ref Names to make sure they are supported in the returning statement
-	// (i.e rowid)
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth);
 };
 
 } // namespace duckdb

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

@@ -18,7 +18,7 @@ public:
 	TableFunctionBinder(Binder &binder, ClientContext &context);
 
 protected:
-	BindResult BindColumnReference(ColumnRefExpression &expr);
+	BindResult BindColumnReference(ColumnRefExpression &expr, idx_t depth);
 	BindResult BindExpression(unique_ptr<ParsedExpression> *expr, idx_t depth, bool root_expression = false) override;
 
 	string UnsupportedAggregateMessage() override;

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

@@ -39,7 +39,7 @@ struct BindResult {
 	}
 	explicit BindResult(string error) : error(error) {
 	}
-	explicit BindResult(unique_ptr<Expression> expr) : expression(move(expr)) {
+	explicit BindResult(unique_ptr<Expression> expr) : expression(std::move(expr)) {
 	}
 
 	bool HasError() {
@@ -126,10 +126,9 @@ protected:
 	BindResult BindExpression(SubqueryExpression &expr, idx_t depth);
 
 	void TransformCapturedLambdaColumn(unique_ptr<Expression> &original, unique_ptr<Expression> &replacement,
-	                                   vector<unique_ptr<Expression>> &captures, LogicalType &list_child_type,
-	                                   string &alias);
+	                                   vector<unique_ptr<Expression>> &captures, LogicalType &list_child_type);
 	void CaptureLambdaColumns(vector<unique_ptr<Expression>> &captures, LogicalType &list_child_type,
-	                          unique_ptr<Expression> &expr, string &alias);
+	                          unique_ptr<Expression> &expr);
 
 protected:
 	virtual BindResult BindGroupingFunction(OperatorExpression &op, idx_t depth);

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

@@ -39,6 +39,7 @@ class LogicalInsert;
 class LogicalJoin;
 class LogicalLimit;
 class LogicalOrder;
+class LogicalPositionalJoin;
 class LogicalPragma;
 class LogicalPrepare;
 class LogicalProjection;

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

@@ -25,6 +25,7 @@
 #include "duckdb/planner/operator/logical_limit.hpp"
 #include "duckdb/planner/operator/logical_limit_percent.hpp"
 #include "duckdb/planner/operator/logical_order.hpp"
+#include "duckdb/planner/operator/logical_positional_join.hpp"
 #include "duckdb/planner/operator/logical_pragma.hpp"
 #include "duckdb/planner/operator/logical_prepare.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"

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

@@ -17,15 +17,21 @@ namespace duckdb {
 class LogicalCopyToFile : public LogicalOperator {
 public:
 	LogicalCopyToFile(CopyFunction function, unique_ptr<FunctionData> bind_data)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_COPY_TO_FILE), function(function), bind_data(move(bind_data)) {
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_COPY_TO_FILE), function(function),
+	      bind_data(std::move(bind_data)) {
 	}
 	CopyFunction function;
 	unique_ptr<FunctionData> bind_data;
 	std::string file_path;
 	bool use_tmp_file;
-	bool is_file_and_exists;
+	bool allow_overwrite;
 	bool per_thread_output;
 
+	bool partition_output;
+	vector<idx_t> partition_columns;
+	vector<string> names;
+	vector<LogicalType> expected_types;
+
 public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);

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

@@ -17,7 +17,7 @@ namespace duckdb {
 class LogicalCreate : public LogicalOperator {
 public:
 	LogicalCreate(LogicalOperatorType type, unique_ptr<CreateInfo> info, SchemaCatalogEntry *schema = nullptr)
-	    : LogicalOperator(type), schema(schema), info(move(info)) {
+	    : LogicalOperator(type), schema(schema), info(std::move(info)) {
 	}
 
 	SchemaCatalogEntry *schema;

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

@@ -19,13 +19,13 @@ public:
 	LogicalCreateIndex(unique_ptr<FunctionData> bind_data_p, unique_ptr<CreateIndexInfo> info_p,
 	                   vector<unique_ptr<Expression>> expressions_p, TableCatalogEntry &table_p,
 	                   TableFunction function_p)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_INDEX), bind_data(move(bind_data_p)), info(move(info_p)),
-	      table(table_p), function(move(function_p)) {
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_INDEX), bind_data(std::move(bind_data_p)),
+	      info(std::move(info_p)), table(table_p), function(std::move(function_p)) {
 
 		for (auto &expr : expressions_p) {
 			this->unbound_expressions.push_back(expr->Copy());
 		}
-		this->expressions = move(expressions_p);
+		this->expressions = std::move(expressions_p);
 
 		if (info->column_ids.empty()) {
 			throw BinderException("CREATE INDEX does not refer to any columns in the base table!");

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

@@ -16,7 +16,7 @@ namespace duckdb {
 class LogicalCreateTable : public LogicalOperator {
 public:
 	LogicalCreateTable(SchemaCatalogEntry *schema, unique_ptr<BoundCreateTableInfo> info)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_TABLE), schema(schema), info(move(info)) {
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_TABLE), schema(schema), info(std::move(info)) {
 	}
 
 	//! Schema to insert to

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

@@ -8,13 +8,13 @@
 
 #pragma once
 
-#include "duckdb/planner/logical_operator.hpp"
+#include "duckdb/planner/operator/logical_unconditional_join.hpp"
 
 namespace duckdb {
 
 //! LogicalCrossProduct represents a cross product between two relations
-class LogicalCrossProduct : public LogicalOperator {
-	LogicalCrossProduct() : LogicalOperator(LogicalOperatorType::LOGICAL_CROSS_PRODUCT) {};
+class LogicalCrossProduct : public LogicalUnconditionalJoin {
+	LogicalCrossProduct() : LogicalUnconditionalJoin(LogicalOperatorType::LOGICAL_CROSS_PRODUCT) {};
 
 public:
 	LogicalCrossProduct(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right);
@@ -22,12 +22,7 @@ public:
 public:
 	static unique_ptr<LogicalOperator> Create(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right);
 
-	vector<ColumnBinding> GetColumnBindings() override;
-
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
-
-protected:
-	void ResolveTypes() override;
 };
 } // namespace duckdb

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

@@ -8,18 +8,14 @@
 
 #pragma once
 
-#include "duckdb/common/field_writer.hpp"
 #include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 
 namespace duckdb {
+class TableCatalogEntry;
 
 class LogicalDelete : public LogicalOperator {
 public:
-	explicit LogicalDelete(TableCatalogEntry *table, idx_t table_index)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_DELETE), table(table), table_index(table_index),
-	      return_chunk(false) {
-	}
+	explicit LogicalDelete(TableCatalogEntry *table, idx_t table_index);
 
 	TableCatalogEntry *table;
 	idx_t table_index;
@@ -32,19 +28,7 @@ public:
 	vector<idx_t> GetTableIndex() const override;
 
 protected:
-	vector<ColumnBinding> GetColumnBindings() override {
-		if (return_chunk) {
-			return GenerateColumnBindings(table_index, table->GetTypes().size());
-		}
-		return {ColumnBinding(0, 0)};
-	}
-
-	void ResolveTypes() override {
-		if (return_chunk) {
-			types = table->GetTypes();
-		} else {
-			types.emplace_back(LogicalType::BIGINT);
-		}
-	}
+	vector<ColumnBinding> GetColumnBindings() override;
+	void ResolveTypes() override;
 };
 } // namespace duckdb

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

@@ -18,7 +18,7 @@ public:
 	LogicalDistinct() : LogicalOperator(LogicalOperatorType::LOGICAL_DISTINCT) {
 	}
 	explicit LogicalDistinct(vector<unique_ptr<Expression>> targets)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_DISTINCT), distinct_targets(move(targets)) {
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_DISTINCT), distinct_targets(std::move(targets)) {
 	}
 	//! The set of distinct targets (optional).
 	vector<unique_ptr<Expression>> distinct_targets;

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

@@ -16,7 +16,7 @@ namespace duckdb {
 class LogicalExecute : public LogicalOperator {
 public:
 	explicit LogicalExecute(shared_ptr<PreparedStatementData> prepared_p)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXECUTE), prepared(move(prepared_p)) {
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXECUTE), prepared(std::move(prepared_p)) {
 		D_ASSERT(prepared);
 		types = prepared->types;
 	}

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

@@ -20,7 +20,7 @@ class LogicalExplain : public LogicalOperator {
 public:
 	LogicalExplain(unique_ptr<LogicalOperator> plan, ExplainType explain_type)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPLAIN), explain_type(explain_type) {
-		children.push_back(move(plan));
+		children.push_back(std::move(plan));
 	}
 
 	ExplainType explain_type;

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

@@ -18,8 +18,8 @@ namespace duckdb {
 class LogicalExport : public LogicalOperator {
 public:
 	LogicalExport(CopyFunction function, unique_ptr<CopyInfo> copy_info, BoundExportData exported_tables)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPORT), function(function), copy_info(move(copy_info)),
-	      exported_tables(move(exported_tables)) {
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPORT), function(function), copy_info(std::move(copy_info)),
+	      exported_tables(std::move(exported_tables)) {
 	}
 	CopyFunction function;
 	unique_ptr<CopyInfo> copy_info;

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

@@ -18,7 +18,7 @@ public:
 	LogicalExpressionGet(idx_t table_index, vector<LogicalType> types,
 	                     vector<vector<unique_ptr<Expression>>> expressions)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPRESSION_GET), table_index(table_index), expr_types(types),
-	      expressions(move(expressions)) {
+	      expressions(std::move(expressions)) {
 	}
 
 	//! The table index in the current bind context

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

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/planner/operator/logical_extension.operator.hpp
+// duckdb/planner/operator/logical_extension_operator.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -14,11 +14,10 @@
 namespace duckdb {
 
 struct LogicalExtensionOperator : public LogicalOperator {
-
 	LogicalExtensionOperator() : LogicalOperator(LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR) {
 	}
 	LogicalExtensionOperator(vector<unique_ptr<Expression>> expressions)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR, move(expressions)) {
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR, std::move(expressions)) {
 	}
 
 	static unique_ptr<LogicalExtensionOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);

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

@@ -10,16 +10,17 @@
 
 #include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/common/index_vector.hpp"
+#include "duckdb/parser/statement/insert_statement.hpp"
 
 namespace duckdb {
+class TableCatalogEntry;
+
+class Index;
 
 //! LogicalInsert represents an insertion of data into a base table
 class LogicalInsert : public LogicalOperator {
 public:
-	LogicalInsert(TableCatalogEntry *table, idx_t table_index)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_INSERT), table(table), table_index(table_index),
-	      return_chunk(false) {
-	}
+	LogicalInsert(TableCatalogEntry *table, idx_t table_index);
 
 	vector<vector<unique_ptr<Expression>>> insert_values;
 	//! The insertion map ([table_index -> index in result, or DConstants::INVALID_INDEX if not specified])
@@ -34,25 +35,34 @@ public:
 	//! The default statements used by the table
 	vector<unique_ptr<Expression>> bound_defaults;
 
+	//! Which action to take on conflict
+	OnConflictAction action_type;
+	// The types that the DO UPDATE .. SET (expressions) are cast to
+	vector<LogicalType> expected_set_types;
+	// The (distinct) column ids to apply the ON CONFLICT on
+	unordered_set<column_t> on_conflict_filter;
+	// The WHERE clause of the conflict_target (ON CONFLICT .. WHERE <condition>)
+	unique_ptr<Expression> on_conflict_condition;
+	// The WHERE clause of the DO UPDATE clause
+	unique_ptr<Expression> do_update_condition;
+	// The columns targeted by the DO UPDATE SET expressions
+	vector<PhysicalIndex> set_columns;
+	// The types of the columns targeted by the DO UPDATE SET expressions
+	vector<LogicalType> set_types;
+	// The table_index referring to the column references qualified with 'excluded'
+	idx_t excluded_table_index;
+	// The columns to fetch from the 'destination' table
+	vector<column_t> columns_to_fetch;
+	// The columns to fetch from the 'source' table
+	vector<column_t> source_columns;
+
 public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 
 protected:
-	vector<ColumnBinding> GetColumnBindings() override {
-		if (return_chunk) {
-			return GenerateColumnBindings(table_index, table->GetTypes().size());
-		}
-		return {ColumnBinding(0, 0)};
-	}
-
-	void ResolveTypes() override {
-		if (return_chunk) {
-			types = table->GetTypes();
-		} else {
-			types.emplace_back(LogicalType::BIGINT);
-		}
-	}
+	vector<ColumnBinding> GetColumnBindings() override;
+	void ResolveTypes() override;
 
 	idx_t EstimateCardinality(ClientContext &context) override;
 	vector<idx_t> GetTableIndex() const override;

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

@@ -18,7 +18,7 @@ public:
 	LogicalLimitPercent(double limit_percent, int64_t offset_val, unique_ptr<Expression> limit,
 	                    unique_ptr<Expression> offset)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_LIMIT_PERCENT), limit_percent(limit_percent),
-	      offset_val(offset_val), limit(move(limit)), offset(move(offset)) {
+	      offset_val(offset_val), limit(std::move(limit)), offset(std::move(offset)) {
 	}
 
 	//! Limit percent and offset values in case they are constants, used in optimizations.

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

@@ -19,7 +19,7 @@ namespace duckdb {
 class LogicalOrder : public LogicalOperator {
 public:
 	explicit LogicalOrder(vector<BoundOrderByNode> orders)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_ORDER_BY), orders(move(orders)) {
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_ORDER_BY), orders(std::move(orders)) {
 	}
 
 	vector<BoundOrderByNode> orders;

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

@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/operator/logical_positional_join.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/planner/operator/logical_unconditional_join.hpp"
+
+namespace duckdb {
+
+//! LogicalPositionalJoin represents a row-wise join between two relations
+class LogicalPositionalJoin : public LogicalUnconditionalJoin {
+	LogicalPositionalJoin() : LogicalUnconditionalJoin(LogicalOperatorType::LOGICAL_POSITIONAL_JOIN) {};
+
+public:
+	LogicalPositionalJoin(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right);
+
+public:
+	static unique_ptr<LogicalOperator> Create(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right);
+
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+};
+} // namespace duckdb

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

@@ -18,7 +18,8 @@ namespace duckdb {
 class LogicalPragma : public LogicalOperator {
 public:
 	LogicalPragma(PragmaFunction function_p, PragmaInfo info_p)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_PRAGMA), function(move(function_p)), info(move(info_p)) {
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_PRAGMA), function(std::move(function_p)),
+	      info(std::move(info_p)) {
 	}
 
 	//! The pragma function to call

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

@@ -20,9 +20,9 @@ class TableCatalogEntry;
 class LogicalPrepare : public LogicalOperator {
 public:
 	LogicalPrepare(string name, shared_ptr<PreparedStatementData> prepared, unique_ptr<LogicalOperator> logical_plan)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_PREPARE), name(name), prepared(move(prepared)) {
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_PREPARE), name(name), prepared(std::move(prepared)) {
 		if (logical_plan) {
-			children.push_back(move(logical_plan));
+			children.push_back(std::move(logical_plan));
 		}
 	}
 

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

@@ -22,8 +22,8 @@ public:
 	                    unique_ptr<LogicalOperator> bottom, LogicalOperatorType type)
 	    : LogicalOperator(type), union_all(union_all), table_index(table_index), column_count(column_count) {
 		D_ASSERT(type == LogicalOperatorType::LOGICAL_RECURSIVE_CTE);
-		children.push_back(move(top));
-		children.push_back(move(bottom));
+		children.push_back(std::move(top));
+		children.push_back(std::move(bottom));
 	}
 
 	bool union_all;

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

@@ -23,8 +23,8 @@ public:
 	    : LogicalOperator(type), table_index(table_index), column_count(column_count) {
 		D_ASSERT(type == LogicalOperatorType::LOGICAL_UNION || type == LogicalOperatorType::LOGICAL_EXCEPT ||
 		         type == LogicalOperatorType::LOGICAL_INTERSECT);
-		children.push_back(move(top));
-		children.push_back(move(bottom));
+		children.push_back(std::move(top));
+		children.push_back(std::move(bottom));
 	}
 
 	idx_t table_index;

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

@@ -17,7 +17,7 @@ class LogicalShow : public LogicalOperator {
 
 public:
 	explicit LogicalShow(unique_ptr<LogicalOperator> plan) : LogicalOperator(LogicalOperatorType::LOGICAL_SHOW) {
-		children.push_back(move(plan));
+		children.push_back(std::move(plan));
 	}
 
 	vector<LogicalType> types_select;

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

@@ -17,7 +17,7 @@ namespace duckdb {
 //! LogicalSimple represents a simple logical operator that only passes on the parse info
 class LogicalSimple : public LogicalOperator {
 public:
-	LogicalSimple(LogicalOperatorType type, unique_ptr<ParseInfo> info) : LogicalOperator(type), info(move(info)) {
+	LogicalSimple(LogicalOperatorType type, unique_ptr<ParseInfo> info) : LogicalOperator(type), info(std::move(info)) {
 	}
 
 	unique_ptr<ParseInfo> info;

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

@@ -17,7 +17,7 @@ namespace duckdb {
 class LogicalTopN : public LogicalOperator {
 public:
 	LogicalTopN(vector<BoundOrderByNode> orders, int64_t limit, int64_t offset)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_TOP_N), orders(move(orders)), limit(limit), offset(offset) {
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_TOP_N), orders(std::move(orders)), limit(limit), offset(offset) {
 	}
 
 	vector<BoundOrderByNode> orders;

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

@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/operator/logical_unconditional_join.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/planner/logical_operator.hpp"
+
+namespace duckdb {
+
+//! LogicalUnconditionalJoin represents a join between two relations
+//! where the join condition is implicit (cross product, position, etc.)
+class LogicalUnconditionalJoin : public LogicalOperator {
+public:
+	explicit LogicalUnconditionalJoin(LogicalOperatorType logical_type) : LogicalOperator(logical_type) {};
+
+public:
+	LogicalUnconditionalJoin(LogicalOperatorType logical_type, unique_ptr<LogicalOperator> left,
+	                         unique_ptr<LogicalOperator> right);
+
+public:
+	vector<ColumnBinding> GetColumnBindings() override;
+
+protected:
+	void ResolveTypes() override;
+};
+} // namespace duckdb

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

@@ -12,8 +12,7 @@
 
 namespace duckdb {
 
-//! LogicalAggregate represents an aggregate operation with (optional) GROUP BY
-//! operator.
+//! LogicalUnnest represents the logical UNNEST operator.
 class LogicalUnnest : public LogicalOperator {
 public:
 	explicit LogicalUnnest(idx_t unnest_index)

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

@@ -9,15 +9,13 @@
 #pragma once
 
 #include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 
 namespace duckdb {
+class TableCatalogEntry;
 
 class LogicalUpdate : public LogicalOperator {
 public:
-	explicit LogicalUpdate(TableCatalogEntry *table)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_UPDATE), table(table), table_index(0), return_chunk(false) {
-	}
+	explicit LogicalUpdate(TableCatalogEntry *table);
 
 	//! The base table to update
 	TableCatalogEntry *table;
@@ -35,19 +33,7 @@ public:
 	idx_t EstimateCardinality(ClientContext &context) override;
 
 protected:
-	vector<ColumnBinding> GetColumnBindings() override {
-		if (return_chunk) {
-			return GenerateColumnBindings(table_index, table->GetTypes().size());
-		}
-		return {ColumnBinding(0, 0)};
-	}
-
-	void ResolveTypes() override {
-		if (return_chunk) {
-			types = table->GetTypes();
-		} else {
-			types.emplace_back(LogicalType::BIGINT);
-		}
-	}
+	vector<ColumnBinding> GetColumnBindings() override;
+	void ResolveTypes() override;
 };
 } // namespace duckdb