duckdb 0.3.5-dev230.0 → 0.3.5-dev242.0

package/src/duckdb.cpp

@@ -70264,11 +70264,10 @@ namespace duckdb {
 
 class TableInOutFunctionState : public OperatorState {
 public:
-	TableInOutFunctionState() : initialized(false) {
+	TableInOutFunctionState() {
 	}
 
 	unique_ptr<FunctionOperatorData> operator_data;
-	bool initialized = false;
 };
 
 PhysicalTableInOutFunction::PhysicalTableInOutFunction(vector<LogicalType> types, TableFunction function_p,
@@ -70279,22 +70278,17 @@ PhysicalTableInOutFunction::PhysicalTableInOutFunction(vector<LogicalType> types
 }
 
 unique_ptr<OperatorState> PhysicalTableInOutFunction::GetOperatorState(ClientContext &context) const {
-	return make_unique<TableInOutFunctionState>();
+	auto result = make_unique<TableInOutFunctionState>();
+	if (function.init) {
+		result->operator_data = function.init(context, bind_data.get(), column_ids, nullptr);
+	}
+	return move(result);
 }
 
 OperatorResultType PhysicalTableInOutFunction::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
                                                        GlobalOperatorState &gstate, OperatorState &state_p) const {
 	auto &state = (TableInOutFunctionState &)state_p;
-
-	if (!state.initialized) {
-		if (function.init) {
-			state.operator_data = function.init(context.client, bind_data.get(), column_ids, nullptr);
-		}
-		state.initialized = true;
-	}
-
-	function.function(context.client, bind_data.get(), state.operator_data.get(), &input, chunk);
-	return OperatorResultType::NEED_MORE_INPUT;
+	return function.in_out_function(context.client, bind_data.get(), state.operator_data.get(), input, chunk);
 }
 
 } // namespace duckdb
@@ -70320,7 +70314,7 @@ public:
 	PhysicalUnnest(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list, idx_t estimated_cardinality,
 	               PhysicalOperatorType type = PhysicalOperatorType::UNNEST);
 
-	//! The projection list of the SELECT statement (that contains aggregates)
+	//! The projection list of the UNNEST
 	vector<unique_ptr<Expression>> select_list;
 
 public:
@@ -70331,6 +70325,12 @@ public:
 	bool ParallelOperator() const override {
 		return true;
 	}
+
+public:
+	static unique_ptr<OperatorState> GetState(ClientContext &context);
+	static OperatorResultType ExecuteInternal(ClientContext &context, DataChunk &input, DataChunk &chunk,
+	                                          OperatorState &state, const vector<unique_ptr<Expression>> &select_list,
+	                                          bool include_input = true);
 };
 
 } // namespace duckdb
