duckdb 0.10.3-dev3.0 → 0.10.3-dev8.0

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

@@ -12,6 +12,14 @@
 #include "duckdb/function/scalar/string_functions.hpp"
 #include "duckdb/function/table/read_csv.hpp"
 #include "duckdb/parser/parsed_data/copy_info.hpp"
+#include "duckdb/parser/expression/cast_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
+#include "duckdb/parser/expression/columnref_expression.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression/bound_expression.hpp"
+#include "duckdb/planner/expression/bound_reference_expression.hpp"
+#include "duckdb/execution/column_binding_resolver.hpp"
+#include "duckdb/planner/operator/logical_dummy_scan.hpp"
 #include <limits>
 
 namespace duckdb {
@@ -93,6 +101,62 @@ string TransformNewLine(string new_line) {
 	;
 }
 
+static vector<unique_ptr<Expression>> CreateCastExpressions(WriteCSVData &bind_data, ClientContext &context,
+                                                            const vector<string> &names,
+                                                            const vector<LogicalType> &sql_types) {
+	auto &options = bind_data.options;
+	auto &formats = options.write_date_format;
+
+	bool has_dateformat = !formats[LogicalTypeId::DATE].IsNull();
+	bool has_timestampformat = !formats[LogicalTypeId::TIMESTAMP].IsNull();
+
+	// Create a binder
+	auto binder = Binder::CreateBinder(context);
+
+	auto &bind_context = binder->bind_context;
+	auto table_index = binder->GenerateTableIndex();
+	bind_context.AddGenericBinding(table_index, "copy_csv", names, sql_types);
+
+	// Create the ParsedExpressions (cast, strftime, etc..)
+	vector<unique_ptr<ParsedExpression>> unbound_expressions;
+	for (idx_t i = 0; i < sql_types.size(); i++) {
+		auto &type = sql_types[i];
+		auto &name = names[i];
+
+		bool is_timestamp = type.id() == LogicalTypeId::TIMESTAMP || type.id() == LogicalTypeId::TIMESTAMP_TZ;
+		if (has_dateformat && type.id() == LogicalTypeId::DATE) {
+			// strftime(<name>, 'format')
+			vector<unique_ptr<ParsedExpression>> children;
+			children.push_back(make_uniq<BoundExpression>(make_uniq<BoundReferenceExpression>(name, type, i)));
+			children.push_back(make_uniq<ConstantExpression>(formats[LogicalTypeId::DATE]));
+			auto func = make_uniq_base<ParsedExpression, FunctionExpression>("strftime", std::move(children));
+			unbound_expressions.push_back(std::move(func));
+		} else if (has_timestampformat && is_timestamp) {
+			// strftime(<name>, 'format')
+			vector<unique_ptr<ParsedExpression>> children;
+			children.push_back(make_uniq<BoundExpression>(make_uniq<BoundReferenceExpression>(name, type, i)));
+			children.push_back(make_uniq<ConstantExpression>(formats[LogicalTypeId::TIMESTAMP]));
+			auto func = make_uniq_base<ParsedExpression, FunctionExpression>("strftime", std::move(children));
+			unbound_expressions.push_back(std::move(func));
+		} else {
+			// CAST <name> AS VARCHAR
+			auto column = make_uniq<BoundExpression>(make_uniq<BoundReferenceExpression>(name, type, i));
+			auto expr = make_uniq_base<ParsedExpression, CastExpression>(LogicalType::VARCHAR, std::move(column));
+			unbound_expressions.push_back(std::move(expr));
+		}
+	}
+
+	// Create an ExpressionBinder, bind the Expressions
+	vector<unique_ptr<Expression>> expressions;
+	ExpressionBinder expression_binder(*binder, context);
+	expression_binder.target_type = LogicalType::VARCHAR;
+	for (auto &expr : unbound_expressions) {
+		expressions.push_back(expression_binder.Bind(expr));
+	}
+
+	return expressions;
+}
+
 static unique_ptr<FunctionData> WriteCSVBind(ClientContext &context, CopyFunctionBindInput &input,
                                              const vector<string> &names, const vector<LogicalType> &sql_types) {
 	auto bind_data = make_uniq<WriteCSVData>(input.info.file_path, sql_types, names);
@@ -110,12 +174,17 @@ static unique_ptr<FunctionData> WriteCSVBind(ClientContext &context, CopyFunctio
 	}
 	bind_data->Finalize();
 
+	auto expressions = CreateCastExpressions(*bind_data, context, names, sql_types);
+	bind_data->cast_expressions = std::move(expressions);
+
 	bind_data->requires_quotes = make_unsafe_uniq_array<bool>(256);
 	memset(bind_data->requires_quotes.get(), 0, sizeof(bool) * 256);
 	bind_data->requires_quotes['\n'] = true;
 	bind_data->requires_quotes['\r'] = true;
-	bind_data->requires_quotes[bind_data->options.dialect_options.state_machine_options.delimiter.GetValue()] = true;
-	bind_data->requires_quotes[bind_data->options.dialect_options.state_machine_options.quote.GetValue()] = true;
+	bind_data->requires_quotes[NumericCast<idx_t>(
+	    bind_data->options.dialect_options.state_machine_options.delimiter.GetValue())] = true;
+	bind_data->requires_quotes[NumericCast<idx_t>(
+	    bind_data->options.dialect_options.state_machine_options.quote.GetValue())] = true;
 
 	if (!bind_data->options.write_newline.empty()) {
 		bind_data->newline = TransformNewLine(bind_data->options.write_newline);
@@ -130,7 +199,9 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, CopyInfo &in
 	bind_data->csv_names = expected_names;
 	bind_data->return_types = expected_types;
 	bind_data->return_names = expected_names;
-	bind_data->files = MultiFileReader::GetFileList(context, Value(info.file_path), "CSV");
+
+	auto multi_file_reader = MultiFileReader::CreateDefault("CSVCopy");
+	bind_data->files = multi_file_reader->CreateFileList(context, Value(info.file_path))->GetAllFiles();
 
 	auto &options = bind_data->options;
 
@@ -159,7 +230,7 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, CopyInfo &in
 	}
 
 	if (options.auto_detect) {
-		auto buffer_manager = make_shared<CSVBufferManager>(context, options, bind_data->files[0], 0);
+		auto buffer_manager = make_shared_ptr<CSVBufferManager>(context, options, bind_data->files[0], 0);
 		CSVSniffer sniffer(options, buffer_manager, CSVStateMachineCache::Get(context),
 		                   {&expected_types, &expected_names});
 		sniffer.SniffCSV();
@@ -262,6 +333,14 @@ static void WriteQuotedString(WriteStream &writer, WriteCSVData &csv_data, const
 // Sink
 //===--------------------------------------------------------------------===//
 struct LocalWriteCSVData : public LocalFunctionData {
+public:
+	LocalWriteCSVData(ClientContext &context, vector<unique_ptr<Expression>> &expressions)
+	    : executor(context, expressions) {
+	}
+
+public:
+	//! Used to execute the expressions that transform input -> string
+	ExpressionExecutor executor;
 	//! The thread-local buffer to write data into
 	MemoryStream stream;
 	//! A chunk with VARCHAR columns to cast intermediates into
@@ -314,7 +393,7 @@ struct GlobalWriteCSVData : public GlobalFunctionData {
 
 static unique_ptr<LocalFunctionData> WriteCSVInitializeLocal(ExecutionContext &context, FunctionData &bind_data) {
 	auto &csv_data = bind_data.Cast<WriteCSVData>();
-	auto local_data = make_uniq<LocalWriteCSVData>();
+	auto local_data = make_uniq<LocalWriteCSVData>(context.client, csv_data.cast_expressions);
 
 	// create the chunk with VARCHAR types
 	vector<LogicalType> types;
@@ -359,33 +438,16 @@ idx_t WriteCSVFileSize(GlobalFunctionData &gstate) {
 }
 
 static void WriteCSVChunkInternal(ClientContext &context, FunctionData &bind_data, DataChunk &cast_chunk,
-                                  MemoryStream &writer, DataChunk &input, bool &written_anything) {
+                                  MemoryStream &writer, DataChunk &input, bool &written_anything,
+                                  ExpressionExecutor &executor) {
 	auto &csv_data = bind_data.Cast<WriteCSVData>();
 	auto &options = csv_data.options;
 
 	// first cast the columns of the chunk to varchar
 	cast_chunk.Reset();
 	cast_chunk.SetCardinality(input);
-	for (idx_t col_idx = 0; col_idx < input.ColumnCount(); col_idx++) {
-		if (csv_data.sql_types[col_idx].id() == LogicalTypeId::VARCHAR) {
-			// VARCHAR, just reinterpret (cannot reference, because LogicalTypeId::VARCHAR is used by the JSON type too)
-			cast_chunk.data[col_idx].Reinterpret(input.data[col_idx]);
-		} else if (!csv_data.options.write_date_format[LogicalTypeId::DATE].Empty() &&
-		           csv_data.sql_types[col_idx].id() == LogicalTypeId::DATE) {
-			// use the date format to cast the chunk
-			csv_data.options.write_date_format[LogicalTypeId::DATE].ConvertDateVector(
-			    input.data[col_idx], cast_chunk.data[col_idx], input.size());
-		} else if (!csv_data.options.write_date_format[LogicalTypeId::TIMESTAMP].Empty() &&
-		           (csv_data.sql_types[col_idx].id() == LogicalTypeId::TIMESTAMP ||
-		            csv_data.sql_types[col_idx].id() == LogicalTypeId::TIMESTAMP_TZ)) {
-			// use the timestamp format to cast the chunk
-			csv_data.options.write_date_format[LogicalTypeId::TIMESTAMP].ConvertTimestampVector(
-			    input.data[col_idx], cast_chunk.data[col_idx], input.size());
-		} else {
-			// non varchar column, perform the cast
-			VectorOperations::Cast(context, input.data[col_idx], cast_chunk.data[col_idx], input.size());
-		}
-	}
+
+	executor.Execute(input, cast_chunk);
 
 	cast_chunk.Flatten();
 	// now loop over the vectors and output the values
@@ -426,7 +488,7 @@ static void WriteCSVSink(ExecutionContext &context, FunctionData &bind_data, Glo
 
 	// write data into the local buffer
 	WriteCSVChunkInternal(context.client, bind_data, local_data.cast_chunk, local_data.stream, input,
-	                      local_data.written_anything);
+	                      local_data.written_anything, local_data.executor);
 
 	// check if we should flush what we have currently written
 	auto &writer = local_data.stream;
@@ -504,11 +566,15 @@ unique_ptr<PreparedBatchData> WriteCSVPrepareBatch(ClientContext &context, Funct
 	DataChunk cast_chunk;
 	cast_chunk.Initialize(Allocator::Get(context), types);
 
+	auto &original_types = collection->Types();
+	auto expressions = CreateCastExpressions(csv_data, context, csv_data.options.name_list, original_types);
+	ExpressionExecutor executor(context, expressions);
+
 	// write CSV chunks to the batch data
 	bool written_anything = false;
 	auto batch = make_uniq<WriteCSVBatchData>();
 	for (auto &chunk : collection->Chunks()) {
-		WriteCSVChunkInternal(context, bind_data, cast_chunk, batch->stream, chunk, written_anything);
+		WriteCSVChunkInternal(context, bind_data, cast_chunk, batch->stream, chunk, written_anything, executor);
 	}
 	return std::move(batch);
 }

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

@@ -8,27 +8,33 @@
 namespace duckdb {
 
 struct GlobFunctionBindData : public TableFunctionData {
-	vector<string> files;
+	unique_ptr<MultiFileList> file_list;
 };
 
 static unique_ptr<FunctionData> GlobFunctionBind(ClientContext &context, TableFunctionBindInput &input,
                                                  vector<LogicalType> &return_types, vector<string> &names) {
 	auto result = make_uniq<GlobFunctionBindData>();
-	result->files = MultiFileReader::GetFileList(context, input.inputs[0], "Globbing", FileGlobOptions::ALLOW_EMPTY);
+	auto multi_file_reader = MultiFileReader::Create(input.table_function);
+	result->file_list = multi_file_reader->CreateFileList(context, input.inputs[0], FileGlobOptions::ALLOW_EMPTY);
 	return_types.emplace_back(LogicalType::VARCHAR);
 	names.emplace_back("file");
 	return std::move(result);
 }
 
 struct GlobFunctionState : public GlobalTableFunctionState {
-	GlobFunctionState() : current_idx(0) {
+	GlobFunctionState() {
 	}
 
-	idx_t current_idx;
+	MultiFileListScanData file_list_scan;
 };
 
 static unique_ptr<GlobalTableFunctionState> GlobFunctionInit(ClientContext &context, TableFunctionInitInput &input) {
-	return make_uniq<GlobFunctionState>();
+	auto &bind_data = input.bind_data->Cast<GlobFunctionBindData>();
+	auto res = make_uniq<GlobFunctionState>();
+
+	bind_data.file_list->InitializeScan(res->file_list_scan);
+
+	return std::move(res);
 }
 
 static void GlobFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
@@ -36,10 +42,12 @@ static void GlobFunction(ClientContext &context, TableFunctionInput &data_p, Dat
 	auto &state = data_p.global_state->Cast<GlobFunctionState>();
 
 	idx_t count = 0;
-	idx_t next_idx = MinValue<idx_t>(state.current_idx + STANDARD_VECTOR_SIZE, bind_data.files.size());
-	for (; state.current_idx < next_idx; state.current_idx++) {
-		output.data[0].SetValue(count, bind_data.files[state.current_idx]);
-		count++;
+	while (count < STANDARD_VECTOR_SIZE) {
+		string file;
+		if (!bind_data.file_list->Scan(state.file_list_scan, file)) {
+			break;
+		}
+		output.data[0].SetValue(count++, file);
 	}
 	output.SetCardinality(count);
 }

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

@@ -48,7 +48,8 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 
 	auto result = make_uniq<ReadCSVData>();
 	auto &options = result->options;
-	result->files = MultiFileReader::GetFileList(context, input.inputs[0], "CSV");
+	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);
 	if (options.rejects_table_name.IsSetByUser() && !options.store_rejects.GetValue() &&
@@ -79,7 +80,7 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 		throw BinderException("REJECTS_LIMIT option is only supported when REJECTS_TABLE is set to a table name");
 	}
 
-	options.file_options.AutoDetectHivePartitioning(result->files, context);
+	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 "
@@ -87,8 +88,8 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 		                      "AUTO_DETECT=TRUE) to automatically guess columns.");
 	}
 	if (options.auto_detect && !options.file_options.union_by_name) {
-		options.file_path = result->files[0];
-		result->buffer_manager = make_shared<CSVBufferManager>(context, options, result->files[0], 0);
+		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});
 		auto sniffer_result = sniffer.SniffCSV();
@@ -103,8 +104,8 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 	D_ASSERT(return_types.size() == names.size());
 	result->options.dialect_options.num_cols = names.size();
 	if (options.file_options.union_by_name) {
-		result->reader_bind =
-		    MultiFileReader::BindUnionReader<CSVFileScan>(context, return_types, names, *result, options);
+		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++) {
@@ -128,7 +129,8 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 	} else {
 		result->csv_types = return_types;
 		result->csv_names = names;
-		result->reader_bind = MultiFileReader::BindOptions(options.file_options, result->files, return_types, names);
+		multi_file_reader->BindOptions(options.file_options, *multi_file_list, return_types, names,
+		                               result->reader_bind);
 	}
 	result->return_types = return_types;
 	result->return_names = names;
@@ -153,6 +155,10 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 			}
 		}
 	}
+
+	// TODO: make the CSV reader use MultiFileList throughout, instead of converting to vector<string>
+	result->files = multi_file_list->GetAllFiles();
+
 	result->Finalize();
 	return std::move(result);
 }
@@ -217,8 +223,8 @@ static void ReadCSVFunction(ClientContext &context, TableFunctionInput &data_p,
 	}
 	do {
 		if (output.size() != 0) {
-			MultiFileReader::FinalizeChunk(bind_data.reader_bind,
-			                               csv_local_state.csv_reader->csv_file_scan->reader_data, output);
+			MultiFileReader().FinalizeChunk(context, bind_data.reader_bind,
+			                                csv_local_state.csv_reader->csv_file_scan->reader_data, output, nullptr);
 			break;
 		}
 		if (csv_local_state.csv_reader->FinishedIterator()) {
@@ -276,6 +282,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;
+
 	MultiFileReader::AddParameters(table_function);
 }
 
@@ -292,10 +299,14 @@ double CSVReaderProgress(ClientContext &context, const FunctionData *bind_data_p
 void CSVComplexFilterPushdown(ClientContext &context, LogicalGet &get, FunctionData *bind_data_p,
                               vector<unique_ptr<Expression>> &filters) {
 	auto &data = bind_data_p->Cast<ReadCSVData>();
-	auto reset_reader =
-	    MultiFileReader::ComplexFilterPushdown(context, data.files, data.options.file_options, get, filters);
-	if (reset_reader) {
-		MultiFileReader::PruneReaders(data);
+	SimpleMultiFileList file_list(data.files);
+	auto filtered_list =
+	    MultiFileReader().ComplexFilterPushdown(context, file_list, data.options.file_options, get, filters);
+	if (filtered_list) {
+		data.files = filtered_list->GetAllFiles();
+		MultiFileReader::PruneReaders(data, file_list);
+	} else {
+		data.files = file_list.GetAllFiles();
 	}
 }
 
@@ -326,6 +337,15 @@ static unique_ptr<FunctionData> CSVReaderDeserialize(Deserializer &deserializer,
 	return std::move(result);
 }
 
+void PushdownTypeToCSVScanner(ClientContext &context, optional_ptr<FunctionData> bind_data,
+                              const unordered_map<idx_t, LogicalType> &new_column_types) {
+	auto &csv_bind = bind_data->Cast<ReadCSVData>();
+	for (auto &type : new_column_types) {
+		csv_bind.csv_types[type.first] = type.second;
+		csv_bind.return_types[type.first] = type.second;
+	}
+}
+
 TableFunction ReadCSVTableFunction::GetFunction() {
 	TableFunction read_csv("read_csv", {LogicalType::VARCHAR}, ReadCSVFunction, ReadCSVBind, ReadCSVInitGlobal,
 	                       ReadCSVInitLocal);
@@ -336,6 +356,7 @@ TableFunction ReadCSVTableFunction::GetFunction() {
 	read_csv.get_batch_index = CSVReaderGetBatchIndex;
 	read_csv.cardinality = CSVReaderCardinality;
 	read_csv.projection_pushdown = true;
+	read_csv.type_pushdown = PushdownTypeToCSVScanner;
 	ReadCSVAddNamedParameters(read_csv);
 	return read_csv;
 }
@@ -352,7 +373,9 @@ void ReadCSVTableFunction::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(MultiFileReader::CreateFunctionSet(ReadCSVTableFunction::GetAutoFunction()));
 }
 
-unique_ptr<TableRef> ReadCSVReplacement(ClientContext &context, const string &table_name, ReplacementScanData *data) {
+unique_ptr<TableRef> ReadCSVReplacement(ClientContext &context, ReplacementScanInput &input,
+                                        optional_ptr<ReplacementScanData> data) {
+	auto &table_name = input.table_name;
 	auto lower_name = StringUtil::Lower(table_name);
 	// remove any compression
 	if (StringUtil::EndsWith(lower_name, ".gz")) {

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

@@ -53,7 +53,10 @@ template <class OP>
 static unique_ptr<FunctionData> ReadFileBind(ClientContext &context, TableFunctionBindInput &input,
                                              vector<LogicalType> &return_types, vector<string> &names) {
 	auto result = make_uniq<ReadFileBindData>();
-	result->files = MultiFileReader::GetFileList(context, input.inputs[0], OP::FILE_TYPE, FileGlobOptions::ALLOW_EMPTY);
+
+	auto multi_file_reader = MultiFileReader::Create(input.table_function);
+	result->files =
+	    multi_file_reader->CreateFileList(context, input.inputs[0], FileGlobOptions::ALLOW_EMPTY)->GetAllFiles();
 
 	return_types.push_back(LogicalType::VARCHAR);
 	names.push_back("filename");
@@ -160,7 +163,8 @@ static void ReadFileExecute(ClientContext &context, TableFunctionInput &input, D
 				} break;
 				case ReadFileBindData::FILE_SIZE_COLUMN: {
 					auto &file_size_vector = output.data[col_idx];
-					FlatVector::GetData<int64_t>(file_size_vector)[out_idx] = file_handle->GetFileSize();
+					FlatVector::GetData<int64_t>(file_size_vector)[out_idx] =
+					    NumericCast<int64_t>(file_handle->GetFileSize());
 				} break;
 				case ReadFileBindData::FILE_LAST_MODIFIED_COLUMN: {
 					auto &last_modified_vector = output.data[col_idx];

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

@@ -26,7 +26,11 @@ static unique_ptr<FunctionData> RepeatBind(ClientContext &context, TableFunction
 	if (inputs[1].IsNull()) {
 		throw BinderException("Repeat second parameter cannot be NULL");
 	}
-	return make_uniq<RepeatFunctionData>(inputs[0], inputs[1].GetValue<int64_t>());
+	auto repeat_count = inputs[1].GetValue<int64_t>();
+	if (repeat_count < 0) {
+		throw BinderException("Repeat second parameter cannot be be less than 0");
+	}
+	return make_uniq<RepeatFunctionData>(inputs[0], NumericCast<idx_t>(repeat_count));
 }
 
 static unique_ptr<GlobalTableFunctionState> RepeatInit(ClientContext &context, TableFunctionInitInput &input) {

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

@@ -32,7 +32,7 @@ static unique_ptr<FunctionData> RepeatRowBind(ClientContext &context, TableFunct
 	if (inputs.empty()) {
 		throw BinderException("repeat_rows requires at least one column to be specified");
 	}
-	return make_uniq<RepeatRowFunctionData>(inputs, entry->second.GetValue<int64_t>());
+	return make_uniq<RepeatRowFunctionData>(inputs, NumericCast<idx_t>(entry->second.GetValue<int64_t>()));
 }
 
 static unique_ptr<GlobalTableFunctionState> RepeatRowInit(ClientContext &context, TableFunctionInitInput &input) {

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

@@ -66,7 +66,9 @@ static unique_ptr<FunctionData> CSVSniffBind(ClientContext &context, TableFuncti
 	return_types.emplace_back(LogicalType::BOOLEAN);
 	names.emplace_back("HasHeader");
 	// 7. List<Struct<Column-Name:Types>>
-	return_types.emplace_back(LogicalType::VARCHAR);
+	child_list_t<LogicalType> struct_children {{"name", LogicalType::VARCHAR}, {"type", LogicalType::VARCHAR}};
+	auto list_child = LogicalType::STRUCT(struct_children);
+	return_types.emplace_back(LogicalType::LIST(list_child));
 	names.emplace_back("Columns");
 	// 8. Date Format
 	return_types.emplace_back(LogicalType::VARCHAR);
@@ -109,7 +111,7 @@ static void CSVSniffFunction(ClientContext &context, TableFunctionInput &data_p,
 	auto sniffer_options = data.options;
 	sniffer_options.file_path = data.path;
 
-	auto buffer_manager = make_shared<CSVBufferManager>(context, sniffer_options, sniffer_options.file_path, 0);
+	auto buffer_manager = make_shared_ptr<CSVBufferManager>(context, sniffer_options, sniffer_options.file_path, 0);
 	if (sniffer_options.name_list.empty()) {
 		sniffer_options.name_list = data.names_csv;
 	}
@@ -141,16 +143,20 @@ static void CSVSniffFunction(ClientContext &context, TableFunctionInput &data_p,
 	auto has_header = Value::BOOLEAN(sniffer_options.dialect_options.header.GetValue()).ToString();
 	output.SetValue(5, 0, has_header);
 	// 7. List<Struct<Column-Name:Types>> {'col1': 'INTEGER', 'col2': 'VARCHAR'}
+	vector<Value> values;
 	std::ostringstream columns;
 	columns << "{";
 	for (idx_t i = 0; i < sniffer_result.return_types.size(); i++) {
+		child_list_t<Value> struct_children {{"name", sniffer_result.names[i]},
+		                                     {"type", {sniffer_result.return_types[i].ToString()}}};
+		values.emplace_back(Value::STRUCT(struct_children));
 		columns << "'" << sniffer_result.names[i] << "': '" << sniffer_result.return_types[i].ToString() << "'";
 		if (i != sniffer_result.return_types.size() - 1) {
 			columns << separator;
 		}
 	}
 	columns << "}";
-	output.SetValue(6, 0, columns.str());
+	output.SetValue(6, 0, Value::LIST(values));
 	// 8. Date Format
 	auto date_format = sniffer_options.dialect_options.date_format[LogicalType::DATE].GetValue();
 	if (!date_format.Empty()) {

package/src/duckdb/src/function/table/system/duckdb_columns.cpp

@@ -209,15 +209,15 @@ void ColumnHelper::WriteColumns(idx_t start_index, idx_t start_col, idx_t end_co
 		// database_name, VARCHAR
 		output.SetValue(col++, index, entry.catalog.GetName());
 		// database_oid, BIGINT
-		output.SetValue(col++, index, Value::BIGINT(entry.catalog.GetOid()));
+		output.SetValue(col++, index, Value::BIGINT(NumericCast<int64_t>(entry.catalog.GetOid())));
 		// schema_name, VARCHAR
 		output.SetValue(col++, index, entry.schema.name);
 		// schema_oid, BIGINT
-		output.SetValue(col++, index, Value::BIGINT(entry.schema.oid));
+		output.SetValue(col++, index, Value::BIGINT(NumericCast<int64_t>(entry.schema.oid)));
 		// table_name, VARCHAR
 		output.SetValue(col++, index, entry.name);
 		// table_oid, BIGINT
-		output.SetValue(col++, index, Value::BIGINT(entry.oid));
+		output.SetValue(col++, index, Value::BIGINT(NumericCast<int64_t>(entry.oid)));
 		// column_name, VARCHAR
 		output.SetValue(col++, index, Value(ColumnName(i)));
 		// column_index, INTEGER

package/src/duckdb/src/function/table/system/duckdb_constraints.cpp

@@ -15,6 +15,7 @@
 #include "duckdb/planner/constraints/bound_not_null_constraint.hpp"
 #include "duckdb/planner/constraints/bound_foreign_key_constraint.hpp"
 #include "duckdb/storage/data_table.hpp"
+#include "duckdb/planner/binder.hpp"
 
 namespace duckdb {
 
@@ -49,11 +50,24 @@ struct hash<duckdb::UniqueKeyInfo> {
 
 namespace duckdb {
 
+struct ConstraintEntry {
+	ConstraintEntry(ClientContext &context, TableCatalogEntry &table) : table(table) {
+		if (!table.IsDuckTable()) {
+			return;
+		}
+		auto binder = Binder::CreateBinder(context);
+		bound_constraints = binder->BindConstraints(table.GetConstraints(), table.name, table.GetColumns());
+	}
+
+	TableCatalogEntry &table;
+	vector<unique_ptr<BoundConstraint>> bound_constraints;
+};
+
 struct DuckDBConstraintsData : public GlobalTableFunctionState {
 	DuckDBConstraintsData() : offset(0), constraint_offset(0), unique_constraint_offset(0) {
 	}
 
-	vector<reference<CatalogEntry>> entries;
+	vector<ConstraintEntry> entries;
 	idx_t offset;
 	idx_t constraint_offset;
 	idx_t unique_constraint_offset;
@@ -118,8 +132,9 @@ unique_ptr<GlobalTableFunctionState> DuckDBConstraintsInit(ClientContext &contex
 		});
 
 		sort(entries.begin(), entries.end(), [&](CatalogEntry &x, CatalogEntry &y) { return (x.name < y.name); });
-
-		result->entries.insert(result->entries.end(), entries.begin(), entries.end());
+		for (auto &entry : entries) {
+			result->entries.emplace_back(context, entry.get().Cast<TableCatalogEntry>());
+		}
 	};
 
 	return std::move(result);
@@ -135,10 +150,9 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 	// either fill up the chunk or return all the remaining columns
 	idx_t count = 0;
 	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset].get();
-		D_ASSERT(entry.type == CatalogType::TABLE_ENTRY);
+		auto &entry = data.entries[data.offset];
 
-		auto &table = entry.Cast<TableCatalogEntry>();
+		auto &table = entry.table;
 		auto &constraints = table.GetConstraints();
 		bool is_duck_table = table.IsDuckTable();
 		for (; data.constraint_offset < constraints.size() && count < STANDARD_VECTOR_SIZE; data.constraint_offset++) {
@@ -163,7 +177,7 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 				if (!is_duck_table) {
 					continue;
 				}
-				auto &bound_constraints = table.GetBoundConstraints();
+				auto &bound_constraints = entry.bound_constraints;
 				auto &bound_foreign_key = bound_constraints[data.constraint_offset]->Cast<BoundForeignKeyConstraint>();
 				if (bound_foreign_key.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE) {
 					// Those are already covered by PRIMARY KEY and UNIQUE entries
@@ -180,21 +194,21 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 			// database_name, LogicalType::VARCHAR
 			output.SetValue(col++, count, Value(table.schema.catalog.GetName()));
 			// database_oid, LogicalType::BIGINT
-			output.SetValue(col++, count, Value::BIGINT(table.schema.catalog.GetOid()));
+			output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(table.schema.catalog.GetOid())));
 			// schema_name, LogicalType::VARCHAR
 			output.SetValue(col++, count, Value(table.schema.name));
 			// schema_oid, LogicalType::BIGINT
-			output.SetValue(col++, count, Value::BIGINT(table.schema.oid));
+			output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(table.schema.oid)));
 			// table_name, LogicalType::VARCHAR
 			output.SetValue(col++, count, Value(table.name));
 			// table_oid, LogicalType::BIGINT
-			output.SetValue(col++, count, Value::BIGINT(table.oid));
+			output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(table.oid)));
 
 			// constraint_index, BIGINT
 			UniqueKeyInfo uk_info;
 
 			if (is_duck_table) {
-				auto &bound_constraint = *table.GetBoundConstraints()[data.constraint_offset];
+				auto &bound_constraint = *entry.bound_constraints[data.constraint_offset];
 				switch (bound_constraint.type) {
 				case ConstraintType::UNIQUE: {
 					auto &bound_unique = bound_constraint.Cast<BoundUniqueConstraint>();
@@ -224,15 +238,16 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 			}
 
 			if (uk_info.columns.empty()) {
-				output.SetValue(col++, count, Value::BIGINT(data.unique_constraint_offset++));
+				output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(data.unique_constraint_offset++)));
 			} else {
 				auto known_unique_constraint_offset = data.known_fk_unique_constraint_offsets.find(uk_info);
 				if (known_unique_constraint_offset == data.known_fk_unique_constraint_offsets.end()) {
 					data.known_fk_unique_constraint_offsets.insert(make_pair(uk_info, data.unique_constraint_offset));
-					output.SetValue(col++, count, Value::BIGINT(data.unique_constraint_offset));
+					output.SetValue(col++, count, Value::BIGINT(NumericCast<int64_t>(data.unique_constraint_offset)));
 					data.unique_constraint_offset++;
 				} else {
-					output.SetValue(col++, count, Value::BIGINT(known_unique_constraint_offset->second));
+					output.SetValue(col++, count,
+					                Value::BIGINT(NumericCast<int64_t>(known_unique_constraint_offset->second)));
 				}
 			}
 			output.SetValue(col++, count, Value(constraint_type));
@@ -250,7 +265,7 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 
 			vector<LogicalIndex> column_index_list;
 			if (is_duck_table) {
-				auto &bound_constraint = *table.GetBoundConstraints()[data.constraint_offset];
+				auto &bound_constraint = *entry.bound_constraints[data.constraint_offset];
 				switch (bound_constraint.type) {
 				case ConstraintType::CHECK: {
 					auto &bound_check = bound_constraint.Cast<BoundCheckConstraint>();
@@ -286,7 +301,7 @@ void DuckDBConstraintsFunction(ClientContext &context, TableFunctionInput &data_
 			vector<Value> index_list;
 			vector<Value> column_name_list;
 			for (auto column_index : column_index_list) {
-				index_list.push_back(Value::BIGINT(column_index.index));
+				index_list.push_back(Value::BIGINT(NumericCast<int64_t>(column_index.index)));
 				column_name_list.emplace_back(table.GetColumn(column_index).Name());
 			}