duckdb 0.3.5-dev1360.0 → 0.3.5-dev1398.0

package/src/duckdb.cpp

@@ -7663,6 +7663,18 @@ string StatementTypeToString(StatementType type) {
 	}
 	return "INVALID";
 }
+
+string StatementReturnTypeToString(StatementReturnType type) {
+	switch (type) {
+	case StatementReturnType::QUERY_RESULT:
+		return "QUERY_RESULT";
+	case StatementReturnType::CHANGED_ROWS:
+		return "CHANGED_ROWS";
+	case StatementReturnType::NOTHING:
+		return "NOTHING";
+	}
+	return "INVALID";
+}
 // LCOV_EXCL_STOP
 
 } // namespace duckdb
@@ -45593,6 +45605,126 @@ bool Value::ValuesAreEqual(const Value &result_value, const Value &value) {
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/scalar/nested_functions.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+
+namespace duckdb {
+
+enum class MapInvalidReason : uint8_t { VALID, NULL_KEY_LIST, NULL_KEY, DUPLICATE_KEY };
+
+struct VariableReturnBindData : public FunctionData {
+	LogicalType stype;
+
+	explicit VariableReturnBindData(const LogicalType &stype_p) : stype(stype_p) {
+	}
+
+	unique_ptr<FunctionData> Copy() const override {
+		return make_unique<VariableReturnBindData>(stype);
+	}
+	bool Equals(const FunctionData &other_p) const override {
+		auto &other = (const VariableReturnBindData &)other_p;
+		return stype == other.stype;
+	}
+};
+
+template <class T, class MAP_TYPE = map<T, idx_t>>
+struct HistogramAggState {
+	MAP_TYPE *hist;
+};
+
+struct ArraySliceFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct StructPackFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct ListValueFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct ListRangeFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct MapFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct MapExtractFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct ListExtractFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct ListConcatFun {
+	static ScalarFunction GetFunction();
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct ListContainsFun {
+	static ScalarFunction GetFunction();
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct ListFlattenFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct ListPositionFun {
+	static ScalarFunction GetFunction();
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct ListAggregateFun {
+	static ScalarFunction GetFunction();
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct ListDistinctFun {
+	static ScalarFunction GetFunction();
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct ListUniqueFun {
+	static ScalarFunction GetFunction();
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct ListSortFun {
+	static ScalarFunction GetFunction();
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct CardinalityFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+struct StructExtractFun {
+	static ScalarFunction GetFunction();
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
+MapInvalidReason CheckMapValidity(Vector &map, idx_t count,
+                                  const SelectionVector &sel = *FlatVector::IncrementalSelectionVector());
+
+} // namespace duckdb
+
 
 #include <cstring> // strlen() on Solaris
 
@@ -46573,6 +46705,14 @@ void Vector::UTFVerify(idx_t count) {
 	UTFVerify(*flat_sel, count);
 }
 
+void Vector::VerifyMap(Vector &vector_p, const SelectionVector &sel_p, idx_t count) {
+#ifdef DEBUG
+	D_ASSERT(vector_p.GetType().id() == LogicalTypeId::MAP);
+	auto valid_check = CheckMapValidity(vector_p, count, sel_p);
+	D_ASSERT(valid_check == MapInvalidReason::VALID);
+#endif // DEBUG
+}
+
 void Vector::Verify(Vector &vector_p, const SelectionVector &sel_p, idx_t count) {
 #ifdef DEBUG
 	if (count == 0) {
@@ -46664,6 +46804,9 @@ void Vector::Verify(Vector &vector_p, const SelectionVector &sel_p, idx_t count)
 				}
 			}
 		}
+		if (vector->GetType().id() == LogicalTypeId::MAP) {
+			VerifyMap(*vector, *sel, count);
+		}
 	}
 
 	if (type.InternalType() == PhysicalType::LIST) {
@@ -86113,120 +86256,6 @@ void BuiltinFunctions::RegisterHolisticAggregates() {
 	Register<ReservoirQuantileFun>();
 }
 
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/function/scalar/nested_functions.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct VariableReturnBindData : public FunctionData {
-	LogicalType stype;
-
-	explicit VariableReturnBindData(const LogicalType &stype_p) : stype(stype_p) {
-	}
-
-	unique_ptr<FunctionData> Copy() const override {
-		return make_unique<VariableReturnBindData>(stype);
-	}
-	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const VariableReturnBindData &)other_p;
-		return stype == other.stype;
-	}
-};
-
-template <class T, class MAP_TYPE = map<T, idx_t>>
-struct HistogramAggState {
-	MAP_TYPE *hist;
-};
-
-struct ArraySliceFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct StructPackFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListValueFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListRangeFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct MapFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct MapExtractFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListExtractFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListConcatFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListContainsFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListFlattenFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListPositionFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListAggregateFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListDistinctFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListUniqueFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListSortFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct CardinalityFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct StructExtractFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
 } // namespace duckdb
 
 //===----------------------------------------------------------------------===//
@@ -91573,6 +91602,7 @@ void DateSubFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+
 namespace duckdb {
 
 struct DateTrunc {
@@ -91590,32 +91620,28 @@ struct DateTrunc {
 	struct MillenniumOperator {
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
-			date_t date = Timestamp::GetDate(input);
-			return Timestamp::FromDatetime(Date::FromDate((Date::ExtractYear(date) / 1000) * 1000, 1, 1), dtime_t(0));
+			return Date::FromDate((Date::ExtractYear(input) / 1000) * 1000, 1, 1);
 		}
 	};
 
 	struct CenturyOperator {
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
-			date_t date = Timestamp::GetDate(input);
-			return Timestamp::FromDatetime(Date::FromDate((Date::ExtractYear(date) / 100) * 100, 1, 1), dtime_t(0));
+			return Date::FromDate((Date::ExtractYear(input) / 100) * 100, 1, 1);
 		}
 	};
 
 	struct DecadeOperator {
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
-			date_t date = Timestamp::GetDate(input);
-			return Timestamp::FromDatetime(Date::FromDate((Date::ExtractYear(date) / 10) * 10, 1, 1), dtime_t(0));
+			return Date::FromDate((Date::ExtractYear(input) / 10) * 10, 1, 1);
 		}
 	};
 
 	struct YearOperator {
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
-			date_t date = Timestamp::GetDate(input);
-			return Timestamp::FromDatetime(Date::FromDate(Date::ExtractYear(date), 1, 1), dtime_t(0));
+			return Date::FromDate(Date::ExtractYear(input), 1, 1);
 		}
 	};
 
@@ -91623,27 +91649,23 @@ struct DateTrunc {
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
 			int32_t yyyy, mm, dd;
-			Date::Convert(Timestamp::GetDate(input), yyyy, mm, dd);
+			Date::Convert(input, yyyy, mm, dd);
 			mm = 1 + (((mm - 1) / 3) * 3);
-			return Timestamp::FromDatetime(Date::FromDate(yyyy, mm, 1), dtime_t(0));
+			return Date::FromDate(yyyy, mm, 1);
 		}
 	};
 
 	struct MonthOperator {
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
-			date_t date = Timestamp::GetDate(input);
-			return Timestamp::FromDatetime(Date::FromDate(Date::ExtractYear(date), Date::ExtractMonth(date), 1),
-			                               dtime_t(0));
+			return Date::FromDate(Date::ExtractYear(input), Date::ExtractMonth(input), 1);
 		}
 	};
 
 	struct WeekOperator {
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
-			date_t date = Timestamp::GetDate(input);
-
-			return Timestamp::FromDatetime(Date::GetMondayOfCurrentWeek(date), dtime_t(0));
+			return Date::GetMondayOfCurrentWeek(input);
 		}
 	};
 
@@ -91653,15 +91675,14 @@ struct DateTrunc {
 			date_t date = Date::GetMondayOfCurrentWeek(input);
 			date.days -= (Date::ExtractISOWeekNumber(date) - 1) * Interval::DAYS_PER_WEEK;
 
-			return Timestamp::FromDatetime(date, dtime_t(0));
+			return date;
 		}
 	};
 
 	struct DayOperator {
 		template <class TA, class TR>
 		static inline TR Operation(TA input) {
-			date_t date = Timestamp::GetDate(input);
-			return Timestamp::FromDatetime(date, dtime_t(0));
+			return input;
 		}
 	};
 
@@ -91723,39 +91744,119 @@ struct DateTrunc {
 };
 
 // DATE specialisations
+template <>
+date_t DateTrunc::MillenniumOperator::Operation(timestamp_t input) {
+	return MillenniumOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
+}
+
 template <>
 timestamp_t DateTrunc::MillenniumOperator::Operation(date_t input) {
-	return MillenniumOperator::Operation<timestamp_t, timestamp_t>(Timestamp::FromDatetime(input, dtime_t(0)));
+	return Timestamp::FromDatetime(MillenniumOperator::Operation<date_t, date_t>(input), dtime_t(0));
+}
+
+template <>
+timestamp_t DateTrunc::MillenniumOperator::Operation(timestamp_t input) {
+	return MillenniumOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
+}
+
+template <>
+date_t DateTrunc::CenturyOperator::Operation(timestamp_t input) {
+	return CenturyOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
 }
 
 template <>
 timestamp_t DateTrunc::CenturyOperator::Operation(date_t input) {
-	return CenturyOperator::Operation<timestamp_t, timestamp_t>(Timestamp::FromDatetime(input, dtime_t(0)));
+	return Timestamp::FromDatetime(CenturyOperator::Operation<date_t, date_t>(input), dtime_t(0));
+}
+
+template <>
+timestamp_t DateTrunc::CenturyOperator::Operation(timestamp_t input) {
+	return CenturyOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
+}
+
+template <>
+date_t DateTrunc::DecadeOperator::Operation(timestamp_t input) {
+	return DecadeOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
 }
 
 template <>
 timestamp_t DateTrunc::DecadeOperator::Operation(date_t input) {
-	return DecadeOperator::Operation<timestamp_t, timestamp_t>(Timestamp::FromDatetime(input, dtime_t(0)));
+	return Timestamp::FromDatetime(DecadeOperator::Operation<date_t, date_t>(input), dtime_t(0));
+}
+
+template <>
+timestamp_t DateTrunc::DecadeOperator::Operation(timestamp_t input) {
+	return DecadeOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
+}
+
+template <>
+date_t DateTrunc::YearOperator::Operation(timestamp_t input) {
+	return YearOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
 }
 
 template <>
 timestamp_t DateTrunc::YearOperator::Operation(date_t input) {
-	return YearOperator::Operation<timestamp_t, timestamp_t>(Timestamp::FromDatetime(input, dtime_t(0)));
+	return Timestamp::FromDatetime(YearOperator::Operation<date_t, date_t>(input), dtime_t(0));
+}
+
+template <>
+timestamp_t DateTrunc::YearOperator::Operation(timestamp_t input) {
+	return YearOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
+}
+
+template <>
+date_t DateTrunc::QuarterOperator::Operation(timestamp_t input) {
+	return QuarterOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
 }
 
 template <>
 timestamp_t DateTrunc::QuarterOperator::Operation(date_t input) {
-	return QuarterOperator::Operation<timestamp_t, timestamp_t>(Timestamp::FromDatetime(input, dtime_t(0)));
+	return Timestamp::FromDatetime(QuarterOperator::Operation<date_t, date_t>(input), dtime_t(0));
+}
+
+template <>
+timestamp_t DateTrunc::QuarterOperator::Operation(timestamp_t input) {
+	return QuarterOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
+}
+
+template <>
+date_t DateTrunc::MonthOperator::Operation(timestamp_t input) {
+	return MonthOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
 }
 
 template <>
 timestamp_t DateTrunc::MonthOperator::Operation(date_t input) {
-	return MonthOperator::Operation<timestamp_t, timestamp_t>(Timestamp::FromDatetime(input, dtime_t(0)));
+	return Timestamp::FromDatetime(MonthOperator::Operation<date_t, date_t>(input), dtime_t(0));
+}
+
+template <>
+timestamp_t DateTrunc::MonthOperator::Operation(timestamp_t input) {
+	return MonthOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
+}
+
+template <>
+date_t DateTrunc::WeekOperator::Operation(timestamp_t input) {
+	return WeekOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
 }
 
 template <>
 timestamp_t DateTrunc::WeekOperator::Operation(date_t input) {
-	return WeekOperator::Operation<timestamp_t, timestamp_t>(Timestamp::FromDatetime(input, dtime_t(0)));
+	return Timestamp::FromDatetime(WeekOperator::Operation<date_t, date_t>(input), dtime_t(0));
+}
+
+template <>
+timestamp_t DateTrunc::WeekOperator::Operation(timestamp_t input) {
+	return WeekOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
+}
+
+template <>
+date_t DateTrunc::ISOYearOperator::Operation(timestamp_t input) {
+	return ISOYearOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
+}
+
+template <>
+timestamp_t DateTrunc::ISOYearOperator::Operation(date_t input) {
+	return Timestamp::FromDatetime(ISOYearOperator::Operation<date_t, date_t>(input), dtime_t(0));
 }
 
 template <>
@@ -91763,9 +91864,24 @@ timestamp_t DateTrunc::ISOYearOperator::Operation(timestamp_t input) {
 	return ISOYearOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
 }
 
+template <>
+date_t DateTrunc::DayOperator::Operation(timestamp_t input) {
+	return DayOperator::Operation<date_t, date_t>(Timestamp::GetDate(input));
+}
+
 template <>
 timestamp_t DateTrunc::DayOperator::Operation(date_t input) {
-	return Timestamp::FromDatetime(input, dtime_t(0));
+	return Timestamp::FromDatetime(DayOperator::Operation<date_t, date_t>(input), dtime_t(0));
+}
+
+template <>
+timestamp_t DateTrunc::DayOperator::Operation(timestamp_t input) {
+	return DayOperator::Operation<date_t, timestamp_t>(Timestamp::GetDate(input));
+}
+
+template <>
+date_t DateTrunc::HourOperator::Operation(date_t input) {
+	return DayOperator::Operation<date_t, date_t>(input);
 }
 
 template <>
@@ -91773,26 +91889,71 @@ timestamp_t DateTrunc::HourOperator::Operation(date_t input) {
 	return DayOperator::Operation<date_t, timestamp_t>(input);
 }
 
+template <>
+date_t DateTrunc::HourOperator::Operation(timestamp_t input) {
+	return Timestamp::GetDate(HourOperator::Operation<timestamp_t, timestamp_t>(input));
+}
+
+template <>
+date_t DateTrunc::MinuteOperator::Operation(date_t input) {
+	return DayOperator::Operation<date_t, date_t>(input);
+}
+
 template <>
 timestamp_t DateTrunc::MinuteOperator::Operation(date_t input) {
 	return DayOperator::Operation<date_t, timestamp_t>(input);
 }
 
