duckdb 0.10.3-dev3.0 → 0.10.3-dev6.0

package/src/duckdb/src/core_functions/function_list.cpp

@@ -341,6 +341,7 @@ static const StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_AGGREGATE_FUNCTION_ALIAS(SumkahanFun),
 	DUCKDB_SCALAR_FUNCTION(TanFun),
 	DUCKDB_SCALAR_FUNCTION_SET(TimeBucketFun),
+	DUCKDB_SCALAR_FUNCTION(TimeTZSortKeyFun),
 	DUCKDB_SCALAR_FUNCTION_SET(TimezoneFun),
 	DUCKDB_SCALAR_FUNCTION_SET(TimezoneHourFun),
 	DUCKDB_SCALAR_FUNCTION_SET(TimezoneMinuteFun),
@@ -357,6 +358,7 @@ static const StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_SCALAR_FUNCTION(ToMillisecondsFun),
 	DUCKDB_SCALAR_FUNCTION(ToMinutesFun),
 	DUCKDB_SCALAR_FUNCTION(ToMonthsFun),
+	DUCKDB_SCALAR_FUNCTION(ToQuartersFun),
 	DUCKDB_SCALAR_FUNCTION(ToSecondsFun),
 	DUCKDB_SCALAR_FUNCTION(ToTimestampFun),
 	DUCKDB_SCALAR_FUNCTION(ToWeeksFun),
@@ -385,7 +387,6 @@ static const StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_SCALAR_FUNCTION_SET(WeekFun),
 	DUCKDB_SCALAR_FUNCTION_SET(WeekDayFun),
 	DUCKDB_SCALAR_FUNCTION_SET(WeekOfYearFun),
-	DUCKDB_SCALAR_FUNCTION(WhichSecretFun),
 	DUCKDB_SCALAR_FUNCTION_SET(BitwiseXorFun),
 	DUCKDB_SCALAR_FUNCTION_SET(YearFun),
 	DUCKDB_SCALAR_FUNCTION_SET(YearWeekFun),

package/src/duckdb/src/core_functions/lambda_functions.cpp

@@ -154,7 +154,7 @@ struct ListFilterFunctor {
 
 		// slice the input chunk's corresponding vector to get the new lists
 		// and append them to the result
-		auto source_list_idx = execute_info.has_index ? 1 : 0;
+		idx_t source_list_idx = execute_info.has_index ? 1 : 0;
 		Vector result_lists(execute_info.input_chunk.data[source_list_idx], sel, count);
 		ListVector::Append(result, result_lists, count, 0);
 	}
@@ -353,7 +353,7 @@ void ExecuteLambda(DataChunk &args, ExpressionState &state, Vector &result) {
 
 			// set the index vector
 			if (info.has_index) {
-				index_vector.SetValue(elem_cnt, Value::BIGINT(child_idx + 1));
+				index_vector.SetValue(elem_cnt, Value::BIGINT(NumericCast<int64_t>(child_idx + 1)));
 			}
 
 			elem_cnt++;

package/src/duckdb/src/core_functions/scalar/array/array_functions.cpp

@@ -208,6 +208,11 @@ static unique_ptr<FunctionData> ArrayGenericBinaryBind(ClientContext &context, S
 	auto &left_type = arguments[0]->return_type;
 	auto &right_type = arguments[1]->return_type;
 
+	// mystery to me how anything non-array could ever end up here but it happened
+	if (left_type.id() != LogicalTypeId::ARRAY || right_type.id() != LogicalTypeId::ARRAY) {
+		throw InvalidInputException(StringUtil::Format("%s: Arguments must be arrays of FLOAT or DOUBLE", OP::NAME));
+	}
+
 	auto left_size = ArrayType::GetSize(left_type);
 	auto right_size = ArrayType::GetSize(right_type);
 	if (left_size != right_size) {

package/src/duckdb/src/core_functions/scalar/bit/bitstring.cpp

@@ -19,9 +19,9 @@ static void BitStringFunction(DataChunk &args, ExpressionState &state, Vector &r
 		    idx_t len;
 		    Bit::TryGetBitStringSize(input, len, nullptr); // string verification
 
-		    len = Bit::ComputeBitstringLen(n);
+		    len = Bit::ComputeBitstringLen(UnsafeNumericCast<idx_t>(n));
 		    string_t target = StringVector::EmptyString(result, len);
-		    Bit::BitString(input, n, target);
+		    Bit::BitString(input, UnsafeNumericCast<idx_t>(n), target);
 		    target.Finalize();
 		    return target;
 	    });
@@ -41,7 +41,7 @@ struct GetBitOperator {
 			throw OutOfRangeException("bit index %s out of valid range (0..%s)", NumericHelper::ToString(n),
 			                          NumericHelper::ToString(Bit::BitLength(input) - 1));
 		}
-		return UnsafeNumericCast<TR>(Bit::GetBit(input, n));
+		return UnsafeNumericCast<TR>(Bit::GetBit(input, UnsafeNumericCast<idx_t>(n)));
 	}
 };
 
