duckdb 0.10.2-dev0.0 → 0.10.2-dev3.0

package/src/duckdb/src/execution/operator/csv_scanner/util/csv_error.cpp

@@ -1,5 +1,7 @@
 #include "duckdb/execution/operator/csv_scanner/csv_error.hpp"
 #include "duckdb/common/exception/conversion_exception.hpp"
+#include "duckdb/common/string_util.hpp"
+
 #include <sstream>
 
 namespace duckdb {
@@ -16,9 +18,17 @@ CSVErrorHandler::CSVErrorHandler(bool ignore_errors_p) : ignore_errors(ignore_er
 void CSVErrorHandler::ThrowError(CSVError csv_error) {
 	std::ostringstream error;
 	if (PrintLineNumber(csv_error)) {
-		error << "CSV Error on Line: " << GetLine(csv_error.error_info) << std::endl;
+		error << "CSV Error on Line: " << GetLine(csv_error.error_info) << '\n';
+		if (!csv_error.csv_row.empty()) {
+			error << "Original Line: " << csv_error.csv_row << '\n';
+		}
+	}
+	if (csv_error.full_error_message.empty()) {
+		error << csv_error.error_message;
+	} else {
+		error << csv_error.full_error_message;
 	}
-	error << csv_error.error_message;
+
 	switch (csv_error.type) {
 	case CSVErrorType::CAST_ERROR:
 		throw ConversionException(error.str());
@@ -76,10 +86,21 @@ CSVError::CSVError(string error_message_p, CSVErrorType type_p, LinesPerBoundary
     : error_message(std::move(error_message_p)), type(type_p), error_info(error_info_p) {
 }
 
-CSVError::CSVError(string error_message_p, CSVErrorType type_p, idx_t column_idx_p, vector<Value> row_p,
-                   LinesPerBoundary error_info_p)
-    : error_message(std::move(error_message_p)), type(type_p), column_idx(column_idx_p), row(std::move(row_p)),
-      error_info(error_info_p) {
+CSVError::CSVError(string error_message_p, CSVErrorType type_p, idx_t column_idx_p, string csv_row_p,
+                   LinesPerBoundary error_info_p, idx_t row_byte_position, int64_t byte_position_p,
+                   const CSVReaderOptions &reader_options, const string &fixes)
+    : error_message(std::move(error_message_p)), type(type_p), column_idx(column_idx_p), csv_row(std::move(csv_row_p)),
+      error_info(error_info_p), row_byte_position(row_byte_position), byte_position(byte_position_p) {
+	// What were the options
+	std::ostringstream error;
+	if (reader_options.ignore_errors.GetValue()) {
+		RemoveNewLine(error_message);
+	}
+	error << error_message << '\n';
+	error << fixes << '\n';
+	error << reader_options.ToString();
+	error << '\n';
+	full_error_message = error.str();
 }
 
 CSVError CSVError::ColumnTypesError(case_insensitive_map_t<idx_t> sql_types_per_column, const vector<string> &names) {
@@ -102,47 +123,60 @@ CSVError CSVError::ColumnTypesError(case_insensitive_map_t<idx_t> sql_types_per_
 	return CSVError(exception, CSVErrorType::COLUMN_NAME_TYPE_MISMATCH, {});
 }
 
+void CSVError::RemoveNewLine(string &error) {
+	error = StringUtil::Split(error, "\n")[0];
+}
+
 CSVError CSVError::CastError(const CSVReaderOptions &options, string &column_name, string &cast_error, idx_t column_idx,
-                             vector<Value> &row, LinesPerBoundary error_info, LogicalTypeId type) {
+                             string &csv_row, LinesPerBoundary error_info, idx_t row_byte_position,
+                             int64_t byte_position, LogicalTypeId type) {
 	std::ostringstream error;
 	// Which column
-	error << "Error when converting column \"" << column_name << "\"." << std::endl;
+	error << "Error when converting column \"" << column_name << "\". ";
 	// What was the cast error
-	error << cast_error << std::endl;
-
-	error << "Column " << column_name << " is being converted as type " << LogicalTypeIdToString(type) << std::endl;
+	error << cast_error << '\n';
+	std::ostringstream how_to_fix_it;
+	how_to_fix_it << "Column " << column_name << " is being converted as type " << LogicalTypeIdToString(type) << '\n';
 	if (!options.WasTypeManuallySet(column_idx)) {
-		error << "This type was auto-detected from the CSV file." << std::endl;
-		error << "Possible solutions:" << std::endl;
-		error << "* Override the type for this column manually by setting the type explicitly, e.g. types={'"
-		      << column_name << "': 'VARCHAR'}" << std::endl;
-		error << "* Set the sample size to a larger value to enable the auto-detection to scan more values, e.g. "
-		         "sample_size=-1"
-		      << std::endl;
-		error << "* Use a COPY statement to automatically derive types from an existing table." << std::endl;
+		how_to_fix_it << "This type was auto-detected from the CSV file." << '\n';
+		how_to_fix_it << "Possible solutions:" << '\n';
+		how_to_fix_it << "* Override the type for this column manually by setting the type explicitly, e.g. types={'"
+		              << column_name << "': 'VARCHAR'}" << '\n';
+		how_to_fix_it
+		    << "* Set the sample size to a larger value to enable the auto-detection to scan more values, e.g. "
+		       "sample_size=-1"
+		    << '\n';
+		how_to_fix_it << "* Use a COPY statement to automatically derive types from an existing table." << '\n';
 	} else {
-		error << "This type was either manually set or derived from an existing table. Select a different type to "
-		         "correctly parse this column."
-		      << std::endl;
+		how_to_fix_it
+		    << "This type was either manually set or derived from an existing table. Select a different type to "
+		       "correctly parse this column."
+		    << '\n';
 	}
-	error << options.ToString();
 
-	return CSVError(error.str(), CSVErrorType::CAST_ERROR, column_idx, row, error_info);
+	return CSVError(error.str(), CSVErrorType::CAST_ERROR, column_idx, csv_row, error_info, row_byte_position,
+	                byte_position, options, how_to_fix_it.str());
 }
 
-CSVError CSVError::LineSizeError(const CSVReaderOptions &options, idx_t actual_size, LinesPerBoundary error_info) {
+CSVError CSVError::LineSizeError(const CSVReaderOptions &options, idx_t actual_size, LinesPerBoundary error_info,
+                                 string &csv_row, idx_t byte_position) {
 	std::ostringstream error;
 	error << "Maximum line size of " << options.maximum_line_size << " bytes exceeded. ";
-	error << "Actual Size:" << actual_size << " bytes." << std::endl;
-	error << options.ToString();
-	return CSVError(error.str(), CSVErrorType::MAXIMUM_LINE_SIZE, error_info);
+	error << "Actual Size:" << actual_size << " bytes." << '\n';
+
+	std::ostringstream how_to_fix_it;
+	how_to_fix_it << "Possible Solution: Change the maximum length size, e.g., max_line_size=" << actual_size + 1
+	              << "\n";
+
+	return CSVError(error.str(), CSVErrorType::MAXIMUM_LINE_SIZE, 0, csv_row, error_info, byte_position, byte_position,
+	                options, how_to_fix_it.str());
 }
 
 CSVError CSVError::SniffingError(string &file_path) {
 	std::ostringstream error;
 	// Which column
-	error << "Error when sniffing file \"" << file_path << "\"." << std::endl;
-	error << "CSV options could not be auto-detected. Consider setting parser options manually." << std::endl;
+	error << "Error when sniffing file \"" << file_path << "\"." << '\n';
+	error << "CSV options could not be auto-detected. Consider setting parser options manually." << '\n';
 	return CSVError(error.str(), CSVErrorType::SNIFFING, {});
 }
 
@@ -150,49 +184,56 @@ CSVError CSVError::NullPaddingFail(const CSVReaderOptions &options, LinesPerBoun
 	std::ostringstream error;
 	error << " The parallel scanner does not support null_padding in conjunction with quoted new lines. Please "
 	         "disable the parallel csv reader with parallel=false"
-	      << std::endl;
+	      << '\n';
 	// What were the options
 	error << options.ToString();
 	return CSVError(error.str(), CSVErrorType::NULLPADDED_QUOTED_NEW_VALUE, error_info);
 }
 
-CSVError CSVError::UnterminatedQuotesError(const CSVReaderOptions &options, string_t *vector_ptr,
-                                           idx_t vector_line_start, idx_t current_column, LinesPerBoundary error_info) {
+CSVError CSVError::UnterminatedQuotesError(const CSVReaderOptions &options, idx_t current_column,
+                                           LinesPerBoundary error_info, string &csv_row, idx_t row_byte_position,
+                                           int64_t byte_position) {
 	std::ostringstream error;
-	error << "Value with unterminated quote found." << std::endl;
-	error << std::endl;
-	// What were the options
-	error << options.ToString();
-	return CSVError(error.str(), CSVErrorType::UNTERMINATED_QUOTES, error_info);
+	error << "Value with unterminated quote found." << '\n';
+	std::ostringstream how_to_fix_it;
+	how_to_fix_it << "Possible Solution: Enable ignore errors (ignore_errors=true) to skip this row" << '\n';
+	return CSVError(error.str(), CSVErrorType::UNTERMINATED_QUOTES, current_column, csv_row, error_info,
+	                row_byte_position, byte_position, options, how_to_fix_it.str());
 }
 
-CSVError CSVError::IncorrectColumnAmountError(const CSVReaderOptions &options, string_t *vector_ptr,
-                                              idx_t vector_line_start, idx_t actual_columns,
-                                              LinesPerBoundary error_info) {
+CSVError CSVError::IncorrectColumnAmountError(const CSVReaderOptions &options, idx_t actual_columns,
+                                              LinesPerBoundary error_info, string &csv_row, idx_t row_byte_position,
+                                              int64_t byte_position) {
 	std::ostringstream error;
-	// How many columns were expected and how many were found
-	error << "Expected Number of Columns: " << options.dialect_options.num_cols << " Found: " << actual_columns
-	      << std::endl;
-	error << std::endl << "Possible fixes:" << std::endl;
+	// We don't have a fix for this
+	std::ostringstream how_to_fix_it;
+	how_to_fix_it << "Possible fixes:" << '\n';
 	if (!options.null_padding) {
-		error << "* Enable null padding (null_padding=true) to replace missing values with NULL" << std::endl;
+		how_to_fix_it << "* Enable null padding (null_padding=true) to replace missing values with NULL" << '\n';
 	}
-	if (!options.ignore_errors) {
-		error << "* Enable ignore errors (ignore_errors=true) to skip this row" << std::endl;
+	if (!options.ignore_errors.GetValue()) {
+		how_to_fix_it << "* Enable ignore errors (ignore_errors=true) to skip this row" << '\n';
+	}
+	// How many columns were expected and how many were found
+	error << "Expected Number of Columns: " << options.dialect_options.num_cols << " Found: " << actual_columns + 1;
+	if (actual_columns >= options.dialect_options.num_cols) {
+		return CSVError(error.str(), CSVErrorType::TOO_MANY_COLUMNS, actual_columns, csv_row, error_info,
+		                row_byte_position, byte_position - 1, options, how_to_fix_it.str());
+	} else {
+		return CSVError(error.str(), CSVErrorType::TOO_FEW_COLUMNS, actual_columns, csv_row, error_info,
+		                row_byte_position, byte_position - 1, options, how_to_fix_it.str());
 	}
-	error << std::endl;
-	// What were the options
-	error << options.ToString();
-	return CSVError(error.str(), CSVErrorType::INCORRECT_COLUMN_AMOUNT, error_info);
 }
 
-CSVError CSVError::InvalidUTF8(const CSVReaderOptions &options, LinesPerBoundary error_info) {
+CSVError CSVError::InvalidUTF8(const CSVReaderOptions &options, idx_t current_column, LinesPerBoundary error_info,
+                               string &csv_row, idx_t row_byte_position, int64_t byte_position) {
 	std::ostringstream error;
 	// How many columns were expected and how many were found
-	error << "Invalid unicode (byte sequence mismatch) detected." << std::endl;
-	// What were the options
-	error << options.ToString();
-	return CSVError(error.str(), CSVErrorType::INVALID_UNICODE, error_info);
+	error << "Invalid unicode (byte sequence mismatch) detected." << '\n';
+	std::ostringstream how_to_fix_it;
+	how_to_fix_it << "Possible Solution: Enable ignore errors (ignore_errors=true) to skip this row" << '\n';
+	return CSVError(error.str(), CSVErrorType::INVALID_UNICODE, current_column, csv_row, error_info, row_byte_position,
+	                byte_position, options, how_to_fix_it.str());
 }
 
 bool CSVErrorHandler::PrintLineNumber(CSVError &error) {
@@ -202,7 +243,8 @@ bool CSVErrorHandler::PrintLineNumber(CSVError &error) {
 	switch (error.type) {
 	case CSVErrorType::CAST_ERROR:
 	case CSVErrorType::UNTERMINATED_QUOTES:
-	case CSVErrorType::INCORRECT_COLUMN_AMOUNT:
+	case CSVErrorType::TOO_FEW_COLUMNS:
+	case CSVErrorType::TOO_MANY_COLUMNS:
 	case CSVErrorType::MAXIMUM_LINE_SIZE:
 	case CSVErrorType::NULLPADDED_QUOTED_NEW_VALUE:
 	case CSVErrorType::INVALID_UNICODE:

package/src/duckdb/src/execution/operator/csv_scanner/util/csv_reader_options.cpp

@@ -180,8 +180,6 @@ void CSVReaderOptions::SetReadOption(const string &loption, const Value &value,
 		SetSkipRows(ParseInteger(value, loption));
 	} else if (loption == "max_line_size" || loption == "maximum_line_size") {
 		maximum_line_size = ParseInteger(value, loption);
-	} else if (loption == "force_not_null") {
-		force_not_null = ParseColumnList(value, expected_names, loption);
 	} else if (loption == "date_format" || loption == "dateformat") {
 		string format = ParseString(value, loption);
 		SetDateFormat(LogicalTypeId::DATE, format, true);
@@ -189,7 +187,7 @@ void CSVReaderOptions::SetReadOption(const string &loption, const Value &value,
 		string format = ParseString(value, loption);
 		SetDateFormat(LogicalTypeId::TIMESTAMP, format, true);
 	} else if (loption == "ignore_errors") {
-		ignore_errors = ParseBoolean(value, loption);
+		ignore_errors.Set(ParseBoolean(value, loption));
 	} else if (loption == "buffer_size") {
 		buffer_size = ParseInteger(value, loption);
 		if (buffer_size == 0) {
@@ -206,20 +204,34 @@ void CSVReaderOptions::SetReadOption(const string &loption, const Value &value,
 		parallel = ParseBoolean(value, loption);
 	} else if (loption == "allow_quoted_nulls") {
 		allow_quoted_nulls = ParseBoolean(value, loption);
+	} else if (loption == "store_rejects") {
+		store_rejects.Set(ParseBoolean(value, loption));
+	} else if (loption == "force_not_null") {
+		if (!expected_names.empty()) {
+			force_not_null = ParseColumnList(value, expected_names, loption);
+		} else {
+			// Get the list of columns to use as a recovery key
+			auto &children = ListValue::GetChildren(value);
+			for (auto &child : children) {
+				auto col_name = child.GetValue<string>();
+				force_not_null_names.insert(col_name);
+			}
+		}
+
 	} else if (loption == "rejects_table") {
 		// skip, handled in SetRejectsOptions
 		auto table_name = ParseString(value, loption);
 		if (table_name.empty()) {
 			throw BinderException("REJECTS_TABLE option cannot be empty");
 		}
-		rejects_table_name = table_name;
-	} else if (loption == "rejects_recovery_columns") {
-		// Get the list of columns to use as a recovery key
-		auto &children = ListValue::GetChildren(value);
-		for (auto &child : children) {
-			auto col_name = child.GetValue<string>();
-			rejects_recovery_columns.push_back(col_name);
+		rejects_table_name.Set(table_name);
+	} else if (loption == "rejects_scan") {
+		// skip, handled in SetRejectsOptions
+		auto table_name = ParseString(value, loption);
+		if (table_name.empty()) {
+			throw BinderException("rejects_scan option cannot be empty");
 		}
+		rejects_scan_name.Set(table_name);
 	} else if (loption == "rejects_limit") {
 		int64_t limit = ParseInteger(value, loption);
 		if (limit < 0) {
@@ -238,7 +250,7 @@ void CSVReaderOptions::SetWriteOption(const string &loption, const Value &value)
 		return;
 	}
 
-	if (SetBaseOption(loption, value)) {
+	if (SetBaseOption(loption, value, true)) {
 		return;
 	}
 
@@ -263,7 +275,7 @@ void CSVReaderOptions::SetWriteOption(const string &loption, const Value &value)
 	}
 }
 
-bool CSVReaderOptions::SetBaseOption(const string &loption, const Value &value) {
+bool CSVReaderOptions::SetBaseOption(const string &loption, const Value &value, bool write_option) {
 	// Make sure this function was only called after the option was turned into lowercase
 	D_ASSERT(!std::any_of(loption.begin(), loption.end(), ::isupper));
 
@@ -277,8 +289,50 @@ bool CSVReaderOptions::SetBaseOption(const string &loption, const Value &value)
 		SetEscape(ParseString(value, loption));
 	} else if (loption == "header") {
 		SetHeader(ParseBoolean(value, loption));
-	} else if (loption == "null" || loption == "nullstr") {
-		null_str = ParseString(value, loption);
+	} else if (loption == "nullstr" || loption == "null") {
+		auto &child_type = value.type();
+		null_str.clear();
+		if (child_type.id() != LogicalTypeId::LIST && child_type.id() != LogicalTypeId::VARCHAR) {
+			throw BinderException("CSV Reader function option %s requires a string or a list as input", loption);
+		}
+		if (!null_str.empty()) {
+			throw BinderException("CSV Reader function option nullstr can only be supplied once");
+		}
+		if (child_type.id() == LogicalTypeId::LIST) {
+			auto &list_child = ListType::GetChildType(child_type);
+			const vector<Value> *children = nullptr;
+			if (list_child.id() == LogicalTypeId::LIST) {
+				// This can happen if it comes from a copy FROM/TO
+				auto &list_grandchild = ListType::GetChildType(list_child);
+				auto &children_ref = ListValue::GetChildren(value);
+				if (list_grandchild.id() != LogicalTypeId::VARCHAR || children_ref.size() != 1) {
+					throw BinderException("CSV Reader function option %s requires a non-empty list of possible null "
+					                      "strings (varchar) as input",
+					                      loption);
+				}
+				children = &ListValue::GetChildren(children_ref.back());
+			} else if (list_child.id() != LogicalTypeId::VARCHAR) {
+				throw BinderException("CSV Reader function option %s requires a non-empty list of possible null "
+				                      "strings (varchar) as input",
+				                      loption);
+			}
+			if (!children) {
+				children = &ListValue::GetChildren(value);
+			}
+			for (auto &child : *children) {
+				if (child.IsNull()) {
+					throw BinderException(
+					    "CSV Reader function option %s does not accept NULL values as a valid nullstr option", loption);
+				}
+				null_str.push_back(StringValue::Get(child));
+			}
+		} else {
+			null_str.push_back(StringValue::Get(ParseString(value, loption)));
+		}
+		if (null_str.size() > 1 && write_option) {
+			throw BinderException("CSV Writer function option %s only accepts one nullstr value.", loption);
+		}
+
 	} else if (loption == "encoding") {
 		auto encoding = StringUtil::Lower(ParseString(value, loption));
 		if (encoding != "utf8" && encoding != "utf-8") {
@@ -337,7 +391,7 @@ string CSVReaderOptions::ToString() const {
 	// sample_size
 	error += "sample_size=" + std::to_string(sample_size_chunks * STANDARD_VECTOR_SIZE) + "\n  ";
 	// ignore_errors
-	error += "ignore_errors=" + std::to_string(ignore_errors) + "\n  ";
+	error += "ignore_errors=" + ignore_errors.FormatValue() + "\n  ";
 	// all_varchar
 	error += "all_varchar=" + std::to_string(all_varchar) + "\n";
 
@@ -361,9 +415,10 @@ static uint8_t GetCandidateSpecificity(const LogicalType &candidate_type) {
 	    {(uint8_t)LogicalTypeId::VARCHAR, 0},  {(uint8_t)LogicalTypeId::TIMESTAMP, 1},
 	    {(uint8_t)LogicalTypeId::DATE, 2},     {(uint8_t)LogicalTypeId::TIME, 3},
 	    {(uint8_t)LogicalTypeId::DOUBLE, 4},   {(uint8_t)LogicalTypeId::FLOAT, 5},
-	    {(uint8_t)LogicalTypeId::BIGINT, 6},   {(uint8_t)LogicalTypeId::INTEGER, 7},
-	    {(uint8_t)LogicalTypeId::SMALLINT, 8}, {(uint8_t)LogicalTypeId::TINYINT, 9},
-	    {(uint8_t)LogicalTypeId::BOOLEAN, 10}, {(uint8_t)LogicalTypeId::SQLNULL, 11}};
+	    {(uint8_t)LogicalTypeId::DECIMAL, 6},  {(uint8_t)LogicalTypeId::BIGINT, 7},
+	    {(uint8_t)LogicalTypeId::INTEGER, 8},  {(uint8_t)LogicalTypeId::SMALLINT, 9},
+	    {(uint8_t)LogicalTypeId::TINYINT, 10}, {(uint8_t)LogicalTypeId::BOOLEAN, 11},
+	    {(uint8_t)LogicalTypeId::SQLNULL, 12}};
 
 	auto id = (uint8_t)candidate_type.id();
 	auto it = auto_type_candidates_specificity.find(id);
@@ -373,17 +428,26 @@ static uint8_t GetCandidateSpecificity(const LogicalType &candidate_type) {
 	}
 	return it->second;
 }
-
+bool StoreUserDefinedParameter(string &option) {
+	if (option == "column_types" || option == "types" || option == "dtypes" || option == "auto_detect" ||
+	    option == "auto_type_candidates" || option == "columns" || option == "names") {
+		// We don't store options related to types, names and auto-detection since these are either irrelevant to our
+		// prompt or are covered by the columns option.
+		return false;
+	}
+	return true;
+}
 void CSVReaderOptions::FromNamedParameters(named_parameter_map_t &in, ClientContext &context,
                                            vector<LogicalType> &return_types, vector<string> &names) {
+	map<string, string> ordered_user_defined_parameters;
 	for (auto &kv : in) {
 		if (MultiFileReader::ParseOption(kv.first, kv.second, file_options, context)) {
 			continue;
 		}
 		auto loption = StringUtil::Lower(kv.first);
 		// skip variables that are specific to auto detection
-		if (loption != "auto_detect" && loption != "auto_type_candidates") {
-			user_defined_parameters += loption + "=" + kv.second.ToSQLString() + ", ";
+		if (StoreUserDefinedParameter(loption)) {
+			ordered_user_defined_parameters[loption] = kv.second.ToSQLString();
 		}
 		if (loption == "columns") {
 			auto &child_type = kv.second.type();
@@ -489,6 +553,9 @@ void CSVReaderOptions::FromNamedParameters(named_parameter_map_t &in, ClientCont
 			SetReadOption(loption, kv.second, names);
 		}
 	}
+	for (auto &udf_parameter : ordered_user_defined_parameters) {
+		user_defined_parameters += udf_parameter.first + "=" + udf_parameter.second + ", ";
+	}
 	if (user_defined_parameters.size() >= 2) {
 		user_defined_parameters.erase(user_defined_parameters.size() - 2);
 	}

package/src/duckdb/src/execution/operator/helper/physical_vacuum.cpp

@@ -7,16 +7,17 @@
 
 namespace duckdb {
 
-PhysicalVacuum::PhysicalVacuum(unique_ptr<VacuumInfo> info_p, idx_t estimated_cardinality)
+PhysicalVacuum::PhysicalVacuum(unique_ptr<VacuumInfo> info_p, optional_ptr<TableCatalogEntry> table,
+                               unordered_map<idx_t, idx_t> column_id_map, idx_t estimated_cardinality)
     : PhysicalOperator(PhysicalOperatorType::VACUUM, {LogicalType::BOOLEAN}, estimated_cardinality),
-      info(std::move(info_p)) {
+      info(std::move(info_p)), table(table), column_id_map(std::move(column_id_map)) {
 }
 
 class VacuumLocalSinkState : public LocalSinkState {
 public:
-	explicit VacuumLocalSinkState(VacuumInfo &info) {
+	explicit VacuumLocalSinkState(VacuumInfo &info, optional_ptr<TableCatalogEntry> table) {
 		for (const auto &column_name : info.columns) {
-			auto &column = info.table->GetColumn(column_name);
+			auto &column = table->GetColumn(column_name);
 			if (DistinctStatistics::TypeIsSupported(column.GetType())) {
 				column_distinct_stats.push_back(make_uniq<DistinctStatistics>());
 			} else {
@@ -29,15 +30,14 @@ public:
 };
 
 unique_ptr<LocalSinkState> PhysicalVacuum::GetLocalSinkState(ExecutionContext &context) const {
-	return make_uniq<VacuumLocalSinkState>(*info);
+	return make_uniq<VacuumLocalSinkState>(*info, table);
 }
 
 class VacuumGlobalSinkState : public GlobalSinkState {
 public:
-	explicit VacuumGlobalSinkState(VacuumInfo &info) {
-
+	explicit VacuumGlobalSinkState(VacuumInfo &info, optional_ptr<TableCatalogEntry> table) {
 		for (const auto &column_name : info.columns) {
-			auto &column = info.table->GetColumn(column_name);
+			auto &column = table->GetColumn(column_name);
 			if (DistinctStatistics::TypeIsSupported(column.GetType())) {
 				column_distinct_stats.push_back(make_uniq<DistinctStatistics>());
 			} else {
@@ -51,12 +51,12 @@ public:
 };
 
 unique_ptr<GlobalSinkState> PhysicalVacuum::GetGlobalSinkState(ClientContext &context) const {
-	return make_uniq<VacuumGlobalSinkState>(*info);
+	return make_uniq<VacuumGlobalSinkState>(*info, table);
 }
 
 SinkResultType PhysicalVacuum::Sink(ExecutionContext &context, DataChunk &chunk, OperatorSinkInput &input) const {
 	auto &lstate = input.local_state.Cast<VacuumLocalSinkState>();
-	D_ASSERT(lstate.column_distinct_stats.size() == info->column_id_map.size());
+	D_ASSERT(lstate.column_distinct_stats.size() == column_id_map.size());
 
 	for (idx_t col_idx = 0; col_idx < chunk.data.size(); col_idx++) {
 		if (!DistinctStatistics::TypeIsSupported(chunk.data[col_idx].GetType())) {
@@ -89,10 +89,9 @@ SinkFinalizeType PhysicalVacuum::Finalize(Pipeline &pipeline, Event &event, Clie
                                           OperatorSinkFinalizeInput &input) const {
 	auto &sink = input.global_state.Cast<VacuumGlobalSinkState>();
 
-	auto table = info->table;
+	auto tbl = table;
 	for (idx_t col_idx = 0; col_idx < sink.column_distinct_stats.size(); col_idx++) {
-		table->GetStorage().SetDistinct(info->column_id_map.at(col_idx),
-		                                std::move(sink.column_distinct_stats[col_idx]));
+		tbl->GetStorage().SetDistinct(column_id_map.at(col_idx), std::move(sink.column_distinct_stats[col_idx]));
 	}
 
 	return SinkFinalizeType::READY;

package/src/duckdb/src/execution/operator/join/physical_iejoin.cpp

@@ -220,6 +220,7 @@ struct IEJoinUnion {
 		DataChunk payload;
 		payload.Initialize(Allocator::DefaultAllocator(), gstate.payload_layout.GetTypes());
 		for (;;) {
+			payload.Reset();
 			scanner.Scan(payload);
 			const auto count = payload.size();
 			if (!count) {
@@ -301,6 +302,7 @@ idx_t IEJoinUnion::AppendKey(SortedTable &table, ExpressionExecutor &executor, S
 
 	idx_t inserted = 0;
 	for (auto rid = base; table_idx < valid;) {
+		scanned.Reset();
 		scanner.Scan(scanned);
 
 		// NULLs are at the end, so stop when we reach them