+template <>
+date_t DateTrunc::MinuteOperator::Operation(timestamp_t input) {
+	return Timestamp::GetDate(HourOperator::Operation<timestamp_t, timestamp_t>(input));
+}
+
+template <>
+date_t DateTrunc::SecondOperator::Operation(date_t input) {
+	return DayOperator::Operation<date_t, date_t>(input);
+}
+
 template <>
 timestamp_t DateTrunc::SecondOperator::Operation(date_t input) {
 	return DayOperator::Operation<date_t, timestamp_t>(input);
 }
 
+template <>
+date_t DateTrunc::SecondOperator::Operation(timestamp_t input) {
+	return Timestamp::GetDate(DayOperator::Operation<timestamp_t, timestamp_t>(input));
+}
+
+template <>
+date_t DateTrunc::MillisecondOperator::Operation(date_t input) {
+	return DayOperator::Operation<date_t, date_t>(input);
+}
+
 template <>
 timestamp_t DateTrunc::MillisecondOperator::Operation(date_t input) {
 	return DayOperator::Operation<date_t, timestamp_t>(input);
 }
 
+template <>
+date_t DateTrunc::MillisecondOperator::Operation(timestamp_t input) {
+	return Timestamp::GetDate(MillisecondOperator::Operation<timestamp_t, timestamp_t>(input));
+}
+
+template <>
+date_t DateTrunc::MicrosecondOperator::Operation(date_t input) {
+	return DayOperator::Operation<date_t, date_t>(input);
+}
+
 template <>
 timestamp_t DateTrunc::MicrosecondOperator::Operation(date_t input) {
 	return DayOperator::Operation<date_t, timestamp_t>(input);
 }
 
