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

package/src/duckdb/src/execution/operator/filter/physical_filter.cpp

@@ -6,17 +6,17 @@ namespace duckdb {
 
 PhysicalFilter::PhysicalFilter(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
                                idx_t estimated_cardinality)
-    : CachingPhysicalOperator(PhysicalOperatorType::FILTER, move(types), estimated_cardinality) {
+    : CachingPhysicalOperator(PhysicalOperatorType::FILTER, std::move(types), estimated_cardinality) {
 	D_ASSERT(select_list.size() > 0);
 	if (select_list.size() > 1) {
 		// create a big AND out of the expressions
 		auto conjunction = make_unique<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND);
 		for (auto &expr : select_list) {
-			conjunction->children.push_back(move(expr));
+			conjunction->children.push_back(std::move(expr));
 		}
-		expression = move(conjunction);
+		expression = std::move(conjunction);
 	} else {
-		expression = move(select_list[0]);
+		expression = std::move(select_list[0]);
 	}
 }
 
@@ -53,7 +53,10 @@ OperatorResultType PhysicalFilter::ExecuteInternal(ExecutionContext &context, Da
 }
 
 string PhysicalFilter::ParamsToString() const {
-	return expression->GetName();
+	auto result = expression->GetName();
+	result += "\n[INFOSEPARATOR]\n";
+	result += StringUtil::Format("EC: %llu", estimated_props->GetCardinality<idx_t>());
+	return result;
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/helper/physical_batch_collector.cpp

@@ -50,9 +50,9 @@ SinkFinalizeType PhysicalBatchCollector::Finalize(Pipeline &pipeline, Event &eve
 	auto &gstate = (BatchCollectorGlobalState &)gstate_p;
 	auto collection = gstate.data.FetchCollection();
 	D_ASSERT(collection);
-	auto result = make_unique<MaterializedQueryResult>(statement_type, properties, names, move(collection),
+	auto result = make_unique<MaterializedQueryResult>(statement_type, properties, names, std::move(collection),
 	                                                   context.GetClientProperties());
-	gstate.result = move(result);
+	gstate.result = std::move(result);
 	return SinkFinalizeType::READY;
 }
 
@@ -67,7 +67,7 @@ unique_ptr<GlobalSinkState> PhysicalBatchCollector::GetGlobalSinkState(ClientCon
 unique_ptr<QueryResult> PhysicalBatchCollector::GetResult(GlobalSinkState &state) {
 	auto &gstate = (BatchCollectorGlobalState &)state;
 	D_ASSERT(gstate.result);
-	return move(gstate.result);
+	return std::move(gstate.result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/helper/physical_limit.cpp

@@ -12,8 +12,9 @@ namespace duckdb {
 PhysicalLimit::PhysicalLimit(vector<LogicalType> types, idx_t limit, idx_t offset,
                              unique_ptr<Expression> limit_expression, unique_ptr<Expression> offset_expression,
                              idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::LIMIT, move(types), estimated_cardinality), limit_value(limit),
-      offset_value(offset), limit_expression(move(limit_expression)), offset_expression(move(offset_expression)) {
+    : PhysicalOperator(PhysicalOperatorType::LIMIT, std::move(types), estimated_cardinality), limit_value(limit),
+      offset_value(offset), limit_expression(std::move(limit_expression)),
+      offset_expression(std::move(offset_expression)) {
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/execution/operator/helper/physical_materialized_collector.cpp

@@ -42,7 +42,7 @@ void PhysicalMaterializedCollector::Combine(ExecutionContext &context, GlobalSin
 
 	lock_guard<mutex> l(gstate.glock);
 	if (!gstate.collection) {
-		gstate.collection = move(lstate.collection);
+		gstate.collection = std::move(lstate.collection);
 	} else {
 		gstate.collection->Combine(*lstate.collection);
 	}
@@ -51,14 +51,14 @@ void PhysicalMaterializedCollector::Combine(ExecutionContext &context, GlobalSin
 unique_ptr<GlobalSinkState> PhysicalMaterializedCollector::GetGlobalSinkState(ClientContext &context) const {
 	auto state = make_unique<MaterializedCollectorGlobalState>();
 	state->context = context.shared_from_this();
-	return move(state);
+	return std::move(state);
 }
 
 unique_ptr<LocalSinkState> PhysicalMaterializedCollector::GetLocalSinkState(ExecutionContext &context) const {
 	auto state = make_unique<MaterializedCollectorLocalState>();
 	state->collection = make_unique<ColumnDataCollection>(Allocator::DefaultAllocator(), types);
 	state->collection->InitializeAppend(state->append_state);
-	return move(state);
+	return std::move(state);
 }
 
 unique_ptr<QueryResult> PhysicalMaterializedCollector::GetResult(GlobalSinkState &state) {
@@ -66,9 +66,9 @@ unique_ptr<QueryResult> PhysicalMaterializedCollector::GetResult(GlobalSinkState
 	if (!gstate.collection) {
 		gstate.collection = make_unique<ColumnDataCollection>(Allocator::DefaultAllocator(), types);
 	}
-	auto result = make_unique<MaterializedQueryResult>(statement_type, properties, names, move(gstate.collection),
+	auto result = make_unique<MaterializedQueryResult>(statement_type, properties, names, std::move(gstate.collection),
 	                                                   gstate.context->GetClientProperties());
-	return move(result);
+	return std::move(result);
 }
 
 bool PhysicalMaterializedCollector::ParallelSink() const {

package/src/duckdb/src/execution/operator/helper/physical_set.cpp

@@ -6,18 +6,19 @@
 
 namespace duckdb {
 
-void PhysicalSet::SetExtensionVariable(ExecutionContext &context, DBConfig &config,
-                                       ExtensionOption &extension_option) const {
+void PhysicalSet::SetExtensionVariable(ClientContext &context, ExtensionOption &extension_option, const string &name,
+                                       SetScope scope, const Value &value) {
+	auto &config = DBConfig::GetConfig(context);
 	auto &target_type = extension_option.type;
-	Value target_value = value.CastAs(context.client, target_type);
+	Value target_value = value.CastAs(context, target_type);
 	if (extension_option.set_function) {
-		extension_option.set_function(context.client, scope, target_value);
+		extension_option.set_function(context, scope, target_value);
 	}
 	if (scope == SetScope::GLOBAL) {
-		config.SetOption(name, move(target_value));
+		config.SetOption(name, std::move(target_value));
 	} else {
-		auto &client_config = ClientConfig::GetConfig(context.client);
-		client_config.set_variables[name] = move(target_value);
+		auto &client_config = ClientConfig::GetConfig(context);
+		client_config.set_variables[name] = std::move(target_value);
 	}
 }
 
@@ -39,7 +40,7 @@ void PhysicalSet::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSou
 			throw CatalogException("unrecognized configuration parameter \"%s\"\n%s", name,
 			                       StringUtil::CandidatesErrorMessage(potential_names, name, "Did you mean"));
 		}
-		SetExtensionVariable(context, config, entry->second);
+		SetExtensionVariable(context.client, entry->second, name, scope, value);
 		return;
 	}
 	SetScope variable_scope = scope;

package/src/duckdb/src/execution/operator/helper/physical_streaming_limit.cpp

@@ -7,9 +7,9 @@ PhysicalStreamingLimit::PhysicalStreamingLimit(vector<LogicalType> types, idx_t
                                                unique_ptr<Expression> limit_expression,
                                                unique_ptr<Expression> offset_expression, idx_t estimated_cardinality,
                                                bool parallel)
-    : PhysicalOperator(PhysicalOperatorType::STREAMING_LIMIT, move(types), estimated_cardinality), limit_value(limit),
-      offset_value(offset), limit_expression(move(limit_expression)), offset_expression(move(offset_expression)),
-      parallel(parallel) {
+    : PhysicalOperator(PhysicalOperatorType::STREAMING_LIMIT, std::move(types), estimated_cardinality),
+      limit_value(limit), offset_value(offset), limit_expression(std::move(limit_expression)),
+      offset_expression(std::move(offset_expression)), parallel(parallel) {
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/execution/operator/helper/physical_streaming_sample.cpp

@@ -6,7 +6,7 @@ namespace duckdb {
 
 PhysicalStreamingSample::PhysicalStreamingSample(vector<LogicalType> types, SampleMethod method, double percentage,
                                                  int64_t seed, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::STREAMING_SAMPLE, move(types), estimated_cardinality), method(method),
+    : PhysicalOperator(PhysicalOperatorType::STREAMING_SAMPLE, std::move(types), estimated_cardinality), method(method),
       percentage(percentage / 100), seed(seed) {
 }
 

package/src/duckdb/src/execution/operator/helper/physical_vacuum.cpp

@@ -3,12 +3,13 @@
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/storage/data_table.hpp"
 #include "duckdb/storage/statistics/distinct_statistics.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 
 namespace duckdb {
 
 PhysicalVacuum::PhysicalVacuum(unique_ptr<VacuumInfo> info_p, idx_t estimated_cardinality)
     : PhysicalOperator(PhysicalOperatorType::VACUUM, {LogicalType::BOOLEAN}, estimated_cardinality),
-      info(move(info_p)) {
+      info(std::move(info_p)) {
 }
 
 class VacuumLocalSinkState : public LocalSinkState {
@@ -71,8 +72,8 @@ SinkFinalizeType PhysicalVacuum::Finalize(Pipeline &pipeline, Event &event, Clie
 
 	auto table = info->table;
 	for (idx_t col_idx = 0; col_idx < sink.column_distinct_stats.size(); col_idx++) {
-		table->storage->SetStatistics(info->column_id_map.at(col_idx), [&](BaseStatistics &stats) {
-			stats.distinct_stats = move(sink.column_distinct_stats[col_idx]);
+		table->GetStorage().SetStatistics(info->column_id_map.at(col_idx), [&](BaseStatistics &stats) {
+			stats.distinct_stats = std::move(sink.column_distinct_stats[col_idx]);
 		});
 	}
 

package/src/duckdb/src/execution/operator/join/perfect_hash_join_executor.cpp

@@ -7,7 +7,7 @@ namespace duckdb {
 
 PerfectHashJoinExecutor::PerfectHashJoinExecutor(const PhysicalHashJoin &join_p, JoinHashTable &ht_p,
                                                  PerfectHashJoinStats perfect_join_stats)
-    : join(join_p), ht(ht_p), perfect_join_statistics(move(perfect_join_stats)) {
+    : join(join_p), ht(ht_p), perfect_join_statistics(std::move(perfect_join_stats)) {
 }
 
 bool PerfectHashJoinExecutor::CanDoPerfectHashJoin() {
@@ -148,7 +148,7 @@ public:
 
 unique_ptr<OperatorState> PerfectHashJoinExecutor::GetOperatorState(ExecutionContext &context) {
 	auto state = make_unique<PerfectHashJoinState>(context.client, join);
-	return move(state);
+	return std::move(state);
 }
 
 OperatorResultType PerfectHashJoinExecutor::ProbePerfectHashTable(ExecutionContext &context, DataChunk &input,

package/src/duckdb/src/execution/operator/join/physical_blockwise_nl_join.cpp

@@ -13,9 +13,9 @@ PhysicalBlockwiseNLJoin::PhysicalBlockwiseNLJoin(LogicalOperator &op, unique_ptr
                                                  unique_ptr<PhysicalOperator> right, unique_ptr<Expression> condition,
                                                  JoinType join_type, idx_t estimated_cardinality)
     : PhysicalJoin(op, PhysicalOperatorType::BLOCKWISE_NL_JOIN, join_type, estimated_cardinality),
-      condition(move(condition)) {
-	children.push_back(move(left));
-	children.push_back(move(right));
+      condition(std::move(condition)) {
+	children.push_back(std::move(left));
+	children.push_back(std::move(right));
 	// MARK and SINGLE joins not handled
 	D_ASSERT(join_type != JoinType::MARK);
 	D_ASSERT(join_type != JoinType::SINGLE);

package/src/duckdb/src/execution/operator/join/physical_comparison_join.cpp

@@ -29,8 +29,9 @@ string PhysicalComparisonJoin::ParamsToString() const {
 		string op = ExpressionTypeToOperator(it.comparison);
 		extra_info += it.left->GetName() + " " + op + " " + it.right->GetName() + "\n";
 	}
-	extra_info += "\nEC = " + std::to_string(estimated_props->GetCardinality<double>()) + "\n";
-	extra_info += "COST = " + std::to_string(estimated_props->GetCost()) + "\n";
+	extra_info += "\n[INFOSEPARATOR]\n";
+	extra_info += StringUtil::Format("EC: %llu\n", estimated_props->GetCardinality<idx_t>());
+	extra_info += StringUtil::Format("Cost: %llu", (idx_t)estimated_props->GetCost());
 	return extra_info;
 }
 

package/src/duckdb/src/execution/operator/join/physical_cross_product.cpp

@@ -8,9 +8,9 @@ namespace duckdb {
 
 PhysicalCrossProduct::PhysicalCrossProduct(vector<LogicalType> types, unique_ptr<PhysicalOperator> left,
                                            unique_ptr<PhysicalOperator> right, idx_t estimated_cardinality)
-    : CachingPhysicalOperator(PhysicalOperatorType::CROSS_PRODUCT, move(types), estimated_cardinality) {
-	children.push_back(move(left));
-	children.push_back(move(right));
+    : CachingPhysicalOperator(PhysicalOperatorType::CROSS_PRODUCT, std::move(types), estimated_cardinality) {
+	children.push_back(std::move(left));
+	children.push_back(std::move(right));
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/execution/operator/join/physical_delim_join.cpp

@@ -13,18 +13,18 @@ namespace duckdb {
 
 PhysicalDelimJoin::PhysicalDelimJoin(vector<LogicalType> types, unique_ptr<PhysicalOperator> original_join,
                                      vector<PhysicalOperator *> delim_scans, idx_t estimated_cardinality)
-    : PhysicalOperator(PhysicalOperatorType::DELIM_JOIN, move(types), estimated_cardinality), join(move(original_join)),
-      delim_scans(move(delim_scans)) {
+    : PhysicalOperator(PhysicalOperatorType::DELIM_JOIN, std::move(types), estimated_cardinality),
+      join(std::move(original_join)), delim_scans(std::move(delim_scans)) {
 	D_ASSERT(join->children.size() == 2);
 	// now for the original join
 	// we take its left child, this is the side that we will duplicate eliminate
-	children.push_back(move(join->children[0]));
+	children.push_back(std::move(join->children[0]));
 
 	// we replace it with a PhysicalColumnDataScan, that scans the ColumnDataCollection that we keep cached
 	// the actual chunk collection to scan will be created in the DelimJoinGlobalState
 	auto cached_chunk_scan = make_unique<PhysicalColumnDataScan>(
 	    children[0]->GetTypes(), PhysicalOperatorType::COLUMN_DATA_SCAN, estimated_cardinality);
-	join->children[0] = move(cached_chunk_scan);
+	join->children[0] = std::move(cached_chunk_scan);
 }
 
 vector<PhysicalOperator *> PhysicalDelimJoin::GetChildren() const {
@@ -81,13 +81,13 @@ unique_ptr<GlobalSinkState> PhysicalDelimJoin::GetGlobalSinkState(ClientContext
 	if (delim_scans.size() > 1) {
 		PhysicalHashAggregate::SetMultiScan(*distinct->sink_state);
 	}
-	return move(state);
+	return std::move(state);
 }
 
 unique_ptr<LocalSinkState> PhysicalDelimJoin::GetLocalSinkState(ExecutionContext &context) const {
 	auto state = make_unique<DelimJoinLocalState>(context.client, *this);
 	state->distinct_state = distinct->GetLocalSinkState(context);
-	return move(state);
+	return std::move(state);
 }
 
 SinkResultType PhysicalDelimJoin::Sink(ExecutionContext &context, GlobalSinkState &state_p, LocalSinkState &lstate_p,

package/src/duckdb/src/execution/operator/join/physical_hash_join.cpp

@@ -20,12 +20,12 @@ PhysicalHashJoin::PhysicalHashJoin(LogicalOperator &op, unique_ptr<PhysicalOpera
                                    const vector<idx_t> &left_projection_map,
                                    const vector<idx_t> &right_projection_map_p, vector<LogicalType> delim_types,
                                    idx_t estimated_cardinality, PerfectHashJoinStats perfect_join_stats)
-    : PhysicalComparisonJoin(op, PhysicalOperatorType::HASH_JOIN, move(cond), join_type, estimated_cardinality),
-      right_projection_map(right_projection_map_p), delim_types(move(delim_types)),
-      perfect_join_statistics(move(perfect_join_stats)) {
+    : PhysicalComparisonJoin(op, PhysicalOperatorType::HASH_JOIN, std::move(cond), join_type, estimated_cardinality),
+      right_projection_map(right_projection_map_p), delim_types(std::move(delim_types)),
+      perfect_join_statistics(std::move(perfect_join_stats)) {
 
-	children.push_back(move(left));
-	children.push_back(move(right));
+	children.push_back(std::move(left));
+	children.push_back(std::move(right));
 
 	D_ASSERT(left_projection_map.empty());
 	for (auto &condition : conditions) {
@@ -41,8 +41,8 @@ PhysicalHashJoin::PhysicalHashJoin(LogicalOperator &op, unique_ptr<PhysicalOpera
 PhysicalHashJoin::PhysicalHashJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
                                    unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
                                    idx_t estimated_cardinality, PerfectHashJoinStats perfect_join_state)
-    : PhysicalHashJoin(op, move(left), move(right), move(cond), join_type, {}, {}, {}, estimated_cardinality,
-                       std::move(perfect_join_state)) {
+    : PhysicalHashJoin(op, std::move(left), std::move(right), std::move(cond), join_type, {}, {}, {},
+                       estimated_cardinality, std::move(perfect_join_state)) {
 }
 
 //===--------------------------------------------------------------------===//
@@ -152,17 +152,17 @@ unique_ptr<JoinHashTable> PhysicalHashJoin::InitializeHashTable(ClientContext &c
 			                                             AggregateType::NON_DISTINCT);
 			correlated_aggregates.push_back(&*aggr);
 			payload_types.push_back(aggr->return_type);
-			info.correlated_aggregates.push_back(move(aggr));
+			info.correlated_aggregates.push_back(std::move(aggr));
 
 			auto count_fun = CountFun::GetFunction();
 			vector<unique_ptr<Expression>> children;
 			// this is a dummy but we need it to make the hash table understand whats going on
 			children.push_back(make_unique_base<Expression, BoundReferenceExpression>(count_fun.return_type, 0));
-			aggr =
-			    function_binder.BindAggregateFunction(count_fun, move(children), nullptr, AggregateType::NON_DISTINCT);
+			aggr = function_binder.BindAggregateFunction(count_fun, std::move(children), nullptr,
+			                                             AggregateType::NON_DISTINCT);
 			correlated_aggregates.push_back(&*aggr);
 			payload_types.push_back(aggr->return_type);
-			info.correlated_aggregates.push_back(move(aggr));
+			info.correlated_aggregates.push_back(std::move(aggr));
 
 			auto &allocator = Allocator::Get(context);
 			info.correlated_counts = make_unique<GroupedAggregateHashTable>(context, allocator, delim_types,
@@ -225,7 +225,7 @@ void PhysicalHashJoin::Combine(ExecutionContext &context, GlobalSinkState &gstat
 	auto &lstate = (HashJoinLocalSinkState &)lstate_p;
 	if (lstate.hash_table) {
 		lock_guard<mutex> local_ht_lock(gstate.lock);
-		gstate.local_hash_tables.push_back(move(lstate.hash_table));
+		gstate.local_hash_tables.push_back(std::move(lstate.hash_table));
 	}
 	auto &client_profiler = QueryProfiler::Get(context.client);
 	context.thread.profiler.Flush(this, &lstate.build_executor, "build_executor", 1);
@@ -239,7 +239,7 @@ class HashJoinFinalizeTask : public ExecutorTask {
 public:
 	HashJoinFinalizeTask(shared_ptr<Event> event_p, ClientContext &context, HashJoinGlobalSinkState &sink,
 	                     idx_t block_idx_start, idx_t block_idx_end, bool parallel)
-	    : ExecutorTask(context), event(move(event_p)), sink(sink), block_idx_start(block_idx_start),
+	    : ExecutorTask(context), event(std::move(event_p)), sink(sink), block_idx_start(block_idx_start),
 	      block_idx_end(block_idx_end), parallel(parallel) {
 	}
 
@@ -295,7 +295,7 @@ public:
 				}
 			}
 		}
-		SetTasks(move(finalize_tasks));
+		SetTasks(std::move(finalize_tasks));
 	}
 
 	void FinishEvent() override {
@@ -312,7 +312,7 @@ void HashJoinGlobalSinkState::ScheduleFinalize(Pipeline &pipeline, Event &event)
 	}
 	hash_table->InitializePointerTable();
 	auto new_event = make_shared<HashJoinFinalizeEvent>(pipeline, *this);
-	event.InsertEvent(move(new_event));
+	event.InsertEvent(std::move(new_event));
 }
 
 void HashJoinGlobalSinkState::InitializeProbeSpill(ClientContext &context) {
@@ -326,7 +326,7 @@ class HashJoinPartitionTask : public ExecutorTask {
 public:
 	HashJoinPartitionTask(shared_ptr<Event> event_p, ClientContext &context, JoinHashTable &global_ht,
 	                      JoinHashTable &local_ht)
-	    : ExecutorTask(context), event(move(event_p)), global_ht(global_ht), local_ht(local_ht) {
+	    : ExecutorTask(context), event(std::move(event_p)), global_ht(global_ht), local_ht(local_ht) {
 	}
 
 	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
@@ -361,7 +361,7 @@ public:
 			partition_tasks.push_back(
 			    make_unique<HashJoinPartitionTask>(shared_from_this(), context, *sink.hash_table, *local_ht));
 		}
-		SetTasks(move(partition_tasks));
+		SetTasks(std::move(partition_tasks));
 	}
 
 	void FinishEvent() override {
@@ -381,7 +381,7 @@ SinkFinalizeType PhysicalHashJoin::Finalize(Pipeline &pipeline, Event &event, Cl
 		sink.perfect_join_executor.reset();
 		sink.hash_table->ComputePartitionSizes(context.config, sink.local_hash_tables, sink.max_ht_size);
 		auto new_event = make_shared<HashJoinPartitionEvent>(pipeline, sink, sink.local_hash_tables);
-		event.InsertEvent(move(new_event));
+		event.InsertEvent(std::move(new_event));
 		sink.finalized = true;
 		return SinkFinalizeType::READY;
 	} else {
@@ -451,7 +451,7 @@ unique_ptr<OperatorState> PhysicalHashJoin::GetOperatorState(ExecutionContext &c
 		sink.InitializeProbeSpill(context.client);
 	}
 
-	return move(state);
+	return std::move(state);
 }
 
 OperatorResultType PhysicalHashJoin::ExecuteInternal(ExecutionContext &context, DataChunk &input, DataChunk &chunk,

package/src/duckdb/src/execution/operator/join/physical_iejoin.cpp

@@ -19,8 +19,8 @@ namespace duckdb {
 PhysicalIEJoin::PhysicalIEJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
                                unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
                                idx_t estimated_cardinality)
-    : PhysicalRangeJoin(op, PhysicalOperatorType::IE_JOIN, move(left), move(right), move(cond), join_type,
-                        estimated_cardinality) {
+    : PhysicalRangeJoin(op, PhysicalOperatorType::IE_JOIN, std::move(left), std::move(right), std::move(cond),
+                        join_type, estimated_cardinality) {
 
 	// 1. let L1 (resp. L2) be the array of column X (resp. Y)
 	D_ASSERT(conditions.size() >= 2);
@@ -52,8 +52,8 @@ PhysicalIEJoin::PhysicalIEJoin(LogicalOperator &op, unique_ptr<PhysicalOperator>
 		default:
 			throw NotImplementedException("Unimplemented join type for IEJoin");
 		}
-		lhs_orders[i].emplace_back(BoundOrderByNode(sense, OrderByNullType::NULLS_LAST, move(left)));
-		rhs_orders[i].emplace_back(BoundOrderByNode(sense, OrderByNullType::NULLS_LAST, move(right)));
+		lhs_orders[i].emplace_back(BoundOrderByNode(sense, OrderByNullType::NULLS_LAST, std::move(left)));
+		rhs_orders[i].emplace_back(BoundOrderByNode(sense, OrderByNullType::NULLS_LAST, std::move(right)));
 	}
 
 	for (idx_t i = 2; i < conditions.size(); ++i) {
@@ -99,7 +99,7 @@ public:
 	}
 
 	IEJoinGlobalState(IEJoinGlobalState &prev)
-	    : GlobalSinkState(prev), tables(move(prev.tables)), child(prev.child + 1) {
+	    : GlobalSinkState(prev), tables(std::move(prev.tables)), child(prev.child + 1) {
 	}
 
 	void Sink(DataChunk &input, IEJoinLocalState &lstate) {
@@ -386,7 +386,7 @@ IEJoinUnion::IEJoinUnion(ClientContext &context, const PhysicalIEJoin &op, Sorte
 	// Sort on the first expression
 	auto ref = make_unique<BoundReferenceExpression>(order1.expression->return_type, 0);
 	vector<BoundOrderByNode> orders;
-	orders.emplace_back(BoundOrderByNode(order1.type, order1.null_order, move(ref)));
+	orders.emplace_back(BoundOrderByNode(order1.type, order1.null_order, std::move(ref)));
 
 	l1 = make_unique<SortedTable>(context, orders, payload_layout);
 
@@ -422,7 +422,7 @@ IEJoinUnion::IEJoinUnion(ClientContext &context, const PhysicalIEJoin &op, Sorte
 	// Sort on the first expression
 	orders.clear();
 	ref = make_unique<BoundReferenceExpression>(order2.expression->return_type, 0);
-	orders.emplace_back(BoundOrderByNode(order2.type, order2.null_order, move(ref)));
+	orders.emplace_back(BoundOrderByNode(order2.type, order2.null_order, std::move(ref)));
 
 	ExpressionExecutor executor(context);
 	executor.AddExpression(*orders[0].expression);

package/src/duckdb/src/execution/operator/join/physical_index_join.cpp

@@ -10,7 +10,8 @@
 #include "duckdb/storage/buffer_manager.hpp"
 #include "duckdb/storage/storage_manager.hpp"
 #include "duckdb/storage/table/append_state.hpp"
-#include "duckdb/transaction/transaction.hpp"
+#include "duckdb/transaction/duck_transaction.hpp"
+#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 
 namespace duckdb {
 
@@ -60,12 +61,12 @@ PhysicalIndexJoin::PhysicalIndexJoin(LogicalOperator &op, unique_ptr<PhysicalOpe
                                      const vector<idx_t> &left_projection_map_p, vector<idx_t> right_projection_map_p,
                                      vector<column_t> column_ids_p, Index *index_p, bool lhs_first,
                                      idx_t estimated_cardinality)
-    : CachingPhysicalOperator(PhysicalOperatorType::INDEX_JOIN, move(op.types), estimated_cardinality),
-      left_projection_map(left_projection_map_p), right_projection_map(move(right_projection_map_p)), index(index_p),
-      conditions(move(cond)), join_type(join_type), lhs_first(lhs_first) {
-	column_ids = move(column_ids_p);
-	children.push_back(move(left));
-	children.push_back(move(right));
+    : CachingPhysicalOperator(PhysicalOperatorType::INDEX_JOIN, std::move(op.types), estimated_cardinality),
+      left_projection_map(left_projection_map_p), right_projection_map(std::move(right_projection_map_p)),
+      index(index_p), conditions(std::move(cond)), join_type(join_type), lhs_first(lhs_first) {
+	column_ids = std::move(column_ids_p);
+	children.push_back(std::move(left));
+	children.push_back(std::move(right));
 	for (auto &condition : conditions) {
 		condition_types.push_back(condition.left->return_type);
 	}
@@ -100,10 +101,10 @@ void PhysicalIndexJoin::Output(ExecutionContext &context, DataChunk &input, Data
                                OperatorState &state_p) const {
 	auto &phy_tbl_scan = (PhysicalTableScan &)*children[1];
 	auto &bind_tbl = (TableScanBindData &)*phy_tbl_scan.bind_data;
-	auto &transaction = Transaction::Get(context.client, *bind_tbl.table->catalog);
+	auto &transaction = DuckTransaction::Get(context.client, *bind_tbl.table->catalog);
 	auto &state = (IndexJoinOperatorState &)state_p;
 
-	auto tbl = bind_tbl.table->storage.get();
+	auto &tbl = bind_tbl.table->GetStorage();
 	idx_t output_sel_idx = 0;
 	vector<row_t> fetch_rows;
 
@@ -129,7 +130,7 @@ void PhysicalIndexJoin::Output(ExecutionContext &context, DataChunk &input, Data
 		state.rhs_chunk.Reset();
 		state.fetch_state = make_unique<ColumnFetchState>();
 		Vector row_ids(LogicalType::ROW_TYPE, (data_ptr_t)&fetch_rows[0]);
-		tbl->Fetch(transaction, state.rhs_chunk, fetch_ids, row_ids, output_sel_idx, *state.fetch_state);
+		tbl.Fetch(transaction, state.rhs_chunk, fetch_ids, row_ids, output_sel_idx, *state.fetch_state);
 	}
 
 	//! Now we actually produce our result chunk

package/src/duckdb/src/execution/operator/join/physical_join.cpp

@@ -46,8 +46,15 @@ void PhysicalJoin::BuildJoinPipelines(Pipeline &current, MetaPipeline &meta_pipe
 	// continue building the current pipeline on the LHS (probe side)
 	op.children[0]->BuildPipelines(current, meta_pipeline);
 
-	if (op.type == PhysicalOperatorType::CROSS_PRODUCT) {
+	switch (op.type) {
+	case PhysicalOperatorType::POSITIONAL_JOIN:
+		// Positional joins are always outer
+		meta_pipeline.CreateChildPipeline(current, &op, last_pipeline);
+		return;
+	case PhysicalOperatorType::CROSS_PRODUCT:
 		return;
+	default:
+		break;
 	}
 
 	// Join can become a source operator if it's RIGHT/OUTER, or if the hash join goes out-of-core

package/src/duckdb/src/execution/operator/join/physical_nested_loop_join.cpp

@@ -12,9 +12,10 @@ namespace duckdb {
 PhysicalNestedLoopJoin::PhysicalNestedLoopJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
                                                unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond,
                                                JoinType join_type, idx_t estimated_cardinality)
-    : PhysicalComparisonJoin(op, PhysicalOperatorType::NESTED_LOOP_JOIN, move(cond), join_type, estimated_cardinality) {
-	children.push_back(move(left));
-	children.push_back(move(right));
+    : PhysicalComparisonJoin(op, PhysicalOperatorType::NESTED_LOOP_JOIN, std::move(cond), join_type,
+                             estimated_cardinality) {
+	children.push_back(std::move(left));
+	children.push_back(std::move(right));
 }
 
 bool PhysicalJoin::HasNullValues(DataChunk &chunk) {

package/src/duckdb/src/execution/operator/join/physical_piecewise_merge_join.cpp

@@ -17,8 +17,8 @@ namespace duckdb {
 PhysicalPiecewiseMergeJoin::PhysicalPiecewiseMergeJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
                                                        unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond,
                                                        JoinType join_type, idx_t estimated_cardinality)
-    : PhysicalRangeJoin(op, PhysicalOperatorType::PIECEWISE_MERGE_JOIN, move(left), move(right), move(cond), join_type,
-                        estimated_cardinality) {
+    : PhysicalRangeJoin(op, PhysicalOperatorType::PIECEWISE_MERGE_JOIN, std::move(left), std::move(right),
+                        std::move(cond), join_type, estimated_cardinality) {
 
 	for (auto &cond : conditions) {
 		D_ASSERT(cond.left->return_type == cond.right->return_type);
@@ -30,20 +30,25 @@ PhysicalPiecewiseMergeJoin::PhysicalPiecewiseMergeJoin(LogicalOperator &op, uniq
 		switch (cond.comparison) {
 		case ExpressionType::COMPARE_LESSTHAN:
 		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			lhs_orders.emplace_back(BoundOrderByNode(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, move(left)));
-			rhs_orders.emplace_back(BoundOrderByNode(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, move(right)));
+			lhs_orders.emplace_back(
+			    BoundOrderByNode(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, std::move(left)));
+			rhs_orders.emplace_back(
+			    BoundOrderByNode(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, std::move(right)));
 			break;
 		case ExpressionType::COMPARE_GREATERTHAN:
 		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			lhs_orders.emplace_back(BoundOrderByNode(OrderType::DESCENDING, OrderByNullType::NULLS_LAST, move(left)));
-			rhs_orders.emplace_back(BoundOrderByNode(OrderType::DESCENDING, OrderByNullType::NULLS_LAST, move(right)));
+			lhs_orders.emplace_back(
+			    BoundOrderByNode(OrderType::DESCENDING, OrderByNullType::NULLS_LAST, std::move(left)));
+			rhs_orders.emplace_back(
+			    BoundOrderByNode(OrderType::DESCENDING, OrderByNullType::NULLS_LAST, std::move(right)));
 			break;
 		case ExpressionType::COMPARE_NOTEQUAL:
 		case ExpressionType::COMPARE_DISTINCT_FROM:
 			// Allowed in multi-predicate joins, but can't be first/sort.
 			D_ASSERT(!lhs_orders.empty());
-			lhs_orders.emplace_back(BoundOrderByNode(OrderType::INVALID, OrderByNullType::NULLS_LAST, move(left)));
-			rhs_orders.emplace_back(BoundOrderByNode(OrderType::INVALID, OrderByNullType::NULLS_LAST, move(right)));
+			lhs_orders.emplace_back(BoundOrderByNode(OrderType::INVALID, OrderByNullType::NULLS_LAST, std::move(left)));
+			rhs_orders.emplace_back(
+			    BoundOrderByNode(OrderType::INVALID, OrderByNullType::NULLS_LAST, std::move(right)));
 			break;
 
 		default: