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

package/src/duckdb/src/execution/operator/projection/physical_tableinout_function.cpp

@@ -25,9 +25,9 @@ PhysicalTableInOutFunction::PhysicalTableInOutFunction(vector<LogicalType> types
                                                        unique_ptr<FunctionData> bind_data_p,
                                                        vector<column_t> column_ids_p, idx_t estimated_cardinality,
                                                        vector<column_t> project_input_p)
-    : PhysicalOperator(PhysicalOperatorType::INOUT_FUNCTION, move(types), estimated_cardinality),
-      function(move(function_p)), bind_data(move(bind_data_p)), column_ids(move(column_ids_p)),
-      projected_input(move(project_input_p)) {
+    : PhysicalOperator(PhysicalOperatorType::INOUT_FUNCTION, std::move(types), estimated_cardinality),
+      function(std::move(function_p)), bind_data(std::move(bind_data_p)), column_ids(std::move(column_ids_p)),
+      projected_input(std::move(project_input_p)) {
 }
 
 unique_ptr<OperatorState> PhysicalTableInOutFunction::GetOperatorState(ExecutionContext &context) const {
@@ -40,7 +40,7 @@ unique_ptr<OperatorState> PhysicalTableInOutFunction::GetOperatorState(Execution
 	if (!projected_input.empty()) {
 		result->input_chunk.Initialize(context.client, children[0]->types);
 	}
-	return move(result);
+	return std::move(result);
 }
 
 unique_ptr<GlobalOperatorState> PhysicalTableInOutFunction::GetGlobalOperatorState(ClientContext &context) const {
@@ -49,7 +49,7 @@ unique_ptr<GlobalOperatorState> PhysicalTableInOutFunction::GetGlobalOperatorSta
 		TableFunctionInitInput input(bind_data.get(), column_ids, vector<idx_t>(), nullptr);
 		result->global_state = function.init_global(context, input);
 	}
-	return move(result);
+	return std::move(result);
 }
 
 OperatorResultType PhysicalTableInOutFunction::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,

package/src/duckdb/src/execution/operator/projection/physical_unnest.cpp

@@ -11,7 +11,11 @@ namespace duckdb {
 class UnnestOperatorState : public OperatorState {
 public:
 	UnnestOperatorState(ClientContext &context, const vector<unique_ptr<Expression>> &select_list)
-	    : parent_position(0), list_position(0), list_length(-1), first_fetch(true), executor(context) {
+	    : current_row(0), list_position(0), longest_list_length(DConstants::INVALID_INDEX), first_fetch(true),
+	      executor(context) {
+
+		// for each UNNEST in the select_list, we add the child expression to the expression executor
+		// and set the return type in the list_data chunk, which will contain the evaluated expression results
 		vector<LogicalType> list_data_types;
 		for (auto &exp : select_list) {
 			D_ASSERT(exp->type == ExpressionType::BOUND_UNNEST);
@@ -19,6 +23,7 @@ public:
 			list_data_types.push_back(bue->child->return_type);
 			executor.AddExpression(*bue->child.get());
 		}
+
 		auto &allocator = Allocator::Get(context);
 		list_data.Initialize(allocator, list_data_types);
 
@@ -26,25 +31,59 @@ public:
 		list_child_data.resize(list_data.ColumnCount());
 	}
 
-	idx_t parent_position;
+	idx_t current_row;
 	idx_t list_position;
-	int64_t list_length;
+	idx_t longest_list_length;
 	bool first_fetch;
 
 	ExpressionExecutor executor;
 	DataChunk list_data;
 	vector<UnifiedVectorFormat> list_vector_data;
 	vector<UnifiedVectorFormat> list_child_data;
+
+public:
+	//! Reset the fields of the unnest operator state
+	void Reset();
+	//! Set the longest list's length for the current row
+	void SetLongestListLength();
 };
 
-// this implements a sorted window functions variant
+void UnnestOperatorState::Reset() {
+	current_row = 0;
+	list_position = 0;
+	longest_list_length = DConstants::INVALID_INDEX;
+	first_fetch = true;
+}
+
+void UnnestOperatorState::SetLongestListLength() {
+
+	longest_list_length = 0;
+	for (idx_t col_idx = 0; col_idx < list_data.ColumnCount(); col_idx++) {
+
+		auto &vector_data = list_vector_data[col_idx];
+		auto current_idx = vector_data.sel->get_index(current_row);
+
+		if (vector_data.validity.RowIsValid(current_idx)) {
+
+			// check if this list is longer
+			auto list_data = (list_entry_t *)vector_data.data;
+			auto list_entry = list_data[current_idx];
+			if (list_entry.length > longest_list_length) {
+				longest_list_length = list_entry.length;
+			}
+		}
+	}
+}
+
 PhysicalUnnest::PhysicalUnnest(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
                                idx_t estimated_cardinality, PhysicalOperatorType type)
-    : PhysicalOperator(type, move(types), estimated_cardinality), select_list(std::move(select_list)) {
+    : PhysicalOperator(type, std::move(types), estimated_cardinality), select_list(std::move(select_list)) {
 	D_ASSERT(!this->select_list.empty());
 }
 
 static void UnnestNull(idx_t start, idx_t end, Vector &result) {
+
+	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
 	auto &validity = FlatVector::Validity(result);
 	for (idx_t i = start; i < end; i++) {
 		validity.SetInvalid(i);
@@ -58,14 +97,17 @@ static void UnnestNull(idx_t start, idx_t end, Vector &result) {
 }
 
 template <class T>
-static void TemplatedUnnest(UnifiedVectorFormat &vdata, idx_t start, idx_t end, Vector &result) {
-	auto source_data = (T *)vdata.data;
-	auto &source_mask = vdata.validity;
+static void TemplatedUnnest(UnifiedVectorFormat &vector_data, idx_t start, idx_t end, Vector &result) {
+
+	auto source_data = (T *)vector_data.data;
+	auto &source_mask = vector_data.validity;
+
+	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
 	auto result_data = FlatVector::GetData<T>(result);
 	auto &result_mask = FlatVector::Validity(result);
 
 	for (idx_t i = start; i < end; i++) {
-		auto source_idx = vdata.sel->get_index(i);
+		auto source_idx = vector_data.sel->get_index(i);
 		auto target_idx = i - start;
 		if (source_mask.RowIsValid(source_idx)) {
 			result_data[target_idx] = source_data[source_idx];
@@ -76,84 +118,131 @@ static void TemplatedUnnest(UnifiedVectorFormat &vdata, idx_t start, idx_t end,
 	}
 }
 
-static void UnnestValidity(UnifiedVectorFormat &vdata, idx_t start, idx_t end, Vector &result) {
-	auto &source_mask = vdata.validity;
+static void UnnestValidity(UnifiedVectorFormat &vector_data, idx_t start, idx_t end, Vector &result) {
+
+	auto &source_mask = vector_data.validity;
+	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
 	auto &result_mask = FlatVector::Validity(result);
 
 	for (idx_t i = start; i < end; i++) {
-		auto source_idx = vdata.sel->get_index(i);
+		auto source_idx = vector_data.sel->get_index(i);
 		auto target_idx = i - start;
 		result_mask.Set(target_idx, source_mask.RowIsValid(source_idx));
 	}
 }
 
-static void UnnestVector(UnifiedVectorFormat &vdata, Vector &source, idx_t list_size, idx_t start, idx_t end,
-                         Vector &result) {
-	D_ASSERT(source.GetType() == result.GetType());
+static void UnnestVector(UnifiedVectorFormat &child_vector_data, Vector &child_vector, idx_t list_size, idx_t start,
+                         idx_t end, Vector &result) {
+
+	D_ASSERT(child_vector.GetType() == result.GetType());
 	switch (result.GetType().InternalType()) {
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
-		TemplatedUnnest<int8_t>(vdata, start, end, result);
+		TemplatedUnnest<int8_t>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::INT16:
-		TemplatedUnnest<int16_t>(vdata, start, end, result);
+		TemplatedUnnest<int16_t>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::INT32:
-		TemplatedUnnest<int32_t>(vdata, start, end, result);
+		TemplatedUnnest<int32_t>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::INT64:
-		TemplatedUnnest<int64_t>(vdata, start, end, result);
+		TemplatedUnnest<int64_t>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::INT128:
-		TemplatedUnnest<hugeint_t>(vdata, start, end, result);
+		TemplatedUnnest<hugeint_t>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::UINT8:
-		TemplatedUnnest<uint8_t>(vdata, start, end, result);
+		TemplatedUnnest<uint8_t>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::UINT16:
-		TemplatedUnnest<uint16_t>(vdata, start, end, result);
+		TemplatedUnnest<uint16_t>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::UINT32:
-		TemplatedUnnest<uint32_t>(vdata, start, end, result);
+		TemplatedUnnest<uint32_t>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::UINT64:
-		TemplatedUnnest<uint64_t>(vdata, start, end, result);
+		TemplatedUnnest<uint64_t>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::FLOAT:
-		TemplatedUnnest<float>(vdata, start, end, result);
+		TemplatedUnnest<float>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::DOUBLE:
-		TemplatedUnnest<double>(vdata, start, end, result);
+		TemplatedUnnest<double>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::INTERVAL:
-		TemplatedUnnest<interval_t>(vdata, start, end, result);
+		TemplatedUnnest<interval_t>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::VARCHAR:
-		TemplatedUnnest<string_t>(vdata, start, end, result);
+		TemplatedUnnest<string_t>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::LIST: {
+		// the child vector of result now references the child vector source
+		// FIXME: only reference relevant children (start - end) instead of all
 		auto &target = ListVector::GetEntry(result);
-		target.Reference(ListVector::GetEntry(source));
-		ListVector::SetListSize(result, ListVector::GetListSize(source));
-		TemplatedUnnest<list_entry_t>(vdata, start, end, result);
+		target.Reference(ListVector::GetEntry(child_vector));
+		ListVector::SetListSize(result, ListVector::GetListSize(child_vector));
+		// unnest
+		TemplatedUnnest<list_entry_t>(child_vector_data, start, end, result);
 		break;
 	}
 	case PhysicalType::STRUCT: {
-		auto &source_entries = StructVector::GetEntries(source);
-		auto &target_entries = StructVector::GetEntries(result);
-		UnnestValidity(vdata, start, end, result);
-		for (idx_t i = 0; i < source_entries.size(); i++) {
-			UnifiedVectorFormat sdata;
-			source_entries[i]->ToUnifiedFormat(list_size, sdata);
-			UnnestVector(sdata, *source_entries[i], list_size, start, end, *target_entries[i]);
+		auto &child_vector_entries = StructVector::GetEntries(child_vector);
+		auto &result_entries = StructVector::GetEntries(result);
+
+		// set the validity mask for the 'outer' struct vector before unnesting its children
+		UnnestValidity(child_vector_data, start, end, result);
+
+		for (idx_t i = 0; i < child_vector_entries.size(); i++) {
+			UnifiedVectorFormat child_vector_entries_data;
+			child_vector_entries[i]->ToUnifiedFormat(list_size, child_vector_entries_data);
+			UnnestVector(child_vector_entries_data, *child_vector_entries[i], list_size, start, end,
+			             *result_entries[i]);
 		}
 		break;
 	}
 	default:
-		throw InternalException("Unimplemented type for UNNEST");
+		throw InternalException("Unimplemented type for UNNEST.");
 	}
 }
 
+static void PrepareInput(UnnestOperatorState &state, DataChunk &input,
+                         const vector<unique_ptr<Expression>> &select_list) {
+
+	state.list_data.Reset();
+	// execute the expressions inside each UNNEST in the select_list to get the list data
+	// execution results (lists) are kept in state.list_data chunk
+	state.executor.Execute(input, state.list_data);
+
+	// verify incoming lists
+	state.list_data.Verify();
+	D_ASSERT(input.size() == state.list_data.size());
+	D_ASSERT(state.list_data.ColumnCount() == select_list.size());
+	D_ASSERT(state.list_vector_data.size() == state.list_data.ColumnCount());
+	D_ASSERT(state.list_child_data.size() == state.list_data.ColumnCount());
+
+	// get the UnifiedVectorFormat of each list_data vector (LIST vectors for the different UNNESTs)
+	// both for the vector itself and its child vector
+	for (idx_t col_idx = 0; col_idx < state.list_data.ColumnCount(); col_idx++) {
+
+		auto &list_vector = state.list_data.data[col_idx];
+		list_vector.ToUnifiedFormat(state.list_data.size(), state.list_vector_data[col_idx]);
+
+		if (list_vector.GetType() == LogicalType::SQLNULL) {
+			// UNNEST(NULL): SQLNULL vectors don't have child vectors, but we need to point to the child vector of
+			// each vector, so we just get the UnifiedVectorFormat of the vector itself
+			auto &child_vector = list_vector;
+			child_vector.ToUnifiedFormat(0, state.list_child_data[col_idx]);
+		} else {
+			auto list_size = ListVector::GetListSize(list_vector);
+			auto &child_vector = ListVector::GetEntry(list_vector);
+			child_vector.ToUnifiedFormat(list_size, state.list_child_data[col_idx]);
+		}
+	}
+
+	state.first_fetch = false;
+}
+
 unique_ptr<OperatorState> PhysicalUnnest::GetOperatorState(ExecutionContext &context) const {
 	return PhysicalUnnest::GetState(context, select_list);
 }
@@ -167,137 +256,107 @@ OperatorResultType PhysicalUnnest::ExecuteInternal(ExecutionContext &context, Da
                                                    OperatorState &state_p,
                                                    const vector<unique_ptr<Expression>> &select_list,
                                                    bool include_input) {
+
 	auto &state = (UnnestOperatorState &)state_p;
+
 	do {
+		// prepare the input data by executing any expressions and getting the
+		// UnifiedVectorFormat of each LIST vector (list_vector_data) and its child vector (list_child_data)
 		if (state.first_fetch) {
-			// get the list data to unnest
-			state.list_data.Reset();
-			state.executor.Execute(input, state.list_data);
-
-			// paranoia aplenty
-			state.list_data.Verify();
-			D_ASSERT(input.size() == state.list_data.size());
-			D_ASSERT(state.list_data.ColumnCount() == select_list.size());
-			D_ASSERT(state.list_vector_data.size() == state.list_data.ColumnCount());
-			D_ASSERT(state.list_child_data.size() == state.list_data.ColumnCount());
-
-			// initialize UnifiedVectorFormat object so the nullmask can accessed
-			for (idx_t col_idx = 0; col_idx < state.list_data.ColumnCount(); col_idx++) {
-				auto &list_vector = state.list_data.data[col_idx];
-				list_vector.ToUnifiedFormat(state.list_data.size(), state.list_vector_data[col_idx]);
-
-				if (list_vector.GetType() == LogicalType::SQLNULL) {
-					// UNNEST(NULL)
-					auto &child_vector = list_vector;
-					child_vector.ToUnifiedFormat(0, state.list_child_data[col_idx]);
-				} else {
-					auto list_size = ListVector::GetListSize(list_vector);
-					auto &child_vector = ListVector::GetEntry(list_vector);
-					child_vector.ToUnifiedFormat(list_size, state.list_child_data[col_idx]);
-				}
-			}
-			state.first_fetch = false;
+			PrepareInput(state, input, select_list);
 		}
-		if (state.parent_position >= input.size()) {
-			// finished with this input chunk
-			state.parent_position = 0;
-			state.list_position = 0;
-			state.list_length = -1;
-			state.first_fetch = true;
+
+		// finished with all rows of this input chunk, reset
+		if (state.current_row >= input.size()) {
+			state.Reset();
 			return OperatorResultType::NEED_MORE_INPUT;
 		}
 
-		// need to figure out how many times we need to repeat for current row
-		if (state.list_length < 0) {
-			for (idx_t col_idx = 0; col_idx < state.list_data.ColumnCount(); col_idx++) {
-				auto &vdata = state.list_vector_data[col_idx];
-				auto current_idx = vdata.sel->get_index(state.parent_position);
-
-				int64_t list_length;
-				// deal with NULL values
-				if (!vdata.validity.RowIsValid(current_idx)) {
-					list_length = 0;
-				} else {
-					auto list_data = (list_entry_t *)vdata.data;
-					auto list_entry = list_data[current_idx];
-					list_length = (int64_t)list_entry.length;
-				}
-
-				if (list_length > state.list_length) {
-					state.list_length = list_length;
-				}
-			}
+		// each UNNEST in the select_list contains a list (or NULL) for this row, find longest list
+		// because this length determines how many times we need to repeat for the current row
+		if (state.longest_list_length == DConstants::INVALID_INDEX) {
+			state.SetLongestListLength();
 		}
+		D_ASSERT(state.longest_list_length != DConstants::INVALID_INDEX);
 
-		D_ASSERT(state.list_length >= 0);
-
-		auto this_chunk_len = MinValue<idx_t>(STANDARD_VECTOR_SIZE, state.list_length - state.list_position);
-
-		// first cols are from child, last n cols from unnest
+		// we emit chunks of either STANDARD_VECTOR_SIZE or smaller
+		auto this_chunk_len = MinValue<idx_t>(STANDARD_VECTOR_SIZE, state.longest_list_length - state.list_position);
 		chunk.SetCardinality(this_chunk_len);
 
-		idx_t output_offset = 0;
+		// if we include other projection input columns, e.g. SELECT 1, UNNEST([1, 2]);, then
+		// we need to add them as a constant vector to the resulting chunk
+		// FIXME: emit multiple unnested rows. Currently, we never emit a chunk containing multiple unnested input rows,
+		//  so setting a constant vector for the value at state.current_row is fine
+		idx_t col_offset = 0;
 		if (include_input) {
 			for (idx_t col_idx = 0; col_idx < input.ColumnCount(); col_idx++) {
-				ConstantVector::Reference(chunk.data[col_idx], input.data[col_idx], state.parent_position,
-				                          input.size());
+				ConstantVector::Reference(chunk.data[col_idx], input.data[col_idx], state.current_row, input.size());
 			}
-			output_offset = input.ColumnCount();
+			col_offset = input.ColumnCount();
 		}
 
+		// unnest the lists
 		for (idx_t col_idx = 0; col_idx < state.list_data.ColumnCount(); col_idx++) {
-			auto &result_vector = chunk.data[col_idx + output_offset];
+
+			auto &result_vector = chunk.data[col_idx + col_offset];
 
 			if (state.list_data.data[col_idx].GetType() == LogicalType::SQLNULL) {
 				// UNNEST(NULL)
 				chunk.SetCardinality(0);
+				break;
+
 			} else {
-				auto &vdata = state.list_vector_data[col_idx];
-				auto &child_data = state.list_child_data[col_idx];
-				auto current_idx = vdata.sel->get_index(state.parent_position);
 
-				auto list_data = (list_entry_t *)vdata.data;
-				auto list_entry = list_data[current_idx];
+				auto &vector_data = state.list_vector_data[col_idx];
+				auto current_idx = vector_data.sel->get_index(state.current_row);
+
+				if (!vector_data.validity.RowIsValid(current_idx)) {
+					UnnestNull(0, this_chunk_len, result_vector);
 
-				idx_t list_count;
-				if (state.list_position >= list_entry.length) {
-					list_count = 0;
 				} else {
-					list_count = MinValue<idx_t>(this_chunk_len, list_entry.length - state.list_position);
-				}
 
-				if (list_entry.length > state.list_position) {
-					if (!vdata.validity.RowIsValid(current_idx)) {
-						UnnestNull(0, list_count, result_vector);
-					} else {
+					auto list_data = (list_entry_t *)vector_data.data;
+					auto list_entry = list_data[current_idx];
+
+					idx_t list_count = 0;
+					if (state.list_position < list_entry.length) {
+						// there are still list_count elements to unnest
+						list_count = MinValue<idx_t>(this_chunk_len, list_entry.length - state.list_position);
+
 						auto &list_vector = state.list_data.data[col_idx];
 						auto &child_vector = ListVector::GetEntry(list_vector);
 						auto list_size = ListVector::GetListSize(list_vector);
+						auto &child_vector_data = state.list_child_data[col_idx];
 
 						auto base_offset = list_entry.offset + state.list_position;
-						UnnestVector(child_data, child_vector, list_size, base_offset, base_offset + list_count,
+						UnnestVector(child_vector_data, child_vector, list_size, base_offset, base_offset + list_count,
 						             result_vector);
 					}
-				}
 
-				UnnestNull(list_count, this_chunk_len, result_vector);
+					// fill the rest with NULLs
+					if (list_count != this_chunk_len) {
+						UnnestNull(list_count, this_chunk_len, result_vector);
+					}
+				}
 			}
 		}
 
+		chunk.Verify();
+
 		state.list_position += this_chunk_len;
-		if ((int64_t)state.list_position == state.list_length) {
-			state.parent_position++;
-			state.list_length = -1;
+		if (state.list_position == state.longest_list_length) {
+			state.current_row++;
+			state.longest_list_length = DConstants::INVALID_INDEX;
 			state.list_position = 0;
 		}
 
-		chunk.Verify();
+		// we only emit one unnested row (that contains data) at a time
 	} while (chunk.size() == 0);
 	return OperatorResultType::HAVE_MORE_OUTPUT;
 }
 
 OperatorResultType PhysicalUnnest::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                           GlobalOperatorState &gstate, OperatorState &state) const {
+                                           GlobalOperatorState &, OperatorState &state) const {
 	return ExecuteInternal(context, input, chunk, state, select_list);
 }
 

package/src/duckdb/src/execution/operator/scan/physical_positional_scan.cpp

@@ -0,0 +1,187 @@
+#include "duckdb/execution/operator/scan/physical_positional_scan.hpp"
+
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/planner/expression/bound_conjunction_expression.hpp"
+#include "duckdb/transaction/transaction.hpp"
+
+#include <utility>
+
+namespace duckdb {
+
+PhysicalPositionalScan::PhysicalPositionalScan(vector<LogicalType> types, unique_ptr<PhysicalOperator> left,
+                                               unique_ptr<PhysicalOperator> right)
+    : PhysicalOperator(PhysicalOperatorType::POSITIONAL_SCAN, std::move(types),
+                       MinValue(left->estimated_cardinality, right->estimated_cardinality)) {
+
+	// Manage the children ourselves
+	D_ASSERT(left->type == PhysicalOperatorType::TABLE_SCAN);
+	D_ASSERT(right->type == PhysicalOperatorType::TABLE_SCAN);
+	child_tables.emplace_back(std::move(left));
+	child_tables.emplace_back(std::move(right));
+}
+
+class PositionalScanGlobalSourceState : public GlobalSourceState {
+public:
+	PositionalScanGlobalSourceState(ClientContext &context, const PhysicalPositionalScan &op) {
+		for (const auto &table : op.child_tables) {
+			global_states.emplace_back(table->GetGlobalSourceState(context));
+		}
+	}
+
+	vector<unique_ptr<GlobalSourceState>> global_states;
+
+	idx_t MaxThreads() override {
+		return 1;
+	}
+};
+
+class PositionalTableScanner {
+public:
+	PositionalTableScanner(ExecutionContext &context, PhysicalOperator &table_p, GlobalSourceState &gstate_p)
+	    : table(table_p), global_state(gstate_p), source_offset(0), exhausted(false) {
+		local_state = table.GetLocalSourceState(context, gstate_p);
+		source.Initialize(Allocator::Get(context.client), table.types);
+	}
+
+	idx_t Refill(ExecutionContext &context) {
+		if (source_offset >= source.size()) {
+			if (!exhausted) {
+				source.Reset();
+				table.GetData(context, source, global_state, *local_state);
+			}
+			source_offset = 0;
+		}
+
+		const auto available = source.size() - source_offset;
+		if (!available) {
+			if (!exhausted) {
+				source.Reset();
+				for (idx_t i = 0; i < source.ColumnCount(); ++i) {
+					auto &vec = source.data[i];
+					vec.SetVectorType(VectorType::CONSTANT_VECTOR);
+					ConstantVector::SetNull(vec, true);
+				}
+				exhausted = true;
+			}
+		}
+
+		return available;
+	}
+
+	idx_t CopyData(ExecutionContext &context, DataChunk &output, const idx_t count, const idx_t col_offset) {
+		if (!source_offset && (source.size() >= count || exhausted)) {
+			//	Fast track: aligned and has enough data
+			for (idx_t i = 0; i < source.ColumnCount(); ++i) {
+				output.data[col_offset + i].Reference(source.data[i]);
+			}
+			source_offset += count;
+		} else {
+			// Copy data
+			for (idx_t target_offset = 0; target_offset < count;) {
+				const auto needed = count - target_offset;
+				const auto available = exhausted ? needed : (source.size() - source_offset);
+				const auto copy_size = MinValue(needed, available);
+				const auto source_count = source_offset + copy_size;
+				for (idx_t i = 0; i < source.ColumnCount(); ++i) {
+					VectorOperations::Copy(source.data[i], output.data[col_offset + i], source_count, source_offset,
+					                       target_offset);
+				}
+				target_offset += copy_size;
+				source_offset += copy_size;
+				Refill(context);
+			}
+		}
+
+		return source.ColumnCount();
+	}
+
+	double GetProgress(ClientContext &context) {
+		return table.GetProgress(context, global_state);
+	}
+
+	PhysicalOperator &table;
+	GlobalSourceState &global_state;
+	unique_ptr<LocalSourceState> local_state;
+	DataChunk source;
+	idx_t source_offset;
+	bool exhausted;
+};
+
+class PositionalScanLocalSourceState : public LocalSourceState {
+public:
+	PositionalScanLocalSourceState(ExecutionContext &context, PositionalScanGlobalSourceState &gstate,
+	                               const PhysicalPositionalScan &op) {
+		for (size_t i = 0; i < op.child_tables.size(); ++i) {
+			auto &child = *op.child_tables[i];
+			auto &global_state = *gstate.global_states[i];
+			scanners.emplace_back(make_unique<PositionalTableScanner>(context, child, global_state));
+		}
+	}
+
+	vector<unique_ptr<PositionalTableScanner>> scanners;
+};
+
+unique_ptr<LocalSourceState> PhysicalPositionalScan::GetLocalSourceState(ExecutionContext &context,
+                                                                         GlobalSourceState &gstate) const {
+	return make_unique<PositionalScanLocalSourceState>(context, (PositionalScanGlobalSourceState &)gstate, *this);
+}
+
+unique_ptr<GlobalSourceState> PhysicalPositionalScan::GetGlobalSourceState(ClientContext &context) const {
+	return make_unique<PositionalScanGlobalSourceState>(context, *this);
+}
+
+void PhysicalPositionalScan::GetData(ExecutionContext &context, DataChunk &output, GlobalSourceState &gstate_p,
+                                     LocalSourceState &lstate_p) const {
+	auto &lstate = (PositionalScanLocalSourceState &)lstate_p;
+
+	// Find the longest source block
+	idx_t count = 0;
+	for (auto &scanner : lstate.scanners) {
+		count = MaxValue(count, scanner->Refill(context));
+	}
+
+	//	All done?
+	if (!count) {
+		return;
+	}
+
+	// Copy or reference the source columns
+	idx_t col_offset = 0;
+	for (auto &scanner : lstate.scanners) {
+		col_offset += scanner->CopyData(context, output, count, col_offset);
+	}
+
+	output.SetCardinality(count);
+}
+
+double PhysicalPositionalScan::GetProgress(ClientContext &context, GlobalSourceState &gstate_p) const {
+	auto &gstate = (PositionalScanGlobalSourceState &)gstate_p;
+
+	double result = child_tables[0]->GetProgress(context, *gstate.global_states[0]);
+	for (size_t t = 1; t < child_tables.size(); ++t) {
+		result = MinValue(result, child_tables[t]->GetProgress(context, *gstate.global_states[t]));
+	}
+
+	return result;
+}
+
+bool PhysicalPositionalScan::Equals(const PhysicalOperator &other_p) const {
+	if (type != other_p.type) {
+		return false;
+	}
+
+	auto &other = (PhysicalPositionalScan &)other_p;
+	if (child_tables.size() != other.child_tables.size()) {
+		return false;
+	}
+	for (size_t i = 0; i < child_tables.size(); ++i) {
+		if (!child_tables[i]->Equals(*other.child_tables[i])) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+} // namespace duckdb