@@ -70344,7 +70344,6 @@ public:
 
 namespace duckdb {
 
-//! The operator state of the window
 class UnnestOperatorState : public OperatorState {
 public:
 	UnnestOperatorState() : parent_position(0), list_position(0), list_length(-1), first_fetch(true) {
@@ -70482,11 +70481,17 @@ static void UnnestVector(VectorData &vdata, Vector &source, idx_t list_size, idx
 }
 
 unique_ptr<OperatorState> PhysicalUnnest::GetOperatorState(ClientContext &context) const {
+	return PhysicalUnnest::GetState(context);
+}
+
+unique_ptr<OperatorState> PhysicalUnnest::GetState(ClientContext &context) {
 	return make_unique<UnnestOperatorState>();
 }
 
-OperatorResultType PhysicalUnnest::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                           GlobalOperatorState &gstate, OperatorState &state_p) const {
+OperatorResultType PhysicalUnnest::ExecuteInternal(ClientContext &context, DataChunk &input, DataChunk &chunk,
+                                                   OperatorState &state_p,
+                                                   const vector<unique_ptr<Expression>> &select_list,
+                                                   bool include_input) {
 	auto &state = (UnnestOperatorState &)state_p;
 	do {
 		if (state.first_fetch) {
@@ -70565,12 +70570,17 @@ OperatorResultType PhysicalUnnest::Execute(ExecutionContext &context, DataChunk
 		// first cols are from child, last n cols from unnest
 		chunk.SetCardinality(this_chunk_len);
 
-		for (idx_t col_idx = 0; col_idx < input.ColumnCount(); col_idx++) {
-			ConstantVector::Reference(chunk.data[col_idx], input.data[col_idx], state.parent_position, input.size());
+		idx_t output_offset = 0;
+		if (include_input) {
+			for (idx_t col_idx = 0; col_idx < input.ColumnCount(); col_idx++) {
+				ConstantVector::Reference(chunk.data[col_idx], input.data[col_idx], state.parent_position,
+				                          input.size());
+			}
+			output_offset = input.ColumnCount();
 		}
 
 		for (idx_t col_idx = 0; col_idx < state.list_data.ColumnCount(); col_idx++) {
-			auto &result_vector = chunk.data[col_idx + input.ColumnCount()];
+			auto &result_vector = chunk.data[col_idx + output_offset];
 
 			if (state.list_data.data[col_idx].GetType() == LogicalType::SQLNULL) {
 				// UNNEST(NULL)
@@ -70620,6 +70630,11 @@ OperatorResultType PhysicalUnnest::Execute(ExecutionContext &context, DataChunk
 	return OperatorResultType::HAVE_MORE_OUTPUT;
 }
 
+OperatorResultType PhysicalUnnest::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
+                                           GlobalOperatorState &gstate, OperatorState &state) const {
+	return ExecuteInternal(context.client, input, chunk, state, select_list);
+}
+
 } // namespace duckdb
 
 
@@ -70930,7 +70945,7 @@ void PhysicalTableScan::GetData(ExecutionContext &context, DataChunk &chunk, Glo
 
 	if (!gstate.parallel_state) {
 		// sequential scan
-		function.function(context.client, bind_data.get(), state.operator_data.get(), nullptr, chunk);
+		function.function(context.client, bind_data.get(), state.operator_data.get(), chunk);
 		if (chunk.size() != 0) {
 			return;
 		}
@@ -70938,10 +70953,10 @@ void PhysicalTableScan::GetData(ExecutionContext &context, DataChunk &chunk, Glo
 		// parallel scan
 		do {
 			if (function.parallel_function) {
-				function.parallel_function(context.client, bind_data.get(), state.operator_data.get(), nullptr, chunk,
+				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(), nullptr, chunk);
+				function.function(context.client, bind_data.get(), state.operator_data.get(), chunk);
 			}
 
 			if (chunk.size() == 0) {
@@ -72490,6 +72505,7 @@ void PerfectAggregateHashTable::Destroy() {
 
 
 
+
 namespace duckdb {
 
 string PhysicalOperator::GetName() const {
@@ -101682,7 +101698,7 @@ private:
 
 	//! Scan Function for Single Thread Execution
 	static void ArrowScanFunction(ClientContext &context, const FunctionData *bind_data,
-	                              FunctionOperatorData *operator_state, DataChunk *input, DataChunk &output);
+	                              FunctionOperatorData *operator_state, DataChunk &output);
 
 	//! -----Multi Thread Functions:-----
 	//! Initialize Parallel State
@@ -101698,7 +101714,7 @@ private:
 	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 *input, DataChunk &output,
+	                                      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,
@@ -102691,7 +102707,7 @@ void ArrowTableFunction::ArrowToDuckDB(ArrowScanState &scan_state,
 }
 
 void ArrowTableFunction::ArrowScanFunction(ClientContext &context, const FunctionData *bind_data,
-                                           FunctionOperatorData *operator_state, DataChunk *input, DataChunk &output) {
+                                           FunctionOperatorData *operator_state, DataChunk &output) {
 
 	auto &data = (ArrowScanFunctionData &)*bind_data;
 	auto &state = (ArrowScanState &)*operator_state;
@@ -102716,8 +102732,8 @@ void ArrowTableFunction::ArrowScanFunction(ClientContext &context, const Functio
 }
 
 void ArrowTableFunction::ArrowScanFunctionParallel(ClientContext &context, const FunctionData *bind_data,
-                                                   FunctionOperatorData *operator_state, DataChunk *input,
-                                                   DataChunk &output, ParallelState *parallel_state_p) {
+                                                   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
@@ -102861,7 +102877,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 *input, DataChunk &output) {
+                                        FunctionOperatorData *operator_state, DataChunk &output) {
 	auto &transaction_manager = TransactionManager::Get(context);
 	transaction_manager.Checkpoint(context, FORCE);
 }
@@ -103375,7 +103391,7 @@ static unique_ptr<FunctionOperatorData> GlobFunctionInit(ClientContext &context,
 }
 
 static void GlobFunction(ClientContext &context, const FunctionData *bind_data_p, FunctionOperatorData *state_p,
-                         DataChunk *input, DataChunk &output) {
+                         DataChunk &output) {
 	auto &bind_data = (GlobFunctionBindData &)*bind_data_p;
 	auto &state = (GlobFunctionState &)*state_p;
 
@@ -103607,8 +103623,7 @@ static void ExtractFunctions(ChunkCollection &collection, ExpressionInfo &info,
 }
 
 static void PragmaDetailedProfilingOutputFunction(ClientContext &context, const FunctionData *bind_data_p,
-                                                  FunctionOperatorData *operator_state, DataChunk *input,
-                                                  DataChunk &output) {
+                                                  FunctionOperatorData *operator_state, DataChunk &output) {
 	auto &state = (PragmaDetailedProfilingOutputOperatorData &)*operator_state;
 	auto &data = (PragmaDetailedProfilingOutputData &)*bind_data_p;
 
@@ -103736,8 +103751,7 @@ unique_ptr<FunctionOperatorData> PragmaLastProfilingOutputInit(ClientContext &co
 }
 
 static void PragmaLastProfilingOutputFunction(ClientContext &context, const FunctionData *bind_data_p,
-                                              FunctionOperatorData *operator_state, DataChunk *input,
-                                              DataChunk &output) {
+                                              FunctionOperatorData *operator_state, DataChunk &output) {
 	auto &state = (PragmaLastProfilingOutputOperatorData &)*operator_state;
 	auto &data = (PragmaLastProfilingOutputData &)*bind_data_p;
 	if (!state.initialized) {
@@ -103876,7 +103890,7 @@ static unique_ptr<FunctionOperatorData> RangeFunctionInit(ClientContext &context
 }
 
 static void RangeFunction(ClientContext &context, const FunctionData *bind_data_p, FunctionOperatorData *state_p,
-                          DataChunk *input, DataChunk &output) {
+                          DataChunk &output) {
 	auto &bind_data = (RangeFunctionBindData &)*bind_data_p;
 	auto &state = (RangeFunctionState &)*state_p;
 
@@ -103995,7 +104009,7 @@ static unique_ptr<FunctionOperatorData> RangeDateTimeInit(ClientContext &context
 }
 
 static void RangeDateTimeFunction(ClientContext &context, const FunctionData *bind_data_p,
-                                  FunctionOperatorData *state_p, DataChunk *input, DataChunk &output) {
+                                  FunctionOperatorData *state_p, DataChunk &output) {
 	auto &bind_data = (RangeDateTimeBindData &)*bind_data_p;
 	auto &state = (RangeDateTimeState &)*state_p;
 	if (state.finished) {
@@ -104180,7 +104194,7 @@ static unique_ptr<FunctionData> ReadCSVAutoBind(ClientContext &context, TableFun
 }
 
 static void ReadCSVFunction(ClientContext &context, const FunctionData *bind_data_p,
-                            FunctionOperatorData *operator_state, DataChunk *input, DataChunk &output) {
+                            FunctionOperatorData *operator_state, DataChunk &output) {
 	auto &bind_data = (ReadCSVData &)*bind_data_p;
 	auto &data = (ReadCSVOperatorData &)*operator_state;
 	do {
@@ -104313,7 +104327,7 @@ static unique_ptr<FunctionOperatorData> RepeatInit(ClientContext &context, const
 }
 
 static void RepeatFunction(ClientContext &context, const FunctionData *bind_data_p,
-                           FunctionOperatorData *operator_state, DataChunk *input, DataChunk &output) {
+                           FunctionOperatorData *operator_state, DataChunk &output) {
 	auto &bind_data = (RepeatFunctionData &)*bind_data_p;
 	auto &state = (RepeatOperatorData &)*operator_state;
 
@@ -104358,32 +104372,32 @@ static unique_ptr<FunctionData> SummaryFunctionBind(ClientContext &context, Tabl
 	return make_unique<TableFunctionData>();
 }
 
-static void SummaryFunction(ClientContext &context, const FunctionData *bind_data_p, FunctionOperatorData *state_p,
-                            DataChunk *input, DataChunk &output) {
-	D_ASSERT(input);
-	output.SetCardinality(input->size());
+static OperatorResultType SummaryFunction(ClientContext &context, const FunctionData *bind_data_p,
+                                          FunctionOperatorData *state_p, DataChunk &input, DataChunk &output) {
+	output.SetCardinality(input.size());
 
-	for (idx_t row_idx = 0; row_idx < input->size(); row_idx++) {
+	for (idx_t row_idx = 0; row_idx < input.size(); row_idx++) {
 		string summary_val = "[";
 
-		for (idx_t col_idx = 0; col_idx < input->ColumnCount(); col_idx++) {
-			summary_val += input->GetValue(col_idx, row_idx).ToString();
-			if (col_idx < input->ColumnCount() - 1) {
+		for (idx_t col_idx = 0; col_idx < input.ColumnCount(); col_idx++) {
+			summary_val += input.GetValue(col_idx, row_idx).ToString();
+			if (col_idx < input.ColumnCount() - 1) {
 				summary_val += ", ";
 			}
 		}
 		summary_val += "]";
 		output.SetValue(0, row_idx, Value(summary_val));
 	}
-	for (idx_t col_idx = 0; col_idx < input->ColumnCount(); col_idx++) {
-		output.data[col_idx + 1].Reference(input->data[col_idx]);
+	for (idx_t col_idx = 0; col_idx < input.ColumnCount(); col_idx++) {
+		output.data[col_idx + 1].Reference(input.data[col_idx]);
 	}
+	return OperatorResultType::NEED_MORE_INPUT;
 }
 
 void SummaryTableFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunctionSet summary("summary");
-	summary.AddFunction(TableFunction({LogicalType::TABLE}, SummaryFunction, SummaryFunctionBind));
-	set.AddFunction(summary);
+	TableFunction summary_function("summary", {LogicalType::TABLE}, nullptr, SummaryFunctionBind);
+	summary_function.in_out_function = SummaryFunction;
+	set.AddFunction(summary_function);
 }
 
 } // namespace duckdb
@@ -104670,7 +104684,7 @@ 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 *input, DataChunk &output) {
+                           DataChunk &output) {
 	auto &data = (DuckDBColumnsData &)*operator_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
@@ -104799,7 +104813,7 @@ unique_ptr<FunctionOperatorData> DuckDBConstraintsInit(ClientContext &context, c
 }
 
 void DuckDBConstraintsFunction(ClientContext &context, const FunctionData *bind_data,
-                               FunctionOperatorData *operator_state, DataChunk *input, DataChunk &output) {
+                               FunctionOperatorData *operator_state, DataChunk &output) {
 	auto &data = (DuckDBConstraintsData &)*operator_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
@@ -104997,7 +105011,7 @@ unique_ptr<FunctionOperatorData> DuckDBDependenciesInit(ClientContext &context,
 }
 
 void DuckDBDependenciesFunction(ClientContext &context, const FunctionData *bind_data,
-                                FunctionOperatorData *operator_state, DataChunk *input, DataChunk &output) {
+                                FunctionOperatorData *operator_state, DataChunk &output) {
 	auto &data = (DuckDBDependenciesData &)*operator_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
@@ -105493,7 +105507,7 @@ bool ExtractFunctionData(StandardEntry *entry, idx_t function_idx, DataChunk &ou
 }
 
 void DuckDBFunctionsFunction(ClientContext &context, const FunctionData *bind_data,
-                             FunctionOperatorData *operator_state, DataChunk *input, DataChunk &output) {
+                             FunctionOperatorData *operator_state, DataChunk &output) {
 	auto &data = (DuckDBFunctionsData &)*operator_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
@@ -105627,7 +105641,7 @@ unique_ptr<FunctionOperatorData> DuckDBIndexesInit(ClientContext &context, const
 }
 
 void DuckDBIndexesFunction(ClientContext &context, const FunctionData *bind_data, FunctionOperatorData *operator_state,
-                           DataChunk *input, DataChunk &output) {
+                           DataChunk &output) {
 	auto &data = (DuckDBIndexesData &)*operator_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
@@ -105712,7 +105726,7 @@ unique_ptr<FunctionOperatorData> DuckDBKeywordsInit(ClientContext &context, cons
 }
 
 void DuckDBKeywordsFunction(ClientContext &context, const FunctionData *bind_data, FunctionOperatorData *operator_state,
-                            DataChunk *input, DataChunk &output) {
+                            DataChunk &output) {
 	auto &data = (DuckDBKeywordsData &)*operator_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
@@ -105806,7 +105820,7 @@ unique_ptr<FunctionOperatorData> DuckDBSchemasInit(ClientContext &context, const
 }
 
 void DuckDBSchemasFunction(ClientContext &context, const FunctionData *bind_data, FunctionOperatorData *operator_state,
-                           DataChunk *input, DataChunk &output) {
+                           DataChunk &output) {
 	auto &data = (DuckDBSchemasData &)*operator_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
@@ -105918,7 +105932,7 @@ unique_ptr<FunctionOperatorData> DuckDBSequencesInit(ClientContext &context, con
 }
 
 void DuckDBSequencesFunction(ClientContext &context, const FunctionData *bind_data,
-                             FunctionOperatorData *operator_state, DataChunk *input, DataChunk &output) {
+                             FunctionOperatorData *operator_state, DataChunk &output) {
 	auto &data = (DuckDBSequencesData &)*operator_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
@@ -106043,7 +106057,7 @@ unique_ptr<FunctionOperatorData> DuckDBSettingsInit(ClientContext &context, cons
 }
 
 void DuckDBSettingsFunction(ClientContext &context, const FunctionData *bind_data, FunctionOperatorData *operator_state,
-                            DataChunk *input, DataChunk &output) {
+                            DataChunk &output) {
 	auto &data = (DuckDBSettingsData &)*operator_state;
 	if (data.offset >= data.settings.size()) {
 		// finished returning values
@@ -106177,7 +106191,7 @@ static idx_t CheckConstraintCount(TableCatalogEntry &table) {
 }
 
 void DuckDBTablesFunction(ClientContext &context, const FunctionData *bind_data, FunctionOperatorData *operator_state,
-                          DataChunk *input, DataChunk &output) {
+                          DataChunk &output) {
 	auto &data = (DuckDBTablesData &)*operator_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
@@ -106283,7 +106297,7 @@ unique_ptr<FunctionOperatorData> DuckDBTypesInit(ClientContext &context, const F
 }
 
 void DuckDBTypesFunction(ClientContext &context, const FunctionData *bind_data, FunctionOperatorData *operator_state,
-                         DataChunk *input, DataChunk &output) {
+                         DataChunk &output) {
 	auto &data = (DuckDBTypesData &)*operator_state;
 	if (data.offset >= data.types.size()) {
 		// finished returning values
@@ -106430,7 +106444,7 @@ unique_ptr<FunctionOperatorData> DuckDBViewsInit(ClientContext &context, const F
 }
 
 void DuckDBViewsFunction(ClientContext &context, const FunctionData *bind_data, FunctionOperatorData *operator_state,
-                         DataChunk *input, DataChunk &output) {
+                         DataChunk &output) {
 	auto &data = (DuckDBViewsData &)*operator_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
@@ -106514,7 +106528,7 @@ unique_ptr<FunctionOperatorData> PragmaCollateInit(ClientContext &context, const
 }
 
 static void PragmaCollateFunction(ClientContext &context, const FunctionData *bind_data,
-                                  FunctionOperatorData *operator_state, DataChunk *input, DataChunk &output) {
+                                  FunctionOperatorData *operator_state, DataChunk &output) {
 	auto &data = (PragmaCollateData &)*operator_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
@@ -106570,7 +106584,7 @@ unique_ptr<FunctionOperatorData> PragmaDatabaseListInit(ClientContext &context,
 }
 
 void PragmaDatabaseListFunction(ClientContext &context, const FunctionData *bind_data,
-                                FunctionOperatorData *operator_state, DataChunk *input, DataChunk &output) {
+                                FunctionOperatorData *operator_state, DataChunk &output) {
 	auto &data = (PragmaDatabaseListData &)*operator_state;
 	if (data.finished) {
 		return;
@@ -106643,7 +106657,7 @@ unique_ptr<FunctionOperatorData> PragmaDatabaseSizeInit(ClientContext &context,
 }
 
 void PragmaDatabaseSizeFunction(ClientContext &context, const FunctionData *bind_data,
-                                FunctionOperatorData *operator_state, DataChunk *input, DataChunk &output) {
+                                FunctionOperatorData *operator_state, DataChunk &output) {
 	auto &data = (PragmaDatabaseSizeData &)*operator_state;
 	if (data.finished) {
 		return;
@@ -106766,7 +106780,7 @@ void AddFunction(BaseScalarFunction &f, idx_t &count, DataChunk &output, bool is
 }
 
 static void PragmaFunctionsFunction(ClientContext &context, const FunctionData *bind_data,
-                                    FunctionOperatorData *operator_state, DataChunk *input, DataChunk &output) {
+                                    FunctionOperatorData *operator_state, DataChunk &output) {
 	auto &data = (PragmaFunctionsData &)*operator_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
@@ -106908,7 +106922,7 @@ unique_ptr<FunctionOperatorData> PragmaStorageInfoInit(ClientContext &context, c
 }
 
 static void PragmaStorageInfoFunction(ClientContext &context, const FunctionData *bind_data_p,
-                                      FunctionOperatorData *operator_state, DataChunk *input, DataChunk &output) {
+                                      FunctionOperatorData *operator_state, DataChunk &output) {
 	auto &bind_data = (PragmaStorageFunctionData &)*bind_data_p;
 	auto &data = (PragmaStorageOperatorData &)*operator_state;
 	idx_t count = 0;
@@ -107095,7 +107109,7 @@ static void PragmaTableInfoView(PragmaTableOperatorData &data, ViewCatalogEntry
 }
 
 static void PragmaTableInfoFunction(ClientContext &context, const FunctionData *bind_data_p,
-                                    FunctionOperatorData *operator_state, DataChunk *input, DataChunk &output) {
+                                    FunctionOperatorData *operator_state, DataChunk &output) {
 	auto &bind_data = (PragmaTableFunctionData &)*bind_data_p;
 	auto &state = (PragmaTableOperatorData &)*operator_state;
 	switch (bind_data.entry->type) {
@@ -107320,7 +107334,7 @@ unique_ptr<FunctionOperatorData> TestAllTypesInit(ClientContext &context, const
 }
 
 void TestAllTypesFunction(ClientContext &context, const FunctionData *bind_data, FunctionOperatorData *operator_state,
-                          DataChunk *input, DataChunk &output) {
+                          DataChunk &output) {
 	auto &data = (TestAllTypesData &)*operator_state;
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
@@ -107529,7 +107543,7 @@ static unique_ptr<FunctionOperatorData> TableScanParallelInit(ClientContext &con
 }
 
 static void TableScanFunc(ClientContext &context, const FunctionData *bind_data_p, FunctionOperatorData *operator_state,
-                          DataChunk *, DataChunk &output) {
+                          DataChunk &output) {
 	D_ASSERT(bind_data_p);
 	D_ASSERT(operator_state);
 	auto &bind_data = (TableScanBindData &)*bind_data_p;
@@ -107636,7 +107650,7 @@ static unique_ptr<FunctionOperatorData> IndexScanInit(ClientContext &context, co
 }
 
 static void IndexScanFunction(ClientContext &context, const FunctionData *bind_data_p,
-                              FunctionOperatorData *operator_state, DataChunk *input, DataChunk &output) {
+                              FunctionOperatorData *operator_state, DataChunk &output) {
 	auto &bind_data = (const TableScanBindData &)*bind_data_p;
 	auto &state = (IndexScanOperatorData &)*operator_state;
 	auto &transaction = Transaction::GetTransaction(context);
@@ -107840,51 +107854,67 @@ TableCatalogEntry *TableScanFunction::GetTableEntry(const TableFunction &functio
 
 
 
+
+
+
 namespace duckdb {
 
-struct UnnestFunctionData : public TableFunctionData {
-	explicit UnnestFunctionData(Value value) : value(move(value)) {
+struct UnnestBindData : public FunctionData {
+	explicit UnnestBindData(LogicalType input_type_p) : input_type(move(input_type_p)) {
 	}
 
-	Value value;
+	LogicalType input_type;
+
+public:
+	unique_ptr<FunctionData> Copy() const override {
+		return make_unique<UnnestBindData>(input_type);
+	}
+
+	bool Equals(const FunctionData &other_p) const override {
+		auto &other = (const UnnestBindData &)other_p;
+		return input_type == other.input_type;
+	}
 };
 
 struct UnnestOperatorData : public FunctionOperatorData {
-	UnnestOperatorData() : current_count(0) {
+	UnnestOperatorData() {
 	}
 
-	idx_t current_count;
+	unique_ptr<OperatorState> operator_state;
+	vector<unique_ptr<Expression>> select_list;
 };
 
 static unique_ptr<FunctionData> UnnestBind(ClientContext &context, TableFunctionBindInput &input,
                                            vector<LogicalType> &return_types, vector<string> &names) {
-	auto &inputs = input.inputs;
-	return_types.push_back(ListType::GetChildType(inputs[0].type()));
-	names.push_back(inputs[0].ToString());
-	return make_unique<UnnestFunctionData>(inputs[0]);
+	if (input.input_table_types.size() != 1 || input.input_table_types[0].id() != LogicalTypeId::LIST) {
+		throw BinderException("UNNEST requires a single list as input");
+	}
+	return_types.push_back(ListType::GetChildType(input.input_table_types[0]));
+	names.push_back(input.input_table_names[0]);
+	return make_unique<UnnestBindData>(input.input_table_types[0]);
 }
 
-static unique_ptr<FunctionOperatorData> UnnestInit(ClientContext &context, const FunctionData *bind_data,
+static unique_ptr<FunctionOperatorData> UnnestInit(ClientContext &context, const FunctionData *bind_data_p,
                                                    const vector<column_t> &column_ids, TableFilterCollection *filters) {
-	return make_unique<UnnestOperatorData>();
+	auto &bind_data = (UnnestBindData &)*bind_data_p;
+	auto result = make_unique<UnnestOperatorData>();
+	result->operator_state = PhysicalUnnest::GetState(context);
+	auto ref = make_unique<BoundReferenceExpression>(bind_data.input_type, 0);
+	auto bound_unnest = make_unique<BoundUnnestExpression>(ListType::GetChildType(bind_data.input_type));
+	bound_unnest->child = move(ref);
+	result->select_list.push_back(move(bound_unnest));
+	return move(result);
 }
 
-static void UnnestFunction(ClientContext &context, const FunctionData *bind_data_p,
-                           FunctionOperatorData *operator_state, DataChunk *input, DataChunk &output) {
-	auto &bind_data = (UnnestFunctionData &)*bind_data_p;
-	auto &state = (UnnestOperatorData &)*operator_state;
-
-	auto &list_value = ListValue::GetChildren(bind_data.value);
-	idx_t count = 0;
-	for (; state.current_count < list_value.size() && count < STANDARD_VECTOR_SIZE; state.current_count++) {
-		output.data[0].SetValue(count, list_value[state.current_count]);
-		count++;
-	}
-	output.SetCardinality(count);
+static OperatorResultType UnnestFunction(ClientContext &context, const FunctionData *bind_data_p,
+                                         FunctionOperatorData *state_p, DataChunk &input, DataChunk &output) {
+	auto &state = (UnnestOperatorData &)*state_p;
+	return PhysicalUnnest::ExecuteInternal(context, input, output, *state.operator_state, state.select_list, false);
 }
 
 void UnnestTableFunction::RegisterFunction(BuiltinFunctions &set) {
-	TableFunction unnest_function("unnest", {LogicalTypeId::LIST}, UnnestFunction, UnnestBind, UnnestInit);
+	TableFunction unnest_function("unnest", {LogicalTypeId::TABLE}, nullptr, UnnestBind, UnnestInit);
+	unnest_function.in_out_function = UnnestFunction;
 	set.AddFunction(unnest_function);
 }
 
@@ -107918,7 +107948,7 @@ static unique_ptr<FunctionOperatorData> PragmaVersionInit(ClientContext &context
 }
 
 static void PragmaVersionFunction(ClientContext &context, const FunctionData *bind_data,
-                                  FunctionOperatorData *operator_state, DataChunk *input, DataChunk &output) {
+                                  FunctionOperatorData *operator_state, DataChunk &output) {
 	auto &data = (PragmaVersionData &)*operator_state;
 	if (data.finished) {
 		// finished returning values
@@ -107994,12 +108024,13 @@ TableFunction::TableFunction(string name, vector<LogicalType> arguments, table_f
                              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)
+                             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),
-      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),
+      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) {
 }
 
@@ -108012,10 +108043,12 @@ TableFunction::TableFunction(const vector<LogicalType> &arguments, table_functio
                              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)
+                             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) {
+                    parallel_init, parallel_state_next, projection_pushdown, filter_pushdown, query_progress,
+                    in_out_function) {
 }
 TableFunction::TableFunction() : SimpleNamedParameterFunction("", {}) {
 }
@@ -110496,7 +110529,7 @@ unique_ptr<FunctionOperatorData> CTableFunctionInit(ClientContext &context, cons
 }
 
 void CTableFunction(ClientContext &context, const FunctionData *bind_data_p, FunctionOperatorData *operator_state,
-                    DataChunk *input, DataChunk &output) {
+                    DataChunk &output) {
 	auto &bind_data = (CTableBindData &)*bind_data_p;
 	auto &init_data = (CTableInitData &)*operator_state;
 	CTableInternalFunctionInfo function_info(bind_data, init_data);
@@ -163333,11 +163366,45 @@ unique_ptr<BoundTableRef> Binder::Bind(SubqueryRef &ref, CommonTableExpressionIn
 
 
 
+
+
 namespace duckdb {
 
-bool Binder::BindFunctionParameters(vector<unique_ptr<ParsedExpression>> &expressions, vector<LogicalType> &arguments,
-                                    vector<Value> &parameters, named_parameter_map_t &named_parameters,
-                                    unique_ptr<BoundSubqueryRef> &subquery, string &error) {
+static bool IsTableInTableOutFunction(TableFunctionCatalogEntry &table_function) {
+	return table_function.functions.size() == 1 && table_function.functions[0].arguments.size() == 1 &&
+	       table_function.functions[0].arguments[0].id() == LogicalTypeId::TABLE;
+}
+
+bool Binder::BindTableInTableOutFunction(vector<unique_ptr<ParsedExpression>> &expressions,
+                                         unique_ptr<BoundSubqueryRef> &subquery, string &error) {
+	auto binder = Binder::CreateBinder(this->context, this, true);
+	if (expressions.size() == 1 && expressions[0]->type == ExpressionType::SUBQUERY) {
+		// general case: argument is a subquery, bind it as part of the node
+		auto &se = (SubqueryExpression &)*expressions[0];
+		auto node = binder->BindNode(*se.subquery->node);
+		subquery = make_unique<BoundSubqueryRef>(move(binder), move(node));
+		return true;
+	}
+	// special case: non-subquery parameter to table-in table-out function
+	// generate a subquery and bind that (i.e. UNNEST([1,2,3]) becomes UNNEST((SELECT [1,2,3]))
+	auto select_node = make_unique<SelectNode>();
+	select_node->select_list = move(expressions);
+	select_node->from_table = make_unique<EmptyTableRef>();
+	auto node = binder->BindNode(*select_node);
+	subquery = make_unique<BoundSubqueryRef>(move(binder), move(node));
+	return true;
+}
+
+bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_function,
+                                         vector<unique_ptr<ParsedExpression>> &expressions,
+                                         vector<LogicalType> &arguments, vector<Value> &parameters,
+                                         named_parameter_map_t &named_parameters,
+                                         unique_ptr<BoundSubqueryRef> &subquery, string &error) {
+	if (IsTableInTableOutFunction(table_function)) {
+		// special case binding for table-in table-out function
+		arguments.emplace_back(LogicalTypeId::TABLE);
+		return BindTableInTableOutFunction(expressions, subquery, error);
+	}
 	bool seen_subquery = false;
 	for (auto &child : expressions) {
 		string parameter_name;
@@ -163367,6 +163434,7 @@ bool Binder::BindFunctionParameters(vector<unique_ptr<ParsedExpression>> &expres
 			arguments.emplace_back(LogicalTypeId::TABLE);
 			continue;
 		}
+
 		ConstantBinder binder(*this, context, "TABLE FUNCTION parameter");
 		LogicalType sql_type;
 		auto expr = binder.Bind(child, &sql_type);
@@ -163435,7 +163503,8 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 	named_parameter_map_t named_parameters;
 	unique_ptr<BoundSubqueryRef> subquery;
 	string error;
-	if (!BindFunctionParameters(fexpr->children, arguments, parameters, named_parameters, subquery, error)) {
+	if (!BindTableFunctionParameters(*function, fexpr->children, arguments, parameters, named_parameters, subquery,
+	                                 error)) {
 		throw BinderException(FormatError(ref, error));
 	}