duckdb 1.0.1-dev22.0 → 1.0.1-dev27.0

package/src/duckdb/src/function/table/query_function.cpp

@@ -0,0 +1,80 @@
+#include "duckdb/parser/parser.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/function/table/range.hpp"
+#include "duckdb/function/function_set.hpp"
+#include "duckdb/parser/tableref/subqueryref.hpp"
+
+namespace duckdb {
+
+static unique_ptr<SubqueryRef> ParseSubquery(const string &query, const ParserOptions &options, const string &err_msg) {
+	Parser parser(options);
+	parser.ParseQuery(query);
+	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
+		throw ParserException(err_msg);
+	}
+	auto select_stmt = unique_ptr_cast<SQLStatement, SelectStatement>(std::move(parser.statements[0]));
+	return duckdb::make_uniq<SubqueryRef>(std::move(select_stmt));
+}
+
+static void UnionTablesQuery(TableFunctionBindInput &input, string &query) {
+	for (auto &input_val : input.inputs) {
+		if (input_val.IsNull()) {
+			throw BinderException("Cannot use NULL as function argument");
+		}
+	}
+	string by_name = (input.inputs.size() == 2 &&
+	                  (input.inputs[1].type().id() == LogicalTypeId::BOOLEAN && input.inputs[1].GetValue<bool>()))
+	                     ? "BY NAME "
+	                     : ""; // 'by_name' variable defaults to false
+	if (input.inputs[0].type().id() == LogicalTypeId::VARCHAR) {
+		query += "FROM " + KeywordHelper::WriteOptionallyQuoted(input.inputs[0].ToString());
+	} else if (input.inputs[0].type() == LogicalType::LIST(LogicalType::VARCHAR)) {
+		string union_all_clause = " UNION ALL " + by_name + "FROM ";
+		const auto &children = ListValue::GetChildren(input.inputs[0]);
+		if (children.empty()) {
+			throw InvalidInputException("Input list is empty");
+		}
+
+		query += "FROM " + KeywordHelper::WriteOptionallyQuoted(children[0].ToString());
+		for (size_t i = 1; i < children.size(); ++i) {
+			auto child = children[i].ToString();
+			query += union_all_clause + KeywordHelper::WriteOptionallyQuoted(child);
+		}
+	} else {
+		throw InvalidInputException("Expected a table or a list with tables as input");
+	}
+}
+
+static unique_ptr<TableRef> QueryBindReplace(ClientContext &context, TableFunctionBindInput &input) {
+	auto query = input.inputs[0].ToString();
+	auto subquery_ref = ParseSubquery(query, context.GetParserOptions(), "Expected a single SELECT statement");
+	return std::move(subquery_ref);
+}
+
+static unique_ptr<TableRef> TableBindReplace(ClientContext &context, TableFunctionBindInput &input) {
+	string query;
+	UnionTablesQuery(input, query);
+	auto subquery_ref =
+	    ParseSubquery(query, context.GetParserOptions(), "Expected a table or a list with tables as input");
+	return std::move(subquery_ref);
+}
+
+void QueryTableFunction::RegisterFunction(BuiltinFunctions &set) {
+	TableFunction query("query", {LogicalType::VARCHAR}, nullptr, nullptr);
+	query.bind_replace = QueryBindReplace;
+	set.AddFunction(query);
+
+	TableFunctionSet query_table("query_table");
+	TableFunction query_table_function({LogicalType::VARCHAR}, nullptr, nullptr);
+	query_table_function.bind_replace = TableBindReplace;
+	query_table.AddFunction(query_table_function);
+
+	query_table_function.arguments = {LogicalType::LIST(LogicalType::VARCHAR)};
+	query_table.AddFunction(query_table_function);
+	// add by_name option
+	query_table_function.arguments.emplace_back(LogicalType::BOOLEAN);
+	query_table.AddFunction(query_table_function);
+	set.AddFunction(query_table);
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/table/range.cpp

@@ -11,129 +11,196 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 // Range (integers)
 //===--------------------------------------------------------------------===//
+static void GetParameters(int64_t values[], idx_t value_count, hugeint_t &start, hugeint_t &end, hugeint_t &increment) {
+	if (value_count < 2) {
+		// single argument: only the end is specified
+		start = 0;
+		end = values[0];
+	} else {
+		// two arguments: first two arguments are start and end
+		start = values[0];
+		end = values[1];
+	}
+	if (value_count < 3) {
+		increment = 1;
+	} else {
+		increment = values[2];
+	}
+}
+
 struct RangeFunctionBindData : public TableFunctionData {
+	explicit RangeFunctionBindData(const vector<Value> &inputs) : cardinality(0) {
+		int64_t values[3];
+		for (idx_t i = 0; i < inputs.size(); i++) {
+			if (inputs[i].IsNull()) {
+				return;
+			}
+			values[i] = inputs[i].GetValue<int64_t>();
+		}
+		hugeint_t start;
+		hugeint_t end;
+		hugeint_t increment;
+		GetParameters(values, inputs.size(), start, end, increment);
+		cardinality = Hugeint::Cast<idx_t>((end - start) / increment);
+	}
+
+	idx_t cardinality;
+};
+
+template <bool GENERATE_SERIES>
+static unique_ptr<FunctionData> RangeFunctionBind(ClientContext &context, TableFunctionBindInput &input,
+                                                  vector<LogicalType> &return_types, vector<string> &names) {
+	return_types.emplace_back(LogicalType::BIGINT);
+	if (GENERATE_SERIES) {
+		names.emplace_back("generate_series");
+	} else {
+		names.emplace_back("range");
+	}
+	if (input.inputs.empty() || input.inputs.size() > 3) {
+		return nullptr;
+	}
+	return make_uniq<RangeFunctionBindData>(input.inputs);
+}
+
+struct RangeFunctionLocalState : public LocalTableFunctionState {
+	RangeFunctionLocalState() {
+	}
+
+	bool initialized_row = false;
+	idx_t current_input_row = 0;
+	idx_t current_idx = 0;
+
 	hugeint_t start;
 	hugeint_t end;
 	hugeint_t increment;
-
-public:
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<RangeFunctionBindData>();
-		return other.start == start && other.end == end && other.increment == increment;
-	}
 };
 
