duckdb 1.1.2-dev2.0 → 1.1.2-dev6.0

package/src/duckdb/src/function/pragma/pragma_queries.cpp

@@ -145,7 +145,7 @@ string PragmaImportDatabase(ClientContext &context, const FunctionParameters &pa
 	auto &fs = FileSystem::GetFileSystem(context);
 
 	string final_query;
-	// read the "shema.sql" and "load.sql" files
+	// read the "schema.sql" and "load.sql" files
 	vector<string> files = {"schema.sql", "load.sql"};
 	for (auto &file : files) {
 		auto file_path = fs.JoinPath(parameters.values[0].ToString(), file);

package/src/duckdb/src/function/scalar/strftime_format.cpp

@@ -1185,8 +1185,7 @@ bool StrpTimeFormat::Parse(const char *data, size_t size, ParseResult &result, b
 				case StrTimeSpecifier::YEAR_WITHOUT_CENTURY_PADDED:
 				case StrTimeSpecifier::YEAR_WITHOUT_CENTURY:
 				case StrTimeSpecifier::YEAR_DECIMAL:
-					// Part of the offset
-					break;
+					// Switch to offset parsing
 				case StrTimeSpecifier::WEEKDAY_DECIMAL:
 					// First offset specifier
 					offset_specifier = specifiers[i];

package/src/duckdb/src/function/scalar/string/concat.cpp

@@ -45,7 +45,7 @@ static void StringConcatFunction(DataChunk &args, ExpressionState &state, Vector
 	vector<idx_t> result_lengths(args.size(), 0);
 	for (idx_t col_idx = 0; col_idx < args.ColumnCount(); col_idx++) {
 		auto &input = args.data[col_idx];
-		D_ASSERT(input.GetType().id() == LogicalTypeId::VARCHAR);
+		D_ASSERT(input.GetType().InternalType() == PhysicalType::VARCHAR);
 		if (input.GetVectorType() == VectorType::CONSTANT_VECTOR) {
 			if (ConstantVector::IsNull(input)) {
 				// constant null, skip
@@ -143,68 +143,60 @@ static void ConcatOperator(DataChunk &args, ExpressionState &state, Vector &resu
 	    });
 }
 
+struct ListConcatInputData {
+	ListConcatInputData(Vector &input, Vector &child_vec) : input(input), child_vec(child_vec) {
+	}
+
+	UnifiedVectorFormat vdata;
+	Vector &input;
+	Vector &child_vec;
+	UnifiedVectorFormat child_vdata;
+	const list_entry_t *input_entries = nullptr;
+};
+
 static void ListConcatFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	D_ASSERT(args.ColumnCount() == 2);
 	auto count = args.size();
 
-	Vector &lhs = args.data[0];
-	Vector &rhs = args.data[1];
-	if (lhs.GetType().id() == LogicalTypeId::SQLNULL) {
-		result.Reference(rhs);
-		return;
-	}
-	if (rhs.GetType().id() == LogicalTypeId::SQLNULL) {
-		result.Reference(lhs);
-		return;
-	}
-
-	UnifiedVectorFormat lhs_data;
-	UnifiedVectorFormat rhs_data;
-	lhs.ToUnifiedFormat(count, lhs_data);
-	rhs.ToUnifiedFormat(count, rhs_data);
-	auto lhs_entries = UnifiedVectorFormat::GetData<list_entry_t>(lhs_data);
-	auto rhs_entries = UnifiedVectorFormat::GetData<list_entry_t>(rhs_data);
-
-	auto lhs_list_size = ListVector::GetListSize(lhs);
-	auto rhs_list_size = ListVector::GetListSize(rhs);
-	auto &lhs_child = ListVector::GetEntry(lhs);
-	auto &rhs_child = ListVector::GetEntry(rhs);
-	UnifiedVectorFormat lhs_child_data;
-	UnifiedVectorFormat rhs_child_data;
-	lhs_child.ToUnifiedFormat(lhs_list_size, lhs_child_data);
-	rhs_child.ToUnifiedFormat(rhs_list_size, rhs_child_data);
-
-	result.SetVectorType(VectorType::FLAT_VECTOR);
 	auto result_entries = FlatVector::GetData<list_entry_t>(result);
-	auto &result_validity = FlatVector::Validity(result);
+	vector<ListConcatInputData> input_data;
+	for (auto &input : args.data) {
+		if (input.GetType().id() == LogicalTypeId::SQLNULL) {
+			// ignore NULL values
+			continue;
+		}
+
+		auto &child_vec = ListVector::GetEntry(input);
+		ListConcatInputData data(input, child_vec);
+		input.ToUnifiedFormat(count, data.vdata);
+
+		data.input_entries = UnifiedVectorFormat::GetData<list_entry_t>(data.vdata);
+		auto list_size = ListVector::GetListSize(input);
+
+		child_vec.ToUnifiedFormat(list_size, data.child_vdata);
+
+		input_data.push_back(std::move(data));
+	}
 
 	idx_t offset = 0;
 	for (idx_t i = 0; i < count; i++) {
-		auto lhs_list_index = lhs_data.sel->get_index(i);
-		auto rhs_list_index = rhs_data.sel->get_index(i);
-		if (!lhs_data.validity.RowIsValid(lhs_list_index) && !rhs_data.validity.RowIsValid(rhs_list_index)) {
-			result_validity.SetInvalid(i);
-			continue;
-		}
-		result_entries[i].offset = offset;
-		result_entries[i].length = 0;
-		if (lhs_data.validity.RowIsValid(lhs_list_index)) {
-			const auto &lhs_entry = lhs_entries[lhs_list_index];
-			result_entries[i].length += lhs_entry.length;
-			ListVector::Append(result, lhs_child, *lhs_child_data.sel, lhs_entry.offset + lhs_entry.length,
-			                   lhs_entry.offset);
-		}
-		if (rhs_data.validity.RowIsValid(rhs_list_index)) {
-			const auto &rhs_entry = rhs_entries[rhs_list_index];
-			result_entries[i].length += rhs_entry.length;
-			ListVector::Append(result, rhs_child, *rhs_child_data.sel, rhs_entry.offset + rhs_entry.length,
-			                   rhs_entry.offset);
+		auto &result_entry = result_entries[i];
+		result_entry.offset = offset;
+		result_entry.length = 0;
+		for (auto &data : input_data) {
+			auto list_index = data.vdata.sel->get_index(i);
+			if (!data.vdata.validity.RowIsValid(list_index)) {
+				continue;
+			}
+			const auto &list_entry = data.input_entries[list_index];
+			result_entry.length += list_entry.length;
+			ListVector::Append(result, data.child_vec, *data.child_vdata.sel, list_entry.offset + list_entry.length,
+			                   list_entry.offset);
 		}
-		offset += result_entries[i].length;
+		offset += result_entry.length;
 	}
-	D_ASSERT(ListVector::GetListSize(result) == offset);
+	ListVector::SetListSize(result, offset);
 
-	if (lhs.GetVectorType() == VectorType::CONSTANT_VECTOR && rhs.GetVectorType() == VectorType::CONSTANT_VECTOR) {
+	if (args.AllConstant()) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
 	}
 }
@@ -235,128 +227,103 @@ static void SetArgumentType(ScalarFunction &bound_function, const LogicalType &t
 	bound_function.return_type = type;
 }
 
-static void HandleArrayBinding(ClientContext &context, vector<unique_ptr<Expression>> &arguments) {
-	if (arguments[1]->return_type.id() != LogicalTypeId::ARRAY &&
-	    arguments[1]->return_type.id() != LogicalTypeId::SQLNULL) {
-		throw BinderException("Cannot concatenate types %s and %s", arguments[0]->return_type.ToString(),
-		                      arguments[1]->return_type.ToString());
-	}
-
-	// if either argument is an array, we cast it to a list
-	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
-	arguments[1] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[1]));
-}
-
-static unique_ptr<FunctionData> HandleListBinding(ClientContext &context, ScalarFunction &bound_function,
-                                                  vector<unique_ptr<Expression>> &arguments, bool is_operator) {
-	// list_concat only accepts two arguments
-	D_ASSERT(arguments.size() == 2);
-
-	auto &lhs = arguments[0]->return_type;
-	auto &rhs = arguments[1]->return_type;
-
-	if (lhs.id() == LogicalTypeId::UNKNOWN || rhs.id() == LogicalTypeId::UNKNOWN) {
-		throw ParameterNotResolvedException();
-	} else if (lhs.id() == LogicalTypeId::SQLNULL || rhs.id() == LogicalTypeId::SQLNULL) {
-		// we mimic postgres behaviour: list_concat(NULL, my_list) = my_list
-		auto return_type = rhs.id() == LogicalTypeId::SQLNULL ? lhs : rhs;
-		SetArgumentType(bound_function, return_type, is_operator);
-		return make_uniq<ConcatFunctionData>(bound_function.return_type, is_operator);
-	}
-	if (lhs.id() != LogicalTypeId::LIST || rhs.id() != LogicalTypeId::LIST) {
-		throw BinderException("Cannot concatenate types %s and %s", lhs.ToString(), rhs.ToString());
-	}
-
-	// Resolve list type
+static unique_ptr<FunctionData> BindListConcat(ClientContext &context, ScalarFunction &bound_function,
+                                               vector<unique_ptr<Expression>> &arguments, bool is_operator) {
 	LogicalType child_type = LogicalType::SQLNULL;
-	for (const auto &argument : arguments) {
-		auto &next_type = ListType::GetChildType(argument->return_type);
+	bool all_null = true;
+	for (auto &arg : arguments) {
+		auto &return_type = arg->return_type;
+		if (return_type == LogicalTypeId::SQLNULL) {
+			// we mimic postgres behaviour: list_concat(NULL, my_list) = my_list
+			continue;
+		}
+		all_null = false;
+		LogicalType next_type = LogicalTypeId::INVALID;
+		switch (return_type.id()) {
+		case LogicalTypeId::UNKNOWN:
+			throw ParameterNotResolvedException();
+		case LogicalTypeId::LIST:
+			next_type = ListType::GetChildType(return_type);
+			break;
+		case LogicalTypeId::ARRAY:
+			next_type = ArrayType::GetChildType(return_type);
+			break;
+		default: {
+			string type_list;
+			for (idx_t arg_idx = 0; arg_idx < arguments.size(); arg_idx++) {
+				if (!type_list.empty()) {
+					if (arg_idx + 1 == arguments.size()) {
+						// last argument
+						type_list += " and ";
+					} else {
+						type_list += ", ";
+					}
+				}
+				type_list += arguments[arg_idx]->return_type.ToString();
+			}
+			throw BinderException(*arg, "Cannot concatenate types %s - an explicit cast is required", type_list);
+		}
+		}
 		if (!LogicalType::TryGetMaxLogicalType(context, child_type, next_type, child_type)) {
-			throw BinderException("Cannot concatenate lists of types %s[] and %s[] - an explicit cast is required",
+			throw BinderException(*arg,
+			                      "Cannot concatenate lists of types %s[] and %s[] - an explicit cast is required",
 			                      child_type.ToString(), next_type.ToString());
 		}
 	}
+	if (all_null) {
+		// all arguments are NULL
+		SetArgumentType(bound_function, LogicalTypeId::SQLNULL, is_operator);
+		return make_uniq<ConcatFunctionData>(bound_function.return_type, is_operator);
+	}
 	auto list_type = LogicalType::LIST(child_type);
 
 	SetArgumentType(bound_function, list_type, is_operator);
 	return make_uniq<ConcatFunctionData>(bound_function.return_type, is_operator);
 }
 
-static void FindFirstTwoArguments(vector<unique_ptr<Expression>> &arguments, LogicalTypeId &first_arg,
-                                  LogicalTypeId &second_arg) {
-	first_arg = arguments[0]->return_type.id();
-	second_arg = first_arg;
-	if (arguments.size() > 1) {
-		second_arg = arguments[1]->return_type.id();
+static unique_ptr<FunctionData> BindConcatFunctionInternal(ClientContext &context, ScalarFunction &bound_function,
+                                                           vector<unique_ptr<Expression>> &arguments,
+                                                           bool is_operator) {
+	bool list_concat = false;
+	// blob concat is only supported for the concat operator - regular concat converts to varchar
+	bool all_blob = is_operator ? true : false;
+	for (auto &arg : arguments) {
+		if (arg->return_type.id() == LogicalTypeId::UNKNOWN) {
+			throw ParameterNotResolvedException();
+		}
+		if (arg->return_type.id() == LogicalTypeId::LIST || arg->return_type.id() == LogicalTypeId::ARRAY) {
+			list_concat = true;
+		}
+		if (arg->return_type.id() != LogicalTypeId::BLOB) {
+			all_blob = false;
+		}
 	}
+	if (list_concat) {
+		return BindListConcat(context, bound_function, arguments, is_operator);
+	}
+	auto return_type = all_blob ? LogicalType::BLOB : LogicalType::VARCHAR;
+
+	// we can now assume that the input is a string or castable to a string
+	SetArgumentType(bound_function, return_type, is_operator);
+	return make_uniq<ConcatFunctionData>(bound_function.return_type, is_operator);
 }
 
 static unique_ptr<FunctionData> BindConcatFunction(ClientContext &context, ScalarFunction &bound_function,
                                                    vector<unique_ptr<Expression>> &arguments) {
-	LogicalTypeId first_arg;
-	LogicalTypeId second_arg;
-	FindFirstTwoArguments(arguments, first_arg, second_arg);
-
-	if (arguments.size() > 2 && (first_arg == LogicalTypeId::ARRAY || first_arg == LogicalTypeId::LIST)) {
-		throw BinderException("list_concat only accepts two arguments");
-	}
-
-	if (first_arg == LogicalTypeId::ARRAY || second_arg == LogicalTypeId::ARRAY) {
-		HandleArrayBinding(context, arguments);
-		FindFirstTwoArguments(arguments, first_arg, second_arg);
-	}
-
-	if (first_arg == LogicalTypeId::LIST || second_arg == LogicalTypeId::LIST) {
-		return HandleListBinding(context, bound_function, arguments, false);
-	}
-
-	// we can now assume that the input is a string or castable to a string
-	SetArgumentType(bound_function, LogicalType::VARCHAR, false);
-	return make_uniq<ConcatFunctionData>(bound_function.return_type, false);
+	return BindConcatFunctionInternal(context, bound_function, arguments, false);
 }
 
 static unique_ptr<FunctionData> BindConcatOperator(ClientContext &context, ScalarFunction &bound_function,
                                                    vector<unique_ptr<Expression>> &arguments) {
-	D_ASSERT(arguments.size() == 2);
-
-	LogicalTypeId lhs;
-	LogicalTypeId rhs;
-	FindFirstTwoArguments(arguments, lhs, rhs);
-
-	if (lhs == LogicalTypeId::UNKNOWN || rhs == LogicalTypeId::UNKNOWN) {
-		throw ParameterNotResolvedException();
-	}
-	if (lhs == LogicalTypeId::ARRAY || rhs == LogicalTypeId::ARRAY) {
-		HandleArrayBinding(context, arguments);
-		FindFirstTwoArguments(arguments, lhs, rhs);
-	}
-
-	if (lhs == LogicalTypeId::LIST || rhs == LogicalTypeId::LIST) {
-		return HandleListBinding(context, bound_function, arguments, true);
-	}
-
-	LogicalType return_type;
-	if (lhs == LogicalTypeId::BLOB && rhs == LogicalTypeId::BLOB) {
-		return_type = LogicalType::BLOB;
-	} else {
-		return_type = LogicalType::VARCHAR;
-	}
-
-	// we can now assume that the input is a string or castable to a string
-	SetArgumentType(bound_function, return_type, true);
-	return make_uniq<ConcatFunctionData>(bound_function.return_type, true);
+	return BindConcatFunctionInternal(context, bound_function, arguments, true);
 }
 
 static unique_ptr<BaseStatistics> ListConcatStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
-	D_ASSERT(child_stats.size() == 2);
-
-	auto &left_stats = child_stats[0];
-	auto &right_stats = child_stats[1];
-
-	auto stats = left_stats.ToUnique();
-	stats->Merge(right_stats);
-
+	auto stats = child_stats[0].ToUnique();
+	for (idx_t i = 1; i < child_stats.size(); i++) {
+		stats->Merge(child_stats[i]);
+	}
 	return stats;
 }
 

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

@@ -99,6 +99,19 @@ static unique_ptr<ArrowType> GetArrowExtensionType(const ArrowSchemaMetadata &ex
 		auto type_info = make_uniq<ArrowStringInfo>(ArrowVariableSizeType::SUPER_SIZE);
 		return make_uniq<ArrowType>(LogicalType::BIT, std::move(type_info));
 
+	} else if (arrow_extension == "duckdb.varint") {
+		if (format != "z" && format != "Z") {
+			std::ostringstream error;
+			error << "duckdb.bit must be a blob (i.e., \'z\'). It is incorrectly defined as:" << format;
+			return make_uniq<ArrowType>(error.str());
+		}
+		unique_ptr<ArrowStringInfo> type_info;
+		if (format == "z") {
+			type_info = make_uniq<ArrowStringInfo>(ArrowVariableSizeType::NORMAL);
+		} else {
+			type_info = make_uniq<ArrowStringInfo>(ArrowVariableSizeType::SUPER_SIZE);
+		}
+		return make_uniq<ArrowType>(LogicalType::VARINT, std::move(type_info));
 	} else {
 		std::ostringstream error;
 		error << "Arrow Type with extension name: " << arrow_extension << " and format: " << format

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

@@ -138,6 +138,12 @@ static ArrowListOffsetData ConvertArrowListOffsetsTemplated(Vector &vector, Arro
 	auto &start_offset = result.start_offset;
 	auto &list_size = result.list_size;
 
+	if (size == 0) {
+		start_offset = 0;
+		list_size = 0;
+		return result;
+	}
+
 	idx_t cur_offset = 0;
 	auto offsets = ArrowBufferData<BUFFER_TYPE>(array, 1) + effective_offset;
 	start_offset = offsets[0];
@@ -765,14 +771,12 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 	case LogicalTypeId::BOOLEAN: {
 		//! Arrow bit-packs boolean values
 		//! Lets first figure out where we are in the source array
-		auto src_ptr = ArrowBufferData<uint8_t>(array, 1) +
-		               GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset) / 8;
+		auto effective_offset =
+		    GetEffectiveOffset(array, NumericCast<int64_t>(parent_offset), scan_state, nested_offset);
+		auto src_ptr = ArrowBufferData<uint8_t>(array, 1) + effective_offset / 8;
 		auto tgt_ptr = (uint8_t *)FlatVector::GetData(vector);
 		int src_pos = 0;
-		idx_t cur_bit = scan_state.chunk_offset % 8;
-		if (nested_offset != -1) {
-			cur_bit = NumericCast<idx_t>(nested_offset % 8);
-		}
+		idx_t cur_bit = effective_offset % 8;
 		for (idx_t row = 0; row < size; row++) {
 			if ((src_ptr[src_pos] & (1 << cur_bit)) == 0) {
 				tgt_ptr[row] = 0;
@@ -1026,7 +1030,8 @@ static void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowArraySca
 		break;
 	}
 	case LogicalTypeId::BLOB:
-	case LogicalTypeId::BIT: {
+	case LogicalTypeId::BIT:
+	case LogicalTypeId::VARINT: {
 		ArrowToDuckDBBlob(vector, array, scan_state, size, arrow_type, nested_offset,
 		                  NumericCast<int64_t>(parent_offset));
 		break;

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

@@ -7,7 +7,7 @@
 #include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/common/types/string_type.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_sniffer.hpp"
+#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
 #include "duckdb/function/copy_function.hpp"
 #include "duckdb/function/scalar/string_functions.hpp"
 #include "duckdb/function/table/read_csv.hpp"

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

@@ -8,7 +8,7 @@
 #include "duckdb/common/union_by_name.hpp"
 #include "duckdb/execution/operator/csv_scanner/global_csv_state.hpp"
 #include "duckdb/execution/operator/csv_scanner/csv_error.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_sniffer.hpp"
+#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
 #include "duckdb/execution/operator/persistent/csv_rejects_table.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/main/client_context.hpp"
@@ -52,36 +52,9 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 	auto multi_file_list = multi_file_reader->CreateFileList(context, input.inputs[0]);
 
 	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");
-	}
-	if (options.rejects_scan_name.IsSetByUser() && !options.store_rejects.GetValue() &&
-	    options.store_rejects.IsSetByUser()) {
-		throw BinderException("REJECTS_SCAN option is only supported when store_rejects is not manually set to false");
-	}
-	if (options.rejects_scan_name.IsSetByUser() || options.rejects_table_name.IsSetByUser()) {
-		// Ensure we set store_rejects to true automagically
-		options.store_rejects.Set(true, false);
-	}
-	// Validate rejects_table options
-	if (options.store_rejects.GetValue()) {
-		if (!options.ignore_errors.GetValue() && options.ignore_errors.IsSetByUser()) {
-			throw BinderException(
-			    "STORE_REJECTS option is only supported when IGNORE_ERRORS is not manually set to false");
-		}
-		// Ensure we set ignore errors to true automagically
-		options.ignore_errors.Set(true, false);
-		if (options.file_options.union_by_name) {
-			throw BinderException("REJECTS_TABLE option is not supported when UNION_BY_NAME is set to true");
-		}
-	}
-	if (options.rejects_limit != 0 && !options.store_rejects.GetValue()) {
-		throw BinderException("REJECTS_LIMIT option is only supported when REJECTS_TABLE is set to a table name");
-	}
 
 	options.file_options.AutoDetectHivePartitioning(*multi_file_list, context);
-
+	options.Verify();
 	if (!options.auto_detect) {
 		if (!options.columns_set) {
 			throw BinderException("read_csv requires columns to be specified through the 'columns' option. Use "
@@ -291,7 +264,6 @@ void ReadCSVTableFunction::ReadCSVAddNamedParameters(TableFunction &table_functi
 	table_function.named_parameters["types"] = LogicalType::ANY;
 	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);

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

@@ -1,7 +1,7 @@
 #include "duckdb/function/built_in_functions.hpp"
 #include "duckdb/execution/operator/csv_scanner/csv_reader_options.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
-#include "duckdb/execution/operator/csv_scanner/csv_sniffer.hpp"
+#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
 #include "duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp"
 #include "duckdb/function/table_function.hpp"
 #include "duckdb/main/client_context.hpp"
@@ -50,6 +50,7 @@ static unique_ptr<FunctionData> CSVSniffBind(ClientContext &context, TableFuncti
 		input.named_parameters.erase("auto_detect");
 	}
 	result->options.FromNamedParameters(input.named_parameters, context);
+	result->options.Verify();
 	// We want to return the whole CSV Configuration
 	// 1. Delimiter
 	return_types.emplace_back(LogicalType::VARCHAR);

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

@@ -107,13 +107,21 @@ void DuckDBSecretsFunction(ClientContext &context, TableFunctionInput &data_p, D
 
 		const auto &secret = *secret_entry.secret;
 
-		output.SetValue(0, count, secret.GetName());
-		output.SetValue(1, count, Value(secret.GetType()));
-		output.SetValue(2, count, Value(secret.GetProvider()));
-		output.SetValue(3, count, Value(secret_entry.persist_type == SecretPersistType::PERSISTENT));
-		output.SetValue(4, count, Value(secret_entry.storage_mode));
-		output.SetValue(5, count, Value::LIST(LogicalType::VARCHAR, scope_value));
-		output.SetValue(6, count, secret.ToString(bind_data.redact));
+		idx_t i = 0;
+		// name
+		output.SetValue(i++, count, secret.GetName());
+		// type
+		output.SetValue(i++, count, Value(secret.GetType()));
+		// provider
+		output.SetValue(i++, count, Value(secret.GetProvider()));
+		// persistent
+		output.SetValue(i++, count, Value(secret_entry.persist_type == SecretPersistType::PERSISTENT));
+		// storage
+		output.SetValue(i++, count, Value(secret_entry.storage_mode));
+		// scope
+		output.SetValue(i++, count, Value::LIST(LogicalType::VARCHAR, scope_value));
+		// secret_string
+		output.SetValue(i++, count, secret.ToString(bind_data.redact));
 
 		data.offset++;
 		count++;

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,5 +1,5 @@
 #ifndef DUCKDB_PATCH_VERSION
-#define DUCKDB_PATCH_VERSION "1"
+#define DUCKDB_PATCH_VERSION "3"
 #endif
 #ifndef DUCKDB_MINOR_VERSION
 #define DUCKDB_MINOR_VERSION 1
@@ -8,10 +8,10 @@
 #define DUCKDB_MAJOR_VERSION 1
 #endif
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "v1.1.1"
+#define DUCKDB_VERSION "v1.1.3"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "af39bd0dcf"
+#define DUCKDB_SOURCE_ID "19864453f7"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/catalog/catalog_entry_retriever.hpp

@@ -64,7 +64,7 @@ private:
 	}
 
 private:
-	//! (optional) callback, called on every succesful entry retrieval
+	//! (optional) callback, called on every successful entry retrieval
 	catalog_entry_callback_t callback = nullptr;
 	ClientContext &context;
 };

package/src/duckdb/src/include/duckdb/common/atomic.hpp

@@ -11,5 +11,17 @@
 #include <atomic>
 
 namespace duckdb {
+
 using std::atomic;
-}
+
+//! NOTE: When repeatedly trying to atomically set a value in a loop, you can use as the loop condition:
+//! * std::atomic_compare_exchange_weak
+//! * std::atomic::compare_exchange_weak
+//! If not used as a loop condition, use:
+//! * std::atomic_compare_exchange_strong
+//! * std::atomic::compare_exchange_strong
+//! If this is not done correctly, we may get correctness issues when using older compiler versions (see: issue #14389)
+//! Performance may be optimized using std::memory_order, but NOT at the cost of correctness.
+//! For correct examples of this, see concurrentqueue.h
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/bitpacking.hpp

@@ -41,16 +41,15 @@ public:
 			}
 		} else {
 			idx_t misaligned_count = count % BITPACKING_ALGORITHM_GROUP_SIZE;
-			T tmp_buffer[BITPACKING_ALGORITHM_GROUP_SIZE]; // TODO maybe faster on the heap?
-
 			count -= misaligned_count;
-
 			for (idx_t i = 0; i < count; i += BITPACKING_ALGORITHM_GROUP_SIZE) {
 				PackGroup<T>(dst + (i * width) / 8, src + i, width);
 			}
 
-			// Input was not aligned to BITPACKING_ALGORITHM_GROUP_SIZE, we need a copy
+			// The input is not aligned to BITPACKING_ALGORITHM_GROUP_SIZE.
+			// Copy the unaligned count into a zero-initialized temporary group, and pack it.
 			if (misaligned_count) {
+				T tmp_buffer[BITPACKING_ALGORITHM_GROUP_SIZE] = {0};
 				memcpy(tmp_buffer, src + count, misaligned_count * sizeof(T));
 				PackGroup<T>(dst + (count * width) / 8, tmp_buffer, width);
 			}

package/src/duckdb/src/include/duckdb/common/enum_util.hpp

@@ -278,6 +278,8 @@ enum class SecretDisplayType : uint8_t;
 
 enum class SecretPersistType : uint8_t;
 
+enum class SecretSerializationType : uint8_t;
+
 enum class SequenceInfo : uint8_t;
 
 enum class SetOperationType : uint8_t;
@@ -728,6 +730,9 @@ const char* EnumUtil::ToChars<SecretDisplayType>(SecretDisplayType value);
 template<>
 const char* EnumUtil::ToChars<SecretPersistType>(SecretPersistType value);
 
+template<>
+const char* EnumUtil::ToChars<SecretSerializationType>(SecretSerializationType value);
+
 template<>
 const char* EnumUtil::ToChars<SequenceInfo>(SequenceInfo value);
 
@@ -1218,6 +1223,9 @@ SecretDisplayType EnumUtil::FromString<SecretDisplayType>(const char *value);
 template<>
 SecretPersistType EnumUtil::FromString<SecretPersistType>(const char *value);
 
+template<>
+SecretSerializationType EnumUtil::FromString<SecretSerializationType>(const char *value);
+
 template<>
 SequenceInfo EnumUtil::FromString<SequenceInfo>(const char *value);
 

package/src/duckdb/src/include/duckdb/common/enums/metric_type.hpp

@@ -30,6 +30,8 @@ enum class MetricsType : uint8_t {
     CUMULATIVE_ROWS_SCANNED,
     OPERATOR_ROWS_SCANNED,
     OPERATOR_TIMING,
+	LATENCY,
+	ROWS_RETURNED,
     RESULT_SET_SIZE,
     ALL_OPTIMIZERS,
     CUMULATIVE_OPTIMIZER_TIMING,

package/src/duckdb/src/include/duckdb/common/exception.hpp

@@ -329,6 +329,16 @@ public:
 	}
 };
 
+class ExecutorException : public Exception {
+public:
+	DUCKDB_API explicit ExecutorException(const string &msg);
+
+	template <typename... ARGS>
+	explicit ExecutorException(const string &msg, ARGS... params)
+	    : ExecutorException(ConstructMessage(msg, params...)) {
+	}
+};
+
 class InvalidConfigurationException : public Exception {
 public:
 	DUCKDB_API explicit InvalidConfigurationException(const string &msg);