+template <>
+date_t DateTrunc::MicrosecondOperator::Operation(timestamp_t input) {
+	return Timestamp::GetDate(MicrosecondOperator::Operation<timestamp_t, timestamp_t>(input));
+}
+
 // INTERVAL specialisations
 template <>
 interval_t DateTrunc::MillenniumOperator::Operation(interval_t input) {
@@ -92016,12 +92177,58 @@ static void DateTruncFunction(DataChunk &args, ExpressionState &state, Vector &r
 	}
 }
 
+static unique_ptr<FunctionData> DateTruncBind(ClientContext &context, ScalarFunction &bound_function,
+                                              vector<unique_ptr<Expression>> &arguments) {
+	if (!arguments[0]->IsFoldable()) {
+		return nullptr;
+	}
+
+	// Rebind to return a date if we are truncating that far
+	Value part_value = ExpressionExecutor::EvaluateScalar(*arguments[0]);
+	if (part_value.IsNull()) {
+		return nullptr;
+	}
+	const auto part_name = part_value.ToString();
+	const auto part_code = GetDatePartSpecifier(part_name);
+	switch (part_code) {
+	case DatePartSpecifier::MILLENNIUM:
+	case DatePartSpecifier::CENTURY:
+	case DatePartSpecifier::DECADE:
+	case DatePartSpecifier::YEAR:
+	case DatePartSpecifier::QUARTER:
+	case DatePartSpecifier::MONTH:
+	case DatePartSpecifier::WEEK:
+	case DatePartSpecifier::YEARWEEK:
+	case DatePartSpecifier::ISOYEAR:
+	case DatePartSpecifier::DAY:
+	case DatePartSpecifier::DOW:
+	case DatePartSpecifier::ISODOW:
+	case DatePartSpecifier::DOY:
+		switch (arguments[1]->return_type.id()) {
+		case LogicalType::TIMESTAMP:
+			bound_function.function = DateTruncFunction<timestamp_t, date_t>;
+			break;
+		case LogicalType::DATE:
+			bound_function.function = DateTruncFunction<date_t, date_t>;
+			break;
+		default:
+			break;
+		}
+		bound_function.return_type = LogicalType::DATE;
+		break;
+	default:
+		break;
+	}
+
+	return nullptr;
+}
+
 void DateTruncFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet date_trunc("date_trunc");
 	date_trunc.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::TIMESTAMP,
-	                                      DateTruncFunction<timestamp_t, timestamp_t>));
+	                                      DateTruncFunction<timestamp_t, timestamp_t>, false, false, DateTruncBind));
 	date_trunc.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE}, LogicalType::TIMESTAMP,
-	                                      DateTruncFunction<date_t, timestamp_t>));
+	                                      DateTruncFunction<date_t, timestamp_t>, false, false, DateTruncBind));
 	date_trunc.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::INTERVAL}, LogicalType::INTERVAL,
 	                                      DateTruncFunction<interval_t, interval_t>));
 	set.AddFunction(date_trunc);