@@ -66,7 +66,7 @@ static void SetBitOperation(DataChunk &args, ExpressionState &state, Vector &res
 		    }
 		    string_t target = StringVector::EmptyString(result, input.GetSize());
 		    memcpy(target.GetDataWriteable(), input.GetData(), input.GetSize());
-		    Bit::SetBit(target, n, new_value);
+		    Bit::SetBit(target, UnsafeNumericCast<idx_t>(n), UnsafeNumericCast<idx_t>(new_value));
 		    return target;
 	    });
 }

package/src/duckdb/src/core_functions/scalar/blob/create_sort_key.cpp

@@ -186,7 +186,7 @@ struct SortKeyVarcharOperator {
 	}
 
 	static idx_t Encode(data_ptr_t result, TYPE input) {
-		auto input_data = input.GetDataUnsafe();
+		auto input_data = const_data_ptr_cast(input.GetDataUnsafe());
 		auto input_size = input.GetSize();
 		for (idx_t r = 0; r < input_size; r++) {
 			result[r] = input_data[r] + 1;
@@ -519,7 +519,8 @@ void ConstructSortKeyList(SortKeyVectorData &vector_data, SortKeyChunk chunk, So
 		}
 
 		// write the end-of-list delimiter
-		result_ptr[offset++] = info.flip_bytes ? ~SortKeyVectorData::LIST_DELIMITER : SortKeyVectorData::LIST_DELIMITER;
+		result_ptr[offset++] = static_cast<data_t>(info.flip_bytes ? ~SortKeyVectorData::LIST_DELIMITER
+		                                                           : SortKeyVectorData::LIST_DELIMITER);
 	}
 }
 

package/src/duckdb/src/core_functions/scalar/date/date_part.cpp

