duckdb 0.10.1 → 0.10.2-dev3.0

package/src/duckdb/src/execution/operator/csv_scanner/sniffer/csv_sniffer.cpp

@@ -13,7 +13,7 @@ CSVSniffer::CSVSniffer(CSVReaderOptions &options_p, shared_ptr<CSVBufferManager>
 	}
 	// Initialize max columns found to either 0 or however many were set
 	max_columns_found = set_columns.Size();
-	error_handler = make_shared<CSVErrorHandler>(options.ignore_errors);
+	error_handler = make_shared<CSVErrorHandler>(options.ignore_errors.GetValue());
 	detection_error_handler = make_shared<CSVErrorHandler>(true);
 }
 
@@ -83,6 +83,7 @@ void CSVSniffer::SetResultOptions() {
 }
 
 SnifferResult CSVSniffer::SniffCSV(bool force_match) {
+	buffer_manager->sniffing = true;
 	// 1. Dialect Detection
 	DetectDialect();
 	// 2. Type Detection
@@ -93,7 +94,15 @@ SnifferResult CSVSniffer::SniffCSV(bool force_match) {
 	DetectHeader();
 	// 5. Type Replacement
 	ReplaceTypes();
-	if (!best_candidate->error_handler->errors.empty() && !options.ignore_errors) {
+
+	// We reset the buffer for compressed files
+	// This is done because we can't easily seek on compressed files, if a buffer goes out of scope we must read from
+	// the start
+	if (!buffer_manager->file_handle->uncompressed) {
+		buffer_manager->ResetBufferManager();
+	}
+	buffer_manager->sniffing = false;
+	if (!best_candidate->error_handler->errors.empty() && !options.ignore_errors.GetValue()) {
 		for (auto &error_vector : best_candidate->error_handler->errors) {
 			for (auto &error : error_vector.second) {
 				if (error.type == CSVErrorType::MAXIMUM_LINE_SIZE) {

package/src/duckdb/src/execution/operator/csv_scanner/sniffer/dialect_detection.cpp

@@ -101,18 +101,19 @@ void CSVSniffer::AnalyzeDialectCandidate(unique_ptr<ColumnCountScanner> scanner,
 	if (sniffed_column_counts.result_position > rows_read) {
 		rows_read = sniffed_column_counts.result_position;
 	}
-	if (set_columns.IsCandidateUnacceptable(num_cols, options.null_padding, options.ignore_errors,
+	if (set_columns.IsCandidateUnacceptable(num_cols, options.null_padding, options.ignore_errors.GetValue(),
 	                                        sniffed_column_counts.last_value_always_empty)) {
 		// Not acceptable
 		return;
 	}
 	for (idx_t row = start_row; row < sniffed_column_counts.result_position; row++) {
-		if (set_columns.IsCandidateUnacceptable(sniffed_column_counts[row], options.null_padding, options.ignore_errors,
+		if (set_columns.IsCandidateUnacceptable(sniffed_column_counts[row], options.null_padding,
+		                                        options.ignore_errors.GetValue(),
 		                                        sniffed_column_counts.last_value_always_empty)) {
 			// Not acceptable
 			return;
 		}
-		if (sniffed_column_counts[row] == num_cols || options.ignore_errors) {
+		if (sniffed_column_counts[row] == num_cols || (options.ignore_errors.GetValue() && !options.null_padding)) {
 			consistent_rows++;
 		} else if (num_cols < sniffed_column_counts[row] && !options.dialect_options.skip_rows.IsSetByUser() &&
 		           (!set_columns.IsSet() || options.null_padding)) {
@@ -176,10 +177,19 @@ void CSVSniffer::AnalyzeDialectCandidate(unique_ptr<ColumnCountScanner> scanner,
 		}
 		auto &sniffing_state_machine = scanner->GetStateMachine();
 
+		if (!candidates.empty() && candidates.front()->ever_quoted && !scanner->ever_quoted) {
+			// Give preference to quoted boys.
+			return;
+		}
+
 		best_consistent_rows = consistent_rows;
 		max_columns_found = num_cols;
 		prev_padding_count = padding_count;
-		sniffing_state_machine.dialect_options.skip_rows = start_row;
+		if (!options.null_padding && !options.ignore_errors.GetValue()) {
+			sniffing_state_machine.dialect_options.skip_rows = start_row;
+		} else {
+			sniffing_state_machine.dialect_options.skip_rows = options.dialect_options.skip_rows.GetValue();
+		}
 		candidates.clear();
 		sniffing_state_machine.dialect_options.num_cols = num_cols;
 		candidates.emplace_back(std::move(scanner));
@@ -200,7 +210,11 @@ void CSVSniffer::AnalyzeDialectCandidate(unique_ptr<ColumnCountScanner> scanner,
 			}
 		}
 		if (!same_quote_is_candidate) {
-			sniffing_state_machine.dialect_options.skip_rows = start_row;
+			if (!options.null_padding && !options.ignore_errors.GetValue()) {
+				sniffing_state_machine.dialect_options.skip_rows = start_row;
+			} else {
+				sniffing_state_machine.dialect_options.skip_rows = options.dialect_options.skip_rows.GetValue();
+			}
 			sniffing_state_machine.dialect_options.num_cols = num_cols;
 			candidates.emplace_back(std::move(scanner));
 		}
@@ -212,10 +226,11 @@ bool CSVSniffer::RefineCandidateNextChunk(ColumnCountScanner &candidate) {
 	for (idx_t i = 0; i < sniffed_column_counts.result_position; i++) {
 		if (set_columns.IsSet()) {
 			return !set_columns.IsCandidateUnacceptable(sniffed_column_counts[i], options.null_padding,
-			                                            options.ignore_errors,
+			                                            options.ignore_errors.GetValue(),
 			                                            sniffed_column_counts.last_value_always_empty);
 		} else {
-			if (max_columns_found != sniffed_column_counts[i] && (!options.null_padding && !options.ignore_errors)) {
+			if (max_columns_found != sniffed_column_counts[i] &&
+			    (!options.null_padding && !options.ignore_errors.GetValue())) {
 				return false;
 			}
 		}

package/src/duckdb/src/execution/operator/csv_scanner/sniffer/type_detection.cpp

@@ -278,7 +278,7 @@ void CSVSniffer::DetectTypes() {
 		// it's good if the dialect creates more non-varchar columns, but only if we sacrifice < 30% of
 		// best_num_cols.
 		if (varchar_cols < min_varchar_cols && info_sql_types_candidates.size() > (max_columns_found * 0.7) &&
-		    (!options.ignore_errors || candidate->error_handler->errors.size() < min_errors)) {
+		    (!options.ignore_errors.GetValue() || candidate->error_handler->errors.size() < min_errors)) {
 			min_errors = candidate->error_handler->errors.size();
 			best_header_row.clear();
 			// we have a new best_options candidate

package/src/duckdb/src/execution/operator/csv_scanner/state_machine/csv_state_machine_cache.cpp

@@ -21,7 +21,6 @@ void CSVStateMachineCache::Insert(const CSVStateMachineOptions &state_machine_op
 			InitializeTransitionArray(transition_array, cur_state, CSVState::QUOTED);
 			break;
 		case CSVState::UNQUOTED:
-		case CSVState::INVALID:
 		case CSVState::ESCAPE:
 			InitializeTransitionArray(transition_array, cur_state, CSVState::INVALID);
 			break;
@@ -38,15 +37,16 @@ void CSVStateMachineCache::Insert(const CSVStateMachineOptions &state_machine_op
 	auto new_line_id = state_machine_options.new_line.GetValue();
 
 	// Now set values depending on configuration
-	// 1) Standard State
-	transition_array[delimiter][static_cast<uint8_t>(static_cast<uint8_t>(CSVState::STANDARD))] = CSVState::DELIMITER;
-	transition_array[static_cast<uint8_t>('\n')][static_cast<uint8_t>(CSVState::STANDARD)] = CSVState::RECORD_SEPARATOR;
-	if (new_line_id == NewLineIdentifier::CARRY_ON) {
-		transition_array[static_cast<uint8_t>('\r')][static_cast<uint8_t>(CSVState::STANDARD)] =
-		    CSVState::CARRIAGE_RETURN;
-	} else {
-		transition_array[static_cast<uint8_t>('\r')][static_cast<uint8_t>(CSVState::STANDARD)] =
-		    CSVState::RECORD_SEPARATOR;
+	// 1) Standard/Invalid State
+	vector<uint8_t> std_inv {static_cast<uint8_t>(CSVState::STANDARD), static_cast<uint8_t>(CSVState::INVALID)};
+	for (auto &state : std_inv) {
+		transition_array[delimiter][state] = CSVState::DELIMITER;
+		transition_array[static_cast<uint8_t>('\n')][state] = CSVState::RECORD_SEPARATOR;
+		if (new_line_id == NewLineIdentifier::CARRY_ON) {
+			transition_array[static_cast<uint8_t>('\r')][state] = CSVState::CARRIAGE_RETURN;
+		} else {
+			transition_array[static_cast<uint8_t>('\r')][state] = CSVState::RECORD_SEPARATOR;
+		}
 	}
 	// 2) Field Separator State
 	transition_array[delimiter][static_cast<uint8_t>(CSVState::DELIMITER)] = CSVState::DELIMITER;

package/src/duckdb/src/execution/operator/csv_scanner/table_function/csv_file_scanner.cpp

@@ -10,7 +10,7 @@ CSVFileScan::CSVFileScan(ClientContext &context, shared_ptr<CSVBufferManager> bu
                          vector<LogicalType> &file_schema)
     : file_path(options_p.file_path), file_idx(0), buffer_manager(std::move(buffer_manager_p)),
       state_machine(std::move(state_machine_p)), file_size(buffer_manager->file_handle->FileSize()),
-      error_handler(make_shared<CSVErrorHandler>(options_p.ignore_errors)),
+      error_handler(make_shared<CSVErrorHandler>(options_p.ignore_errors.GetValue())),
       on_disk_file(buffer_manager->file_handle->OnDiskFile()), options(options_p) {
 	if (bind_data.initial_reader.get()) {
 		auto &union_reader = *bind_data.initial_reader;
@@ -43,7 +43,7 @@ CSVFileScan::CSVFileScan(ClientContext &context, const string &file_path_p, cons
                          const idx_t file_idx_p, const ReadCSVData &bind_data, const vector<column_t> &column_ids,
                          const vector<LogicalType> &file_schema)
     : file_path(file_path_p), file_idx(file_idx_p),
-      error_handler(make_shared<CSVErrorHandler>(options_p.ignore_errors)), options(options_p) {
+      error_handler(make_shared<CSVErrorHandler>(options_p.ignore_errors.GetValue())), options(options_p) {
 	if (file_idx < bind_data.union_readers.size()) {
 		// we are doing UNION BY NAME - fetch the options from the union reader for this file
 		optional_ptr<CSVFileScan> union_reader_ptr;
@@ -129,8 +129,8 @@ CSVFileScan::CSVFileScan(ClientContext &context, const string &file_path_p, cons
 }
 
 CSVFileScan::CSVFileScan(ClientContext &context, const string &file_name, CSVReaderOptions &options_p)
-    : file_path(file_name), file_idx(0), error_handler(make_shared<CSVErrorHandler>(options_p.ignore_errors)),
-      options(options_p) {
+    : file_path(file_name), file_idx(0),
+      error_handler(make_shared<CSVErrorHandler>(options_p.ignore_errors.GetValue())), options(options_p) {
 	buffer_manager = make_shared<CSVBufferManager>(context, options, file_path, file_idx);
 	// Initialize On Disk and Size of file
 	on_disk_file = buffer_manager->file_handle->OnDiskFile();
@@ -172,20 +172,6 @@ void CSVFileScan::InitializeFileNamesTypes() {
 		projection_ids.emplace_back(result_idx, i);
 	}
 
-	if (!projected_columns.empty()) {
-		// We might have to add recovery rejects column ids
-		for (idx_t i = 0; i < options.rejects_recovery_column_ids.size(); i++) {
-			idx_t col_id = options.rejects_recovery_column_ids[i];
-			if (projected_columns.find(col_id) == projected_columns.end()) {
-				// We have to insert this column in our projection
-				projected_columns.insert(col_id);
-				file_types.emplace_back(LogicalType::VARCHAR);
-				projected_columns.insert(col_id);
-				projection_ids.emplace_back(col_id, col_id);
-			}
-		}
-	}
-
 	if (reader_data.column_ids.empty()) {
 		file_types = types;
 	}
@@ -222,4 +208,9 @@ void CSVFileScan::InitializeProjection() {
 		reader_data.column_mapping.push_back(i);
 	}
 }
+
+void CSVFileScan::Finish() {
+	buffer_manager.reset();
+}
+
 } // namespace duckdb

package/src/duckdb/src/execution/operator/csv_scanner/table_function/global_csv_state.cpp

@@ -24,7 +24,7 @@ CSVGlobalState::CSVGlobalState(ClientContext &context_p, const shared_ptr<CSVBuf
 		file_scans.emplace_back(
 		    make_uniq<CSVFileScan>(context, files[0], options, 0, bind_data, column_ids, file_schema));
 	};
-	//! There are situations where we only support single threaded scanning
+	// There are situations where we only support single threaded scanning
 	bool many_csv_files = files.size() > 1 && files.size() > system_threads * 2;
 	single_threaded = many_csv_files || !options.parallel;
 	last_file_idx = 0;
@@ -43,20 +43,20 @@ double CSVGlobalState::GetProgress(const ReadCSVData &bind_data_p) const {
 	lock_guard<mutex> parallel_lock(main_mutex);
 	idx_t total_files = bind_data.files.size();
 	// get the progress WITHIN the current file
-	double progress;
+	double percentage = 0;
 	if (file_scans.back()->file_size == 0) {
-		progress = 1.0;
+		percentage = 1.0;
 	} else {
 		// for compressed files, readed bytes may greater than files size.
-		progress = std::min(1.0, double(file_scans.back()->bytes_read) / double(file_scans.back()->file_size));
+		for (auto &file : file_scans) {
+			percentage +=
+			    (double(1) / double(total_files)) * std::min(1.0, double(file->bytes_read) / double(file->file_size));
+		}
 	}
-	// now get the total percentage of files read
-	double percentage = double(current_boundary.GetFileIdx()) / total_files;
-	percentage += (double(1) / double(total_files)) * progress;
 	return percentage * 100;
 }
 
-unique_ptr<StringValueScanner> CSVGlobalState::Next() {
+unique_ptr<StringValueScanner> CSVGlobalState::Next(optional_ptr<StringValueScanner> previous_scanner) {
 	if (single_threaded) {
 		idx_t cur_idx = last_file_idx++;
 		if (cur_idx >= bind_data.files.size()) {
@@ -66,8 +66,16 @@ unique_ptr<StringValueScanner> CSVGlobalState::Next() {
 		if (cur_idx == 0) {
 			current_file = file_scans.back();
 		} else {
-			current_file = make_shared<CSVFileScan>(context, bind_data.files[cur_idx], bind_data.options, cur_idx,
-			                                        bind_data, column_ids, file_schema);
+			lock_guard<mutex> parallel_lock(main_mutex);
+			file_scans.emplace_back(make_shared<CSVFileScan>(context, bind_data.files[cur_idx], bind_data.options,
+			                                                 cur_idx, bind_data, column_ids, file_schema));
+			current_file = file_scans.back();
+		}
+		if (previous_scanner) {
+			lock_guard<mutex> parallel_lock(main_mutex);
+			previous_scanner->buffer_tracker.reset();
+			current_buffer_in_use.reset();
+			previous_scanner->csv_file_scan->Finish();
 		}
 		auto csv_scanner =
 		    make_uniq<StringValueScanner>(scanner_idx++, current_file->buffer_manager, current_file->state_machine,
@@ -87,7 +95,14 @@ unique_ptr<StringValueScanner> CSVGlobalState::Next() {
 	auto csv_scanner =
 	    make_uniq<StringValueScanner>(scanner_idx++, current_file.buffer_manager, current_file.state_machine,
 	                                  current_file.error_handler, file_scans.back(), false, current_boundary);
-
+	threads_per_file[csv_scanner->csv_file_scan->file_idx]++;
+	if (previous_scanner) {
+		threads_per_file[previous_scanner->csv_file_scan->file_idx]--;
+		if (threads_per_file[previous_scanner->csv_file_scan->file_idx] == 0) {
+			previous_scanner->buffer_tracker.reset();
+			previous_scanner->csv_file_scan->Finish();
+		}
+	}
 	csv_scanner->buffer_tracker = current_buffer_in_use;
 
 	// We then produce the next boundary
@@ -130,6 +145,9 @@ void CSVGlobalState::DecrementThread() {
 	D_ASSERT(running_threads > 0);
 	running_threads--;
 	if (running_threads == 0) {
+		for (auto &file : file_scans) {
+			file->error_handler->ErrorIfNeeded();
+		}
 		FillRejectsTable();
 		if (context.client_data->debug_set_max_line_length) {
 			context.client_data->debug_max_line_length = file_scans[0]->error_handler->GetMaxLineLength();
@@ -137,24 +155,119 @@ void CSVGlobalState::DecrementThread() {
 	}
 }
 
+bool IsCSVErrorAcceptedReject(CSVErrorType type) {
+	switch (type) {
+	case CSVErrorType::CAST_ERROR:
+	case CSVErrorType::TOO_MANY_COLUMNS:
+	case CSVErrorType::TOO_FEW_COLUMNS:
+	case CSVErrorType::MAXIMUM_LINE_SIZE:
+	case CSVErrorType::UNTERMINATED_QUOTES:
+	case CSVErrorType::INVALID_UNICODE:
+		return true;
+	default:
+		return false;
+	}
+}
+
+string CSVErrorTypeToEnum(CSVErrorType type) {
+	switch (type) {
+	case CSVErrorType::CAST_ERROR:
+		return "CAST";
+	case CSVErrorType::TOO_FEW_COLUMNS:
+		return "MISSING COLUMNS";
+	case CSVErrorType::TOO_MANY_COLUMNS:
+		return "TOO MANY COLUMNS";
+	case CSVErrorType::MAXIMUM_LINE_SIZE:
+		return "LINE SIZE OVER MAXIMUM";
+	case CSVErrorType::UNTERMINATED_QUOTES:
+		return "UNQUOTED VALUE";
+	case CSVErrorType::INVALID_UNICODE:
+		return "INVALID UNICODE";
+	default:
+		throw InternalException("CSV Error is not valid to be stored in a Rejects Table");
+	}
+}
+
+void FillScanErrorTable(InternalAppender &scan_appender, idx_t scan_idx, idx_t file_idx, CSVFileScan &file) {
+	CSVReaderOptions &options = file.options;
+	// Add the row to the rejects table
+	scan_appender.BeginRow();
+	// 1. Scan Idx
+	scan_appender.Append(scan_idx);
+	// 2. File Idx
+	scan_appender.Append(file_idx);
+	// 3. File Path
+	scan_appender.Append(string_t(file.file_path));
+	// 4. Delimiter
+	scan_appender.Append(string_t(options.dialect_options.state_machine_options.delimiter.FormatValue()));
+	// 5. Quote
+	scan_appender.Append(string_t(options.dialect_options.state_machine_options.quote.FormatValue()));
+	// 6. Escape
+	scan_appender.Append(string_t(options.dialect_options.state_machine_options.escape.FormatValue()));
+	// 7. NewLine Delimiter
+	scan_appender.Append(string_t(options.NewLineIdentifierToString()));
+	// 8. Skip Rows
+	scan_appender.Append(Value::UINTEGER(NumericCast<uint32_t>(options.dialect_options.skip_rows.GetValue())));
+	// 9. Has Header
+	scan_appender.Append(Value::BOOLEAN(options.dialect_options.header.GetValue()));
+	// 10. List<Struct<Column-Name:Types>> {'col1': 'INTEGER', 'col2': 'VARCHAR'}
+	std::ostringstream columns;
+	columns << "{";
+	for (idx_t i = 0; i < file.types.size(); i++) {
+		columns << "'" << file.names[i] << "': '" << file.types[i].ToString() << "'";
+		if (i != file.types.size() - 1) {
+			columns << ",";
+		}
+	}
+	columns << "}";
+	scan_appender.Append(string_t(columns.str()));
+	// 11. Date Format
+	auto date_format = options.dialect_options.date_format[LogicalType::DATE].GetValue();
+	if (!date_format.Empty()) {
+		scan_appender.Append(string_t(date_format.format_specifier));
+	} else {
+		scan_appender.Append(Value());
+	}
+
+	// 12. Timestamp Format
+	auto timestamp_format = options.dialect_options.date_format[LogicalType::TIMESTAMP].GetValue();
+	if (!timestamp_format.Empty()) {
+		scan_appender.Append(string_t(timestamp_format.format_specifier));
+	} else {
+		scan_appender.Append(Value());
+	}
+
+	// 13. The Extra User Arguments
+	if (options.user_defined_parameters.empty()) {
+		scan_appender.Append(Value());
+	} else {
+		scan_appender.Append(string_t(options.user_defined_parameters));
+	}
+	// Finish the row to the rejects table
+	scan_appender.EndRow();
+}
+
 void CSVGlobalState::FillRejectsTable() {
 	auto &options = bind_data.options;
 
-	if (!options.rejects_table_name.empty()) {
+	if (options.store_rejects.GetValue()) {
 		auto limit = options.rejects_limit;
-
-		auto rejects = CSVRejectsTable::GetOrCreate(context, options.rejects_table_name);
+		auto rejects = CSVRejectsTable::GetOrCreate(context, options.rejects_scan_name.GetValue(),
+		                                            options.rejects_table_name.GetValue());
 		lock_guard<mutex> lock(rejects->write_lock);
-		auto &table = rejects->GetTable(context);
-		InternalAppender appender(context, table);
-
+		auto &errors_table = rejects->GetErrorsTable(context);
+		auto &scans_table = rejects->GetScansTable(context);
+		InternalAppender errors_appender(context, errors_table);
+		InternalAppender scans_appender(context, scans_table);
+		idx_t scan_idx = context.transaction.GetActiveQuery();
 		for (auto &file : file_scans) {
+			idx_t file_idx = rejects->GetCurrentFileIndex(scan_idx);
 			auto file_name = file->file_path;
 			auto &errors = file->error_handler->errors;
+			// We first insert the file into the file scans table
 			for (auto &error_vector : errors) {
 				for (auto &error : error_vector.second) {
-					if (error.type != CSVErrorType::CAST_ERROR) {
-						// For now we only will use it for casting errors
+					if (!IsCSVErrorAcceptedReject(error.type)) {
 						continue;
 					}
 					// short circuit if we already have too many rejects
@@ -165,40 +278,60 @@ void CSVGlobalState::FillRejectsTable() {
 						rejects->count++;
 						auto row_line = file->error_handler->GetLine(error.error_info);
 						auto col_idx = error.column_idx;
-						auto col_name = bind_data.return_names[col_idx];
 						// Add the row to the rejects table
-						appender.BeginRow();
-						appender.Append(string_t(file_name));
-						appender.Append(row_line);
-						appender.Append(col_idx);
-						appender.Append(string_t("\"" + col_name + "\""));
-						appender.Append(error.row[col_idx]);
-
-						if (!options.rejects_recovery_columns.empty()) {
-							child_list_t<Value> recovery_key;
-							for (auto &key_idx : options.rejects_recovery_column_ids) {
-								// Figure out if the recovery key is valid.
-								// If not, error out for real.
-								auto &value = error.row[key_idx];
-								if (value.IsNull()) {
-									throw InvalidInputException("%s at line %llu in column %s. Parser options:\n%s ",
-									                            "Could not parse recovery column", row_line, col_name,
-									                            options.ToString());
-								}
-								recovery_key.emplace_back(bind_data.return_names[key_idx], value);
-							}
-							appender.Append(Value::STRUCT(recovery_key));
+						errors_appender.BeginRow();
+						// 1. Scan Id
+						errors_appender.Append(scan_idx);
+						// 2. File Id
+						errors_appender.Append(file_idx);
+						// 3. Row Line
+						errors_appender.Append(row_line);
+						// 4. Byte Position of the row error
+						errors_appender.Append(error.row_byte_position + 1);
+						// 5. Byte Position where error occurred
+						if (error.byte_position == -1) {
+							// This means this error comes from a flush, and we don't support this yet, so we give it
+							// a null
+							errors_appender.Append(Value());
+						} else {
+							errors_appender.Append(error.byte_position + 1);
+						}
+						// 6. Column Index
+						if (error.type == CSVErrorType::MAXIMUM_LINE_SIZE) {
+							errors_appender.Append(Value());
+						} else {
+							errors_appender.Append(col_idx + 1);
 						}
-						auto row_error_msg =
-						    StringUtil::Format("Could not convert string '%s' to '%s'", error.row[col_idx].ToString(),
-						                       file->types[col_idx].ToString());
-						appender.Append(string_t(row_error_msg));
-						appender.EndRow();
+						// 7. Column Name (If Applicable)
+						switch (error.type) {
+						case CSVErrorType::TOO_MANY_COLUMNS:
+						case CSVErrorType::MAXIMUM_LINE_SIZE:
+							errors_appender.Append(Value());
+							break;
+						case CSVErrorType::TOO_FEW_COLUMNS:
+							D_ASSERT(bind_data.return_names.size() > col_idx + 1);
+							errors_appender.Append(string_t(bind_data.return_names[col_idx + 1]));
+							break;
+						default:
+							errors_appender.Append(string_t(bind_data.return_names[col_idx]));
+						}
+						// 8. Error Type
+						errors_appender.Append(string_t(CSVErrorTypeToEnum(error.type)));
+						// 9. Original CSV Line
+						errors_appender.Append(string_t(error.csv_row));
+						// 10. Full Error Message
+						errors_appender.Append(string_t(error.error_message));
+						errors_appender.EndRow();
 					}
-					appender.Close();
 				}
 			}
+			if (rejects->count != 0) {
+				rejects->count = 0;
+				FillScanErrorTable(scans_appender, scan_idx, file_idx, *file);
+			}
 		}
+		errors_appender.Close();
+		scans_appender.Close();
 	}
 }