+static unique_ptr<LocalTableFunctionState> RangeFunctionLocalInit(ExecutionContext &context,
+                                                                  TableFunctionInitInput &input,
+                                                                  GlobalTableFunctionState *global_state) {
+	return make_uniq<RangeFunctionLocalState>();
+}
+
 template <bool GENERATE_SERIES>
-static void GenerateRangeParameters(const vector<Value> &inputs, RangeFunctionBindData &result) {
-	for (auto &input : inputs) {
-		if (input.IsNull()) {
+static void GenerateRangeParameters(DataChunk &input, idx_t row_id, RangeFunctionLocalState &result) {
+	input.Flatten();
+	for (idx_t c = 0; c < input.ColumnCount(); c++) {
+		if (FlatVector::IsNull(input.data[c], row_id)) {
 			result.start = GENERATE_SERIES ? 1 : 0;
 			result.end = 0;
 			result.increment = 1;
 			return;
 		}
 	}
-	if (inputs.size() < 2) {
-		// single argument: only the end is specified
-		result.start = 0;
-		result.end = inputs[0].GetValue<int64_t>();
-	} else {
-		// two arguments: first two arguments are start and end
-		result.start = inputs[0].GetValue<int64_t>();
-		result.end = inputs[1].GetValue<int64_t>();
-	}
-	if (inputs.size() < 3) {
-		result.increment = 1;
-	} else {
-		result.increment = inputs[2].GetValue<int64_t>();
+	int64_t values[3];
+	for (idx_t c = 0; c < input.ColumnCount(); c++) {
+		if (c >= 3) {
+			throw InternalException("Unsupported parameter count for range function");
+		}
+		values[c] = FlatVector::GetValue<int64_t>(input.data[c], row_id);
 	}
+	GetParameters(values, input.ColumnCount(), result.start, result.end, result.increment);
 	if (result.increment == 0) {
 		throw BinderException("interval cannot be 0!");
 	}
 	if (result.start > result.end && result.increment > 0) {
 		throw BinderException("start is bigger than end, but increment is positive: cannot generate infinite series");
-	} else if (result.start < result.end && result.increment < 0) {
+	}
+	if (result.start < result.end && result.increment < 0) {
 		throw BinderException("start is smaller than end, but increment is negative: cannot generate infinite series");
 	}
-}
-
-template <bool GENERATE_SERIES>
-static unique_ptr<FunctionData> RangeFunctionBind(ClientContext &context, TableFunctionBindInput &input,
-                                                  vector<LogicalType> &return_types, vector<string> &names) {
-	auto result = make_uniq<RangeFunctionBindData>();
-	auto &inputs = input.inputs;
-	GenerateRangeParameters<GENERATE_SERIES>(inputs, *result);
-
-	return_types.emplace_back(LogicalType::BIGINT);
 	if (GENERATE_SERIES) {
 		// generate_series has inclusive bounds on the RHS
-		if (result->increment < 0) {
-			result->end = result->end - 1;
+		if (result.increment < 0) {
+			result.end = result.end - 1;
 		} else {
-			result->end = result->end + 1;
+			result.end = result.end + 1;
 		}
-		names.emplace_back("generate_series");
-	} else {
-		names.emplace_back("range");
 	}
-	return std::move(result);
 }
 
-struct RangeFunctionState : public GlobalTableFunctionState {
-	RangeFunctionState() : current_idx(0) {
-	}
-
-	int64_t current_idx;
-};
-
-static unique_ptr<GlobalTableFunctionState> RangeFunctionInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_uniq<RangeFunctionState>();
-}
-
-static void RangeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = data_p.bind_data->Cast<RangeFunctionBindData>();
-	auto &state = data_p.global_state->Cast<RangeFunctionState>();
-
-	auto increment = bind_data.increment;
-	auto end = bind_data.end;
-	hugeint_t current_value = bind_data.start + increment * state.current_idx;
-	int64_t current_value_i64;
-	if (!Hugeint::TryCast<int64_t>(current_value, current_value_i64)) {
-		return;
+template <bool GENERATE_SERIES>
+static OperatorResultType RangeFunction(ExecutionContext &context, TableFunctionInput &data_p, DataChunk &input,
+                                        DataChunk &output) {
+	auto &state = data_p.local_state->Cast<RangeFunctionLocalState>();
+	while (true) {
+		if (!state.initialized_row) {
+			// initialize for the current input row
+			if (state.current_input_row >= input.size()) {
+				// ran out of rows
+				state.current_input_row = 0;
+				state.initialized_row = false;
+				return OperatorResultType::NEED_MORE_INPUT;
+			}
+			GenerateRangeParameters<GENERATE_SERIES>(input, state.current_input_row, state);
+			state.initialized_row = true;
+			state.current_idx = 0;
+		}
+		auto increment = state.increment;
+		auto end = state.end;
+		hugeint_t current_value = state.start + increment * UnsafeNumericCast<int64_t>(state.current_idx);
+		int64_t current_value_i64;
+		if (!Hugeint::TryCast<int64_t>(current_value, current_value_i64)) {
+			// move to next row
+			state.current_input_row++;
+			state.initialized_row = false;
+			continue;
+		}
+		int64_t offset = increment < 0 ? 1 : -1;
+		idx_t remaining = MinValue<idx_t>(
+		    Hugeint::Cast<idx_t>((end - current_value + (increment + offset)) / increment), STANDARD_VECTOR_SIZE);
+		// set the result vector as a sequence vector
+		output.data[0].Sequence(current_value_i64, Hugeint::Cast<int64_t>(increment), remaining);
+		// increment the index pointer by the remaining count
+		state.current_idx += remaining;
+		output.SetCardinality(remaining);
+		if (remaining == 0) {
+			// move to next row
+			state.current_input_row++;
+			state.initialized_row = false;
+			continue;
+		}
+		return OperatorResultType::HAVE_MORE_OUTPUT;
 	}
-	int64_t offset = increment < 0 ? 1 : -1;
-	idx_t remaining = MinValue<idx_t>(Hugeint::Cast<idx_t>((end - current_value + (increment + offset)) / increment),
-	                                  STANDARD_VECTOR_SIZE);
-	// set the result vector as a sequence vector
-	output.data[0].Sequence(current_value_i64, Hugeint::Cast<int64_t>(increment), remaining);
-	// increment the index pointer by the remaining count
-	state.current_idx += remaining;
-	output.SetCardinality(remaining);
 }
 
 unique_ptr<NodeStatistics> RangeCardinality(ClientContext &context, const FunctionData *bind_data_p) {
+	if (!bind_data_p) {
+		return nullptr;
+	}
 	auto &bind_data = bind_data_p->Cast<RangeFunctionBindData>();
-	idx_t cardinality = Hugeint::Cast<idx_t>((bind_data.end - bind_data.start) / bind_data.increment);
-	return make_uniq<NodeStatistics>(cardinality, cardinality);
+	return make_uniq<NodeStatistics>(bind_data.cardinality, bind_data.cardinality);
 }
 
 //===--------------------------------------------------------------------===//
 // Range (timestamp)
 //===--------------------------------------------------------------------===//
-struct RangeDateTimeBindData : public TableFunctionData {
+template <bool GENERATE_SERIES>
+static unique_ptr<FunctionData> RangeDateTimeBind(ClientContext &context, TableFunctionBindInput &input,
+                                                  vector<LogicalType> &return_types, vector<string> &names) {
+	return_types.push_back(LogicalType::TIMESTAMP);
+	if (GENERATE_SERIES) {
+		names.emplace_back("generate_series");
+	} else {
+		names.emplace_back("range");
+	}
+	return nullptr;
+}
+
+struct RangeDateTimeLocalState : public LocalTableFunctionState {
+	RangeDateTimeLocalState() {
+	}
+
+	bool initialized_row = false;
+	idx_t current_input_row = 0;
+	timestamp_t current_state;
+
 	timestamp_t start;
 	timestamp_t end;
 	interval_t increment;
 	bool inclusive_bound;
 	bool greater_than_check;
 
-public:
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = other_p.Cast<RangeDateTimeBindData>();
-		return other.start == start && other.end == end && other.increment == increment &&
-		       other.inclusive_bound == inclusive_bound && other.greater_than_check == greater_than_check;
-	}
-
 	bool Finished(timestamp_t current_value) const {
 		if (greater_than_check) {
 			if (inclusive_bound) {
@@ -152,98 +219,105 @@ public:
 };
 
 template <bool GENERATE_SERIES>
-static unique_ptr<FunctionData> RangeDateTimeBind(ClientContext &context, TableFunctionBindInput &input,
-                                                  vector<LogicalType> &return_types, vector<string> &names) {
-	auto result = make_uniq<RangeDateTimeBindData>();
-	auto &inputs = input.inputs;
-	D_ASSERT(inputs.size() == 3);
-	for (idx_t i = 0; i < inputs.size(); ++i) {
-		if (inputs[i].IsNull()) {
-			throw BinderException("RANGE with NULL argument is not supported");
+static void GenerateRangeDateTimeParameters(DataChunk &input, idx_t row_id, RangeDateTimeLocalState &result) {
+	input.Flatten();
+
+	for (idx_t c = 0; c < input.ColumnCount(); c++) {
+		if (FlatVector::IsNull(input.data[c], row_id)) {
+			result.start = timestamp_t(0);
+			result.end = timestamp_t(0);
+			result.increment = interval_t();
+			result.greater_than_check = true;
+			result.inclusive_bound = false;
+			return;
 		}
 	}
-	result->start = inputs[0].GetValue<timestamp_t>();
-	result->end = inputs[1].GetValue<timestamp_t>();
-	result->increment = inputs[2].GetValue<interval_t>();
+
+	result.start = FlatVector::GetValue<timestamp_t>(input.data[0], row_id);
+	result.end = FlatVector::GetValue<timestamp_t>(input.data[1], row_id);
+	result.increment = FlatVector::GetValue<interval_t>(input.data[2], row_id);
 
 	// Infinities either cause errors or infinite loops, so just ban them
-	if (!Timestamp::IsFinite(result->start) || !Timestamp::IsFinite(result->end)) {
+	if (!Timestamp::IsFinite(result.start) || !Timestamp::IsFinite(result.end)) {
 		throw BinderException("RANGE with infinite bounds is not supported");
 	}
 
-	if (result->increment.months == 0 && result->increment.days == 0 && result->increment.micros == 0) {
+	if (result.increment.months == 0 && result.increment.days == 0 && result.increment.micros == 0) {
 		throw BinderException("interval cannot be 0!");
 	}
 	// all elements should point in the same direction
-	if (result->increment.months > 0 || result->increment.days > 0 || result->increment.micros > 0) {
-		if (result->increment.months < 0 || result->increment.days < 0 || result->increment.micros < 0) {
+	if (result.increment.months > 0 || result.increment.days > 0 || result.increment.micros > 0) {
+		if (result.increment.months < 0 || result.increment.days < 0 || result.increment.micros < 0) {
 			throw BinderException("RANGE with composite interval that has mixed signs is not supported");
 		}
-		result->greater_than_check = true;
-		if (result->start > result->end) {
+		result.greater_than_check = true;
+		if (result.start > result.end) {
 			throw BinderException(
 			    "start is bigger than end, but increment is positive: cannot generate infinite series");
 		}
 	} else {
-		result->greater_than_check = false;
-		if (result->start < result->end) {
+		result.greater_than_check = false;
+		if (result.start < result.end) {
 			throw BinderException(
 			    "start is smaller than end, but increment is negative: cannot generate infinite series");
 		}
 	}
-	return_types.push_back(inputs[0].type());
-	if (GENERATE_SERIES) {
-		// generate_series has inclusive bounds on the RHS
-		result->inclusive_bound = true;
-		names.emplace_back("generate_series");
-	} else {
-		result->inclusive_bound = false;
-		names.emplace_back("range");
-	}
-	return std::move(result);
+	result.inclusive_bound = GENERATE_SERIES;
 }
 
-struct RangeDateTimeState : public GlobalTableFunctionState {
-	explicit RangeDateTimeState(timestamp_t start_p) : current_state(start_p) {
-	}
-
-	timestamp_t current_state;
-	bool finished = false;
-};
-
-static unique_ptr<GlobalTableFunctionState> RangeDateTimeInit(ClientContext &context, TableFunctionInitInput &input) {
-	auto &bind_data = input.bind_data->Cast<RangeDateTimeBindData>();
-	return make_uniq<RangeDateTimeState>(bind_data.start);
+static unique_ptr<LocalTableFunctionState> RangeDateTimeLocalInit(ExecutionContext &context,
+                                                                  TableFunctionInitInput &input,
+                                                                  GlobalTableFunctionState *global_state) {
+	return make_uniq<RangeDateTimeLocalState>();
 }
 
-static void RangeDateTimeFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = data_p.bind_data->Cast<RangeDateTimeBindData>();
-	auto &state = data_p.global_state->Cast<RangeDateTimeState>();
-	if (state.finished) {
-		return;
-	}
-
-	idx_t size = 0;
-	auto data = FlatVector::GetData<timestamp_t>(output.data[0]);
+template <bool GENERATE_SERIES>
+static OperatorResultType RangeDateTimeFunction(ExecutionContext &context, TableFunctionInput &data_p, DataChunk &input,
+                                                DataChunk &output) {
+	auto &state = data_p.local_state->Cast<RangeDateTimeLocalState>();
 	while (true) {
-		if (bind_data.Finished(state.current_state)) {
-			state.finished = true;
-			break;
+		if (!state.initialized_row) {
+			// initialize for the current input row
+			if (state.current_input_row >= input.size()) {
+				// ran out of rows
+				state.current_input_row = 0;
+				state.initialized_row = false;
+				return OperatorResultType::NEED_MORE_INPUT;
+			}
+			GenerateRangeDateTimeParameters<GENERATE_SERIES>(input, state.current_input_row, state);
+			state.initialized_row = true;
+			state.current_state = state.start;
+		}
+		idx_t size = 0;
+		auto data = FlatVector::GetData<timestamp_t>(output.data[0]);
+		while (true) {
+			if (state.Finished(state.current_state)) {
+				break;
+			}
+			if (size >= STANDARD_VECTOR_SIZE) {
+				break;
+			}
+			data[size++] = state.current_state;
+			state.current_state =
+			    AddOperator::Operation<timestamp_t, interval_t, timestamp_t>(state.current_state, state.increment);
 		}
-		if (size >= STANDARD_VECTOR_SIZE) {
-			break;
+		if (size == 0) {
+			// move to next row
+			state.current_input_row++;
+			state.initialized_row = false;
+			continue;
 		}
-		data[size++] = state.current_state;
-		state.current_state =
-		    AddOperator::Operation<timestamp_t, interval_t, timestamp_t>(state.current_state, bind_data.increment);
+		output.SetCardinality(size);
+		return OperatorResultType::HAVE_MORE_OUTPUT;
 	}
-	output.SetCardinality(size);
 }
 
 void RangeTableFunction::RegisterFunction(BuiltinFunctions &set) {
 	TableFunctionSet range("range");
 
-	TableFunction range_function({LogicalType::BIGINT}, RangeFunction, RangeFunctionBind<false>, RangeFunctionInit);
+	TableFunction range_function({LogicalType::BIGINT}, nullptr, RangeFunctionBind<false>, nullptr,
+	                             RangeFunctionLocalInit);
+	range_function.in_out_function = RangeFunction<false>;
 	range_function.cardinality = RangeCardinality;
 
 	// single argument range: (end) - implicit start = 0 and increment = 1
@@ -254,20 +328,25 @@ void RangeTableFunction::RegisterFunction(BuiltinFunctions &set) {
 	// three arguments range: (start, end, increment)
 	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));
+	TableFunction range_in_out({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP, LogicalType::INTERVAL}, nullptr,
+	                           RangeDateTimeBind<false>, nullptr, RangeDateTimeLocalInit);
+	range_in_out.in_out_function = RangeDateTimeFunction<false>;
+	range.AddFunction(range_in_out);
 	set.AddFunction(range);
 	// generate_series: similar to range, but inclusive instead of exclusive bounds on the RHS
 	TableFunctionSet generate_series("generate_series");
 	range_function.bind = RangeFunctionBind<true>;
+	range_function.in_out_function = RangeFunction<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));
+	TableFunction generate_series_in_out({LogicalType::TIMESTAMP, LogicalType::TIMESTAMP, LogicalType::INTERVAL},
+	                                     nullptr, RangeDateTimeBind<true>, nullptr, RangeDateTimeLocalInit);
+	generate_series_in_out.in_out_function = RangeDateTimeFunction<true>;
+	generate_series.AddFunction(generate_series_in_out);
 	set.AddFunction(generate_series);
 }
 
@@ -282,6 +361,7 @@ void BuiltinFunctions::RegisterTableFunctions() {
 	CSVSnifferFunction::RegisterFunction(*this);
 	ReadBlobFunction::RegisterFunction(*this);
 	ReadTextFunction::RegisterFunction(*this);
+	QueryTableFunction::RegisterFunction(*this);
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/table/read_csv.cpp

@@ -51,7 +51,7 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 	auto multi_file_reader = MultiFileReader::Create(input.table_function);
 	auto multi_file_list = multi_file_reader->CreateFileList(context, input.inputs[0]);
 
-	options.FromNamedParameters(input.named_parameters, context, return_types, names);
+	options.FromNamedParameters(input.named_parameters, context);
 	if (options.rejects_table_name.IsSetByUser() && !options.store_rejects.GetValue() &&
 	    options.store_rejects.IsSetByUser()) {
 		throw BinderException("REJECTS_TABLE option is only supported when store_rejects is not manually set to false");
@@ -82,16 +82,20 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 
 	options.file_options.AutoDetectHivePartitioning(*multi_file_list, context);
 
-	if (!options.auto_detect && return_types.empty()) {
-		throw BinderException("read_csv requires columns to be specified through the 'columns' option. Use "
-		                      "read_csv_auto or set read_csv(..., "
-		                      "AUTO_DETECT=TRUE) to automatically guess columns.");
+	if (!options.auto_detect) {
+		if (!options.columns_set) {
+			throw BinderException("read_csv requires columns to be specified through the 'columns' option. Use "
+			                      "read_csv_auto or set read_csv(..., "
+			                      "AUTO_DETECT=TRUE) to automatically guess columns.");
+		} else {
+			names = options.name_list;
+			return_types = options.sql_type_list;
+		}
 	}
 	if (options.auto_detect && !options.file_options.union_by_name) {
 		options.file_path = multi_file_list->GetFirstFile();
 		result->buffer_manager = make_shared_ptr<CSVBufferManager>(context, options, options.file_path, 0);
-		CSVSniffer sniffer(options, result->buffer_manager, CSVStateMachineCache::Get(context),
-		                   {&return_types, &names});
+		CSVSniffer sniffer(options, result->buffer_manager, CSVStateMachineCache::Get(context));
 		auto sniffer_result = sniffer.SniffCSV();
 		if (names.empty()) {
 			names = sniffer_result.names;
@@ -107,8 +111,7 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 		result->reader_bind = multi_file_reader->BindUnionReader<CSVFileScan>(context, return_types, names,
 		                                                                      *multi_file_list, *result, options);
 		if (result->union_readers.size() > 1) {
-			result->column_info.emplace_back(result->initial_reader->names, result->initial_reader->types);
-			for (idx_t i = 1; i < result->union_readers.size(); i++) {
+			for (idx_t i = 0; i < result->union_readers.size(); i++) {
 				result->column_info.emplace_back(result->union_readers[i]->names, result->union_readers[i]->types);
 			}
 		}
@@ -202,6 +205,10 @@ unique_ptr<LocalTableFunctionState> ReadCSVInitLocal(ExecutionContext &context,
 		return nullptr;
 	}
 	auto &global_state = global_state_p->Cast<CSVGlobalState>();
+	if (global_state.IsDone()) {
+		// nothing to do
+		return nullptr;
+	}
 	auto csv_scanner = global_state.Next(nullptr);
 	if (!csv_scanner) {
 		global_state.DecrementThread();
@@ -215,6 +222,9 @@ static void ReadCSVFunction(ClientContext &context, TableFunctionInput &data_p,
 		return;
 	}
 	auto &csv_global_state = data_p.global_state->Cast<CSVGlobalState>();
+	if (!data_p.local_state) {
+		return;
+	}
 	auto &csv_local_state = data_p.local_state->Cast<CSVLocalState>();
 
 	if (!csv_local_state.csv_reader) {
@@ -282,6 +292,7 @@ void ReadCSVTableFunction::ReadCSVAddNamedParameters(TableFunction &table_functi
 	table_function.named_parameters["names"] = LogicalType::LIST(LogicalType::VARCHAR);
 	table_function.named_parameters["column_names"] = LogicalType::LIST(LogicalType::VARCHAR);
 	table_function.named_parameters["parallel"] = LogicalType::BOOLEAN;
+	table_function.named_parameters["comment"] = LogicalType::VARCHAR;
 
 	MultiFileReader::AddParameters(table_function);
 }
@@ -300,8 +311,9 @@ void CSVComplexFilterPushdown(ClientContext &context, LogicalGet &get, FunctionD
                               vector<unique_ptr<Expression>> &filters) {
 	auto &data = bind_data_p->Cast<ReadCSVData>();
 	SimpleMultiFileList file_list(data.files);
+	MultiFilePushdownInfo info(get);
 	auto filtered_list =
-	    MultiFileReader().ComplexFilterPushdown(context, file_list, data.options.file_options, get, filters);
+	    MultiFileReader().ComplexFilterPushdown(context, file_list, data.options.file_options, info, filters);
 	if (filtered_list) {
 		data.files = filtered_list->GetAllFiles();
 		MultiFileReader::PruneReaders(data, file_list);
@@ -375,12 +387,12 @@ void ReadCSVTableFunction::RegisterFunction(BuiltinFunctions &set) {
 
 unique_ptr<TableRef> ReadCSVReplacement(ClientContext &context, ReplacementScanInput &input,
                                         optional_ptr<ReplacementScanData> data) {
-	auto &table_name = input.table_name;
+	auto table_name = ReplacementScan::GetFullPath(input);
 	auto lower_name = StringUtil::Lower(table_name);
 	// remove any compression
-	if (StringUtil::EndsWith(lower_name, ".gz")) {
+	if (StringUtil::EndsWith(lower_name, CompressionExtensionFromType(FileCompressionType::GZIP))) {
 		lower_name = lower_name.substr(0, lower_name.size() - 3);
-	} else if (StringUtil::EndsWith(lower_name, ".zst")) {
+	} else if (StringUtil::EndsWith(lower_name, CompressionExtensionFromType(FileCompressionType::ZSTD))) {
 		if (!Catalog::TryAutoLoad(context, "parquet")) {
 			throw MissingExtensionException("parquet extension is required for reading zst compressed file");
 		}