@@ -1432,8 +1432,8 @@ void DatePart::StructOperator::Operation(bigint_vec &bigint_values, double_vec &
 
 	// Both define epoch, and the correct value is the sum.
 	// So mask it out and compute it separately.
-	Operation(bigint_values, double_values, d, idx, mask & ~EPOCH);
-	Operation(bigint_values, double_values, t, idx, mask & ~EPOCH);
+	Operation(bigint_values, double_values, d, idx, mask & ~UnsafeNumericCast<part_mask_t>(EPOCH));
+	Operation(bigint_values, double_values, t, idx, mask & ~UnsafeNumericCast<part_mask_t>(EPOCH));
 
 	if (mask & EPOCH) {
 		auto part_data = HasPartValue(double_values, DatePartSpecifier::EPOCH);

package/src/duckdb/src/core_functions/scalar/date/epoch.cpp

@@ -28,4 +28,21 @@ ScalarFunction ToTimestampFun::GetFunction() {
 	return ScalarFunction({LogicalType::DOUBLE}, LogicalType::TIMESTAMP_TZ, EpochSecFunction);
 }
 
+struct TimeTZSortKeyOperator {
+	template <typename INPUT_TYPE, typename RESULT_TYPE>
+	static RESULT_TYPE Operation(INPUT_TYPE input) {
+		return input.sort_key();
+	}
+};
+
+static void TimeTZSortKeyFunction(DataChunk &input, ExpressionState &state, Vector &result) {
+	D_ASSERT(input.ColumnCount() == 1);
+
+	UnaryExecutor::Execute<dtime_tz_t, uint64_t, TimeTZSortKeyOperator>(input.data[0], result, input.size());
+}
+
+ScalarFunction TimeTZSortKeyFun::GetFunction() {
+	return ScalarFunction({LogicalType::TIME_TZ}, LogicalType::UBIGINT, TimeTZSortKeyFunction);
+}
+
 } // namespace duckdb

package/src/duckdb/src/core_functions/scalar/date/strftime.cpp

@@ -33,7 +33,7 @@ struct StrfTimeBindData : public FunctionData {
 template <bool REVERSED>
 static unique_ptr<FunctionData> StrfTimeBindFunction(ClientContext &context, ScalarFunction &bound_function,
                                                      vector<unique_ptr<Expression>> &arguments) {
-	auto format_idx = REVERSED ? 0 : 1;
+	auto format_idx = REVERSED ? 0U : 1U;
 	auto &format_arg = arguments[format_idx];
 	if (format_arg->HasParameter()) {
 		throw ParameterNotResolvedException();

package/src/duckdb/src/core_functions/scalar/date/to_interval.cpp

@@ -65,6 +65,20 @@ struct ToYearsOperator {
 	}
 };
 
+struct ToQuartersOperator {
+	template <class TA, class TR>
+	static inline TR Operation(TA input) {
+		interval_t result;
+		if (!TryMultiplyOperator::Operation<int32_t, int32_t, int32_t>(input, Interval::MONTHS_PER_QUARTER,
+		                                                               result.months)) {
+			throw OutOfRangeException("Interval value %d quarters out of range", input);
+		}
+		result.days = 0;
+		result.micros = 0;
+		return result;
+	}
+};
+
 struct ToMonthsOperator {
 	template <class TA, class TR>
 	static inline TR Operation(TA input) {
@@ -170,6 +184,11 @@ ScalarFunction ToYearsFun::GetFunction() {
 	                      ScalarFunction::UnaryFunction<int32_t, interval_t, ToYearsOperator>);
 }
 
+ScalarFunction ToQuartersFun::GetFunction() {
+	return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
+	                      ScalarFunction::UnaryFunction<int32_t, interval_t, ToQuartersOperator>);
+}
+
 ScalarFunction ToMonthsFun::GetFunction() {
 	return ScalarFunction({LogicalType::INTEGER}, LogicalType::INTERVAL,
 	                      ScalarFunction::UnaryFunction<int32_t, interval_t, ToMonthsOperator>);

package/src/duckdb/src/core_functions/scalar/debug/vector_type.cpp

@@ -1,6 +1,5 @@
 #include "duckdb/core_functions/scalar/debug_functions.hpp"
 
-#include "duckdb/common/exception.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/common/enum_util.hpp"
@@ -14,10 +13,12 @@ static void VectorTypeFunction(DataChunk &input, ExpressionState &state, Vector
 }
 
 ScalarFunction VectorTypeFun::GetFunction() {
-	return ScalarFunction("vector_type",        // name of the function
-	                      {LogicalType::ANY},   // argument list
-	                      LogicalType::VARCHAR, // return type
-	                      VectorTypeFunction);
+	auto vector_type_fun = ScalarFunction("vector_type",        // name of the function
+	                                      {LogicalType::ANY},   // argument list
+	                                      LogicalType::VARCHAR, // return type
+	                                      VectorTypeFunction);
+	vector_type_fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	return vector_type_fun;
 }
 
 } // namespace duckdb

package/src/duckdb/src/core_functions/scalar/generic/current_setting.cpp

@@ -43,12 +43,11 @@ unique_ptr<FunctionData> CurrentSettingBind(ClientContext &context, ScalarFuncti
 	}
 	Value key_val = ExpressionExecutor::EvaluateScalar(context, *key_child);
 	D_ASSERT(key_val.type().id() == LogicalTypeId::VARCHAR);
-	auto &key_str = StringValue::Get(key_val);
-	if (key_val.IsNull() || key_str.empty()) {
+	if (key_val.IsNull() || StringValue::Get(key_val).empty()) {
 		throw ParserException("Key name for current_setting needs to be neither NULL nor empty");
 	}
 
-	auto key = StringUtil::Lower(key_str);
+	auto key = StringUtil::Lower(StringValue::Get(key_val));
 	Value val;
 	if (!context.TryGetCurrentSetting(key, val)) {
 		Catalog::AutoloadExtensionByConfigName(context, key);

package/src/duckdb/src/core_functions/scalar/generic/system_functions.cpp

@@ -92,7 +92,7 @@ static void TransactionIdCurrent(DataChunk &input, ExpressionState &state, Vecto
 	auto &context = state.GetContext();
 	auto &catalog = Catalog::GetCatalog(context, DatabaseManager::GetDefaultDatabase(context));
 	auto &transaction = DuckTransaction::Get(context, catalog);
-	auto val = Value::BIGINT(transaction.start_time);
+	auto val = Value::UBIGINT(transaction.start_time);
 	result.Reference(val);
 }
 
@@ -136,7 +136,7 @@ ScalarFunction InSearchPathFun::GetFunction() {
 }
 
 ScalarFunction CurrentTransactionIdFun::GetFunction() {
-	ScalarFunction txid_current({}, LogicalType::BIGINT, TransactionIdCurrent);
+	ScalarFunction txid_current({}, LogicalType::UBIGINT, TransactionIdCurrent);
 	txid_current.stability = FunctionStability::CONSISTENT_WITHIN_QUERY;
 	return txid_current;
 }

package/src/duckdb/src/core_functions/scalar/list/array_slice.cpp

@@ -48,14 +48,14 @@ static idx_t CalculateSliceLength(idx_t begin, idx_t end, INDEX_TYPE step, bool
 		throw InvalidInputException("Slice step cannot be zero");
 	}
 	if (step == 1) {
-		return NumericCast<int>(end - begin);
+		return NumericCast<idx_t>(end - begin);
 	} else if (static_cast<idx_t>(step) >= (end - begin)) {
 		return 1;
 	}
-	if ((end - begin) % step != 0) {
-		return (end - begin) / step + 1;
+	if ((end - begin) % UnsafeNumericCast<idx_t>(step) != 0) {
+		return (end - begin) / UnsafeNumericCast<idx_t>(step) + 1;
 	}
-	return (end - begin) / step;
+	return (end - begin) / UnsafeNumericCast<idx_t>(step);
 }
 
 template <typename INPUT_TYPE, typename INDEX_TYPE>
@@ -65,7 +65,7 @@ INDEX_TYPE ValueLength(const INPUT_TYPE &value) {
 
 template <>
 int64_t ValueLength(const list_entry_t &value) {
-	return value.length;
+	return UnsafeNumericCast<int64_t>(value.length);
 }
 
 template <>
@@ -119,8 +119,8 @@ INPUT_TYPE SliceValue(Vector &result, INPUT_TYPE input, INDEX_TYPE begin, INDEX_
 
 template <>
 list_entry_t SliceValue(Vector &result, list_entry_t input, int64_t begin, int64_t end) {
-	input.offset += begin;
-	input.length = end - begin;
+	input.offset = UnsafeNumericCast<uint64_t>(UnsafeNumericCast<int64_t>(input.offset) + begin);
+	input.length = UnsafeNumericCast<uint64_t>(end - begin);
 	return input;
 }
 
@@ -144,15 +144,15 @@ list_entry_t SliceValueWithSteps(Vector &result, SelectionVector &sel, list_entr
 		input.offset = sel_idx;
 		return input;
 	}
-	input.length = CalculateSliceLength(begin, end, step, true);
-	idx_t child_idx = input.offset + begin;
+	input.length = CalculateSliceLength(UnsafeNumericCast<idx_t>(begin), UnsafeNumericCast<idx_t>(end), step, true);
+	idx_t child_idx = input.offset + UnsafeNumericCast<idx_t>(begin);
 	if (step < 0) {
-		child_idx = input.offset + end - 1;
+		child_idx = input.offset + UnsafeNumericCast<idx_t>(end) - 1;
 	}
 	input.offset = sel_idx;
 	for (idx_t i = 0; i < input.length; i++) {
 		sel.set_index(sel_idx, child_idx);
-		child_idx += step;
+		child_idx += static_cast<idx_t>(step); // intentional overflow??
 		sel_idx++;
 	}
 	return input;
@@ -163,6 +163,18 @@ static void ExecuteConstantSlice(Vector &result, Vector &str_vector, Vector &beg
                                  optional_ptr<Vector> step_vector, const idx_t count, SelectionVector &sel,
                                  idx_t &sel_idx, optional_ptr<Vector> result_child_vector, bool begin_is_empty,
                                  bool end_is_empty) {
+
+	// check all this nullness early
+	auto str_valid = !ConstantVector::IsNull(str_vector);
+	auto begin_valid = !ConstantVector::IsNull(begin_vector);
+	auto end_valid = !ConstantVector::IsNull(end_vector);
+	auto step_valid = step_vector && !ConstantVector::IsNull(*step_vector);
+
+	if (!str_valid || !begin_valid || !end_valid || (step_vector && !step_valid)) {
+		ConstantVector::SetNull(result, true);
+		return;
+	}
+
 	auto result_data = ConstantVector::GetData<INPUT_TYPE>(result);
 	auto str_data = ConstantVector::GetData<INPUT_TYPE>(str_vector);
 	auto begin_data = ConstantVector::GetData<INDEX_TYPE>(begin_vector);
@@ -180,27 +192,23 @@ static void ExecuteConstantSlice(Vector &result, Vector &str_vector, Vector &beg
 		end = begin_is_empty ? ValueLength<INPUT_TYPE, INDEX_TYPE>(str) : end;
 	}
 
-	auto str_valid = !ConstantVector::IsNull(str_vector);
-	auto begin_valid = !ConstantVector::IsNull(begin_vector);
-	auto end_valid = !ConstantVector::IsNull(end_vector);
-	auto step_valid = step_vector && !ConstantVector::IsNull(*step_vector);
-
 	// Clamp offsets
 	bool clamp_result = false;
-	if (str_valid && begin_valid && end_valid && (step_valid || step == 1)) {
+	if (step_valid || step == 1) {
 		clamp_result = ClampSlice(str, begin, end);
 	}
 
 	idx_t sel_length = 0;
 	bool sel_valid = false;
-	if (step_vector && step_valid && str_valid && begin_valid && end_valid && step != 1 && end - begin > 0) {
-		sel_length = CalculateSliceLength(begin, end, step, step_valid);
+	if (step_valid && step != 1 && end - begin > 0) {
+		sel_length =
+		    CalculateSliceLength(UnsafeNumericCast<idx_t>(begin), UnsafeNumericCast<idx_t>(end), step, step_valid);
 		sel.Initialize(sel_length);
 		sel_valid = true;
 	}
 
 	// Try to slice
-	if (!str_valid || !begin_valid || !end_valid || (step_vector && !step_valid) || !clamp_result) {
+	if (!clamp_result) {
 		ConstantVector::SetNull(result, true);
 	} else if (step == 1) {
 		result_data[0] = SliceValue<INPUT_TYPE, INDEX_TYPE>(result, str, begin, end);
@@ -268,7 +276,8 @@ static void ExecuteFlatSlice(Vector &result, Vector &list_vector, Vector &begin_
 
 		idx_t length = 0;
 		if (end - begin > 0) {
-			length = CalculateSliceLength(begin, end, step, step_valid);
+			length =
+			    CalculateSliceLength(UnsafeNumericCast<idx_t>(begin), UnsafeNumericCast<idx_t>(end), step, step_valid);
 		}
 		sel_length += length;
 

package/src/duckdb/src/core_functions/scalar/list/list_reduce.cpp

@@ -99,7 +99,7 @@ static bool ExecuteReduce(idx_t loops, ReduceExecuteInfo &execute_info, LambdaFu
 	}
 
 	// create the index vector
-	Vector index_vector(Value::BIGINT(loops + 1));
+	Vector index_vector(Value::BIGINT(UnsafeNumericCast<int64_t>(loops + 1)));
 
 	// slice the left and right slice
 	execute_info.left_slice.Slice(execute_info.left_slice, execute_info.left_sel, reduced_row_idx);

package/src/duckdb/src/core_functions/scalar/list/list_sort.cpp

@@ -52,8 +52,8 @@ ListSortBindData::ListSortBindData(OrderType order_type_p, OrderByNullType null_
 	payload_layout.Initialize(payload_types);
 
 	// get the BoundOrderByNode
-	auto idx_col_expr = make_uniq_base<Expression, BoundReferenceExpression>(LogicalType::USMALLINT, 0);
-	auto lists_col_expr = make_uniq_base<Expression, BoundReferenceExpression>(child_type, 1);
+	auto idx_col_expr = make_uniq_base<Expression, BoundReferenceExpression>(LogicalType::USMALLINT, 0U);
+	auto lists_col_expr = make_uniq_base<Expression, BoundReferenceExpression>(child_type, 1U);
 	orders.emplace_back(OrderType::ASCENDING, OrderByNullType::ORDER_DEFAULT, std::move(idx_col_expr));
 	orders.emplace_back(order_type, null_order, std::move(lists_col_expr));
 }
@@ -244,7 +244,7 @@ static void ListSortFunction(DataChunk &args, ExpressionState &state, Vector &re
 				}
 				for (idx_t j = result_data[i].offset; j < result_data[i].offset + result_data[i].length; j++) {
 					auto b = sel_sorted.get_index(j) - result_data[i].offset;
-					result_entry.SetValue(j, Value::BIGINT(b + 1));
+					result_entry.SetValue(j, Value::BIGINT(UnsafeNumericCast<int64_t>(b + 1)));
 				}
 			}
 		} else {

package/src/duckdb/src/core_functions/scalar/list/list_value.cpp

@@ -59,7 +59,7 @@ static unique_ptr<FunctionData> ListValueBind(ClientContext &context, ScalarFunc
 				    StringUtil::Format("Cannot unpivot columns of types %s and %s - an explicit cast is required",
 				                       child_type.ToString(), arg_type.ToString());
 				throw BinderException(arguments[i]->query_location,
-				                      QueryErrorContext::Format(list_arguments, error, int(error_index), false));
+				                      QueryErrorContext::Format(list_arguments, error, error_index, false));
 			} else {
 				throw BinderException(arguments[i]->query_location,
 				                      "Cannot create a list of types %s and %s - an explicit cast is required",

package/src/duckdb/src/core_functions/scalar/list/range.cpp

@@ -80,7 +80,7 @@ struct TimestampRangeInfo {
 		if (start_value < end_value && is_negative) {
 			return 0;
 		}
-		int64_t total_values = 0;
+		uint64_t total_values = 0;
 		if (is_negative) {
 			// negative interval, start_value is going down
 			while (inclusive_bound ? start_value >= end_value : start_value > end_value) {
@@ -203,7 +203,7 @@ static void ListRangeFunction(DataChunk &args, ExpressionState &state, Vector &r
 	}
 	auto list_data = FlatVector::GetData<list_entry_t>(result);
 	auto &result_validity = FlatVector::Validity(result);
-	int64_t total_size = 0;
+	uint64_t total_size = 0;
 	for (idx_t i = 0; i < args_size; i++) {
 		if (!info.RowIsValid(i)) {
 			result_validity.SetInvalid(i);

package/src/duckdb/src/core_functions/scalar/map/map.cpp

@@ -21,14 +21,38 @@ static void MapFunctionEmptyInput(Vector &result, const idx_t row_count) {
 	result.Verify(row_count);
 }
 
+static bool MapIsNull(DataChunk &chunk) {
+	if (chunk.data.empty()) {
+		return false;
+	}
+	D_ASSERT(chunk.data.size() == 2);
+	auto &keys = chunk.data[0];
+	auto &values = chunk.data[1];
+
+	if (keys.GetType().id() == LogicalTypeId::SQLNULL) {
+		return true;
+	}
+	if (values.GetType().id() == LogicalTypeId::SQLNULL) {
+		return true;
+	}
+	return false;
+}
+
 static void MapFunction(DataChunk &args, ExpressionState &, Vector &result) {
 
 	// internal MAP representation
 	// - LIST-vector that contains STRUCTs as child entries
 	// - STRUCTs have exactly two fields, a key-field, and a value-field
 	// - key names are unique
-
 	D_ASSERT(result.GetType().id() == LogicalTypeId::MAP);
+
+	if (MapIsNull(args)) {
+		auto &validity = FlatVector::Validity(result);
+		validity.SetInvalid(0);
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+		return;
+	}
+
 	auto row_count = args.size();
 
 	// early-out, if no data
@@ -63,13 +87,15 @@ static void MapFunction(DataChunk &args, ExpressionState &, Vector &result) {
 	UnifiedVectorFormat result_data;
 	result.ToUnifiedFormat(row_count, result_data);
 	auto result_entries = UnifiedVectorFormat::GetDataNoConst<list_entry_t>(result_data);
-	result_data.validity.SetAllValid(row_count);
+
+	auto &result_validity = FlatVector::Validity(result);
 
 	// get the resulting size of the key/value child lists
 	idx_t result_child_size = 0;
 	for (idx_t row_idx = 0; row_idx < row_count; row_idx++) {
 		auto keys_idx = keys_data.sel->get_index(row_idx);
-		if (!keys_data.validity.RowIsValid(keys_idx)) {
+		auto values_idx = values_data.sel->get_index(row_idx);
+		if (!keys_data.validity.RowIsValid(keys_idx) || !values_data.validity.RowIsValid(values_idx)) {
 			continue;
 		}
 		auto keys_entry = keys_entries[keys_idx];
@@ -87,22 +113,15 @@ static void MapFunction(DataChunk &args, ExpressionState &, Vector &result) {
 		auto values_idx = values_data.sel->get_index(row_idx);
 		auto result_idx = result_data.sel->get_index(row_idx);
 
-		// empty map
-		if (!keys_data.validity.RowIsValid(keys_idx) && !values_data.validity.RowIsValid(values_idx)) {
-			result_entries[result_idx] = list_entry_t();
+		// NULL MAP
+		if (!keys_data.validity.RowIsValid(keys_idx) || !values_data.validity.RowIsValid(values_idx)) {
+			result_validity.SetInvalid(row_idx);
 			continue;
 		}
 
 		auto keys_entry = keys_entries[keys_idx];
 		auto values_entry = values_entries[values_idx];
 
-		// validity checks
-		if (!keys_data.validity.RowIsValid(keys_idx)) {
-			MapVector::EvalMapInvalidReason(MapInvalidReason::NULL_KEY_LIST);
-		}
-		if (!values_data.validity.RowIsValid(values_idx)) {
-			MapVector::EvalMapInvalidReason(MapInvalidReason::NULL_VALUE_LIST);
-		}
 		if (keys_entry.length != values_entry.length) {
 			MapVector::EvalMapInvalidReason(MapInvalidReason::NOT_ALIGNED);
 		}
@@ -160,8 +179,19 @@ static unique_ptr<FunctionData> MapBind(ClientContext &, ScalarFunction &bound_f
 		MapVector::EvalMapInvalidReason(MapInvalidReason::INVALID_PARAMS);
 	}
 
-	// bind an empty MAP
+	bool is_null = false;
 	if (arguments.empty()) {
+		is_null = true;
+	}
+	if (!is_null) {
+		auto key_id = arguments[0]->return_type.id();
+		auto value_id = arguments[1]->return_type.id();
+		if (key_id == LogicalTypeId::SQLNULL || value_id == LogicalTypeId::SQLNULL) {
+			is_null = true;
+		}
+	}
+
+	if (is_null) {
 		bound_function.return_type = LogicalType::MAP(LogicalTypeId::SQLNULL, LogicalTypeId::SQLNULL);
 		return make_uniq<VariableReturnBindData>(bound_function.return_type);
 	}

package/src/duckdb/src/core_functions/scalar/map/map_concat.cpp

@@ -61,14 +61,20 @@ static void MapConcatFunction(DataChunk &args, ExpressionState &state, Vector &r
 		auto &result_entry = result_data[i];
 		vector<MapKeyIndexPair> index_to_map;
 		vector<Value> keys_list;
+		bool all_null = true;
 		for (idx_t map_idx = 0; map_idx < map_count; map_idx++) {
 			if (args.data[map_idx].GetType().id() == LogicalTypeId::SQLNULL) {
 				continue;
 			}
-			auto &map_format = map_formats[map_idx];
-			auto &keys = MapVector::GetKeys(args.data[map_idx]);
 
+			auto &map_format = map_formats[map_idx];
 			auto index = map_format.sel->get_index(i);
+			if (!map_format.validity.RowIsValid(index)) {
+				continue;
+			}
+
+			all_null = false;
+			auto &keys = MapVector::GetKeys(args.data[map_idx]);
 			auto entry = UnifiedVectorFormat::GetData<list_entry_t>(map_format)[index];
 
 			// Update the list for this row
@@ -89,6 +95,15 @@ static void MapConcatFunction(DataChunk &args, ExpressionState &state, Vector &r
 				}
 			}
 		}
+
+		result_entry.offset = ListVector::GetListSize(result);
+		result_entry.length = keys_list.size();
+		if (all_null) {
+			D_ASSERT(keys_list.empty() && index_to_map.empty());
+			FlatVector::SetNull(result, i, true);
+			continue;
+		}
+
 		vector<Value> values_list;
 		D_ASSERT(keys_list.size() == index_to_map.size());
 		// Get the values from the mapping
@@ -98,8 +113,6 @@ static void MapConcatFunction(DataChunk &args, ExpressionState &state, Vector &r
 			values_list.push_back(values.GetValue(mapping.key_index));
 		}
 		D_ASSERT(values_list.size() == keys_list.size());
-		result_entry.offset = ListVector::GetListSize(result);
-		result_entry.length = values_list.size();
 		auto list_entries = GetListEntries(std::move(keys_list), std::move(values_list));
 		for (auto &list_entry : list_entries) {
 			ListVector::PushBack(result, list_entry);

package/src/duckdb/src/core_functions/scalar/map/map_entries.cpp

@@ -12,7 +12,15 @@ namespace duckdb {
 static void MapEntriesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	auto count = args.size();
 
-	MapUtil::ReinterpretMap(result, args.data[0], count);
+	auto &map = args.data[0];
+	if (map.GetType().id() == LogicalTypeId::SQLNULL) {
+		// Input is a constant NULL
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+		ConstantVector::SetNull(result, true);
+		return;
+	}
+
+	MapUtil::ReinterpretMap(result, map, count);
 
 	if (args.AllConstant()) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
@@ -20,10 +28,20 @@ static void MapEntriesFunction(DataChunk &args, ExpressionState &state, Vector &
 	result.Verify(count);
 }
 
-static unique_ptr<FunctionData> MapEntriesBind(ClientContext &context, ScalarFunction &bound_function,
-                                               vector<unique_ptr<Expression>> &arguments) {
+static LogicalType CreateReturnType(const LogicalType &map) {
+	auto &key_type = MapType::KeyType(map);
+	auto &value_type = MapType::ValueType(map);
+
 	child_list_t<LogicalType> child_types;
+	child_types.push_back(make_pair("key", key_type));
+	child_types.push_back(make_pair("value", value_type));
+
+	auto row_type = LogicalType::STRUCT(child_types);
+	return LogicalType::LIST(row_type);
+}
 
+static unique_ptr<FunctionData> MapEntriesBind(ClientContext &context, ScalarFunction &bound_function,
+                                               vector<unique_ptr<Expression>> &arguments) {
 	if (arguments.size() != 1) {
 		throw InvalidInputException("Too many arguments provided, only expecting a single map");
 	}
@@ -36,25 +54,24 @@ static unique_ptr<FunctionData> MapEntriesBind(ClientContext &context, ScalarFun
 		return nullptr;
 	}
 
+	if (map.id() == LogicalTypeId::SQLNULL) {
+		// Input is NULL, output is STRUCT(NULL, NULL)[]
+		auto map_type = LogicalType::MAP(LogicalTypeId::SQLNULL, LogicalTypeId::SQLNULL);
+		bound_function.return_type = CreateReturnType(map_type);
+		return make_uniq<VariableReturnBindData>(bound_function.return_type);
+	}
+
 	if (map.id() != LogicalTypeId::MAP) {
 		throw InvalidInputException("The provided argument is not a map");
 	}
-	auto &key_type = MapType::KeyType(map);
-	auto &value_type = MapType::ValueType(map);
-
-	child_types.push_back(make_pair("key", key_type));
-	child_types.push_back(make_pair("value", value_type));
-
-	auto row_type = LogicalType::STRUCT(child_types);
-
-	bound_function.return_type = LogicalType::LIST(row_type);
+	bound_function.return_type = CreateReturnType(map);
 	return make_uniq<VariableReturnBindData>(bound_function.return_type);
 }
 
 ScalarFunction MapEntriesFun::GetFunction() {
 	//! the arguments and return types are actually set in the binder function
 	ScalarFunction fun({}, LogicalTypeId::LIST, MapEntriesFunction, MapEntriesBind);
-	fun.null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING;
+	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	fun.varargs = LogicalType::ANY;
 	return fun;
 }