duckdb 0.3.5-dev725.0 → 0.3.5-dev750.0

package/src/duckdb.cpp

@@ -18499,6 +18499,13 @@ DUCKDB_API bool TryCastToTimestampMS::Operation(string_t input, timestamp_t &res
 template <>
 DUCKDB_API bool TryCastToTimestampSec::Operation(string_t input, timestamp_t &result, bool strict);
 
+template <>
+DUCKDB_API bool TryCastToTimestampNS::Operation(date_t input, timestamp_t &result, bool strict);
+template <>
+DUCKDB_API bool TryCastToTimestampMS::Operation(date_t input, timestamp_t &result, bool strict);
+template <>
+DUCKDB_API bool TryCastToTimestampSec::Operation(date_t input, timestamp_t &result, bool strict);
+
 //===--------------------------------------------------------------------===//
 // Non-Standard Timestamps -> string/standard timestamp
 //===--------------------------------------------------------------------===//
@@ -19528,6 +19535,108 @@ string_t StringCastFromDecimal::Operation(hugeint_t input, uint8_t width, uint8_
 
 } // namespace duckdb
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/operator/multiply.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+namespace duckdb {
+
+struct MultiplyOperator {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA left, TB right) {
+		return left * right;
+	}
+};
+
+template <>
+float MultiplyOperator::Operation(float left, float right);
+template <>
+double MultiplyOperator::Operation(double left, double right);
+template <>
+interval_t MultiplyOperator::Operation(interval_t left, int64_t right);
+template <>
+interval_t MultiplyOperator::Operation(int64_t left, interval_t right);
+
+struct TryMultiplyOperator {
+	template <class TA, class TB, class TR>
+	static inline bool Operation(TA left, TB right, TR &result) {
+		throw InternalException("Unimplemented type for TryMultiplyOperator");
+	}
+};
+
+template <>
+bool TryMultiplyOperator::Operation(uint8_t left, uint8_t right, uint8_t &result);
+template <>
+bool TryMultiplyOperator::Operation(uint16_t left, uint16_t right, uint16_t &result);
+template <>
+bool TryMultiplyOperator::Operation(uint32_t left, uint32_t right, uint32_t &result);
+template <>
+bool TryMultiplyOperator::Operation(uint64_t left, uint64_t right, uint64_t &result);
+
+template <>
+bool TryMultiplyOperator::Operation(int8_t left, int8_t right, int8_t &result);
+template <>
+bool TryMultiplyOperator::Operation(int16_t left, int16_t right, int16_t &result);
+template <>
+bool TryMultiplyOperator::Operation(int32_t left, int32_t right, int32_t &result);
+template <>
+DUCKDB_API bool TryMultiplyOperator::Operation(int64_t left, int64_t right, int64_t &result);
+
+struct MultiplyOperatorOverflowCheck {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA left, TB right) {
+		TR result;
+		if (!TryMultiplyOperator::Operation(left, right, result)) {
+			throw OutOfRangeException("Overflow in multiplication of %s (%d * %d)!", TypeIdToString(GetTypeId<TA>()),
+			                          left, right);
+		}
+		return result;
+	}
+};
+
+struct TryDecimalMultiply {
+	template <class TA, class TB, class TR>
+	static inline bool Operation(TA left, TB right, TR &result) {
+		throw InternalException("Unimplemented type for TryDecimalMultiply");
+	}
+};
+
+template <>
+bool TryDecimalMultiply::Operation(int16_t left, int16_t right, int16_t &result);
+template <>
+bool TryDecimalMultiply::Operation(int32_t left, int32_t right, int32_t &result);
+template <>
+bool TryDecimalMultiply::Operation(int64_t left, int64_t right, int64_t &result);
+template <>
+bool TryDecimalMultiply::Operation(hugeint_t left, hugeint_t right, hugeint_t &result);
+
+struct DecimalMultiplyOverflowCheck {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA left, TB right) {
+		TR result;
+		if (!TryDecimalMultiply::Operation<TA, TB, TR>(left, right, result)) {
+			throw OutOfRangeException("Overflow in multiplication of DECIMAL(18) (%d * %d). You might want to add an "
+			                          "explicit cast to a bigger decimal.",
+			                          left, right);
+		}
+		return result;
+	}
+};
+
+template <>
+hugeint_t DecimalMultiplyOverflowCheck::Operation(hugeint_t left, hugeint_t right);
+
+} // namespace duckdb
+
 
 
 
@@ -23709,6 +23818,35 @@ bool TryCastToTimestampSec::Operation(string_t input, timestamp_t &result, bool
 	return true;
 }
 
+template <>
+bool TryCastToTimestampNS::Operation(date_t input, timestamp_t &result, bool strict) {
+	if (!TryCast::Operation<date_t, timestamp_t>(input, result, strict)) {
+		return false;
+	}
+	if (!TryMultiplyOperator::Operation(result.value, Interval::NANOS_PER_MICRO, result.value)) {
+		return false;
+	}
+	return true;
+}
+
+template <>
+bool TryCastToTimestampMS::Operation(date_t input, timestamp_t &result, bool strict) {
+	if (!TryCast::Operation<date_t, timestamp_t>(input, result, strict)) {
+		return false;
+	}
+	result.value /= Interval::MICROS_PER_MSEC;
+	return true;
+}
+
+template <>
+bool TryCastToTimestampSec::Operation(date_t input, timestamp_t &result, bool strict) {
+	if (!TryCast::Operation<date_t, timestamp_t>(input, result, strict)) {
+		return false;
+	}
+	result.value /= Interval::MICROS_PER_MSEC * Interval::MSECS_PER_SEC;
+	return true;
+}
+
 //===--------------------------------------------------------------------===//
 // Cast From Blob
 //===--------------------------------------------------------------------===//
@@ -38787,14 +38925,17 @@ struct SelCache {
 
 
 namespace duckdb {
+
 struct ArrowAuxiliaryData : VectorAuxiliaryData {
 	explicit ArrowAuxiliaryData(shared_ptr<ArrowArrayWrapper> arrow_array_p)
 	    : VectorAuxiliaryData(VectorAuxiliaryDataType::ARROW_AUXILIARY), arrow_array(std::move(arrow_array_p)) {
+	}
+	~ArrowAuxiliaryData() override {
+	}
 
-	                                                                     };
-	~ArrowAuxiliaryData() override {};
 	shared_ptr<ArrowArrayWrapper> arrow_array;
 };
+
 } // namespace duckdb
 
 
@@ -41571,107 +41712,6 @@ dtime_t AddTimeOperator::Operation(interval_t left, dtime_t right);
 
 } // namespace duckdb
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/operator/multiply.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct MultiplyOperator {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		return left * right;
-	}
-};
-
-template <>
-float MultiplyOperator::Operation(float left, float right);
-template <>
-double MultiplyOperator::Operation(double left, double right);
-template <>
-interval_t MultiplyOperator::Operation(interval_t left, int64_t right);
-template <>
-interval_t MultiplyOperator::Operation(int64_t left, interval_t right);
-
-struct TryMultiplyOperator {
-	template <class TA, class TB, class TR>
-	static inline bool Operation(TA left, TB right, TR &result) {
-		throw InternalException("Unimplemented type for TryMultiplyOperator");
-	}
-};
-
-template <>
-bool TryMultiplyOperator::Operation(uint8_t left, uint8_t right, uint8_t &result);
-template <>
-bool TryMultiplyOperator::Operation(uint16_t left, uint16_t right, uint16_t &result);
-template <>
-bool TryMultiplyOperator::Operation(uint32_t left, uint32_t right, uint32_t &result);
-template <>
-bool TryMultiplyOperator::Operation(uint64_t left, uint64_t right, uint64_t &result);
-
-template <>
-bool TryMultiplyOperator::Operation(int8_t left, int8_t right, int8_t &result);
-template <>
-bool TryMultiplyOperator::Operation(int16_t left, int16_t right, int16_t &result);
-template <>
-bool TryMultiplyOperator::Operation(int32_t left, int32_t right, int32_t &result);
-template <>
-DUCKDB_API bool TryMultiplyOperator::Operation(int64_t left, int64_t right, int64_t &result);
-
-struct MultiplyOperatorOverflowCheck {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		TR result;
-		if (!TryMultiplyOperator::Operation(left, right, result)) {
-			throw OutOfRangeException("Overflow in multiplication of %s (%d * %d)!", TypeIdToString(GetTypeId<TA>()),
-			                          left, right);
-		}
-		return result;
-	}
-};
-
-struct TryDecimalMultiply {
-	template <class TA, class TB, class TR>
-	static inline bool Operation(TA left, TB right, TR &result) {
-		throw InternalException("Unimplemented type for TryDecimalMultiply");
-	}
-};
-
-template <>
-bool TryDecimalMultiply::Operation(int16_t left, int16_t right, int16_t &result);
-template <>
-bool TryDecimalMultiply::Operation(int32_t left, int32_t right, int32_t &result);
-template <>
-bool TryDecimalMultiply::Operation(int64_t left, int64_t right, int64_t &result);
-template <>
-bool TryDecimalMultiply::Operation(hugeint_t left, hugeint_t right, hugeint_t &result);
-
-struct DecimalMultiplyOverflowCheck {
-	template <class TA, class TB, class TR>
-	static inline TR Operation(TA left, TB right) {
-		TR result;
-		if (!TryDecimalMultiply::Operation<TA, TB, TR>(left, right, result)) {
-			throw OutOfRangeException("Overflow in multiplication of DECIMAL(18) (%d * %d). You might want to add an "
-			                          "explicit cast to a bigger decimal.",
-			                          left, right);
-		}
-		return result;
-	}
-};
-
-template <>
-hugeint_t DecimalMultiplyOverflowCheck::Operation(hugeint_t left, hugeint_t right);
-
-} // namespace duckdb
 
 
 
@@ -50869,6 +50909,15 @@ static bool DateCastSwitch(Vector &source, Vector &result, idx_t count, string *
 	case LogicalTypeId::TIMESTAMP_TZ:
 		// date to timestamp
 		return VectorTryCastLoop<date_t, timestamp_t, duckdb::TryCast>(source, result, count, error_message);
+	case LogicalTypeId::TIMESTAMP_NS:
+		return VectorTryCastLoop<date_t, timestamp_t, duckdb::TryCastToTimestampNS>(source, result, count,
+		                                                                            error_message);
+	case LogicalTypeId::TIMESTAMP_SEC:
+		return VectorTryCastLoop<date_t, timestamp_t, duckdb::TryCastToTimestampSec>(source, result, count,
+		                                                                             error_message);
+	case LogicalTypeId::TIMESTAMP_MS:
+		return VectorTryCastLoop<date_t, timestamp_t, duckdb::TryCastToTimestampMS>(source, result, count,
+		                                                                            error_message);
 	default:
 		return TryVectorNullCast(source, result, count, error_message);
 	}
@@ -65676,7 +65725,7 @@ public:
 	}
 
 	bool SupportsBatchIndex() const override {
-		return function.supports_batch_index;
+		return function.get_batch_index != nullptr;
 	}
 
 	double GetProgress(ClientContext &context, GlobalSourceState &gstate) const override;
@@ -71665,6 +71714,7 @@ public:
 
 public:
 	unique_ptr<OperatorState> GetOperatorState(ClientContext &context) const override;
+	unique_ptr<GlobalOperatorState> GetGlobalOperatorState(ClientContext &context) const override;
 	OperatorResultType Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
 	                           GlobalOperatorState &gstate, OperatorState &state) const override;
 