@@ -96612,8 +96819,110 @@ void CardinalityFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/expression_map.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+
+
+namespace duckdb {
+
+struct ValueHashFunction {
+	uint64_t operator()(const Value &value) const {
+		return (uint64_t)value.Hash();
+	}
+};
+
+struct ValueEquality {
+	bool operator()(const Value &a, const Value &b) const {
+		return Value::NotDistinctFrom(a, b);
+	}
+};
+
+template <typename T>
+using value_map_t = unordered_map<Value, T, ValueHashFunction, ValueEquality>;
+
+using value_set_t = unordered_set<Value, ValueHashFunction, ValueEquality>;
+
+} // namespace duckdb
+
+
 namespace duckdb {
 
+// TODO: this doesn't recursively verify maps if maps are nested
+MapInvalidReason CheckMapValidity(Vector &map, idx_t count, const SelectionVector &sel) {
+	D_ASSERT(map.GetType().id() == LogicalTypeId::MAP);
+	VectorData map_vdata;
+	map.Orrify(count, map_vdata);
+	auto &map_validity = map_vdata.validity;
+
+	auto &key_vector = *(StructVector::GetEntries(map)[0]);
+	VectorData key_vdata;
+	key_vector.Orrify(count, key_vdata);
+	auto key_data = (list_entry_t *)key_vdata.data;
+	auto &key_validity = key_vdata.validity;
+
+	auto &key_entries = ListVector::GetEntry(key_vector);
+	VectorData key_entry_vdata;
+	key_entries.Orrify(count, key_entry_vdata);
+	auto &entry_validity = key_entry_vdata.validity;
+
+	for (idx_t row = 0; row < count; row++) {
+		auto mapped_row = sel.get_index(row);
+		auto row_idx = map_vdata.sel->get_index(mapped_row);
+		// map is allowed to be NULL
+		if (!map_validity.RowIsValid(row_idx)) {
+			continue;
+		}
+		row_idx = key_vdata.sel->get_index(row);
+		if (!key_validity.RowIsValid(row_idx)) {
+			return MapInvalidReason::NULL_KEY_LIST;
+		}
+		value_set_t unique_keys;
+		for (idx_t i = 0; i < key_data[row_idx].length; i++) {
+			auto index = key_data[row_idx].offset + i;
+			index = key_entry_vdata.sel->get_index(index);
+			if (!entry_validity.RowIsValid(index)) {
+				return MapInvalidReason::NULL_KEY;
+			}
+			auto value = key_entries.GetValue(index);
+			auto result = unique_keys.insert(value);
+			if (!result.second) {
+				return MapInvalidReason::DUPLICATE_KEY;
+			}
+		}
+	}
+	return MapInvalidReason::VALID;
+}
+
+static void MapConversionVerify(Vector &vector, idx_t count) {
+	auto valid_check = CheckMapValidity(vector, count);
+	switch (valid_check) {
+	case MapInvalidReason::VALID:
+		break;
+	case MapInvalidReason::DUPLICATE_KEY: {
+		throw InvalidInputException("Map keys have to be unique");
+	}
+	case MapInvalidReason::NULL_KEY: {
+		throw InvalidInputException("Map keys can not be NULL");
+	}
+	case MapInvalidReason::NULL_KEY_LIST: {
+		throw InvalidInputException("The list of map keys is not allowed to be NULL");
+	}
+	default: {
+		throw InternalException("MapInvalidReason not implemented");
+	}
+	}
+}
+
 static void MapFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(result.GetType().id() == LogicalTypeId::MAP);
 
@@ -96627,19 +96936,19 @@ static void MapFunction(DataChunk &args, ExpressionState &state, Vector &result)
 
 	auto &child_entries = StructVector::GetEntries(result);
 	D_ASSERT(child_entries.size() == 2);
-	auto &key_vector = child_entries[0];
-	auto &value_vector = child_entries[1];
+	auto &key_vector = *child_entries[0];
+	auto &value_vector = *child_entries[1];
 	if (args.data.empty()) {
 		// no arguments: construct an empty map
-		ListVector::SetListSize(*key_vector, 0);
-		key_vector->SetVectorType(VectorType::CONSTANT_VECTOR);
-		auto list_data = ConstantVector::GetData<list_entry_t>(*key_vector);
+		ListVector::SetListSize(key_vector, 0);
+		key_vector.SetVectorType(VectorType::CONSTANT_VECTOR);
+		auto list_data = ConstantVector::GetData<list_entry_t>(key_vector);
 		list_data->offset = 0;
 		list_data->length = 0;
 
-		ListVector::SetListSize(*value_vector, 0);
-		value_vector->SetVectorType(VectorType::CONSTANT_VECTOR);
-		list_data = ConstantVector::GetData<list_entry_t>(*value_vector);
+		ListVector::SetListSize(value_vector, 0);
+		value_vector.SetVectorType(VectorType::CONSTANT_VECTOR);
+		list_data = ConstantVector::GetData<list_entry_t>(value_vector);
 		list_data->offset = 0;
 		list_data->length = 0;
 
@@ -96650,8 +96959,10 @@ static void MapFunction(DataChunk &args, ExpressionState &state, Vector &result)
 	if (ListVector::GetListSize(args.data[0]) != ListVector::GetListSize(args.data[1])) {
 		throw Exception("Key list has a different size from Value list");
 	}
-	key_vector->Reference(args.data[0]);
-	value_vector->Reference(args.data[1]);
+
+	key_vector.Reference(args.data[0]);
+	value_vector.Reference(args.data[1]);
+	MapConversionVerify(result, args.size());
 
 	result.Verify(args.size());
 }
@@ -105177,6 +105488,7 @@ void BuiltinFunctions::RegisterArrowFunctions() {
 
 
 
+
 namespace duckdb {
 
 void ShiftRight(unsigned char *ar, int size, int shift) {
@@ -105379,6 +105691,26 @@ void ArrowToDuckDBBlob(Vector &vector, ArrowArray &array, ArrowScanLocalState &s
 	}
 }
 
+void ArrowToDuckDBMapVerify(Vector &vector, idx_t count) {
+	auto valid_check = CheckMapValidity(vector, count);
+	switch (valid_check) {
+	case MapInvalidReason::VALID:
+		break;
+	case MapInvalidReason::DUPLICATE_KEY: {
+		throw InvalidInputException("Arrow map contains duplicate key, which isn't supported by DuckDB map type");
+	}
+	case MapInvalidReason::NULL_KEY: {
+		throw InvalidInputException("Arrow map contains NULL as map key, which isn't supported by DuckDB map type");
+	}
+	case MapInvalidReason::NULL_KEY_LIST: {
+		throw InvalidInputException("Arrow map contains NULL as key list, which isn't supported by DuckDB map type");
+	}
+	default: {
+		throw InternalException("MapInvalidReason not implemented");
+	}
+	}
+}
+
 void ArrowToDuckDBMapList(Vector &vector, ArrowArray &array, ArrowScanLocalState &scan_state, idx_t size,
                           unordered_map<idx_t, unique_ptr<ArrowConvertData>> &arrow_convert_data, idx_t col_idx,
                           pair<idx_t, idx_t> &arrow_convert_idx, uint32_t *offsets, ValidityMask *parent_mask) {
@@ -105785,6 +106117,7 @@ void ColumnArrowToDuckDB(Vector &vector, ArrowArray &array, ArrowScanLocalState
 			ArrowToDuckDBMapList(*child_entries[type_idx], *struct_arrow.children[type_idx], scan_state, size,
 			                     arrow_convert_data, col_idx, arrow_convert_idx, offsets, &struct_validity_mask);
 		}
+		ArrowToDuckDBMapVerify(vector, size);
 		break;
 	}
 	case LogicalTypeId::STRUCT: {