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

package/src/duckdb/src/function/scalar/operators/arithmetic.cpp

@@ -115,7 +115,7 @@ struct SubtractPropagateStatistics {
 };
 
 struct DecimalArithmeticBindData : public FunctionData {
-	DecimalArithmeticBindData() : check_overflow(true) {
+	DecimalArithmeticBindData() : check_overflow(false) {
 	}
 
 	unique_ptr<FunctionData> Copy() const override {
@@ -182,10 +182,9 @@ static unique_ptr<BaseStatistics> PropagateNumericStats(ClientContext &context,
 	return result.ToUnique();
 }
 
-template <class OP, class OPOVERFLOWCHECK, bool IS_SUBTRACT = false>
-unique_ptr<FunctionData> BindDecimalAddSubtract(ClientContext &context, ScalarFunction &bound_function,
-                                                vector<unique_ptr<Expression>> &arguments) {
-
+template <bool IS_MODULO = false>
+unique_ptr<DecimalArithmeticBindData> BindDecimalArithmetic(ClientContext &context, ScalarFunction &bound_function,
+                                                            vector<unique_ptr<Expression>> &arguments) {
 	auto bind_data = make_uniq<DecimalArithmeticBindData>();
 
 	// get the max width and scale of the input arguments
@@ -204,12 +203,15 @@ unique_ptr<FunctionData> BindDecimalAddSubtract(ClientContext &context, ScalarFu
 		max_width_over_scale = MaxValue<uint8_t>(width - scale, max_width_over_scale);
 	}
 	D_ASSERT(max_width > 0);
-	// for addition/subtraction, we add 1 to the width to ensure we don't overflow
-	auto required_width = NumericCast<uint8_t>(MaxValue<uint8_t>(max_scale + max_width_over_scale, max_width) + 1);
-	if (required_width > Decimal::MAX_WIDTH_INT64 && max_width <= Decimal::MAX_WIDTH_INT64) {
-		// we don't automatically promote past the hugeint boundary to avoid the large hugeint performance penalty
-		bind_data->check_overflow = true;
-		required_width = Decimal::MAX_WIDTH_INT64;
+	uint8_t required_width = MaxValue<uint8_t>(max_scale + max_width_over_scale, max_width);
+	if (!IS_MODULO) {
+		// for addition/subtraction, we add 1 to the width to ensure we don't overflow
+		required_width = NumericCast<uint8_t>(required_width + 1);
+		if (required_width > Decimal::MAX_WIDTH_INT64 && max_width <= Decimal::MAX_WIDTH_INT64) {
+			// we don't automatically promote past the hugeint boundary to avoid the large hugeint performance penalty
+			bind_data->check_overflow = true;
+			required_width = Decimal::MAX_WIDTH_INT64;
+		}
 	}
 	if (required_width > Decimal::MAX_WIDTH_DECIMAL) {
 		// target width does not fit in decimal at all: truncate the scale and perform overflow detection
@@ -232,7 +234,16 @@ unique_ptr<FunctionData> BindDecimalAddSubtract(ClientContext &context, ScalarFu
 		}
 	}
 	bound_function.return_type = result_type;
+	return bind_data;
+}
+
+template <class OP, class OPOVERFLOWCHECK, bool IS_SUBTRACT = false>
+unique_ptr<FunctionData> BindDecimalAddSubtract(ClientContext &context, ScalarFunction &bound_function,
+                                                vector<unique_ptr<Expression>> &arguments) {
+	auto bind_data = BindDecimalArithmetic(context, bound_function, arguments);
+
 	// now select the physical function to execute
+	auto &result_type = bound_function.return_type;
 	if (bind_data->check_overflow) {
 		bound_function.function = GetScalarBinaryFunction<OPOVERFLOWCHECK>(result_type.InternalType());
 	} else {
@@ -435,8 +446,8 @@ void AddFun::RegisterFunction(BuiltinFunctions &set) {
 struct NegateOperator {
 	template <class T>
 	static bool CanNegate(T input) {
-		using Limits = std::numeric_limits<T>;
-		return !(Limits::is_integer && Limits::is_signed && Limits::lowest() == input);
+		using Limits = NumericLimits<T>;
+		return !(Limits::IsSigned() && Limits::Minimum() == input);
 	}
 
 	template <class TA, class TR>
@@ -910,31 +921,31 @@ static void BinaryScalarFunctionIgnoreZero(DataChunk &input, ExpressionState &st
 }
 
 template <class OP>
-static scalar_function_t GetBinaryFunctionIgnoreZero(const LogicalType &type) {
-	switch (type.id()) {
-	case LogicalTypeId::TINYINT:
+static scalar_function_t GetBinaryFunctionIgnoreZero(PhysicalType type) {
+	switch (type) {
+	case PhysicalType::INT8:
 		return BinaryScalarFunctionIgnoreZero<int8_t, int8_t, int8_t, OP, BinaryNumericDivideWrapper>;
-	case LogicalTypeId::SMALLINT:
+	case PhysicalType::INT16:
 		return BinaryScalarFunctionIgnoreZero<int16_t, int16_t, int16_t, OP, BinaryNumericDivideWrapper>;
-	case LogicalTypeId::INTEGER:
+	case PhysicalType::INT32:
 		return BinaryScalarFunctionIgnoreZero<int32_t, int32_t, int32_t, OP, BinaryNumericDivideWrapper>;
-	case LogicalTypeId::BIGINT:
+	case PhysicalType::INT64:
 		return BinaryScalarFunctionIgnoreZero<int64_t, int64_t, int64_t, OP, BinaryNumericDivideWrapper>;
-	case LogicalTypeId::UTINYINT:
+	case PhysicalType::UINT8:
 		return BinaryScalarFunctionIgnoreZero<uint8_t, uint8_t, uint8_t, OP>;
-	case LogicalTypeId::USMALLINT:
+	case PhysicalType::UINT16:
 		return BinaryScalarFunctionIgnoreZero<uint16_t, uint16_t, uint16_t, OP>;
-	case LogicalTypeId::UINTEGER:
+	case PhysicalType::UINT32:
 		return BinaryScalarFunctionIgnoreZero<uint32_t, uint32_t, uint32_t, OP>;
-	case LogicalTypeId::UBIGINT:
+	case PhysicalType::UINT64:
 		return BinaryScalarFunctionIgnoreZero<uint64_t, uint64_t, uint64_t, OP>;
-	case LogicalTypeId::HUGEINT:
+	case PhysicalType::INT128:
 		return BinaryScalarFunctionIgnoreZero<hugeint_t, hugeint_t, hugeint_t, OP, BinaryNumericDivideHugeintWrapper>;
-	case LogicalTypeId::UHUGEINT:
+	case PhysicalType::UINT128:
 		return BinaryScalarFunctionIgnoreZero<uhugeint_t, uhugeint_t, uhugeint_t, OP>;
-	case LogicalTypeId::FLOAT:
+	case PhysicalType::FLOAT:
 		return BinaryScalarFunctionIgnoreZero<float, float, float, OP>;
-	case LogicalTypeId::DOUBLE:
+	case PhysicalType::DOUBLE:
 		return BinaryScalarFunctionIgnoreZero<double, double, double, OP>;
 	default:
 		throw NotImplementedException("Unimplemented type for GetScalarUnaryFunction");
@@ -944,9 +955,9 @@ static scalar_function_t GetBinaryFunctionIgnoreZero(const LogicalType &type) {
 void DivideFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet fp_divide("/");
 	fp_divide.AddFunction(ScalarFunction({LogicalType::FLOAT, LogicalType::FLOAT}, LogicalType::FLOAT,
-	                                     GetBinaryFunctionIgnoreZero<DivideOperator>(LogicalType::FLOAT)));
+	                                     GetBinaryFunctionIgnoreZero<DivideOperator>(PhysicalType::FLOAT)));
 	fp_divide.AddFunction(ScalarFunction({LogicalType::DOUBLE, LogicalType::DOUBLE}, LogicalType::DOUBLE,
-	                                     GetBinaryFunctionIgnoreZero<DivideOperator>(LogicalType::DOUBLE)));
+	                                     GetBinaryFunctionIgnoreZero<DivideOperator>(PhysicalType::DOUBLE)));
 	fp_divide.AddFunction(
 	    ScalarFunction({LogicalType::INTERVAL, LogicalType::BIGINT}, LogicalType::INTERVAL,
 	                   BinaryScalarFunctionIgnoreZero<interval_t, int64_t, interval_t, DivideOperator>));
@@ -958,7 +969,7 @@ void DivideFun::RegisterFunction(BuiltinFunctions &set) {
 			continue;
 		} else {
 			full_divide.AddFunction(
-			    ScalarFunction({type, type}, type, GetBinaryFunctionIgnoreZero<DivideOperator>(type)));
+			    ScalarFunction({type, type}, type, GetBinaryFunctionIgnoreZero<DivideOperator>(type.InternalType())));
 		}
 	}
 	set.AddFunction(full_divide);
@@ -970,6 +981,23 @@ void DivideFun::RegisterFunction(BuiltinFunctions &set) {
 //===--------------------------------------------------------------------===//
 // % [modulo]
 //===--------------------------------------------------------------------===//
+template <class OP>
+unique_ptr<FunctionData> BindDecimalModulo(ClientContext &context, ScalarFunction &bound_function,
+                                           vector<unique_ptr<Expression>> &arguments) {
+	auto bind_data = BindDecimalArithmetic<true>(context, bound_function, arguments);
+	// now select the physical function to execute
+	if (bind_data->check_overflow) {
+		// fallback to DOUBLE if the decimal type is not guaranteed to fit within the max decimal width
+		for (auto &arg : bound_function.arguments) {
+			arg = LogicalType::DOUBLE;
+		}
+		bound_function.return_type = LogicalType::DOUBLE;
+	}
+	auto &result_type = bound_function.return_type;
+	bound_function.function = GetBinaryFunctionIgnoreZero<OP>(result_type.InternalType());
+	return std::move(bind_data);
+}
+
 template <>
 float ModuloOperator::Operation(float left, float right) {
 	D_ASSERT(right != 0);
@@ -996,10 +1024,10 @@ void ModFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet functions("%");
 	for (auto &type : LogicalType::Numeric()) {
 		if (type.id() == LogicalTypeId::DECIMAL) {
-			continue;
+			functions.AddFunction(ScalarFunction({type, type}, type, nullptr, BindDecimalModulo<ModuloOperator>));
 		} else {
 			functions.AddFunction(
-			    ScalarFunction({type, type}, type, GetBinaryFunctionIgnoreZero<ModuloOperator>(type)));
+			    ScalarFunction({type, type}, type, GetBinaryFunctionIgnoreZero<ModuloOperator>(type.InternalType())));
 		}
 	}
 	set.AddFunction(functions);

package/src/duckdb/src/function/scalar/sequence/nextval.cpp

@@ -78,7 +78,7 @@ static unique_ptr<FunctionData> NextValBind(ClientContext &context, ScalarFuncti
 	return make_uniq<NextvalBindData>(sequence);
 }
 
-static void NextValDependency(BoundFunctionExpression &expr, DependencyList &dependencies) {
+static void NextValDependency(BoundFunctionExpression &expr, LogicalDependencyList &dependencies) {
 	auto &info = expr.bind_info->Cast<NextvalBindData>();
 	if (info.sequence) {
 		dependencies.AddDependency(*info.sequence);

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

@@ -5,6 +5,7 @@
 #include "duckdb/common/types/date.hpp"
 #include "duckdb/common/types/time.hpp"
 #include "duckdb/common/types/timestamp.hpp"
+#include <cctype>
 
 namespace duckdb {
 
@@ -598,7 +599,9 @@ string StrTimeFormat::ParseFormatSpecifier(const string &format_string, StrTimeF
 					// parse the subformat in a separate format specifier
 					StrfTimeFormat locale_format;
 					string error = StrTimeFormat::ParseFormatSpecifier(subformat, locale_format);
-					D_ASSERT(error.empty());
+					if (!error.empty()) {
+						throw InternalException("Failed to bind sub-format specifier \"%s\": %s", subformat, error);
+					}
 					// add the previous literal to the first literal of the subformat
 					locale_format.literals[0] = std::move(current_literal) + locale_format.literals[0];
 					current_literal = "";
@@ -1339,11 +1342,11 @@ bool StrTimeFormat::Empty() const {
 	return format_specifier.empty();
 }
 
-string StrpTimeFormat::FormatStrpTimeError(const string &input, idx_t position) {
-	if (position == DConstants::INVALID_INDEX) {
+string StrpTimeFormat::FormatStrpTimeError(const string &input, optional_idx position) {
+	if (!position.IsValid()) {
 		return string();
 	}
-	return input + "\n" + string(position, ' ') + "^";
+	return input + "\n" + string(position.GetIndex(), ' ') + "^";
 }
 
 date_t StrpTimeFormat::ParseResult::ToDate() {
@@ -1357,6 +1360,20 @@ bool StrpTimeFormat::ParseResult::TryToDate(date_t &result) {
 	return Date::TryFromDate(data[0], data[1], data[2], result);
 }
 
+dtime_t StrpTimeFormat::ParseResult::ToTime() {
+	const auto hour_offset = data[7] / Interval::MINS_PER_HOUR;
+	const auto mins_offset = data[7] % Interval::MINS_PER_HOUR;
+	return Time::FromTime(data[3] - hour_offset, data[4] - mins_offset, data[5], data[6]);
+}
+
+bool StrpTimeFormat::ParseResult::TryToTime(dtime_t &result) {
+	if (data[7]) {
+		return false;
+	}
+	result = Time::FromTime(data[3], data[4], data[5], data[6]);
+	return true;
+}
+
 timestamp_t StrpTimeFormat::ParseResult::ToTimestamp() {
 	if (is_special) {
 		if (special == date_t::infinity()) {
@@ -1368,9 +1385,7 @@ timestamp_t StrpTimeFormat::ParseResult::ToTimestamp() {
 	}
 
 	date_t date = Date::FromDate(data[0], data[1], data[2]);
-	const auto hour_offset = data[7] / Interval::MINS_PER_HOUR;
-	const auto mins_offset = data[7] % Interval::MINS_PER_HOUR;
-	dtime_t time = Time::FromTime(data[3] - hour_offset, data[4] - mins_offset, data[5], data[6]);
+	dtime_t time = ToTime();
 	return Timestamp::FromDatetime(date, time);
 }
 
@@ -1379,9 +1394,7 @@ bool StrpTimeFormat::ParseResult::TryToTimestamp(timestamp_t &result) {
 	if (!TryToDate(date)) {
 		return false;
 	}
-	const auto hour_offset = data[7] / Interval::MINS_PER_HOUR;
-	const auto mins_offset = data[7] % Interval::MINS_PER_HOUR;
-	dtime_t time = Time::FromTime(data[3] - hour_offset, data[4] - mins_offset, data[5], data[6]);
+	dtime_t time = ToTime();
 	return Timestamp::TryFromDatetime(date, time, result);
 }
 
@@ -1400,29 +1413,22 @@ bool StrpTimeFormat::TryParseDate(string_t input, date_t &result, string &error_
 	return parse_result.TryToDate(result);
 }
 
-bool StrpTimeFormat::TryParseTimestamp(string_t input, timestamp_t &result, string &error_message) const {
+bool StrpTimeFormat::TryParseTime(string_t input, dtime_t &result, string &error_message) const {
 	ParseResult parse_result;
 	if (!Parse(input, parse_result)) {
 		error_message = parse_result.FormatError(input, format_specifier);
 		return false;
 	}
-	return parse_result.TryToTimestamp(result);
-}
-
-date_t StrpTimeFormat::ParseDate(string_t input) {
-	ParseResult result;
-	if (!Parse(input, result)) {
-		throw InvalidInputException(result.FormatError(input, format_specifier));
-	}
-	return result.ToDate();
+	return parse_result.TryToTime(result);
 }
 
-timestamp_t StrpTimeFormat::ParseTimestamp(string_t input) {
-	ParseResult result;
-	if (!Parse(input, result)) {
-		throw InvalidInputException(result.FormatError(input, format_specifier));
+bool StrpTimeFormat::TryParseTimestamp(string_t input, timestamp_t &result, string &error_message) const {
+	ParseResult parse_result;
+	if (!Parse(input, parse_result)) {
+		error_message = parse_result.FormatError(input, format_specifier);
+		return false;
 	}
-	return result.ToTimestamp();
+	return parse_result.TryToTimestamp(result);
 }
 
 } // namespace duckdb

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

@@ -11,7 +11,7 @@
 
 namespace duckdb {
 
-uint8_t UpperFun::ascii_to_upper_map[] = {
+const uint8_t UpperFun::ASCII_TO_UPPER_MAP[] = {
     0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,
     22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,
     44,  45,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,  65,
@@ -24,7 +24,7 @@ uint8_t UpperFun::ascii_to_upper_map[] = {
     198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
     220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241,
     242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255};
-uint8_t LowerFun::ascii_to_lower_map[] = {
+const uint8_t LowerFun::ASCII_TO_LOWER_MAP[] = {
     0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,
     22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,
     44,  45,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,  97,
@@ -44,8 +44,8 @@ static string_t ASCIICaseConvert(Vector &result, const char *input_data, idx_t i
 	auto result_str = StringVector::EmptyString(result, output_length);
 	auto result_data = result_str.GetDataWriteable();
 	for (idx_t i = 0; i < input_length; i++) {
-		result_data[i] = IS_UPPER ? UpperFun::ascii_to_upper_map[uint8_t(input_data[i])]
-		                          : LowerFun::ascii_to_lower_map[uint8_t(input_data[i])];
+		result_data[i] = IS_UPPER ? UpperFun::ASCII_TO_UPPER_MAP[uint8_t(input_data[i])]
+		                          : LowerFun::ASCII_TO_LOWER_MAP[uint8_t(input_data[i])];
 	}
 	result_str.Finalize();
 	return result_str;
@@ -88,8 +88,8 @@ static void CaseConvert(const char *input_data, idx_t input_length, char *result
 			i += sz;
 		} else {
 			// ascii
-			*result_data = IS_UPPER ? UpperFun::ascii_to_upper_map[uint8_t(input_data[i])]
-			                        : LowerFun::ascii_to_lower_map[uint8_t(input_data[i])];
+			*result_data = IS_UPPER ? UpperFun::ASCII_TO_UPPER_MAP[uint8_t(input_data[i])]
+			                        : LowerFun::ASCII_TO_LOWER_MAP[uint8_t(input_data[i])];
 			result_data++;
 			i++;
 		}

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

@@ -70,7 +70,6 @@ static unique_ptr<BaseStatistics> LengthPropagateStats(ClientContext &context, F
 //------------------------------------------------------------------
 // ARRAY / LIST LENGTH
 //------------------------------------------------------------------
-
 static void ListLengthFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &input = args.data[0];
 	D_ASSERT(input.GetType().id() == LogicalTypeId::LIST);
@@ -83,9 +82,31 @@ static void ListLengthFunction(DataChunk &args, ExpressionState &state, Vector &
 
 static void ArrayLengthFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto &input = args.data[0];
-	// If the input is an array, the length is constant
+
+	UnifiedVectorFormat format;
+	args.data[0].ToUnifiedFormat(args.size(), format);
+
+	// for arrays the length is constant
 	result.SetVectorType(VectorType::CONSTANT_VECTOR);
 	ConstantVector::GetData<int64_t>(result)[0] = static_cast<int64_t>(ArrayType::GetSize(input.GetType()));
+
+	// but we do need to take null values into account
+	if (format.validity.AllValid()) {
+		// if there are no null values we can just return the constant
+		return;
+	}
+	// otherwise we flatten and inherit the null values of the parent
+	result.Flatten(args.size());
+	auto &result_validity = FlatVector::Validity(result);
+	for (idx_t r = 0; r < args.size(); r++) {
+		auto idx = format.sel->get_index(r);
+		if (!format.validity.RowIsValid(idx)) {
+			result_validity.SetInvalid(r);
+		}
+	}
+	if (args.AllConstant()) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
 }
 
 static unique_ptr<FunctionData> ArrayOrListLengthBind(ClientContext &context, ScalarFunction &bound_function,

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

@@ -26,7 +26,7 @@ struct ASCIILCaseReader {
 	}
 
 	static char Operation(const char *data, idx_t pos) {
-		return (char)LowerFun::ascii_to_lower_map[(uint8_t)data[pos]];
+		return (char)LowerFun::ASCII_TO_LOWER_MAP[(uint8_t)data[pos]];
 	}
 };
 

package/src/duckdb/src/function/scalar/string/regexp/regexp_extract_all.cpp

@@ -27,7 +27,7 @@ bool ExtractAll(duckdb_re2::StringPiece &input, duckdb_re2::RE2 &pattern, idx_t
 	D_ASSERT(pattern.ok());
 	D_ASSERT(pattern.NumberOfCapturingGroups() == ngroups);
 
-	if (!pattern.Match(input, *startpos, input.size(), pattern.Anchored(), groups, ngroups + 1)) {
+	if (!pattern.Match(input, *startpos, input.size(), pattern.UNANCHORED, groups, ngroups + 1)) {
 		return false;
 	}
 	idx_t consumed = static_cast<size_t>(groups[0].end() - (input.begin() + *startpos));

package/src/duckdb/src/function/scalar/system/aggregate_export.cpp

@@ -216,13 +216,13 @@ static unique_ptr<FunctionData> BindAggregateState(ClientContext &context, Scala
 	ErrorData error;
 
 	FunctionBinder function_binder(context);
-	idx_t best_function =
+	auto best_function =
 	    function_binder.BindFunction(aggr.name, aggr.functions, state_type.bound_argument_types, error);
-	if (best_function == DConstants::INVALID_INDEX) {
+	if (!best_function.IsValid()) {
 		throw InternalException("Could not re-bind exported aggregate %s: %s", state_type.function_name,
 		                        error.Message());
 	}
-	auto bound_aggr = aggr.functions.GetFunctionByOffset(best_function);
+	auto bound_aggr = aggr.functions.GetFunctionByOffset(best_function.GetIndex());
 	if (bound_aggr.bind) {
 		// FIXME: this is really hacky
 		// but the aggregate state export needs a rework around how it handles more complex aggregates anyway

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

@@ -14,7 +14,7 @@ ArrowArrayScanState &ArrowArrayScanState::GetChild(idx_t child_idx) {
 		auto child_p = make_uniq<ArrowArrayScanState>(state);
 		auto &child = *child_p;
 		child.owned_data = owned_data;
-		children.emplace(std::make_pair(child_idx, std::move(child_p)));
+		children.emplace(child_idx, std::move(child_p));
 		return child;
 	}
 	if (!it->second->owned_data) {

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

@@ -125,6 +125,10 @@ static unique_ptr<ArrowType> GetArrowLogicalTypeNoDictionary(ArrowSchema &schema
 	} else if (format == "+s") {
 		child_list_t<LogicalType> child_types;
 		vector<unique_ptr<ArrowType>> children;
+		if (schema.n_children == 0) {
+			throw InvalidInputException(
+			    "Attempted to convert a STRUCT with no fields to DuckDB which is not supported");
+		}
 		for (idx_t type_idx = 0; type_idx < (idx_t)schema.n_children; type_idx++) {
 			children.emplace_back(ArrowTableFunction::GetArrowLogicalType(*schema.children[type_idx]));
 			child_types.emplace_back(schema.children[type_idx]->name, children.back()->GetDuckType());
@@ -144,6 +148,9 @@ static unique_ptr<ArrowType> GetArrowLogicalTypeNoDictionary(ArrowSchema &schema
 
 		child_list_t<LogicalType> members;
 		vector<unique_ptr<ArrowType>> children;
+		if (schema.n_children == 0) {
+			throw InvalidInputException("Attempted to convert a UNION with no fields to DuckDB which is not supported");
+		}
 		for (idx_t type_idx = 0; type_idx < (idx_t)schema.n_children; type_idx++) {
 			auto type = schema.children[type_idx];
 
@@ -237,7 +244,6 @@ void ArrowTableFunction::PopulateArrowTableType(ArrowTableType &arrow_table, Arr
 		auto arrow_type = GetArrowLogicalType(schema);
 		return_types.emplace_back(arrow_type->GetDuckType(true));
 		arrow_table.AddColumn(col_idx, std::move(arrow_type));
-		auto format = string(schema.format);
 		auto name = string(schema.name);
 		if (name.empty()) {
 			name = string("v") + to_string(col_idx);

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

@@ -61,17 +61,20 @@ void BaseCSVData::Finalize() {
 		AreOptionsEqual(options.dialect_options.state_machine_options.quote.GetValue(),
 		                options.dialect_options.state_machine_options.escape.GetValue(), "QUOTE", "ESCAPE");
 	}
-	if (!options.null_str.empty()) {
-		// null string and delimiter must not be substrings of each other
-		SubstringDetection(options.dialect_options.state_machine_options.delimiter.GetValue(), options.null_str,
-		                   "DELIMITER", "NULL");
 
-		// quote/escape and nullstr must not be substrings of each other
-		SubstringDetection(options.dialect_options.state_machine_options.quote.GetValue(), options.null_str, "QUOTE",
-		                   "NULL");
+	// null string and delimiter must not be substrings of each other
+	for (auto &null_str : options.null_str) {
+		if (!null_str.empty()) {
+			SubstringDetection(options.dialect_options.state_machine_options.delimiter.GetValue(), null_str,
+			                   "DELIMITER", "NULL");
 
-		SubstringDetection(options.dialect_options.state_machine_options.escape.GetValue(), options.null_str, "ESCAPE",
-		                   "NULL");
+			// quote/escape and nullstr must not be substrings of each other
+			SubstringDetection(options.dialect_options.state_machine_options.quote.GetValue(), null_str, "QUOTE",
+			                   "NULL");
+
+			SubstringDetection(options.dialect_options.state_machine_options.escape.GetValue(), null_str, "ESCAPE",
+			                   "NULL");
+		}
 	}
 
 	if (!options.prefix.empty() || !options.suffix.empty()) {
@@ -194,7 +197,7 @@ static string AddEscapes(char to_be_escaped, const char escape, const string &va
 static bool RequiresQuotes(WriteCSVData &csv_data, const char *str, idx_t len) {
 	auto &options = csv_data.options;
 	// check if the string is equal to the null string
-	if (len == options.null_str.size() && memcmp(str, options.null_str.c_str(), len) == 0) {
+	if (len == options.null_str[0].size() && memcmp(str, options.null_str[0].c_str(), len) == 0) {
 		return true;
 	}
 	auto str_data = reinterpret_cast<const_data_ptr_t>(str);
@@ -270,8 +273,8 @@ struct LocalWriteCSVData : public LocalFunctionData {
 struct GlobalWriteCSVData : public GlobalFunctionData {
 	GlobalWriteCSVData(FileSystem &fs, const string &file_path, FileCompressionType compression)
 	    : fs(fs), written_anything(false) {
-		handle = fs.OpenFile(file_path, FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE_NEW,
-		                     FileLockType::WRITE_LOCK, compression);
+		handle = fs.OpenFile(file_path, FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_FILE_CREATE_NEW |
+		                                    FileLockType::WRITE_LOCK | compression);
 	}
 
 	//! Write generic data, e.g., CSV header
@@ -393,13 +396,14 @@ static void WriteCSVChunkInternal(ClientContext &context, FunctionData &bind_dat
 			writer.WriteData(const_data_ptr_cast(csv_data.newline.c_str()), csv_data.newline.size());
 		}
 		// write values
+		D_ASSERT(options.null_str.size() == 1);
 		for (idx_t col_idx = 0; col_idx < cast_chunk.ColumnCount(); col_idx++) {
 			if (col_idx != 0) {
 				WriteQuoteOrEscape(writer, options.dialect_options.state_machine_options.delimiter.GetValue());
 			}
 			if (FlatVector::IsNull(cast_chunk.data[col_idx], row_idx)) {
 				// write null value
-				writer.WriteData(const_data_ptr_cast(options.null_str.c_str()), options.null_str.size());
+				writer.WriteData(const_data_ptr_cast(options.null_str[0].c_str()), options.null_str[0].size());
 				continue;
 			}