@@ -71686,12 +71736,20 @@ private:
 
 namespace duckdb {
 
-class TableInOutFunctionState : public OperatorState {
+class TableInOutLocalState : public OperatorState {
 public:
-	TableInOutFunctionState() {
+	TableInOutLocalState() {
 	}
 
-	unique_ptr<FunctionOperatorData> operator_data;
+	unique_ptr<LocalTableFunctionState> local_state;
+};
+
+class TableInOutGlobalState : public GlobalOperatorState {
+public:
+	TableInOutGlobalState() {
+	}
+
+	unique_ptr<GlobalTableFunctionState> global_state;
 };
 
 PhysicalTableInOutFunction::PhysicalTableInOutFunction(vector<LogicalType> types, TableFunction function_p,
@@ -71702,17 +71760,29 @@ PhysicalTableInOutFunction::PhysicalTableInOutFunction(vector<LogicalType> types
 }
 
 unique_ptr<OperatorState> PhysicalTableInOutFunction::GetOperatorState(ClientContext &context) const {
-	auto result = make_unique<TableInOutFunctionState>();
-	if (function.init) {
-		result->operator_data = function.init(context, bind_data.get(), column_ids, nullptr);
+	auto result = make_unique<TableInOutLocalState>();
+	if (function.init_local) {
+		TableFunctionInitInput input(bind_data.get(), column_ids, nullptr);
+		result->local_state = function.init_local(context, input, nullptr);
+	}
+	return move(result);
+}
+
+unique_ptr<GlobalOperatorState> PhysicalTableInOutFunction::GetGlobalOperatorState(ClientContext &context) const {
+	auto result = make_unique<TableInOutGlobalState>();
+	if (function.init_global) {
+		TableFunctionInitInput input(bind_data.get(), column_ids, nullptr);
+		result->global_state = function.init_global(context, input);
 	}
 	return move(result);
 }
 
 OperatorResultType PhysicalTableInOutFunction::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                                       GlobalOperatorState &gstate, OperatorState &state_p) const {
-	auto &state = (TableInOutFunctionState &)state_p;
-	return function.in_out_function(context.client, bind_data.get(), state.operator_data.get(), input, chunk);
+                                                       GlobalOperatorState &gstate_p, OperatorState &state_p) const {
+	auto &gstate = (TableInOutGlobalState &)gstate_p;
+	auto &state = (TableInOutLocalState &)state_p;
+	TableFunctionInput data(bind_data.get(), state.local_state.get(), gstate.global_state.get());
+	return function.in_out_function(context.client, data, input, chunk);
 }
 
 } // namespace duckdb
@@ -72328,7 +72398,6 @@ bool PhysicalExpressionScan::IsFoldable() const {
 
 
 
-
 #include <utility>
 
 namespace duckdb {
@@ -72342,103 +72411,64 @@ PhysicalTableScan::PhysicalTableScan(vector<LogicalType> types, TableFunction fu
       table_filters(move(table_filters_p)) {
 }
 
-class TableScanGlobalState : public GlobalSourceState {
+class TableScanGlobalSourceState : public GlobalSourceState {
 public:
-	TableScanGlobalState(ClientContext &context, const PhysicalTableScan &op) {
-		if (!op.function.max_threads || !op.function.init_parallel_state) {
-			// table function cannot be parallelized
-			return;
-		}
-		// table function can be parallelized
-		// check how many threads we can have
-		max_threads = op.function.max_threads(context, op.bind_data.get());
-		if (max_threads <= 1) {
-			return;
-		}
-		if (op.function.init_parallel_state) {
-			TableFilterCollection collection(op.table_filters.get());
-			parallel_state = op.function.init_parallel_state(context, op.bind_data.get(), op.column_ids, &collection);
+	TableScanGlobalSourceState(ClientContext &context, const PhysicalTableScan &op) {
+		if (op.function.init_global) {
+			TableFunctionInitInput input(op.bind_data.get(), op.column_ids, op.table_filters.get());
+			global_state = op.function.init_global(context, input);
+			if (global_state) {
+				max_threads = global_state->MaxThreads();
+			}
+		} else {
+			max_threads = 1;
 		}
 	}
 
 	idx_t max_threads = 0;
-	unique_ptr<ParallelState> parallel_state;
+	unique_ptr<GlobalTableFunctionState> global_state;
 
 	idx_t MaxThreads() override {
 		return max_threads;
 	}
 };
 
-class TableScanLocalState : public LocalSourceState {
+class TableScanLocalSourceState : public LocalSourceState {
 public:
-	TableScanLocalState(ExecutionContext &context, TableScanGlobalState &gstate, const PhysicalTableScan &op) {
-		TableFilterCollection filters(op.table_filters.get());
-		if (gstate.parallel_state) {
-			// parallel scan init
-			operator_data = op.function.parallel_init(context.client, op.bind_data.get(), gstate.parallel_state.get(),
-			                                          op.column_ids, &filters);
-		} else if (op.function.init) {
-			// sequential scan init
-			operator_data = op.function.init(context.client, op.bind_data.get(), op.column_ids, &filters);
+	TableScanLocalSourceState(ExecutionContext &context, TableScanGlobalSourceState &gstate,
+	                          const PhysicalTableScan &op) {
+		if (op.function.init_local) {
+			TableFunctionInitInput input(op.bind_data.get(), op.column_ids, op.table_filters.get());
+			local_state = op.function.init_local(context.client, input, gstate.global_state.get());
 		}
 	}
 
-	unique_ptr<FunctionOperatorData> operator_data;
+	unique_ptr<LocalTableFunctionState> local_state;
 };
 
 unique_ptr<LocalSourceState> PhysicalTableScan::GetLocalSourceState(ExecutionContext &context,
                                                                     GlobalSourceState &gstate) const {
-	return make_unique<TableScanLocalState>(context, (TableScanGlobalState &)gstate, *this);
+	return make_unique<TableScanLocalSourceState>(context, (TableScanGlobalSourceState &)gstate, *this);
 }
 
 unique_ptr<GlobalSourceState> PhysicalTableScan::GetGlobalSourceState(ClientContext &context) const {
-	return make_unique<TableScanGlobalState>(context, *this);
+	return make_unique<TableScanGlobalSourceState>(context, *this);
 }
 
 void PhysicalTableScan::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate_p,
                                 LocalSourceState &lstate) const {
 	D_ASSERT(!column_ids.empty());
-	auto &gstate = (TableScanGlobalState &)gstate_p;
-	auto &state = (TableScanLocalState &)lstate;
+	auto &gstate = (TableScanGlobalSourceState &)gstate_p;
+	auto &state = (TableScanLocalSourceState &)lstate;
 
-	if (!gstate.parallel_state) {
-		// sequential scan
-		function.function(context.client, bind_data.get(), state.operator_data.get(), chunk);
-		if (chunk.size() != 0) {
-			return;
-		}
-	} else {
-		// parallel scan
-		do {
-			if (function.parallel_function) {
-				function.parallel_function(context.client, bind_data.get(), state.operator_data.get(), chunk,
-				                           gstate.parallel_state.get());
-			} else {
-				function.function(context.client, bind_data.get(), state.operator_data.get(), chunk);
-			}
-
-			if (chunk.size() == 0) {
-				D_ASSERT(function.parallel_state_next);
-				if (function.parallel_state_next(context.client, bind_data.get(), state.operator_data.get(),
-				                                 gstate.parallel_state.get())) {
-					continue;
-				} else {
-					break;
-				}
-			} else {
-				return;
-			}
-		} while (true);
-	}
-	D_ASSERT(chunk.size() == 0);
-	if (function.cleanup) {
-		function.cleanup(context.client, bind_data.get(), state.operator_data.get());
-	}
+	TableFunctionInput data(bind_data.get(), state.local_state.get(), gstate.global_state.get());
+	function.function(context.client, data, chunk);
 }
 
 double PhysicalTableScan::GetProgress(ClientContext &context, GlobalSourceState &gstate_p) const {
+	auto &gstate = (TableScanGlobalSourceState &)gstate_p;
 	if (function.table_scan_progress) {
-		return function.table_scan_progress(context, bind_data.get());
+		return function.table_scan_progress(context, bind_data.get(), gstate.global_state.get());
 	}
 	// if table_scan_progress is not implemented we don't support this function yet in the progress bar
 	return -1;
@@ -72448,10 +72478,10 @@ idx_t PhysicalTableScan::GetBatchIndex(ExecutionContext &context, DataChunk &chu
                                        LocalSourceState &lstate) const {
 	D_ASSERT(SupportsBatchIndex());
 	D_ASSERT(function.get_batch_index);
-	auto &gstate = (TableScanGlobalState &)gstate_p;
-	auto &state = (TableScanLocalState &)lstate;
-	return function.get_batch_index(context.client, bind_data.get(), state.operator_data.get(),
-	                                gstate.parallel_state.get());
+	auto &gstate = (TableScanGlobalSourceState &)gstate_p;
+	auto &state = (TableScanLocalSourceState &)lstate;
+	return function.get_batch_index(context.client, bind_data.get(), state.local_state.get(),
+	                                gstate.global_state.get());
 }
 
 string PhysicalTableScan::GetName() const {
@@ -104041,7 +104071,6 @@ unique_ptr<MacroFunction> ScalarMacroFunction::Copy() {
 
 
 
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -104073,8 +104102,7 @@ namespace duckdb {
 using std::thread;
 }
 
-#include <map>
-#include <condition_variable>
+
 
 namespace duckdb {
 //===--------------------------------------------------------------------===//
@@ -104093,78 +104121,64 @@ enum class ArrowDateTimeType : uint8_t {
 	DAYS = 4,
 	MONTHS = 5
 };
+
 struct ArrowConvertData {
 	ArrowConvertData(LogicalType type) : dictionary_type(type) {};
 	ArrowConvertData() {};
 	//! Hold type of dictionary
 	LogicalType dictionary_type;
 	//! If its a variable size type (e.g., strings, blobs, lists) holds which type it is
-	vector<std::pair<ArrowVariableSizeType, idx_t>> variable_sz_type;
+	vector<pair<ArrowVariableSizeType, idx_t>> variable_sz_type;
 	//! If this is a date/time holds its precision
 	vector<ArrowDateTimeType> date_time_precision;
 };
 
-struct ArrowScanFunctionData : public TableFunctionData {
-#ifndef DUCKDB_NO_THREADS
+typedef unique_ptr<ArrowArrayStreamWrapper> (*stream_factory_produce_t)(
+    uintptr_t stream_factory_ptr, pair<unordered_map<idx_t, string>, vector<string>> &project_columns,
+    TableFilterSet *filters);
+typedef void (*stream_factory_get_schema_t)(uintptr_t stream_factory_ptr, ArrowSchemaWrapper &schema);
 
-	ArrowScanFunctionData(idx_t rows_per_thread_p,
-	                      unique_ptr<ArrowArrayStreamWrapper> (*scanner_producer_p)(
-	                          uintptr_t stream_factory_ptr,
-	                          std::pair<std::unordered_map<idx_t, string>, std::vector<string>> &project_columns,
-	                          TableFilterCollection *filters),
-	                      uintptr_t stream_factory_ptr_p, std::thread::id thread_id_p)
-	    : lines_read(0), rows_per_thread(rows_per_thread_p), stream_factory_ptr(stream_factory_ptr_p),
-	      scanner_producer(scanner_producer_p), number_of_rows(0), thread_id(thread_id_p) {
-	}
-#endif
-
-	ArrowScanFunctionData(idx_t rows_per_thread_p,
-	                      unique_ptr<ArrowArrayStreamWrapper> (*scanner_producer_p)(
-	                          uintptr_t stream_factory_ptr,
-	                          std::pair<std::unordered_map<idx_t, string>, std::vector<string>> &project_columns,
-	                          TableFilterCollection *filters),
+struct ArrowScanFunctionData : public TableFunctionData {
+	ArrowScanFunctionData(idx_t rows_per_thread_p, stream_factory_produce_t scanner_producer_p,
 	                      uintptr_t stream_factory_ptr_p)
 	    : lines_read(0), rows_per_thread(rows_per_thread_p), stream_factory_ptr(stream_factory_ptr_p),
 	      scanner_producer(scanner_producer_p), number_of_rows(0) {
 	}
 	//! This holds the original list type (col_idx, [ArrowListType,size])
-	std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> arrow_convert_data;
-	std::atomic<idx_t> lines_read;
+	unordered_map<idx_t, unique_ptr<ArrowConvertData>> arrow_convert_data;
+	atomic<idx_t> lines_read;
 	ArrowSchemaWrapper schema_root;
 	idx_t rows_per_thread;
 	//! Pointer to the scanner factory
 	uintptr_t stream_factory_ptr;
 	//! Pointer to the scanner factory produce
-	unique_ptr<ArrowArrayStreamWrapper> (*scanner_producer)(
-	    uintptr_t stream_factory_ptr,
-	    std::pair<std::unordered_map<idx_t, string>, std::vector<string>> &project_columns,
-	    TableFilterCollection *filters);
+	stream_factory_produce_t scanner_producer;
 	//! Number of rows (Used in cardinality and progress bar)
 	int64_t number_of_rows;
-#ifndef DUCKDB_NO_THREADS
-	// Thread that made first call in the binder
-	std::thread::id thread_id;
-#endif
 };
 
-struct ArrowScanState : public FunctionOperatorData {
-	explicit ArrowScanState(unique_ptr<ArrowArrayWrapper> current_chunk) : chunk(move(current_chunk)) {
+struct ArrowScanLocalState : public LocalTableFunctionState {
+	explicit ArrowScanLocalState(unique_ptr<ArrowArrayWrapper> current_chunk) : chunk(move(current_chunk)) {
 	}
+
 	unique_ptr<ArrowArrayStreamWrapper> stream;
 	shared_ptr<ArrowArrayWrapper> chunk;
 	idx_t chunk_offset = 0;
 	vector<column_t> column_ids;
 	//! Store child vectors for Arrow Dictionary Vectors (col-idx,vector)
 	unordered_map<idx_t, unique_ptr<Vector>> arrow_dictionary_vectors;
-	TableFilterCollection *filters = nullptr;
+	TableFilterSet *filters = nullptr;
 };
 
-struct ParallelArrowScanState : public ParallelState {
-	ParallelArrowScanState() {
-	}
+struct ArrowScanGlobalState : public GlobalTableFunctionState {
 	unique_ptr<ArrowArrayStreamWrapper> stream;
-	std::mutex main_mutex;
+	mutex main_mutex;
 	bool ready = false;
+	idx_t max_threads = 1;
+
+	idx_t MaxThreads() const override {
+		return max_threads;
+	}
 };
 
 struct ArrowTableFunction {
@@ -104176,45 +104190,30 @@ private:
 	static unique_ptr<FunctionData> ArrowScanBind(ClientContext &context, TableFunctionBindInput &input,
 	                                              vector<LogicalType> &return_types, vector<string> &names);
 	//! Actual conversion from Arrow to DuckDB
-	static void ArrowToDuckDB(ArrowScanState &scan_state,
+	static void ArrowToDuckDB(ArrowScanLocalState &scan_state,
 	                          std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data,
 	                          DataChunk &output, idx_t start);
 
-	//! -----Single Thread Functions:-----
-	//! Initialize Single Thread Scan
-	static unique_ptr<FunctionOperatorData> ArrowScanInit(ClientContext &context, const FunctionData *bind_data,
-	                                                      const vector<column_t> &column_ids,
-	                                                      TableFilterCollection *filters);
-
-	//! Scan Function for Single Thread Execution
-	static void ArrowScanFunction(ClientContext &context, const FunctionData *bind_data,
-	                              FunctionOperatorData *operator_state, DataChunk &output);
-
-	//! -----Multi Thread Functions:-----
-	//! Initialize Parallel State
-	static unique_ptr<ParallelState> ArrowScanInitParallelState(ClientContext &context, const FunctionData *bind_data_p,
-	                                                            const vector<column_t> &column_ids,
-	                                                            TableFilterCollection *filters);
-	//! Initialize Parallel Scans
-	static unique_ptr<FunctionOperatorData> ArrowScanParallelInit(ClientContext &context,
-	                                                              const FunctionData *bind_data_p, ParallelState *state,
-	                                                              const vector<column_t> &column_ids,
-	                                                              TableFilterCollection *filters);
+	//! Initialize Global State
+	static unique_ptr<GlobalTableFunctionState> ArrowScanInitGlobal(ClientContext &context,
+	                                                                TableFunctionInitInput &input);
+
+	//! Initialize Local State
+	static unique_ptr<LocalTableFunctionState> ArrowScanInitLocal(ClientContext &context, TableFunctionInitInput &input,
+	                                                              GlobalTableFunctionState *global_state);
+
+	//! Scan Function
+	static void ArrowScanFunction(ClientContext &context, TableFunctionInput &data, DataChunk &output);
+
 	//! Defines Maximum Number of Threads
-	static idx_t ArrowScanMaxThreads(ClientContext &context, const FunctionData *bind_data_p);
-	//! Scan Function for Parallel Execution
-	static void ArrowScanFunctionParallel(ClientContext &context, const FunctionData *bind_data,
-	                                      FunctionOperatorData *operator_state, DataChunk &output,
-	                                      ParallelState *parallel_state_p);
-	//! Get next chunk for the running thread
-	static bool ArrowScanParallelStateNext(ClientContext &context, const FunctionData *bind_data_p,
-	                                       FunctionOperatorData *operator_state, ParallelState *parallel_state_p);
+	static idx_t ArrowScanMaxThreads(ClientContext &context, const FunctionData *bind_data);
 
 	//! -----Utility Functions:-----
 	//! Gets Arrow Table's Cardinality
 	static unique_ptr<NodeStatistics> ArrowScanCardinality(ClientContext &context, const FunctionData *bind_data);
 	//! Gets the progress on the table scan, used for Progress Bars
-	static double ArrowProgress(ClientContext &context, const FunctionData *bind_data_p);
+	static double ArrowProgress(ClientContext &context, const FunctionData *bind_data,
+	                            const GlobalTableFunctionState *global_state);
 };
 
 } // namespace duckdb
@@ -104224,12 +104223,6 @@ private:
 
 
 
-
-
-
-
-#include <map>
-
 namespace duckdb {
 
 LogicalType GetArrowLogicalType(ArrowSchema &schema,
@@ -104413,26 +104406,14 @@ void RenameArrowColumns(vector<string> &names) {
 
 unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBind(ClientContext &context, TableFunctionBindInput &input,
                                                            vector<LogicalType> &return_types, vector<string> &names) {
-	typedef unique_ptr<ArrowArrayStreamWrapper> (*stream_factory_produce_t)(
-	    uintptr_t stream_factory_ptr,
-	    std::pair<std::unordered_map<idx_t, string>, std::vector<string>> & project_columns,
-	    TableFilterCollection * filters);
-
-	typedef void (*stream_factory_get_schema_t)(uintptr_t stream_factory_ptr, ArrowSchemaWrapper & schema);
-
 	auto stream_factory_ptr = input.inputs[0].GetPointer();
 	auto stream_factory_produce = (stream_factory_produce_t)input.inputs[1].GetPointer();
 	auto stream_factory_get_schema = (stream_factory_get_schema_t)input.inputs[2].GetPointer();
 	auto rows_per_thread = input.inputs[3].GetValue<uint64_t>();
 
-	std::pair<std::unordered_map<idx_t, string>, std::vector<string>> project_columns;
-#ifndef DUCKDB_NO_THREADS
-
-	auto res = make_unique<ArrowScanFunctionData>(rows_per_thread, stream_factory_produce, stream_factory_ptr,
-	                                              std::this_thread::get_id());
-#else
+	pair<unordered_map<idx_t, string>, vector<string>> project_columns;
 	auto res = make_unique<ArrowScanFunctionData>(rows_per_thread, stream_factory_produce, stream_factory_ptr);
-#endif
+
 	auto &data = *res;
 	stream_factory_get_schema(stream_factory_ptr, data.schema_root);
 	for (idx_t col_idx = 0; col_idx < (idx_t)data.schema_root.arrow_schema.n_children; col_idx++) {
@@ -104459,8 +104440,7 @@ unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBind(ClientContext &contex
 }
 
 unique_ptr<ArrowArrayStreamWrapper> ProduceArrowScan(const ArrowScanFunctionData &function,
-                                                     const vector<column_t> &column_ids,
-                                                     TableFilterCollection *filters) {
+                                                     const vector<column_t> &column_ids, TableFilterSet *filters) {
 	//! Generate Projection Pushdown Vector
 	pair<unordered_map<idx_t, string>, vector<string>> project_columns;
 	D_ASSERT(!column_ids.empty());
@@ -104475,18 +104455,114 @@ unique_ptr<ArrowArrayStreamWrapper> ProduceArrowScan(const ArrowScanFunctionData
 	return function.scanner_producer(function.stream_factory_ptr, project_columns, filters);
 }
 
-unique_ptr<FunctionOperatorData> ArrowTableFunction::ArrowScanInit(ClientContext &context,
-                                                                   const FunctionData *bind_data,
-                                                                   const vector<column_t> &column_ids,
-                                                                   TableFilterCollection *filters) {
+idx_t ArrowTableFunction::ArrowScanMaxThreads(ClientContext &context, const FunctionData *bind_data_p) {
+	auto &bind_data = (const ArrowScanFunctionData &)*bind_data_p;
+	if (bind_data.number_of_rows <= 0 || ClientConfig::GetConfig(context).verify_parallelism) {
+		return context.db->NumberOfThreads();
+	}
+	return ((bind_data.number_of_rows + bind_data.rows_per_thread - 1) / bind_data.rows_per_thread) + 1;
+}
+
+bool ArrowScanParallelStateNext(ClientContext &context, const FunctionData *bind_data_p, ArrowScanLocalState &state,
+                                ArrowScanGlobalState &parallel_state) {
+	lock_guard<mutex> parallel_lock(parallel_state.main_mutex);
+	state.chunk_offset = 0;
+
+	auto current_chunk = parallel_state.stream->GetNextChunk();
+	while (current_chunk->arrow_array.length == 0 && current_chunk->arrow_array.release) {
+		current_chunk = parallel_state.stream->GetNextChunk();
+	}
+	state.chunk = move(current_chunk);
+	//! have we run out of chunks? we are done
+	if (!state.chunk->arrow_array.release) {
+		return false;
+	}
+	return true;
+}
+
+unique_ptr<GlobalTableFunctionState> ArrowTableFunction::ArrowScanInitGlobal(ClientContext &context,
+                                                                             TableFunctionInitInput &input) {
+	auto &bind_data = (const ArrowScanFunctionData &)*input.bind_data;
+	auto result = make_unique<ArrowScanGlobalState>();
+	result->stream = ProduceArrowScan(bind_data, input.column_ids, input.filters);
+	result->max_threads = ArrowScanMaxThreads(context, input.bind_data);
+	return move(result);
+}
+
+unique_ptr<LocalTableFunctionState> ArrowTableFunction::ArrowScanInitLocal(ClientContext &context,
+                                                                           TableFunctionInitInput &input,
+                                                                           GlobalTableFunctionState *global_state_p) {
+	auto &global_state = (ArrowScanGlobalState &)*global_state_p;
 	auto current_chunk = make_unique<ArrowArrayWrapper>();
-	auto result = make_unique<ArrowScanState>(move(current_chunk));
-	result->column_ids = column_ids;
-	auto &data = (const ArrowScanFunctionData &)*bind_data;
-	result->stream = ProduceArrowScan(data, column_ids, filters);
+	auto result = make_unique<ArrowScanLocalState>(move(current_chunk));
+	result->column_ids = input.column_ids;
+	result->filters = input.filters;
+	if (!ArrowScanParallelStateNext(context, input.bind_data, *result, global_state)) {
+		return nullptr;
+	}
 	return move(result);
 }
 
+void ArrowTableFunction::ArrowScanFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	if (!data_p.local_state) {
+		return;
+	}
+	auto &data = (ArrowScanFunctionData &)*data_p.bind_data;
+	auto &state = (ArrowScanLocalState &)*data_p.local_state;
+	auto &global_state = (ArrowScanGlobalState &)*data_p.global_state;
+
+	//! Out of tuples in this chunk
+	if (state.chunk_offset >= (idx_t)state.chunk->arrow_array.length) {
+		if (!ArrowScanParallelStateNext(context, data_p.bind_data, state, global_state)) {
+			return;
+		}
+	}
+	int64_t output_size = MinValue<int64_t>(STANDARD_VECTOR_SIZE, state.chunk->arrow_array.length - state.chunk_offset);
+	data.lines_read += output_size;
+	output.SetCardinality(output_size);
+	ArrowToDuckDB(state, data.arrow_convert_data, output, data.lines_read - output_size);
+	output.Verify();
+	state.chunk_offset += output.size();
+}
+
+unique_ptr<NodeStatistics> ArrowTableFunction::ArrowScanCardinality(ClientContext &context, const FunctionData *data) {
+	auto &bind_data = (ArrowScanFunctionData &)*data;
+	return make_unique<NodeStatistics>(bind_data.number_of_rows, bind_data.number_of_rows);
+}
+
+double ArrowTableFunction::ArrowProgress(ClientContext &context, const FunctionData *bind_data_p,
+                                         const GlobalTableFunctionState *global_state) {
+	auto &bind_data = (const ArrowScanFunctionData &)*bind_data_p;
+	if (bind_data.number_of_rows == 0) {
+		return 100;
+	}
+	auto percentage = bind_data.lines_read * 100.0 / bind_data.number_of_rows;
+	return percentage;
+}
+
+void ArrowTableFunction::RegisterFunction(BuiltinFunctions &set) {
+	TableFunction arrow("arrow_scan",
+	                    {LogicalType::POINTER, LogicalType::POINTER, LogicalType::POINTER, LogicalType::UBIGINT},
+	                    ArrowScanFunction, ArrowScanBind, ArrowScanInitGlobal, ArrowScanInitLocal);
+	arrow.cardinality = ArrowScanCardinality;
+	arrow.projection_pushdown = true;
+	arrow.filter_pushdown = true;
+	arrow.table_scan_progress = ArrowProgress;
+	set.AddFunction(arrow);
+}
+
+void BuiltinFunctions::RegisterArrowFunctions() {
+	ArrowTableFunction::RegisterFunction(*this);
+}
+} // namespace duckdb
+
+
+
+
+
+
+namespace duckdb {
+
 void ShiftRight(unsigned char *ar, int size, int shift) {
 	int carry = 0;
 	while (shift--) {
@@ -104498,8 +104574,8 @@ void ShiftRight(unsigned char *ar, int size, int shift) {
 	}
 }
 
-void SetValidityMask(Vector &vector, ArrowArray &array, ArrowScanState &scan_state, idx_t size, int64_t nested_offset,
-                     bool add_null = false) {
+void SetValidityMask(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
+                     int64_t nested_offset, bool add_null = false) {
 	auto &mask = FlatVector::Validity(vector);
 	if (array.null_count != 0 && array.buffers[0]) {
 		D_ASSERT(vector.GetVectorType() == VectorType::FLAT_VECTOR);
@@ -104530,7 +104606,7 @@ void SetValidityMask(Vector &vector, ArrowArray &array, ArrowScanState &scan_sta
 	}
 }
 
-void GetValidityMask(ValidityMask &mask, ArrowArray &array, ArrowScanState &scan_state, idx_t size) {
+void GetValidityMask(ValidityMask &mask, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size) {
 	if (array.null_count != 0 && array.buffers[0]) {
 		auto bit_offset = scan_state.chunk_offset + array.offset;
 		auto n_bitmask_bytes = (size + 8 - 1) / 8;
@@ -104549,12 +104625,12 @@ void GetValidityMask(ValidityMask &mask, ArrowArray &array, ArrowScanState &scan
 	}
 }
 
-void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanState &scan_state, idx_t size,
+void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
                          std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data, idx_t col_idx,
                          std::pair<idx_t, idx_t> &arrow_convert_idx, int64_t nested_offset = -1,
                          ValidityMask *parent_mask = nullptr);
 
-void ArrowToDuckDBList(Vector &vector, ArrowArray &array, ArrowScanState &scan_state, idx_t size,
+void ArrowToDuckDBList(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
                        std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data, idx_t col_idx,
                        std::pair<idx_t, idx_t> &arrow_convert_idx, int64_t nested_offset, ValidityMask *parent_mask) {
 	auto original_type = arrow_convert_data[col_idx]->variable_sz_type[arrow_convert_idx.first++];
@@ -104631,7 +104707,7 @@ void ArrowToDuckDBList(Vector &vector, ArrowArray &array, ArrowScanState &scan_s
 	}
 }
 
-void ArrowToDuckDBBlob(Vector &vector, ArrowArray &array, ArrowScanState &scan_state, idx_t size,
+void ArrowToDuckDBBlob(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
                        std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data, idx_t col_idx,
                        std::pair<idx_t, idx_t> &arrow_convert_idx, int64_t nested_offset) {
 	auto original_type = arrow_convert_data[col_idx]->variable_sz_type[arrow_convert_idx.first++];
@@ -104687,9 +104763,9 @@ void ArrowToDuckDBBlob(Vector &vector, ArrowArray &array, ArrowScanState &scan_s
 	}
 }
 
-void ArrowToDuckDBMapList(Vector &vector, ArrowArray &array, ArrowScanState &scan_state, idx_t size,
-                          std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data, idx_t col_idx,
-                          std::pair<idx_t, idx_t> &arrow_convert_idx, uint32_t *offsets, ValidityMask *parent_mask) {
+void ArrowToDuckDBMapList(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
+                          unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data, idx_t col_idx,
+                          pair<idx_t, idx_t> &arrow_convert_idx, uint32_t *offsets, ValidityMask *parent_mask) {
 	idx_t list_size = offsets[size] - offsets[0];
 	ListVector::Reserve(vector, list_size);
 
@@ -104741,7 +104817,7 @@ static void SetVectorString(Vector &vector, idx_t size, char *cdata, T *offsets)
 	}
 }
 
-void DirectConversion(Vector &vector, ArrowArray &array, ArrowScanState &scan_state, int64_t nested_offset) {
+void DirectConversion(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, int64_t nested_offset) {
 	auto internal_type = GetTypeIdSize(vector.GetType().InternalType());
 	auto data_ptr = (data_ptr_t)array.buffers[1] + internal_type * (scan_state.chunk_offset + array.offset);
 	if (nested_offset != -1) {
@@ -104751,8 +104827,8 @@ void DirectConversion(Vector &vector, ArrowArray &array, ArrowScanState &scan_st
 }
 
 template <class T>
-void TimeConversion(Vector &vector, ArrowArray &array, ArrowScanState &scan_state, int64_t nested_offset, idx_t size,
-                    int64_t conversion) {
+void TimeConversion(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, int64_t nested_offset,
+                    idx_t size, int64_t conversion) {
 	auto tgt_ptr = (dtime_t *)FlatVector::GetData(vector);
 	auto &validity_mask = FlatVector::Validity(vector);
 	auto src_ptr = (T *)array.buffers[1] + scan_state.chunk_offset + array.offset;
@@ -104769,7 +104845,7 @@ void TimeConversion(Vector &vector, ArrowArray &array, ArrowScanState &scan_stat
 	}
 }
 
-void TimestampTZConversion(Vector &vector, ArrowArray &array, ArrowScanState &scan_state, int64_t nested_offset,
+void TimestampTZConversion(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, int64_t nested_offset,
                            idx_t size, int64_t conversion) {
 	auto tgt_ptr = (timestamp_t *)FlatVector::GetData(vector);
 	auto &validity_mask = FlatVector::Validity(vector);
@@ -104787,7 +104863,7 @@ void TimestampTZConversion(Vector &vector, ArrowArray &array, ArrowScanState &sc
 	}
 }
 
-void IntervalConversionUs(Vector &vector, ArrowArray &array, ArrowScanState &scan_state, int64_t nested_offset,
+void IntervalConversionUs(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, int64_t nested_offset,
                           idx_t size, int64_t conversion) {
 	auto tgt_ptr = (interval_t *)FlatVector::GetData(vector);
 	auto src_ptr = (int64_t *)array.buffers[1] + scan_state.chunk_offset + array.offset;
@@ -104803,7 +104879,7 @@ void IntervalConversionUs(Vector &vector, ArrowArray &array, ArrowScanState &sca
 	}
 }
 
-void IntervalConversionMonths(Vector &vector, ArrowArray &array, ArrowScanState &scan_state, int64_t nested_offset,
+void IntervalConversionMonths(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, int64_t nested_offset,
                               idx_t size) {
 	auto tgt_ptr = (interval_t *)FlatVector::GetData(vector);
 	auto src_ptr = (int32_t *)array.buffers[1] + scan_state.chunk_offset + array.offset;
@@ -104817,7 +104893,7 @@ void IntervalConversionMonths(Vector &vector, ArrowArray &array, ArrowScanState
 	}
 }
 
-void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanState &scan_state, idx_t size,
+void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
                          std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data, idx_t col_idx,
                          std::pair<idx_t, idx_t> &arrow_convert_idx, int64_t nested_offset, ValidityMask *parent_mask) {
 	switch (vector.GetType().id()) {
@@ -105242,7 +105318,7 @@ void SetSelectionVector(SelectionVector &sel, data_ptr_t indices_p, LogicalType
 	}
 }
 
-void ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, ArrowScanState &scan_state, idx_t size,
+void ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
                                    std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data,
                                    idx_t col_idx, std::pair<idx_t, idx_t> &arrow_convert_idx) {
 	SelectionVector sel;
@@ -105269,8 +105345,8 @@ void ColumnArrowToDuckDBDictionary(Vector &vector, ArrowArray &array, ArrowScanS
 	vector.Slice(*dict_vectors[col_idx], sel, size);
 }
 
-void ArrowTableFunction::ArrowToDuckDB(ArrowScanState &scan_state,
-                                       std::unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data,
+void ArrowTableFunction::ArrowToDuckDB(ArrowScanLocalState &scan_state,
+                                       unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data,
                                        DataChunk &output, idx_t start) {
 	for (idx_t idx = 0; idx < output.ColumnCount(); idx++) {
 		auto col_idx = scan_state.column_ids[idx];
@@ -105294,125 +105370,6 @@ void ArrowTableFunction::ArrowToDuckDB(ArrowScanState &scan_state,
 	}
 }
 
-void ArrowTableFunction::ArrowScanFunction(ClientContext &context, const FunctionData *bind_data,
-                                           FunctionOperatorData *operator_state, DataChunk &output) {
-
-	auto &data = (ArrowScanFunctionData &)*bind_data;
-	auto &state = (ArrowScanState &)*operator_state;
-
-	//! have we run out of data on the current chunk? move to next one
-	while (state.chunk_offset >= (idx_t)state.chunk->arrow_array.length) {
-		state.chunk_offset = 0;
-		state.arrow_dictionary_vectors.clear();
-		state.chunk = state.stream->GetNextChunk();
-		//! have we run out of chunks? we are done
-		if (!state.chunk->arrow_array.release) {
-			return;
-		}
-	}
-
-	int64_t output_size = MinValue<int64_t>(STANDARD_VECTOR_SIZE, state.chunk->arrow_array.length - state.chunk_offset);
-	data.lines_read += output_size;
-	output.SetCardinality(output_size);
-	ArrowToDuckDB(state, data.arrow_convert_data, output, data.lines_read - output_size);
-	output.Verify();
-	state.chunk_offset += output.size();
-}
-
-void ArrowTableFunction::ArrowScanFunctionParallel(ClientContext &context, const FunctionData *bind_data,
-                                                   FunctionOperatorData *operator_state, DataChunk &output,
-                                                   ParallelState *parallel_state_p) {
-	auto &data = (ArrowScanFunctionData &)*bind_data;
-	auto &state = (ArrowScanState &)*operator_state;
-	//! Out of tuples in this chunk
-	if (state.chunk_offset >= (idx_t)state.chunk->arrow_array.length) {
-		return;
-	}
-	int64_t output_size = MinValue<int64_t>(STANDARD_VECTOR_SIZE, state.chunk->arrow_array.length - state.chunk_offset);
-	data.lines_read += output_size;
-	output.SetCardinality(output_size);
-	ArrowToDuckDB(state, data.arrow_convert_data, output, data.lines_read - output_size);
-	output.Verify();
-	state.chunk_offset += output.size();
-}
-
-idx_t ArrowTableFunction::ArrowScanMaxThreads(ClientContext &context, const FunctionData *bind_data_p) {
-	auto &bind_data = (const ArrowScanFunctionData &)*bind_data_p;
-	if (bind_data.number_of_rows <= 0 || ClientConfig::GetConfig(context).verify_parallelism) {
-		return context.db->NumberOfThreads();
-	}
-	return ((bind_data.number_of_rows + bind_data.rows_per_thread - 1) / bind_data.rows_per_thread) + 1;
-}
-
-unique_ptr<ParallelState> ArrowTableFunction::ArrowScanInitParallelState(ClientContext &context,
-                                                                         const FunctionData *bind_data_p,
-                                                                         const vector<column_t> &column_ids,
-                                                                         TableFilterCollection *filters) {
-	auto &bind_data = (const ArrowScanFunctionData &)*bind_data_p;
-	auto result = make_unique<ParallelArrowScanState>();
-	result->stream = ProduceArrowScan(bind_data, column_ids, filters);
-	return move(result);
-}
-
-bool ArrowTableFunction::ArrowScanParallelStateNext(ClientContext &context, const FunctionData *bind_data_p,
-                                                    FunctionOperatorData *operator_state,
-                                                    ParallelState *parallel_state_p) {
-	auto &state = (ArrowScanState &)*operator_state;
-	auto &parallel_state = (ParallelArrowScanState &)*parallel_state_p;
-
-	lock_guard<mutex> parallel_lock(parallel_state.main_mutex);
-	state.chunk_offset = 0;
-
-	auto current_chunk = parallel_state.stream->GetNextChunk();
-	while (current_chunk->arrow_array.length == 0 && current_chunk->arrow_array.release) {
-		current_chunk = parallel_state.stream->GetNextChunk();
-	}
-	state.chunk = move(current_chunk);
-	//! have we run out of chunks? we are done
-	if (!state.chunk->arrow_array.release) {
-		return false;
-	}
-	return true;
-}
-
-unique_ptr<FunctionOperatorData>
-ArrowTableFunction::ArrowScanParallelInit(ClientContext &context, const FunctionData *bind_data_p, ParallelState *state,
-                                          const vector<column_t> &column_ids, TableFilterCollection *filters) {
-	auto current_chunk = make_unique<ArrowArrayWrapper>();
-	auto result = make_unique<ArrowScanState>(move(current_chunk));
-	result->column_ids = column_ids;
-	result->filters = filters;
-	ArrowScanParallelStateNext(context, bind_data_p, result.get(), state);
-	return move(result);
-}
-
-unique_ptr<NodeStatistics> ArrowTableFunction::ArrowScanCardinality(ClientContext &context, const FunctionData *data) {
-	auto &bind_data = (ArrowScanFunctionData &)*data;
-	return make_unique<NodeStatistics>(bind_data.number_of_rows, bind_data.number_of_rows);
-}
-
-double ArrowTableFunction::ArrowProgress(ClientContext &context, const FunctionData *bind_data_p) {
-	auto &bind_data = (const ArrowScanFunctionData &)*bind_data_p;
-	if (bind_data.number_of_rows == 0) {
-		return 100;
-	}
-	auto percentage = bind_data.lines_read * 100.0 / bind_data.number_of_rows;
-	return percentage;
-}
-
-void ArrowTableFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunctionSet arrow("arrow_scan");
-	arrow.AddFunction(
-	    TableFunction({LogicalType::POINTER, LogicalType::POINTER, LogicalType::POINTER, LogicalType::UBIGINT},
-	                  ArrowScanFunction, ArrowScanBind, ArrowScanInit, nullptr, nullptr, nullptr, ArrowScanCardinality,
-	                  nullptr, nullptr, ArrowScanMaxThreads, ArrowScanInitParallelState, ArrowScanFunctionParallel,
-	                  ArrowScanParallelInit, ArrowScanParallelStateNext, true, true, ArrowProgress));
-	set.AddFunction(arrow);
-}
-
-void BuiltinFunctions::RegisterArrowFunctions() {
-	ArrowTableFunction::RegisterFunction(*this);
-}
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -105464,8 +105421,7 @@ static unique_ptr<FunctionData> CheckpointBind(ClientContext &context, TableFunc
 }
 
 template <bool FORCE>
-static void TemplatedCheckpointFunction(ClientContext &context, const FunctionData *bind_data_p,
-                                        FunctionOperatorData *operator_state, DataChunk &output) {
+static void TemplatedCheckpointFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &transaction_manager = TransactionManager::Get(context);
 	transaction_manager.Checkpoint(context, FORCE);
 }
@@ -105525,10 +105481,6 @@ struct ReadCSVData : public BaseCSVData {
 	//! The initial reader (if any): this is used when automatic detection is used during binding.
 	//! In this case, the CSV reader is already created and might as well be re-used.
 	unique_ptr<BufferedCSVReader> initial_reader;
-	//! Total File Size
-	atomic<idx_t> file_size;
-	//! How many bytes were read up to this point
-	atomic<idx_t> bytes_read;
 };
 
 struct CSVCopyFunction {
@@ -105965,23 +105917,20 @@ static unique_ptr<FunctionData> GlobFunctionBind(ClientContext &context, TableFu
 	return move(result);
 }
 
-struct GlobFunctionState : public FunctionOperatorData {
+struct GlobFunctionState : public GlobalTableFunctionState {
 	GlobFunctionState() : current_idx(0) {
 	}
 
 	idx_t current_idx;
 };
 
-static unique_ptr<FunctionOperatorData> GlobFunctionInit(ClientContext &context, const FunctionData *bind_data,
-                                                         const vector<column_t> &column_ids,
-                                                         TableFilterCollection *filters) {
+static unique_ptr<GlobalTableFunctionState> GlobFunctionInit(ClientContext &context, TableFunctionInitInput &input) {
 	return make_unique<GlobFunctionState>();
 }
 
-static void GlobFunction(ClientContext &context, const FunctionData *bind_data_p, FunctionOperatorData *state_p,
-                         DataChunk &output) {
-	auto &bind_data = (GlobFunctionBindData &)*bind_data_p;
-	auto &state = (GlobFunctionState &)*state_p;
+static void GlobFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &bind_data = (GlobFunctionBindData &)*data_p.bind_data;
+	auto &state = (GlobFunctionState &)*data_p.global_state;
 
 	idx_t count = 0;
 	idx_t next_idx = MinValue<idx_t>(state.current_idx + STANDARD_VECTOR_SIZE, bind_data.files.size());
@@ -106113,7 +106062,7 @@ struct TestAllTypesFun {
 
 namespace duckdb {
 
-struct PragmaDetailedProfilingOutputOperatorData : public FunctionOperatorData {
+struct PragmaDetailedProfilingOutputOperatorData : public GlobalTableFunctionState {
 	explicit PragmaDetailedProfilingOutputOperatorData() : chunk_index(0), initialized(false) {
 	}
 	idx_t chunk_index;
@@ -106160,10 +106109,8 @@ static unique_ptr<FunctionData> PragmaDetailedProfilingOutputBind(ClientContext
 	return make_unique<PragmaDetailedProfilingOutputData>(return_types);
 }
 
-unique_ptr<FunctionOperatorData> PragmaDetailedProfilingOutputInit(ClientContext &context,
-                                                                   const FunctionData *bind_data,
-                                                                   const vector<column_t> &column_ids,
-                                                                   TableFilterCollection *filters) {
+unique_ptr<GlobalTableFunctionState> PragmaDetailedProfilingOutputInit(ClientContext &context,
+                                                                       TableFunctionInitInput &input) {
 	return make_unique<PragmaDetailedProfilingOutputOperatorData>();
 }
 
@@ -106210,10 +106157,10 @@ static void ExtractFunctions(ChunkCollection &collection, ExpressionInfo &info,
 	}
 }
 
-static void PragmaDetailedProfilingOutputFunction(ClientContext &context, const FunctionData *bind_data_p,
-                                                  FunctionOperatorData *operator_state, DataChunk &output) {
-	auto &state = (PragmaDetailedProfilingOutputOperatorData &)*operator_state;
-	auto &data = (PragmaDetailedProfilingOutputData &)*bind_data_p;
+static void PragmaDetailedProfilingOutputFunction(ClientContext &context, TableFunctionInput &data_p,
+                                                  DataChunk &output) {
+	auto &state = (PragmaDetailedProfilingOutputOperatorData &)*data_p.global_state;
+	auto &data = (PragmaDetailedProfilingOutputData &)*data_p.bind_data;
 
 	if (!state.initialized) {
 		// create a ChunkCollection
@@ -106288,7 +106235,7 @@ void PragmaDetailedProfilingOutput::RegisterFunction(BuiltinFunctions &set) {
 
 namespace duckdb {
 
-struct PragmaLastProfilingOutputOperatorData : public FunctionOperatorData {
+struct PragmaLastProfilingOutputOperatorData : public GlobalTableFunctionState {
 	PragmaLastProfilingOutputOperatorData() : chunk_index(0), initialized(false) {
 	}
 	idx_t chunk_index;
@@ -106332,16 +106279,14 @@ static void SetValue(DataChunk &output, int index, int op_id, string name, doubl
 	output.SetValue(4, index, move(description));
 }
 
-unique_ptr<FunctionOperatorData> PragmaLastProfilingOutputInit(ClientContext &context, const FunctionData *bind_data,
-                                                               const vector<column_t> &column_ids,
-                                                               TableFilterCollection *filters) {
+unique_ptr<GlobalTableFunctionState> PragmaLastProfilingOutputInit(ClientContext &context,
+                                                                   TableFunctionInitInput &input) {
 	return make_unique<PragmaLastProfilingOutputOperatorData>();
 }
 
-static void PragmaLastProfilingOutputFunction(ClientContext &context, const FunctionData *bind_data_p,
-                                              FunctionOperatorData *operator_state, DataChunk &output) {
-	auto &state = (PragmaLastProfilingOutputOperatorData &)*operator_state;
-	auto &data = (PragmaLastProfilingOutputData &)*bind_data_p;
+static void PragmaLastProfilingOutputFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &state = (PragmaLastProfilingOutputOperatorData &)*data_p.global_state;
+	auto &data = (PragmaLastProfilingOutputData &)*data_p.bind_data;
 	if (!state.initialized) {
 		// create a ChunkCollection
 		auto collection = make_unique<ChunkCollection>();
@@ -106465,23 +106410,20 @@ static unique_ptr<FunctionData> RangeFunctionBind(ClientContext &context, TableF
 	return move(result);
 }
 
-struct RangeFunctionState : public FunctionOperatorData {
+struct RangeFunctionState : public GlobalTableFunctionState {
 	RangeFunctionState() : current_idx(0) {
 	}
 
 	int64_t current_idx;
 };
 
-static unique_ptr<FunctionOperatorData> RangeFunctionInit(ClientContext &context, const FunctionData *bind_data,
-                                                          const vector<column_t> &column_ids,
-                                                          TableFilterCollection *filters) {
+static unique_ptr<GlobalTableFunctionState> RangeFunctionInit(ClientContext &context, TableFunctionInitInput &input) {
 	return make_unique<RangeFunctionState>();
 }
 
-static void RangeFunction(ClientContext &context, const FunctionData *bind_data_p, FunctionOperatorData *state_p,
-                          DataChunk &output) {
-	auto &bind_data = (RangeFunctionBindData &)*bind_data_p;
-	auto &state = (RangeFunctionState &)*state_p;
+static void RangeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &bind_data = (RangeFunctionBindData &)*data_p.bind_data;
+	auto &state = (RangeFunctionState &)*data_p.global_state;
 
 	auto increment = bind_data.increment;
 	auto end = bind_data.end;
@@ -106587,7 +106529,7 @@ static unique_ptr<FunctionData> RangeDateTimeBind(ClientContext &context, TableF
 	return move(result);
 }
 
-struct RangeDateTimeState : public FunctionOperatorData {
+struct RangeDateTimeState : public GlobalTableFunctionState {
 	explicit RangeDateTimeState(timestamp_t start_p) : current_state(start_p) {
 	}
 
@@ -106595,17 +106537,14 @@ struct RangeDateTimeState : public FunctionOperatorData {
 	bool finished = false;
 };
 
-static unique_ptr<FunctionOperatorData> RangeDateTimeInit(ClientContext &context, const FunctionData *bind_data_p,
-                                                          const vector<column_t> &column_ids,
-                                                          TableFilterCollection *filters) {
-	auto &bind_data = (RangeDateTimeBindData &)*bind_data_p;
+static unique_ptr<GlobalTableFunctionState> RangeDateTimeInit(ClientContext &context, TableFunctionInitInput &input) {
+	auto &bind_data = (RangeDateTimeBindData &)*input.bind_data;
 	return make_unique<RangeDateTimeState>(bind_data.start);
 }
 
-static void RangeDateTimeFunction(ClientContext &context, const FunctionData *bind_data_p,
-                                  FunctionOperatorData *state_p, DataChunk &output) {
-	auto &bind_data = (RangeDateTimeBindData &)*bind_data_p;
-	auto &state = (RangeDateTimeState &)*state_p;
+static void RangeDateTimeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &bind_data = (RangeDateTimeBindData &)*data_p.bind_data;
+	auto &state = (RangeDateTimeState &)*data_p.global_state;
 	if (state.finished) {
 		return;
 	}
@@ -106630,29 +106569,29 @@ static void RangeDateTimeFunction(ClientContext &context, const FunctionData *bi
 void RangeTableFunction::RegisterFunction(BuiltinFunctions &set) {
 	TableFunctionSet range("range");
 
+	TableFunction range_function({LogicalType::BIGINT}, RangeFunction, RangeFunctionBind<false>, RangeFunctionInit);
+	range_function.cardinality = RangeCardinality;
+
 	// single argument range: (end) - implicit start = 0 and increment = 1
-	range.AddFunction(TableFunction({LogicalType::BIGINT}, RangeFunction, RangeFunctionBind<false>, RangeFunctionInit,
-	                                nullptr, nullptr, nullptr, RangeCardinality));
+	range.AddFunction(range_function);
 	// two arguments range: (start, end) - implicit increment = 1
-	range.AddFunction(TableFunction({LogicalType::BIGINT, LogicalType::BIGINT}, RangeFunction, RangeFunctionBind<false>,
-	                                RangeFunctionInit, nullptr, nullptr, nullptr, RangeCardinality));
+	range_function.arguments = {LogicalType::BIGINT, LogicalType::BIGINT};
+	range.AddFunction(range_function);
 	// three arguments range: (start, end, increment)
-	range.AddFunction(TableFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT}, RangeFunction,
-	                                RangeFunctionBind<false>, RangeFunctionInit, nullptr, nullptr, nullptr,
-	                                RangeCardinality));
+	range_function.arguments = {LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT};
+	range.AddFunction(range_function);
 	range.AddFunction(TableFunction({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP, LogicalType::INTERVAL},
 	                                RangeDateTimeFunction, RangeDateTimeBind<false>, RangeDateTimeInit));
 	set.AddFunction(range);
 	// generate_series: similar to range, but inclusive instead of exclusive bounds on the RHS
 	TableFunctionSet generate_series("generate_series");
-	generate_series.AddFunction(TableFunction({LogicalType::BIGINT}, RangeFunction, RangeFunctionBind<true>,
-	                                          RangeFunctionInit, nullptr, nullptr, nullptr, RangeCardinality));
-	generate_series.AddFunction(TableFunction({LogicalType::BIGINT, LogicalType::BIGINT}, RangeFunction,
-	                                          RangeFunctionBind<true>, RangeFunctionInit, nullptr, nullptr, nullptr,
-	                                          RangeCardinality));
-	generate_series.AddFunction(TableFunction({LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT},
-	                                          RangeFunction, RangeFunctionBind<true>, RangeFunctionInit, nullptr,
-	                                          nullptr, nullptr, RangeCardinality));
+	range_function.bind = RangeFunctionBind<true>;
+	range_function.arguments = {LogicalType::BIGINT};
+	generate_series.AddFunction(range_function);
+	range_function.arguments = {LogicalType::BIGINT, LogicalType::BIGINT};
+	generate_series.AddFunction(range_function);
+	range_function.arguments = {LogicalType::BIGINT, LogicalType::BIGINT, LogicalType::BIGINT};
+	generate_series.AddFunction(range_function);
 	generate_series.AddFunction(TableFunction({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP, LogicalType::INTERVAL},
 	                                          RangeDateTimeFunction, RangeDateTimeBind<true>, RangeDateTimeInit));
 	set.AddFunction(generate_series);
@@ -106757,17 +106696,19 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 	return move(result);
 }
 
-struct ReadCSVOperatorData : public FunctionOperatorData {
+struct ReadCSVOperatorData : public GlobalTableFunctionState {
 	//! The CSV reader
 	unique_ptr<BufferedCSVReader> csv_reader;
 	//! The index of the next file to read (i.e. current file + 1)
 	idx_t file_index;
+	//! Total File Size
+	idx_t file_size;
+	//! How many bytes were read up to this point
+	atomic<idx_t> bytes_read;
 };
 
-static unique_ptr<FunctionOperatorData> ReadCSVInit(ClientContext &context, const FunctionData *bind_data_p,
-                                                    const vector<column_t> &column_ids,
-                                                    TableFilterCollection *filters) {
-	auto &bind_data = (ReadCSVData &)*bind_data_p;
+static unique_ptr<GlobalTableFunctionState> ReadCSVInit(ClientContext &context, TableFunctionInitInput &input) {
+	auto &bind_data = (ReadCSVData &)*input.bind_data;
 	auto result = make_unique<ReadCSVOperatorData>();
 	if (bind_data.initial_reader) {
 		result->csv_reader = move(bind_data.initial_reader);
@@ -106775,8 +106716,7 @@ static unique_ptr<FunctionOperatorData> ReadCSVInit(ClientContext &context, cons
 		bind_data.options.file_path = bind_data.files[0];
 		result->csv_reader = make_unique<BufferedCSVReader>(context, bind_data.options, bind_data.sql_types);
 	}
-	bind_data.bytes_read = 0;
-	bind_data.file_size = result->csv_reader->GetFileSize();
+	result->file_size = result->csv_reader->GetFileSize();
 	result->file_index = 1;
 	return move(result);
 }
@@ -106787,13 +106727,12 @@ static unique_ptr<FunctionData> ReadCSVAutoBind(ClientContext &context, TableFun
 	return ReadCSVBind(context, input, return_types, names);
 }
 
-static void ReadCSVFunction(ClientContext &context, const FunctionData *bind_data_p,
-                            FunctionOperatorData *operator_state, DataChunk &output) {
-	auto &bind_data = (ReadCSVData &)*bind_data_p;
-	auto &data = (ReadCSVOperatorData &)*operator_state;
+static void ReadCSVFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &bind_data = (ReadCSVData &)*data_p.bind_data;
+	auto &data = (ReadCSVOperatorData &)*data_p.global_state;
 	do {
 		data.csv_reader->ParseCSV(output);
-		bind_data.bytes_read = data.csv_reader->bytes_in_chunk;
+		data.bytes_read = data.csv_reader->bytes_in_chunk;
 		if (output.size() == 0 && data.file_index < bind_data.files.size()) {
 			// exhausted this file, but we have more files we can read
 			// open the next file and increment the counter
@@ -106834,12 +106773,13 @@ static void ReadCSVAddNamedParameters(TableFunction &table_function) {
 	table_function.named_parameters["maximum_line_size"] = LogicalType::VARCHAR;
 }
 
-double CSVReaderProgress(ClientContext &context, const FunctionData *bind_data_p) {
-	auto &bind_data = (ReadCSVData &)*bind_data_p;
-	if (bind_data.file_size == 0) {
+double CSVReaderProgress(ClientContext &context, const FunctionData *bind_data_p,
+                         const GlobalTableFunctionState *global_state) {
+	auto &data = (const ReadCSVOperatorData &)*global_state;
+	if (data.file_size == 0) {
 		return 100;
 	}
-	auto percentage = (bind_data.bytes_read * 100.0) / bind_data.file_size;
+	auto percentage = (data.bytes_read * 100.0) / data.file_size;
 	return percentage;
 }
 
@@ -106900,7 +106840,7 @@ struct RepeatFunctionData : public TableFunctionData {
 	idx_t target_count;
 };
 
-struct RepeatOperatorData : public FunctionOperatorData {
+struct RepeatOperatorData : public GlobalTableFunctionState {
 	RepeatOperatorData() : current_count(0) {
 	}
 	idx_t current_count;
@@ -106915,15 +106855,13 @@ static unique_ptr<FunctionData> RepeatBind(ClientContext &context, TableFunction
 	return make_unique<RepeatFunctionData>(inputs[0], inputs[1].GetValue<int64_t>());
 }
 
-static unique_ptr<FunctionOperatorData> RepeatInit(ClientContext &context, const FunctionData *bind_data,
-                                                   const vector<column_t> &column_ids, TableFilterCollection *filters) {
+static unique_ptr<GlobalTableFunctionState> RepeatInit(ClientContext &context, TableFunctionInitInput &input) {
 	return make_unique<RepeatOperatorData>();
 }
 
-static void RepeatFunction(ClientContext &context, const FunctionData *bind_data_p,
-                           FunctionOperatorData *operator_state, DataChunk &output) {
-	auto &bind_data = (RepeatFunctionData &)*bind_data_p;
-	auto &state = (RepeatOperatorData &)*operator_state;
+static void RepeatFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &bind_data = (const RepeatFunctionData &)*data_p.bind_data;
+	auto &state = (RepeatOperatorData &)*data_p.global_state;
 
 	idx_t remaining = MinValue<idx_t>(bind_data.target_count - state.current_count, STANDARD_VECTOR_SIZE);
 	output.data[0].Reference(bind_data.value);
@@ -106932,13 +106870,13 @@ static void RepeatFunction(ClientContext &context, const FunctionData *bind_data
 }
 
 static unique_ptr<NodeStatistics> RepeatCardinality(ClientContext &context, const FunctionData *bind_data_p) {
-	auto &bind_data = (RepeatFunctionData &)*bind_data_p;
+	auto &bind_data = (const RepeatFunctionData &)*bind_data_p;
 	return make_unique<NodeStatistics>(bind_data.target_count, bind_data.target_count);
 }
 
 void RepeatTableFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunction repeat("repeat", {LogicalType::ANY, LogicalType::BIGINT}, RepeatFunction, RepeatBind, RepeatInit,
-	                     nullptr, nullptr, nullptr, RepeatCardinality);
+	TableFunction repeat("repeat", {LogicalType::ANY, LogicalType::BIGINT}, RepeatFunction, RepeatBind, RepeatInit);
+	repeat.cardinality = RepeatCardinality;
 	set.AddFunction(repeat);
 }
 
@@ -106966,8 +106904,8 @@ static unique_ptr<FunctionData> SummaryFunctionBind(ClientContext &context, Tabl
 	return make_unique<TableFunctionData>();
 }
 
-static OperatorResultType SummaryFunction(ClientContext &context, const FunctionData *bind_data_p,
-                                          FunctionOperatorData *state_p, DataChunk &input, DataChunk &output) {
+static OperatorResultType SummaryFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &input,
+                                          DataChunk &output) {
 	output.SetCardinality(input.size());
 
 	for (idx_t row_idx = 0; row_idx < input.size(); row_idx++) {
@@ -107009,7 +106947,7 @@ void SummaryTableFunction::RegisterFunction(BuiltinFunctions &set) {
 
 namespace duckdb {
 
-struct DuckDBColumnsData : public FunctionOperatorData {
+struct DuckDBColumnsData : public GlobalTableFunctionState {
 	DuckDBColumnsData() : offset(0), column_offset(0) {
 	}
 
@@ -107068,8 +107006,7 @@ static unique_ptr<FunctionData> DuckDBColumnsBind(ClientContext &context, TableF
 	return nullptr;
 }
 
-unique_ptr<FunctionOperatorData> DuckDBColumnsInit(ClientContext &context, const FunctionData *bind_data,
-                                                   const vector<column_t> &column_ids, TableFilterCollection *filters) {
+unique_ptr<GlobalTableFunctionState> DuckDBColumnsInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_unique<DuckDBColumnsData>();
 
 	// scan all the schemas for tables and views and collect them
@@ -107084,8 +107021,6 @@ unique_ptr<FunctionOperatorData> DuckDBColumnsInit(ClientContext &context, const
 	return move(result);
 }
 
-namespace { // anonymous namespace for the ColumnHelper classes for working with tables/views
-
 class ColumnHelper {
 public:
 	static unique_ptr<ColumnHelper> Create(CatalogEntry *entry);
@@ -107275,11 +107210,8 @@ void ColumnHelper::WriteColumns(idx_t start_index, idx_t start_col, idx_t end_co
 	}
 }
 
-} // anonymous namespace
-
-void DuckDBColumnsFunction(ClientContext &context, const FunctionData *bind_data, FunctionOperatorData *operator_state,
-                           DataChunk &output) {
-	auto &data = (DuckDBColumnsData &)*operator_state;
+void DuckDBColumnsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = (DuckDBColumnsData &)*data_p.global_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -107343,7 +107275,7 @@ void DuckDBColumnsFun::RegisterFunction(BuiltinFunctions &set) {
 
 namespace duckdb {
 
-struct DuckDBConstraintsData : public FunctionOperatorData {
+struct DuckDBConstraintsData : public GlobalTableFunctionState {
 	DuckDBConstraintsData() : offset(0), constraint_offset(0) {
 	}
 
@@ -107389,9 +107321,7 @@ static unique_ptr<FunctionData> DuckDBConstraintsBind(ClientContext &context, Ta
 	return nullptr;
 }
 
-unique_ptr<FunctionOperatorData> DuckDBConstraintsInit(ClientContext &context, const FunctionData *bind_data,
-                                                       const vector<column_t> &column_ids,
-                                                       TableFilterCollection *filters) {
+unique_ptr<GlobalTableFunctionState> DuckDBConstraintsInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_unique<DuckDBConstraintsData>();
 
 	// scan all the schemas for tables and collect themand collect them
@@ -107406,9 +107336,8 @@ unique_ptr<FunctionOperatorData> DuckDBConstraintsInit(ClientContext &context, c
 	return move(result);
 }
 
-void DuckDBConstraintsFunction(ClientContext &context, const FunctionData *bind_data,
-                               FunctionOperatorData *operator_state, DataChunk &output) {
-	auto &data = (DuckDBConstraintsData &)*operator_state;
+void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = (DuckDBConstraintsData &)*data_p.global_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -107551,7 +107480,7 @@ struct DependencyInformation {
 	DependencyType type;
 };
 
-struct DuckDBDependenciesData : public FunctionOperatorData {
+struct DuckDBDependenciesData : public GlobalTableFunctionState {
 	DuckDBDependenciesData() : offset(0) {
 	}
 
@@ -107585,9 +107514,7 @@ static unique_ptr<FunctionData> DuckDBDependenciesBind(ClientContext &context, T
 	return nullptr;
 }
 
-unique_ptr<FunctionOperatorData> DuckDBDependenciesInit(ClientContext &context, const FunctionData *bind_data,
-                                                        const vector<column_t> &column_ids,
-                                                        TableFilterCollection *filters) {
+unique_ptr<GlobalTableFunctionState> DuckDBDependenciesInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_unique<DuckDBDependenciesData>();
 
 	// scan all the schemas and collect them
@@ -107604,9 +107531,8 @@ unique_ptr<FunctionOperatorData> DuckDBDependenciesInit(ClientContext &context,
 	return move(result);
 }
 
-void DuckDBDependenciesFunction(ClientContext &context, const FunctionData *bind_data,
-                                FunctionOperatorData *operator_state, DataChunk &output) {
-	auto &data = (DuckDBDependenciesData &)*operator_state;
+void DuckDBDependenciesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = (DuckDBDependenciesData &)*data_p.global_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -107675,7 +107601,7 @@ void DuckDBDependenciesFun::RegisterFunction(BuiltinFunctions &set) {
 
 namespace duckdb {
 
-struct DuckDBFunctionsData : public FunctionOperatorData {
+struct DuckDBFunctionsData : public GlobalTableFunctionState {
 	DuckDBFunctionsData() : offset(0), offset_in_entry(0) {
 	}
 
@@ -107729,9 +107655,7 @@ static void ExtractFunctionsFromSchema(ClientContext &context, SchemaCatalogEntr
 	            [&](CatalogEntry *entry) { result.entries.push_back(entry); });
 }
 
-unique_ptr<FunctionOperatorData> DuckDBFunctionsInit(ClientContext &context, const FunctionData *bind_data,
-                                                     const vector<column_t> &column_ids,
-                                                     TableFilterCollection *filters) {
+unique_ptr<GlobalTableFunctionState> DuckDBFunctionsInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_unique<DuckDBFunctionsData>();
 
 	// scan all the schemas for tables and collect themand collect them
@@ -108100,9 +108024,8 @@ bool ExtractFunctionData(StandardEntry *entry, idx_t function_idx, DataChunk &ou
 	return function_idx + 1 == OP::FunctionCount(function);
 }
 
-void DuckDBFunctionsFunction(ClientContext &context, const FunctionData *bind_data,
-                             FunctionOperatorData *operator_state, DataChunk &output) {
-	auto &data = (DuckDBFunctionsData &)*operator_state;
+void DuckDBFunctionsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = (DuckDBFunctionsData &)*data_p.global_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -108175,7 +108098,7 @@ void DuckDBFunctionsFun::RegisterFunction(BuiltinFunctions &set) {
 
 namespace duckdb {
 
-struct DuckDBIndexesData : public FunctionOperatorData {
+struct DuckDBIndexesData : public GlobalTableFunctionState {
 	DuckDBIndexesData() : offset(0) {
 	}
 
@@ -108218,8 +108141,7 @@ static unique_ptr<FunctionData> DuckDBIndexesBind(ClientContext &context, TableF
 	return nullptr;
 }
 
-unique_ptr<FunctionOperatorData> DuckDBIndexesInit(ClientContext &context, const FunctionData *bind_data,
-                                                   const vector<column_t> &column_ids, TableFilterCollection *filters) {
+unique_ptr<GlobalTableFunctionState> DuckDBIndexesInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_unique<DuckDBIndexesData>();
 
 	// scan all the schemas for tables and collect themand collect them
@@ -108234,9 +108156,8 @@ unique_ptr<FunctionOperatorData> DuckDBIndexesInit(ClientContext &context, const
 	return move(result);
 }
 
-void DuckDBIndexesFunction(ClientContext &context, const FunctionData *bind_data, FunctionOperatorData *operator_state,
-                           DataChunk &output) {
-	auto &data = (DuckDBIndexesData &)*operator_state;
+void DuckDBIndexesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = (DuckDBIndexesData &)*data_p.global_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -108292,7 +108213,7 @@ void DuckDBIndexesFun::RegisterFunction(BuiltinFunctions &set) {
 
 namespace duckdb {
 
-struct DuckDBKeywordsData : public FunctionOperatorData {
+struct DuckDBKeywordsData : public GlobalTableFunctionState {
 	DuckDBKeywordsData() : offset(0) {
 	}
 
@@ -108311,17 +108232,14 @@ static unique_ptr<FunctionData> DuckDBKeywordsBind(ClientContext &context, Table
 	return nullptr;
 }
 
-unique_ptr<FunctionOperatorData> DuckDBKeywordsInit(ClientContext &context, const FunctionData *bind_data,
-                                                    const vector<column_t> &column_ids,
-                                                    TableFilterCollection *filters) {
+unique_ptr<GlobalTableFunctionState> DuckDBKeywordsInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_unique<DuckDBKeywordsData>();
 	result->entries = Parser::KeywordList();
 	return move(result);
 }
 
-void DuckDBKeywordsFunction(ClientContext &context, const FunctionData *bind_data, FunctionOperatorData *operator_state,
-                            DataChunk &output) {
-	auto &data = (DuckDBKeywordsData &)*operator_state;
+void DuckDBKeywordsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = (DuckDBKeywordsData &)*data_p.global_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -108375,7 +108293,7 @@ void DuckDBKeywordsFun::RegisterFunction(BuiltinFunctions &set) {
 
 namespace duckdb {
 
-struct DuckDBSchemasData : public FunctionOperatorData {
+struct DuckDBSchemasData : public GlobalTableFunctionState {
 	DuckDBSchemasData() : offset(0) {
 	}
 
@@ -108400,8 +108318,7 @@ static unique_ptr<FunctionData> DuckDBSchemasBind(ClientContext &context, TableF
 	return nullptr;
 }
 
-unique_ptr<FunctionOperatorData> DuckDBSchemasInit(ClientContext &context, const FunctionData *bind_data,
-                                                   const vector<column_t> &column_ids, TableFilterCollection *filters) {
+unique_ptr<GlobalTableFunctionState> DuckDBSchemasInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_unique<DuckDBSchemasData>();
 
 	// scan all the schemas and collect them
@@ -108413,9 +108330,8 @@ unique_ptr<FunctionOperatorData> DuckDBSchemasInit(ClientContext &context, const
 	return move(result);
 }
 
-void DuckDBSchemasFunction(ClientContext &context, const FunctionData *bind_data, FunctionOperatorData *operator_state,
-                           DataChunk &output) {
-	auto &data = (DuckDBSchemasData &)*operator_state;
+void DuckDBSchemasFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = (DuckDBSchemasData &)*data_p.global_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -108458,7 +108374,7 @@ void DuckDBSchemasFun::RegisterFunction(BuiltinFunctions &set) {
 
 namespace duckdb {
 
-struct DuckDBSequencesData : public FunctionOperatorData {
+struct DuckDBSequencesData : public GlobalTableFunctionState {
 	DuckDBSequencesData() : offset(0) {
 	}
 
@@ -108507,9 +108423,7 @@ static unique_ptr<FunctionData> DuckDBSequencesBind(ClientContext &context, Tabl
 	return nullptr;
 }
 
-unique_ptr<FunctionOperatorData> DuckDBSequencesInit(ClientContext &context, const FunctionData *bind_data,
-                                                     const vector<column_t> &column_ids,
-                                                     TableFilterCollection *filters) {
+unique_ptr<GlobalTableFunctionState> DuckDBSequencesInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_unique<DuckDBSequencesData>();
 
 	// scan all the schemas for tables and collect themand collect them
@@ -108525,9 +108439,8 @@ unique_ptr<FunctionOperatorData> DuckDBSequencesInit(ClientContext &context, con
 	return move(result);
 }
 
-void DuckDBSequencesFunction(ClientContext &context, const FunctionData *bind_data,
-                             FunctionOperatorData *operator_state, DataChunk &output) {
-	auto &data = (DuckDBSequencesData &)*operator_state;
+void DuckDBSequencesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = (DuckDBSequencesData &)*data_p.global_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -108590,7 +108503,7 @@ struct DuckDBSettingValue {
 	string input_type;
 };
 
-struct DuckDBSettingsData : public FunctionOperatorData {
+struct DuckDBSettingsData : public GlobalTableFunctionState {
 	DuckDBSettingsData() : offset(0) {
 	}
 
@@ -108615,9 +108528,7 @@ static unique_ptr<FunctionData> DuckDBSettingsBind(ClientContext &context, Table
 	return nullptr;
 }
 
-unique_ptr<FunctionOperatorData> DuckDBSettingsInit(ClientContext &context, const FunctionData *bind_data,
-                                                    const vector<column_t> &column_ids,
-                                                    TableFilterCollection *filters) {
+unique_ptr<GlobalTableFunctionState> DuckDBSettingsInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_unique<DuckDBSettingsData>();
 
 	auto &config = DBConfig::GetConfig(context);
@@ -108650,9 +108561,8 @@ unique_ptr<FunctionOperatorData> DuckDBSettingsInit(ClientContext &context, cons
 	return move(result);
 }
 
-void DuckDBSettingsFunction(ClientContext &context, const FunctionData *bind_data, FunctionOperatorData *operator_state,
-                            DataChunk &output) {
-	auto &data = (DuckDBSettingsData &)*operator_state;
+void DuckDBSettingsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = (DuckDBSettingsData &)*data_p.global_state;
 	if (data.offset >= data.settings.size()) {
 		// finished returning values
 		return;
@@ -108697,7 +108607,7 @@ void DuckDBSettingsFun::RegisterFunction(BuiltinFunctions &set) {
 
 namespace duckdb {
 
-struct DuckDBTablesData : public FunctionOperatorData {
+struct DuckDBTablesData : public GlobalTableFunctionState {
 	DuckDBTablesData() : offset(0) {
 	}
 
@@ -108746,8 +108656,7 @@ static unique_ptr<FunctionData> DuckDBTablesBind(ClientContext &context, TableFu
 	return nullptr;
 }
 
-unique_ptr<FunctionOperatorData> DuckDBTablesInit(ClientContext &context, const FunctionData *bind_data,
-                                                  const vector<column_t> &column_ids, TableFilterCollection *filters) {
+unique_ptr<GlobalTableFunctionState> DuckDBTablesInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_unique<DuckDBTablesData>();
 
 	// scan all the schemas for tables and collect themand collect them
@@ -108784,9 +108693,8 @@ static idx_t CheckConstraintCount(TableCatalogEntry &table) {
 	return check_count;
 }
 
-void DuckDBTablesFunction(ClientContext &context, const FunctionData *bind_data, FunctionOperatorData *operator_state,
-                          DataChunk &output) {
-	auto &data = (DuckDBTablesData &)*operator_state;
+void DuckDBTablesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = (DuckDBTablesData &)*data_p.global_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -108848,7 +108756,7 @@ void DuckDBTablesFun::RegisterFunction(BuiltinFunctions &set) {
 
 namespace duckdb {
 
-struct DuckDBTypesData : public FunctionOperatorData {
+struct DuckDBTypesData : public GlobalTableFunctionState {
 	DuckDBTypesData() : offset(0) {
 	}
 
@@ -108887,8 +108795,7 @@ static unique_ptr<FunctionData> DuckDBTypesBind(ClientContext &context, TableFun
 	return nullptr;
 }
 
-unique_ptr<FunctionOperatorData> DuckDBTypesInit(ClientContext &context, const FunctionData *bind_data,
-                                                 const vector<column_t> &column_ids, TableFilterCollection *filters) {
+unique_ptr<GlobalTableFunctionState> DuckDBTypesInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_unique<DuckDBTypesData>();
 	auto schemas = Catalog::GetCatalog(context).schemas->GetEntries<SchemaCatalogEntry>(context);
 	for (auto &schema : schemas) {
@@ -108903,9 +108810,8 @@ unique_ptr<FunctionOperatorData> DuckDBTypesInit(ClientContext &context, const F
 	return move(result);
 }
 
-void DuckDBTypesFunction(ClientContext &context, const FunctionData *bind_data, FunctionOperatorData *operator_state,
-                         DataChunk &output) {
-	auto &data = (DuckDBTypesData &)*operator_state;
+void DuckDBTypesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = (DuckDBTypesData &)*data_p.global_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -109013,7 +108919,7 @@ void DuckDBTypesFun::RegisterFunction(BuiltinFunctions &set) {
 
 namespace duckdb {
 
-struct DuckDBViewsData : public FunctionOperatorData {
+struct DuckDBViewsData : public GlobalTableFunctionState {
 	DuckDBViewsData() : offset(0) {
 	}
 
@@ -109050,8 +108956,7 @@ static unique_ptr<FunctionData> DuckDBViewsBind(ClientContext &context, TableFun
 	return nullptr;
 }
 
-unique_ptr<FunctionOperatorData> DuckDBViewsInit(ClientContext &context, const FunctionData *bind_data,
-                                                 const vector<column_t> &column_ids, TableFilterCollection *filters) {
+unique_ptr<GlobalTableFunctionState> DuckDBViewsInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_unique<DuckDBViewsData>();
 
 	// scan all the schemas for tables and collect themand collect them
@@ -109066,9 +108971,8 @@ unique_ptr<FunctionOperatorData> DuckDBViewsInit(ClientContext &context, const F
 	return move(result);
 }
 
-void DuckDBViewsFunction(ClientContext &context, const FunctionData *bind_data, FunctionOperatorData *operator_state,
-                         DataChunk &output) {
-	auto &data = (DuckDBViewsData &)*operator_state;
+void DuckDBViewsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = (DuckDBViewsData &)*data_p.global_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -109121,7 +109025,7 @@ void DuckDBViewsFun::RegisterFunction(BuiltinFunctions &set) {
 
 namespace duckdb {
 
-struct PragmaCollateData : public FunctionOperatorData {
+struct PragmaCollateData : public GlobalTableFunctionState {
 	PragmaCollateData() : offset(0) {
 	}
 
@@ -109137,8 +109041,7 @@ static unique_ptr<FunctionData> PragmaCollateBind(ClientContext &context, TableF
 	return nullptr;
 }
 
-unique_ptr<FunctionOperatorData> PragmaCollateInit(ClientContext &context, const FunctionData *bind_data,
-                                                   const vector<column_t> &column_ids, TableFilterCollection *filters) {
+unique_ptr<GlobalTableFunctionState> PragmaCollateInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_unique<PragmaCollateData>();
 
 	Catalog::GetCatalog(context).schemas->Scan(context, [&](CatalogEntry *entry) {
@@ -109150,9 +109053,8 @@ unique_ptr<FunctionOperatorData> PragmaCollateInit(ClientContext &context, const
 	return move(result);
 }
 
-static void PragmaCollateFunction(ClientContext &context, const FunctionData *bind_data,
-                                  FunctionOperatorData *operator_state, DataChunk &output) {
-	auto &data = (PragmaCollateData &)*operator_state;
+static void PragmaCollateFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = (PragmaCollateData &)*data_p.global_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -109179,7 +109081,7 @@ void PragmaCollations::RegisterFunction(BuiltinFunctions &set) {
 
 namespace duckdb {
 
-struct PragmaDatabaseListData : public FunctionOperatorData {
+struct PragmaDatabaseListData : public GlobalTableFunctionState {
 	PragmaDatabaseListData() : finished(false) {
 	}
 
@@ -109200,15 +109102,12 @@ static unique_ptr<FunctionData> PragmaDatabaseListBind(ClientContext &context, T
 	return nullptr;
 }
 
-unique_ptr<FunctionOperatorData> PragmaDatabaseListInit(ClientContext &context, const FunctionData *bind_data,
-                                                        const vector<column_t> &column_ids,
-                                                        TableFilterCollection *filters) {
+unique_ptr<GlobalTableFunctionState> PragmaDatabaseListInit(ClientContext &context, TableFunctionInitInput &input) {
 	return make_unique<PragmaDatabaseListData>();
 }
 
-void PragmaDatabaseListFunction(ClientContext &context, const FunctionData *bind_data,
-                                FunctionOperatorData *operator_state, DataChunk &output) {
-	auto &data = (PragmaDatabaseListData &)*operator_state;
+void PragmaDatabaseListFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = (PragmaDatabaseListData &)*data_p.global_state;
 	if (data.finished) {
 		return;
 	}
@@ -109237,7 +109136,7 @@ void PragmaDatabaseList::RegisterFunction(BuiltinFunctions &set) {
 
 namespace duckdb {
 
-struct PragmaDatabaseSizeData : public FunctionOperatorData {
+struct PragmaDatabaseSizeData : public GlobalTableFunctionState {
 	PragmaDatabaseSizeData() : finished(false) {
 	}
 
@@ -109273,15 +109172,12 @@ static unique_ptr<FunctionData> PragmaDatabaseSizeBind(ClientContext &context, T
 	return nullptr;
 }
 
-unique_ptr<FunctionOperatorData> PragmaDatabaseSizeInit(ClientContext &context, const FunctionData *bind_data,
-                                                        const vector<column_t> &column_ids,
-                                                        TableFilterCollection *filters) {
+unique_ptr<GlobalTableFunctionState> PragmaDatabaseSizeInit(ClientContext &context, TableFunctionInitInput &input) {
 	return make_unique<PragmaDatabaseSizeData>();
 }
 
-void PragmaDatabaseSizeFunction(ClientContext &context, const FunctionData *bind_data,
-                                FunctionOperatorData *operator_state, DataChunk &output) {
-	auto &data = (PragmaDatabaseSizeData &)*operator_state;
+void PragmaDatabaseSizeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = (PragmaDatabaseSizeData &)*data_p.global_state;
 	if (data.finished) {
 		return;
 	}
@@ -109337,7 +109233,7 @@ void PragmaDatabaseSize::RegisterFunction(BuiltinFunctions &set) {
 
 namespace duckdb {
 
-struct PragmaFunctionsData : public FunctionOperatorData {
+struct PragmaFunctionsData : public GlobalTableFunctionState {
 	PragmaFunctionsData() : offset(0), offset_in_entry(0) {
 	}
 
@@ -109369,9 +109265,7 @@ static unique_ptr<FunctionData> PragmaFunctionsBind(ClientContext &context, Tabl
 	return nullptr;
 }
 
-unique_ptr<FunctionOperatorData> PragmaFunctionsInit(ClientContext &context, const FunctionData *bind_data,
-                                                     const vector<column_t> &column_ids,
-                                                     TableFilterCollection *filters) {
+unique_ptr<GlobalTableFunctionState> PragmaFunctionsInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_unique<PragmaFunctionsData>();
 
 	Catalog::GetCatalog(context).schemas->Scan(context, [&](CatalogEntry *entry) {
@@ -109402,9 +109296,8 @@ void AddFunction(BaseScalarFunction &f, idx_t &count, DataChunk &output, bool is
 	count++;
 }
 
-static void PragmaFunctionsFunction(ClientContext &context, const FunctionData *bind_data,
-                                    FunctionOperatorData *operator_state, DataChunk &output) {
-	auto &data = (PragmaFunctionsData &)*operator_state;
+static void PragmaFunctionsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = (PragmaFunctionsData &)*data_p.global_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -109472,7 +109365,7 @@ struct PragmaStorageFunctionData : public TableFunctionData {
 	vector<vector<Value>> storage_info;
 };
 
-struct PragmaStorageOperatorData : public FunctionOperatorData {
+struct PragmaStorageOperatorData : public GlobalTableFunctionState {
 	PragmaStorageOperatorData() : offset(0) {
 	}
 
@@ -109538,16 +109431,13 @@ static unique_ptr<FunctionData> PragmaStorageInfoBind(ClientContext &context, Ta
 	return move(result);
 }
 
-unique_ptr<FunctionOperatorData> PragmaStorageInfoInit(ClientContext &context, const FunctionData *bind_data,
-                                                       const vector<column_t> &column_ids,
-                                                       TableFilterCollection *filters) {
+unique_ptr<GlobalTableFunctionState> PragmaStorageInfoInit(ClientContext &context, TableFunctionInitInput &input) {
 	return make_unique<PragmaStorageOperatorData>();
 }
 
-static void PragmaStorageInfoFunction(ClientContext &context, const FunctionData *bind_data_p,
-                                      FunctionOperatorData *operator_state, DataChunk &output) {
-	auto &bind_data = (PragmaStorageFunctionData &)*bind_data_p;
-	auto &data = (PragmaStorageOperatorData &)*operator_state;
+static void PragmaStorageInfoFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &bind_data = (PragmaStorageFunctionData &)*data_p.bind_data;
+	auto &data = (PragmaStorageOperatorData &)*data_p.global_state;
 	idx_t count = 0;
 	while (data.offset < bind_data.storage_info.size() && count < STANDARD_VECTOR_SIZE) {
 		auto &entry = bind_data.storage_info[data.offset++];
@@ -109597,7 +109487,7 @@ struct PragmaTableFunctionData : public TableFunctionData {
 	CatalogEntry *entry;
 };
 
-struct PragmaTableOperatorData : public FunctionOperatorData {
+struct PragmaTableOperatorData : public GlobalTableFunctionState {
 	PragmaTableOperatorData() : offset(0) {
 	}
 	idx_t offset;
@@ -109631,9 +109521,7 @@ static unique_ptr<FunctionData> PragmaTableInfoBind(ClientContext &context, Tabl
 	return make_unique<PragmaTableFunctionData>(entry);
 }
 
-unique_ptr<FunctionOperatorData> PragmaTableInfoInit(ClientContext &context, const FunctionData *bind_data,
-                                                     const vector<column_t> &column_ids,
-                                                     TableFilterCollection *filters) {
+unique_ptr<GlobalTableFunctionState> PragmaTableInfoInit(ClientContext &context, TableFunctionInitInput &input) {
 	return make_unique<PragmaTableOperatorData>();
 }
 
@@ -109731,10 +109619,9 @@ static void PragmaTableInfoView(PragmaTableOperatorData &data, ViewCatalogEntry
 	data.offset = next;
 }
 
-static void PragmaTableInfoFunction(ClientContext &context, const FunctionData *bind_data_p,
-                                    FunctionOperatorData *operator_state, DataChunk &output) {
-	auto &bind_data = (PragmaTableFunctionData &)*bind_data_p;
-	auto &state = (PragmaTableOperatorData &)*operator_state;
+static void PragmaTableInfoFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &bind_data = (PragmaTableFunctionData &)*data_p.bind_data;
+	auto &state = (PragmaTableOperatorData &)*data_p.global_state;
 	switch (bind_data.entry->type) {
 	case CatalogType::TABLE_ENTRY:
 		PragmaTableInfoTable(state, (TableCatalogEntry *)bind_data.entry, output);
@@ -109762,7 +109649,7 @@ void PragmaTableInfo::RegisterFunction(BuiltinFunctions &set) {
 
 namespace duckdb {
 
-struct TestAllTypesData : public FunctionOperatorData {
+struct TestAllTypesData : public GlobalTableFunctionState {
 	TestAllTypesData() : offset(0) {
 	}
 
@@ -109964,8 +109851,7 @@ static unique_ptr<FunctionData> TestAllTypesBind(ClientContext &context, TableFu
 	return nullptr;
 }
 
-unique_ptr<FunctionOperatorData> TestAllTypesInit(ClientContext &context, const FunctionData *bind_data,
-                                                  const vector<column_t> &column_ids, TableFilterCollection *filters) {
+unique_ptr<GlobalTableFunctionState> TestAllTypesInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_unique<TestAllTypesData>();
 	auto test_types = GetTestTypes();
 	// 3 rows: min, max and NULL
@@ -109979,9 +109865,8 @@ unique_ptr<FunctionOperatorData> TestAllTypesInit(ClientContext &context, const
 	return move(result);
 }
 
-void TestAllTypesFunction(ClientContext &context, const FunctionData *bind_data, FunctionOperatorData *operator_state,
-                          DataChunk &output) {
-	auto &data = (TestAllTypesData &)*operator_state;
+void TestAllTypesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = (TestAllTypesData &)*data_p.global_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;
@@ -110139,31 +110024,50 @@ void BuiltinFunctions::RegisterSQLiteFunctions() {
 
 
 
-
 namespace duckdb {
 
 //===--------------------------------------------------------------------===//
 // Table Scan
 //===--------------------------------------------------------------------===//
-bool TableScanParallelStateNext(ClientContext &context, const FunctionData *bind_data,
-                                FunctionOperatorData *operator_state, ParallelState *parallel_state_p);
+bool TableScanParallelStateNext(ClientContext &context, const FunctionData *bind_data_p,
+                                LocalTableFunctionState *local_state, GlobalTableFunctionState *gstate);
 
-struct TableScanOperatorData : public FunctionOperatorData {
+struct TableScanLocalState : public LocalTableFunctionState {
 	//! The current position in the scan
 	TableScanState scan_state;
 	vector<column_t> column_ids;
 };
 
-static unique_ptr<FunctionOperatorData> TableScanInit(ClientContext &context, const FunctionData *bind_data_p,
-                                                      const vector<column_t> &column_ids,
-                                                      TableFilterCollection *filters) {
-	auto result = make_unique<TableScanOperatorData>();
-	auto &transaction = Transaction::GetTransaction(context);
-	auto &bind_data = (const TableScanBindData &)*bind_data_p;
-	result->column_ids = column_ids;
-	result->scan_state.table_filters = filters->table_filters;
-	bind_data.table->storage->InitializeScan(transaction, result->scan_state, result->column_ids,
-	                                         filters->table_filters);
+struct TableScanGlobalState : public GlobalTableFunctionState {
+	TableScanGlobalState(ClientContext &context, const FunctionData *bind_data_p) {
+		D_ASSERT(bind_data_p);
+		auto &bind_data = (const TableScanBindData &)*bind_data_p;
+		max_threads = bind_data.table->storage->MaxThreads(context);
+	}
+
+	ParallelTableScanState state;
+	mutex lock;
+	idx_t max_threads;
+
+	idx_t MaxThreads() const override {
+		return max_threads;
+	}
+};
+
+static unique_ptr<LocalTableFunctionState> TableScanInitLocal(ClientContext &context, TableFunctionInitInput &input,
+                                                              GlobalTableFunctionState *gstate) {
+	auto result = make_unique<TableScanLocalState>();
+	result->column_ids = input.column_ids;
+	result->scan_state.table_filters = input.filters;
+	TableScanParallelStateNext(context, input.bind_data, result.get(), gstate);
+	return move(result);
+}
+
+unique_ptr<GlobalTableFunctionState> TableScanInitGlobal(ClientContext &context, TableFunctionInitInput &input) {
+	D_ASSERT(input.bind_data);
+	auto &bind_data = (const TableScanBindData &)*input.bind_data;
+	auto result = make_unique<TableScanGlobalState>(context, input.bind_data);
+	bind_data.table->storage->InitializeParallelScan(context, result->state);
 	return move(result);
 }
 
@@ -110178,63 +110082,34 @@ static unique_ptr<BaseStatistics> TableScanStatistics(ClientContext &context, co
 	return bind_data.table->storage->GetStatistics(context, column_id);
 }
 
-static unique_ptr<FunctionOperatorData> TableScanParallelInit(ClientContext &context, const FunctionData *bind_data_p,
-                                                              ParallelState *state, const vector<column_t> &column_ids,
-                                                              TableFilterCollection *filters) {
-	auto result = make_unique<TableScanOperatorData>();
-	result->column_ids = column_ids;
-	result->scan_state.table_filters = filters->table_filters;
-	TableScanParallelStateNext(context, bind_data_p, result.get(), state);
-	return move(result);
-}
-
-static void TableScanFunc(ClientContext &context, const FunctionData *bind_data_p, FunctionOperatorData *operator_state,
-                          DataChunk &output) {
-	D_ASSERT(bind_data_p);
-	D_ASSERT(operator_state);
-	auto &bind_data = (TableScanBindData &)*bind_data_p;
-	auto &state = (TableScanOperatorData &)*operator_state;
+static void TableScanFunc(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &bind_data = (TableScanBindData &)*data_p.bind_data;
+	auto &state = (TableScanLocalState &)*data_p.local_state;
 	auto &transaction = Transaction::GetTransaction(context);
-	bind_data.table->storage->Scan(transaction, output, state.scan_state, state.column_ids);
-	bind_data.chunk_count++;
-}
-
-struct ParallelTableFunctionScanState : public ParallelState {
-	ParallelTableScanState state;
-	mutex lock;
-};
-
-idx_t TableScanMaxThreads(ClientContext &context, const FunctionData *bind_data_p) {
-	D_ASSERT(bind_data_p);
-	auto &bind_data = (const TableScanBindData &)*bind_data_p;
-	return bind_data.table->storage->MaxThreads(context);
-}
-
-unique_ptr<ParallelState> TableScanInitParallelState(ClientContext &context, const FunctionData *bind_data_p,
-                                                     const vector<column_t> &column_ids,
-                                                     TableFilterCollection *filters) {
-	D_ASSERT(bind_data_p);
-	auto &bind_data = (const TableScanBindData &)*bind_data_p;
-	auto result = make_unique<ParallelTableFunctionScanState>();
-	bind_data.table->storage->InitializeParallelScan(context, result->state);
-	return move(result);
+	do {
+		bind_data.table->storage->Scan(transaction, output, state.scan_state, state.column_ids);
+		if (output.size() > 0) {
+			return;
+		}
+		if (!TableScanParallelStateNext(context, data_p.bind_data, data_p.local_state, data_p.global_state)) {
+			return;
+		}
+	} while (true);
 }
 
 bool TableScanParallelStateNext(ClientContext &context, const FunctionData *bind_data_p,
-                                FunctionOperatorData *operator_state, ParallelState *parallel_state_p) {
-	D_ASSERT(bind_data_p);
-	D_ASSERT(parallel_state_p);
-	D_ASSERT(operator_state);
+                                LocalTableFunctionState *local_state, GlobalTableFunctionState *global_state) {
 	auto &bind_data = (const TableScanBindData &)*bind_data_p;
-	auto &parallel_state = (ParallelTableFunctionScanState &)*parallel_state_p;
-	auto &state = (TableScanOperatorData &)*operator_state;
+	auto &parallel_state = (TableScanGlobalState &)*global_state;
+	auto &state = (TableScanLocalState &)*local_state;
 
 	lock_guard<mutex> parallel_lock(parallel_state.lock);
 	return bind_data.table->storage->NextParallelScan(context, parallel_state.state, state.scan_state,
 	                                                  state.column_ids);
 }
 
-double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p) {
+double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p,
+                         const GlobalTableFunctionState *gstate) {
 	auto &bind_data = (TableScanBindData &)*bind_data_p;
 	idx_t total_rows = bind_data.table->storage->GetTotalRows();
 	if (total_rows == 0 || total_rows < STANDARD_VECTOR_SIZE) {
@@ -110251,9 +110126,9 @@ double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p
 }
 
 idx_t TableScanGetBatchIndex(ClientContext &context, const FunctionData *bind_data_p,
-                             FunctionOperatorData *operator_state, ParallelState *parallel_state_p) {
+                             LocalTableFunctionState *local_state, GlobalTableFunctionState *global_state) {
 	auto &bind_data = (const TableScanBindData &)*bind_data_p;
-	auto &state = (TableScanOperatorData &)*operator_state;
+	auto &state = (TableScanLocalState &)*local_state;
 	if (state.scan_state.row_group_scan_state.row_group) {
 		return state.scan_state.row_group_scan_state.row_group->start;
 	}
@@ -110279,8 +110154,8 @@ unique_ptr<NodeStatistics> TableScanCardinality(ClientContext &context, const Fu
 //===--------------------------------------------------------------------===//
 // Index Scan
 //===--------------------------------------------------------------------===//
-struct IndexScanOperatorData : public FunctionOperatorData {
-	explicit IndexScanOperatorData(data_ptr_t row_id_data) : row_ids(LogicalType::ROW_TYPE, row_id_data) {
+struct IndexScanGlobalState : public GlobalTableFunctionState {
+	explicit IndexScanGlobalState(data_ptr_t row_id_data) : row_ids(LogicalType::ROW_TYPE, row_id_data) {
 	}
 
 	Vector row_ids;
@@ -110290,28 +110165,24 @@ struct IndexScanOperatorData : public FunctionOperatorData {
 	bool finished;
 };
 
-static unique_ptr<FunctionOperatorData> IndexScanInit(ClientContext &context, const FunctionData *bind_data_p,
-                                                      const vector<column_t> &column_ids,
-                                                      TableFilterCollection *filters) {
-	auto &bind_data = (const TableScanBindData &)*bind_data_p;
+static unique_ptr<GlobalTableFunctionState> IndexScanInitGlobal(ClientContext &context, TableFunctionInitInput &input) {
+	auto &bind_data = (const TableScanBindData &)*input.bind_data;
 	data_ptr_t row_id_data = nullptr;
 	if (!bind_data.result_ids.empty()) {
 		row_id_data = (data_ptr_t)&bind_data.result_ids[0];
 	}
-	auto result = make_unique<IndexScanOperatorData>(row_id_data);
+	auto result = make_unique<IndexScanGlobalState>(row_id_data);
 	auto &transaction = Transaction::GetTransaction(context);
-	result->column_ids = column_ids;
-	transaction.storage.InitializeScan(bind_data.table->storage.get(), result->local_storage_state,
-	                                   filters->table_filters);
+	result->column_ids = input.column_ids;
+	transaction.storage.InitializeScan(bind_data.table->storage.get(), result->local_storage_state, input.filters);
 
 	result->finished = false;
 	return move(result);
 }
 
-static void IndexScanFunction(ClientContext &context, const FunctionData *bind_data_p,
-                              FunctionOperatorData *operator_state, DataChunk &output) {
-	auto &bind_data = (const TableScanBindData &)*bind_data_p;
-	auto &state = (IndexScanOperatorData &)*operator_state;
+static void IndexScanFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &bind_data = (const TableScanBindData &)*data_p.bind_data;
+	auto &state = (IndexScanGlobalState &)*data_p.global_state;
 	auto &transaction = Transaction::GetTransaction(context);
 	if (!state.finished) {
 		bind_data.table->storage->Fetch(transaction, output, state.column_ids, state.row_ids,
@@ -110461,15 +110332,12 @@ void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, Fun
 			if (index.Scan(transaction, storage, *index_state, STANDARD_VECTOR_SIZE, bind_data.result_ids)) {
 				// use an index scan!
 				bind_data.is_index_scan = true;
-				get.function.init = IndexScanInit;
+				get.function.init_local = nullptr;
+				get.function.init_global = IndexScanInitGlobal;
 				get.function.function = IndexScanFunction;
-				get.function.max_threads = nullptr;
-				get.function.init_parallel_state = nullptr;
-				get.function.parallel_state_next = nullptr;
 				get.function.table_scan_progress = nullptr;
 				get.function.get_batch_index = nullptr;
 				get.function.filter_pushdown = false;
-				get.function.supports_batch_index = false;
 			} else {
 				bind_data.result_ids.clear();
 			}
@@ -110487,21 +110355,17 @@ string TableScanToString(const FunctionData *bind_data_p) {
 
 TableFunction TableScanFunction::GetFunction() {
 	TableFunction scan_function("seq_scan", {}, TableScanFunc);
-	scan_function.init = TableScanInit;
+	scan_function.init_local = TableScanInitLocal;
+	scan_function.init_global = TableScanInitGlobal;
 	scan_function.statistics = TableScanStatistics;
 	scan_function.dependency = TableScanDependency;
 	scan_function.cardinality = TableScanCardinality;
 	scan_function.pushdown_complex_filter = TableScanPushdownComplexFilter;
 	scan_function.to_string = TableScanToString;
-	scan_function.max_threads = TableScanMaxThreads;
-	scan_function.init_parallel_state = TableScanInitParallelState;
-	scan_function.parallel_init = TableScanParallelInit;
-	scan_function.parallel_state_next = TableScanParallelStateNext;
 	scan_function.table_scan_progress = TableScanProgress;
 	scan_function.get_batch_index = TableScanGetBatchIndex;
 	scan_function.projection_pushdown = true;
 	scan_function.filter_pushdown = true;
-	scan_function.supports_batch_index = true;
 	return scan_function;
 }
 
@@ -110539,12 +110403,16 @@ public:
 	}
 };
 
-struct UnnestOperatorData : public FunctionOperatorData {
+struct UnnestOperatorData : public GlobalTableFunctionState {
 	UnnestOperatorData() {
 	}
 
 	unique_ptr<OperatorState> operator_state;
 	vector<unique_ptr<Expression>> select_list;
+
+	idx_t MaxThreads() const override {
+		return GlobalTableFunctionState::MAX_THREADS;
+	}
 };
 
 static unique_ptr<FunctionData> UnnestBind(ClientContext &context, TableFunctionBindInput &input,
@@ -110557,9 +110425,8 @@ static unique_ptr<FunctionData> UnnestBind(ClientContext &context, TableFunction
 	return make_unique<UnnestBindData>(input.input_table_types[0]);
 }
 
-static unique_ptr<FunctionOperatorData> UnnestInit(ClientContext &context, const FunctionData *bind_data_p,
-                                                   const vector<column_t> &column_ids, TableFilterCollection *filters) {
-	auto &bind_data = (UnnestBindData &)*bind_data_p;
+static unique_ptr<GlobalTableFunctionState> UnnestInit(ClientContext &context, TableFunctionInitInput &input) {
+	auto &bind_data = (UnnestBindData &)*input.bind_data;
 	auto result = make_unique<UnnestOperatorData>();
 	result->operator_state = PhysicalUnnest::GetState(context);
 	auto ref = make_unique<BoundReferenceExpression>(bind_data.input_type, 0);
@@ -110569,9 +110436,9 @@ static unique_ptr<FunctionOperatorData> UnnestInit(ClientContext &context, const
 	return move(result);
 }
 
-static OperatorResultType UnnestFunction(ClientContext &context, const FunctionData *bind_data_p,
-                                         FunctionOperatorData *state_p, DataChunk &input, DataChunk &output) {
-	auto &state = (UnnestOperatorData &)*state_p;
+static OperatorResultType UnnestFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &input,
+                                         DataChunk &output) {
+	auto &state = (UnnestOperatorData &)*data_p.global_state;
 	return PhysicalUnnest::ExecuteInternal(context, input, output, *state.operator_state, state.select_list, false);
 }
 
@@ -110589,9 +110456,10 @@ void UnnestTableFunction::RegisterFunction(BuiltinFunctions &set) {
 
 namespace duckdb {
 
-struct PragmaVersionData : public FunctionOperatorData {
+struct PragmaVersionData : public GlobalTableFunctionState {
 	PragmaVersionData() : finished(false) {
 	}
+
 	bool finished;
 };
 
@@ -110604,15 +110472,12 @@ static unique_ptr<FunctionData> PragmaVersionBind(ClientContext &context, TableF
 	return nullptr;
 }
 
-static unique_ptr<FunctionOperatorData> PragmaVersionInit(ClientContext &context, const FunctionData *bind_data,
-                                                          const vector<column_t> &column_ids,
-                                                          TableFilterCollection *filters) {
+static unique_ptr<GlobalTableFunctionState> PragmaVersionInit(ClientContext &context, TableFunctionInitInput &input) {
 	return make_unique<PragmaVersionData>();
 }
 
-static void PragmaVersionFunction(ClientContext &context, const FunctionData *bind_data,
-                                  FunctionOperatorData *operator_state, DataChunk &output) {
-	auto &data = (PragmaVersionData &)*operator_state;
+static void PragmaVersionFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = (PragmaVersionData &)*data_p.global_state;
 	if (data.finished) {
 		// finished returning values
 		return;
@@ -110624,7 +110489,10 @@ static void PragmaVersionFunction(ClientContext &context, const FunctionData *bi
 }
 
 void PragmaVersion::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(TableFunction("pragma_version", {}, PragmaVersionFunction, PragmaVersionBind, PragmaVersionInit));
+	TableFunction pragma_version("pragma_version", {}, PragmaVersionFunction);
+	pragma_version.bind = PragmaVersionBind;
+	pragma_version.init_global = PragmaVersionInit;
+	set.AddFunction(pragma_version);
 }
 
 const char *DuckDB::SourceID() {
@@ -110669,49 +110537,28 @@ string DuckDB::Platform() {
 
 namespace duckdb {
 
-FunctionOperatorData::~FunctionOperatorData() {
+GlobalTableFunctionState::~GlobalTableFunctionState() {
 }
 
-TableFunctionInfo::~TableFunctionInfo() {
+LocalTableFunctionState::~LocalTableFunctionState() {
 }
 
-TableFilterCollection::TableFilterCollection(TableFilterSet *table_filters) : table_filters(table_filters) {
+TableFunctionInfo::~TableFunctionInfo() {
 }
 
 TableFunction::TableFunction(string name, vector<LogicalType> arguments, table_function_t function,
-                             table_function_bind_t bind, table_function_init_t init, table_statistics_t statistics,
-                             table_function_cleanup_t cleanup, table_function_dependency_t dependency,
-                             table_function_cardinality_t cardinality,
-                             table_function_pushdown_complex_filter_t pushdown_complex_filter,
-                             table_function_to_string_t to_string, table_function_max_threads_t max_threads,
-                             table_function_init_parallel_state_t init_parallel_state,
-                             table_function_parallel_t parallel_function, table_function_init_parallel_t parallel_init,
-                             table_function_parallel_state_next_t parallel_state_next, bool projection_pushdown,
-                             bool filter_pushdown, table_function_progress_t query_progress,
-                             table_in_out_function_t in_out_function)
-    : SimpleNamedParameterFunction(move(name), move(arguments)), bind(bind), init(init), function(function),
-      in_out_function(in_out_function), statistics(statistics), cleanup(cleanup), dependency(dependency),
-      cardinality(cardinality), pushdown_complex_filter(pushdown_complex_filter), to_string(to_string),
-      max_threads(max_threads), init_parallel_state(init_parallel_state), parallel_function(parallel_function),
-      parallel_init(parallel_init), parallel_state_next(parallel_state_next), table_scan_progress(query_progress),
-      projection_pushdown(projection_pushdown), filter_pushdown(filter_pushdown), supports_batch_index(false) {
+                             table_function_bind_t bind, table_function_init_global_t init_global,
+                             table_function_init_local_t init_local)
+    : SimpleNamedParameterFunction(move(name), move(arguments)), bind(bind), init_global(init_global),
+      init_local(init_local), function(function), in_out_function(nullptr), statistics(nullptr), dependency(nullptr),
+      cardinality(nullptr), pushdown_complex_filter(nullptr), to_string(nullptr), table_scan_progress(nullptr),
+      get_batch_index(nullptr), projection_pushdown(false), filter_pushdown(false) {
 }
 
 TableFunction::TableFunction(const vector<LogicalType> &arguments, table_function_t function,
-                             table_function_bind_t bind, table_function_init_t init, table_statistics_t statistics,
-                             table_function_cleanup_t cleanup, table_function_dependency_t dependency,
-                             table_function_cardinality_t cardinality,
-                             table_function_pushdown_complex_filter_t pushdown_complex_filter,
-                             table_function_to_string_t to_string, table_function_max_threads_t max_threads,
-                             table_function_init_parallel_state_t init_parallel_state,
-                             table_function_parallel_t parallel_function, table_function_init_parallel_t parallel_init,
-                             table_function_parallel_state_next_t parallel_state_next, bool projection_pushdown,
-                             bool filter_pushdown, table_function_progress_t query_progress,
-                             table_in_out_function_t in_out_function)
-    : TableFunction(string(), arguments, function, bind, init, statistics, cleanup, dependency, cardinality,
-                    pushdown_complex_filter, to_string, max_threads, init_parallel_state, parallel_function,
-                    parallel_init, parallel_state_next, projection_pushdown, filter_pushdown, query_progress,
-                    in_out_function) {
+                             table_function_bind_t bind, table_function_init_global_t init_global,
+                             table_function_init_local_t init_local)
+    : TableFunction(string(), arguments, function, bind, init_global, init_local) {
 }
 TableFunction::TableFunction() : SimpleNamedParameterFunction("", {}) {
 }
@@ -113099,6 +112946,7 @@ struct CTableFunctionInfo : public TableFunctionInfo {
 
 	duckdb_table_function_bind_t bind = nullptr;
 	duckdb_table_function_init_t init = nullptr;
+	duckdb_table_function_init_t local_init = nullptr;
 	duckdb_table_function_t function = nullptr;
 	void *extra_info = nullptr;
 	duckdb_delete_callback_t delete_callback = nullptr;
@@ -113135,7 +112983,7 @@ struct CTableInternalBindInfo {
 	string error;
 };
 
-struct CTableInitData : public FunctionOperatorData {
+struct CTableInitData {
 	~CTableInitData() {
 		if (init_data && delete_callback) {
 			delete_callback(init_data);
@@ -113146,29 +112994,43 @@ struct CTableInitData : public FunctionOperatorData {
 
 	void *init_data = nullptr;
 	duckdb_delete_callback_t delete_callback = nullptr;
+	idx_t max_threads = 1;
+};
+
+struct CTableGlobalInitData : public GlobalTableFunctionState {
+	CTableInitData init_data;
+
+	idx_t MaxThreads() const override {
+		return init_data.max_threads;
+	}
+};
+
+struct CTableLocalInitData : public LocalTableFunctionState {
+	CTableInitData init_data;
 };
 
 struct CTableInternalInitInfo {
 	CTableInternalInitInfo(CTableBindData &bind_data, CTableInitData &init_data, const vector<column_t> &column_ids,
-	                       TableFilterCollection *filters)
+	                       TableFilterSet *filters)
 	    : bind_data(bind_data), init_data(init_data), column_ids(column_ids), filters(filters), success(true) {
 	}
 
 	CTableBindData &bind_data;
 	CTableInitData &init_data;
 	const vector<column_t> &column_ids;
-	TableFilterCollection *filters;
+	TableFilterSet *filters;
 	bool success;
 	string error;
 };
 
 struct CTableInternalFunctionInfo {
-	CTableInternalFunctionInfo(CTableBindData &bind_data, CTableInitData &init_data)
-	    : bind_data(bind_data), init_data(init_data), success(true) {
+	CTableInternalFunctionInfo(CTableBindData &bind_data, CTableInitData &init_data, CTableInitData &local_data)
+	    : bind_data(bind_data), init_data(init_data), local_data(local_data), success(true) {
 	}
 
 	CTableBindData &bind_data;
 	CTableInitData &init_data;
+	CTableInitData &local_data;
 	bool success;
 	string error;
 };
@@ -113188,13 +113050,11 @@ unique_ptr<FunctionData> CTableFunctionBind(ClientContext &context, TableFunctio
 	return move(result);
 }
 
-unique_ptr<FunctionOperatorData> CTableFunctionInit(ClientContext &context, const FunctionData *bind_data_p,
-                                                    const vector<column_t> &column_ids,
-                                                    TableFilterCollection *filters) {
-	auto &bind_data = (CTableBindData &)*bind_data_p;
-	auto result = make_unique<CTableInitData>();
+unique_ptr<GlobalTableFunctionState> CTableFunctionInit(ClientContext &context, TableFunctionInitInput &data_p) {
+	auto &bind_data = (CTableBindData &)*data_p.bind_data;
+	auto result = make_unique<CTableGlobalInitData>();
 
-	CTableInternalInitInfo init_info(bind_data, *result, column_ids, filters);
+	CTableInternalInitInfo init_info(bind_data, result->init_data, data_p.column_ids, data_p.filters);
 	bind_data.info->init(&init_info);
 	if (!init_info.success) {
 		throw Exception(init_info.error);
@@ -113202,11 +113062,27 @@ unique_ptr<FunctionOperatorData> CTableFunctionInit(ClientContext &context, cons
 	return move(result);
 }
 
-void CTableFunction(ClientContext &context, const FunctionData *bind_data_p, FunctionOperatorData *operator_state,
-                    DataChunk &output) {
-	auto &bind_data = (CTableBindData &)*bind_data_p;
-	auto &init_data = (CTableInitData &)*operator_state;
-	CTableInternalFunctionInfo function_info(bind_data, init_data);
+unique_ptr<LocalTableFunctionState> CTableFunctionLocalInit(ClientContext &context, TableFunctionInitInput &data_p,
+                                                            GlobalTableFunctionState *gstate) {
+	auto &bind_data = (CTableBindData &)*data_p.bind_data;
+	auto result = make_unique<CTableLocalInitData>();
+	if (!bind_data.info->local_init) {
+		return move(result);
+	}
+
+	CTableInternalInitInfo init_info(bind_data, result->init_data, data_p.column_ids, data_p.filters);
+	bind_data.info->local_init(&init_info);
+	if (!init_info.success) {
+		throw Exception(init_info.error);
+	}
+	return move(result);
+}
+
+void CTableFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &bind_data = (CTableBindData &)*data_p.bind_data;
+	auto &global_data = (CTableGlobalInitData &)*data_p.global_state;
+	auto &local_data = (CTableLocalInitData &)*data_p.local_state;
+	CTableInternalFunctionInfo function_info(bind_data, global_data.init_data, local_data.init_data);
 	bind_data.info->function(&function_info, &output);
 	if (!function_info.success) {
 		throw Exception(function_info.error);
@@ -113220,7 +113096,7 @@ void CTableFunction(ClientContext &context, const FunctionData *bind_data_p, Fun
 //===--------------------------------------------------------------------===//
 duckdb_table_function duckdb_create_table_function() {
 	auto function = new duckdb::TableFunction("", {}, duckdb::CTableFunction, duckdb::CTableFunctionBind,
-	                                          duckdb::CTableFunctionInit);
+	                                          duckdb::CTableFunctionInit, duckdb::CTableFunctionLocalInit);
 	function->function_info = duckdb::make_shared<duckdb::CTableFunctionInfo>();
 	return function;
 }
@@ -113279,6 +113155,15 @@ void duckdb_table_function_set_init(duckdb_table_function function, duckdb_table
 	info->init = init;
 }
 
+void duckdb_table_function_set_local_init(duckdb_table_function function, duckdb_table_function_init_t init) {
+	if (!function || !init) {
+		return;
+	}
+	auto tf = (duckdb::TableFunction *)function;
+	auto info = (duckdb::CTableFunctionInfo *)tf->function_info.get();
+	info->local_init = init;
+}
+
 void duckdb_table_function_set_function(duckdb_table_function table_function, duckdb_table_function_t function) {
 	if (!table_function || !function) {
 		return;
@@ -113426,6 +113311,14 @@ idx_t duckdb_init_get_column_index(duckdb_init_info info, idx_t column_index) {
 	return function_info->column_ids[column_index];
 }
 
+void duckdb_init_set_max_threads(duckdb_init_info info, idx_t max_threads) {
+	if (!info) {
+		return;
+	}
+	auto function_info = (duckdb::CTableInternalInitInfo *)info;
+	function_info->init_data.max_threads = max_threads;
+}
+
 //===--------------------------------------------------------------------===//
 // Function Interface
 //===--------------------------------------------------------------------===//
@@ -113453,6 +113346,14 @@ void *duckdb_function_get_init_data(duckdb_function_info info) {
 	return function_info->init_data.init_data;
 }
 
+void *duckdb_function_get_local_init_data(duckdb_function_info info) {
+	if (!info) {
+		return nullptr;
+	}
+	auto function_info = (duckdb::CTableInternalFunctionInfo *)info;
+	return function_info->local_data.init_data;
+}
+
 void duckdb_function_set_error(duckdb_function_info info, const char *error) {
 	if (!info || !error) {
 		return;
@@ -178610,6 +178511,7 @@ void DataTable::InitializeParallelScan(ClientContext &context, ParallelTableScan
 	state.transaction_local_data = false;
 	// figure out the max row we can scan for both the regular and the transaction-local storage
 	state.max_row = total_rows;
+	state.vector_index = 0;
 	state.local_state.max_index = 0;
 	auto &transaction = Transaction::GetTransaction(context);
 	transaction.storage.InitializeScan(this, state.local_state, nullptr);
@@ -178625,13 +178527,19 @@ bool DataTable::NextParallelScan(ClientContext &context, ParallelTableScanState
 			max_row = state.current_row_group->start +
 			          MinValue<idx_t>(state.current_row_group->count,
 			                          STANDARD_VECTOR_SIZE * state.vector_index + STANDARD_VECTOR_SIZE);
+			D_ASSERT(vector_index * STANDARD_VECTOR_SIZE < state.current_row_group->count);
 		} else {
 			vector_index = 0;
 			max_row = state.current_row_group->start + state.current_row_group->count;
 		}
 		max_row = MinValue<idx_t>(max_row, state.max_row);
-		bool need_to_scan = InitializeScanInRowGroup(scan_state, column_ids, scan_state.table_filters,
-		                                             state.current_row_group, vector_index, max_row);
+		bool need_to_scan;
+		if (state.current_row_group->count == 0) {
+			need_to_scan = false;
+		} else {
+			need_to_scan = InitializeScanInRowGroup(scan_state, column_ids, scan_state.table_filters,
+			                                        state.current_row_group, vector_index, max_row);
+		}
 		if (ClientConfig::GetConfig(context).verify_parallelism) {
 			state.vector_index++;
 			if (state.vector_index * STANDARD_VECTOR_SIZE >= state.current_row_group->count) {
@@ -179739,16 +179647,18 @@ LocalTableStorage::~LocalTableStorage() {
 }
 
 void LocalTableStorage::InitializeScan(LocalScanState &state, TableFilterSet *table_filters) {
+	state.table_filters = table_filters;
+	state.chunk_index = 0;
 	if (collection.ChunkCount() == 0) {
 		// nothing to scan
+		state.max_index = 0;
+		state.last_chunk_count = 0;
 		return;
 	}
 	state.SetStorage(shared_from_this());
 
-	state.chunk_index = 0;
 	state.max_index = collection.ChunkCount() - 1;
 	state.last_chunk_count = collection.Chunks().back()->size();
-	state.table_filters = table_filters;
 }
 
 idx_t LocalTableStorage::EstimatedSize() {