duckdb 0.7.2-dev0.0 → 0.7.2-dev1138.0

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

@@ -1,4 +1,5 @@
 #include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/common/serializer/enum_serializer.hpp"
 #include "duckdb/common/types/chunk_collection.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/execution/expression_executor.hpp"
@@ -243,28 +244,30 @@ static unique_ptr<FunctionData> ListSortBind(ClientContext &context, ScalarFunct
 	return make_unique<ListSortBindData>(order, null_order, bound_function.return_type, child_type, context);
 }
 
-OrderByNullType GetNullOrder(ClientContext &context, vector<unique_ptr<Expression>> &arguments, idx_t idx) {
+static OrderByNullType GetNullOrder(ClientContext &context, vector<unique_ptr<Expression>> &arguments, idx_t idx) {
 
 	if (!arguments[idx]->IsFoldable()) {
 		throw InvalidInputException("Null sorting order must be a constant");
 	}
 	Value null_order_value = ExpressionExecutor::EvaluateScalar(context, *arguments[idx]);
 	auto null_order_name = StringUtil::Upper(null_order_value.ToString());
-	if (null_order_name != "NULLS FIRST" && null_order_name != "NULLS LAST") {
-		throw InvalidInputException("Null sorting order must be either NULLS FIRST or NULLS LAST");
+	const auto null_order_arg = EnumSerializer::StringToEnum<OrderByNullType>(null_order_name.c_str());
+	switch (null_order_arg) {
+	case OrderByNullType::NULLS_FIRST:
+	case OrderByNullType::NULLS_LAST:
+		return null_order_arg;
+	case OrderByNullType::ORDER_DEFAULT:
+		return DBConfig::GetConfig(context).options.default_null_order;
+	default:
+		throw InvalidInputException("Null sorting order must be either NULLS FIRST, NULLS LAST or DEFAULT");
 	}
-
-	if (null_order_name == "NULLS LAST") {
-		return OrderByNullType::NULLS_LAST;
-	}
-	return OrderByNullType::NULLS_FIRST;
 }
 
 static unique_ptr<FunctionData> ListNormalSortBind(ClientContext &context, ScalarFunction &bound_function,
                                                    vector<unique_ptr<Expression>> &arguments) {
 
-	D_ASSERT(bound_function.arguments.size() >= 1 && bound_function.arguments.size() <= 3);
-	D_ASSERT(arguments.size() >= 1 && arguments.size() <= 3);
+	D_ASSERT(!bound_function.arguments.empty() && bound_function.arguments.size() <= 3);
+	D_ASSERT(!arguments.empty() && arguments.size() <= 3);
 
 	// set default values
 	auto &config = DBConfig::GetConfig(context);
@@ -278,14 +281,18 @@ static unique_ptr<FunctionData> ListNormalSortBind(ClientContext &context, Scala
 			throw InvalidInputException("Sorting order must be a constant");
 		}
 		Value order_value = ExpressionExecutor::EvaluateScalar(context, *arguments[1]);
-		auto order_name = StringUtil::Upper(order_value.ToString());
-		if (order_name != "DESC" && order_name != "ASC") {
-			throw InvalidInputException("Sorting order must be either ASC or DESC");
-		}
-		if (order_name == "DESC") {
-			order = OrderType::DESCENDING;
-		} else {
-			order = OrderType::ASCENDING;
+
+		const auto order_name = StringUtil::Upper(order_value.ToString());
+		const auto order_arg = EnumSerializer::StringToEnum<OrderType>(order_name.c_str());
+		switch (order_arg) {
+		case OrderType::ASCENDING:
+		case OrderType::DESCENDING:
+			order = order_arg;
+			break;
+		case OrderType::ORDER_DEFAULT:
+			break;
+		default:
+			throw InvalidInputException("Sorting order must be either ASC, DESC or DEFAULT");
 		}
 	}
 

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

@@ -4,7 +4,7 @@
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/common/pair.hpp"
-#include "duckdb/storage/statistics/list_statistics.hpp"
+#include "duckdb/storage/statistics/list_stats.hpp"
 #include "duckdb/planner/expression_binder.hpp"
 
 namespace duckdb {
@@ -42,23 +42,19 @@ static unique_ptr<FunctionData> ListValueBind(ClientContext &context, ScalarFunc
 
 	// this is more for completeness reasons
 	bound_function.varargs = child_type;
-	bound_function.return_type = LogicalType::LIST(std::move(child_type));
+	bound_function.return_type = LogicalType::LIST(child_type);
 	return make_unique<VariableReturnBindData>(bound_function.return_type);
 }
 
 unique_ptr<BaseStatistics> ListValueStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &expr = input.expr;
-	auto list_stats = make_unique<ListStatistics>(expr.return_type);
+	auto list_stats = ListStats::CreateEmpty(expr.return_type);
+	auto &list_child_stats = ListStats::GetChildStats(list_stats);
 	for (idx_t i = 0; i < child_stats.size(); i++) {
-		if (child_stats[i]) {
-			list_stats->child_stats->Merge(*child_stats[i]);
-		} else {
-			list_stats->child_stats.reset();
-			return std::move(list_stats);
-		}
+		list_child_stats.Merge(child_stats[i]);
 	}
-	return std::move(list_stats);
+	return list_stats.ToUnique();
 }
 
 void ListValueFun::RegisterFunction(BuiltinFunctions &set) {

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

@@ -98,6 +98,52 @@ static void AlignVectorToReference(const Vector &original, const Vector &referen
 	result.Reference(expanded_const);
 }
 
+static bool ListEntriesEqual(Vector &keys, Vector &values, idx_t count) {
+	auto key_count = ListVector::GetListSize(keys);
+	auto value_count = ListVector::GetListSize(values);
+	bool same_vector_type = keys.GetVectorType() == values.GetVectorType();
+
+	D_ASSERT(keys.GetType().id() == LogicalTypeId::LIST);
+	D_ASSERT(values.GetType().id() == LogicalTypeId::LIST);
+
+	UnifiedVectorFormat keys_data;
+	UnifiedVectorFormat values_data;
+
+	keys.ToUnifiedFormat(count, keys_data);
+	values.ToUnifiedFormat(count, values_data);
+
+	auto keys_entries = (list_entry_t *)keys_data.data;
+	auto values_entries = (list_entry_t *)values_data.data;
+
+	if (same_vector_type) {
+		const auto key_data = keys_data.data;
+		const auto value_data = values_data.data;
+
+		if (keys.GetVectorType() == VectorType::CONSTANT_VECTOR) {
+			D_ASSERT(values.GetVectorType() == VectorType::CONSTANT_VECTOR);
+			// Only need to compare one entry in this case
+			return memcmp(key_data, value_data, sizeof(list_entry_t)) == 0;
+		}
+
+		// Fast path if the vector types are equal, can just check if the entries are the same
+		if (key_count != value_count) {
+			return false;
+		}
+		return memcmp(key_data, value_data, count * sizeof(list_entry_t)) == 0;
+	}
+
+	// Compare the list_entries one by one
+	for (idx_t i = 0; i < count; i++) {
+		auto keys_idx = keys_data.sel->get_index(i);
+		auto values_idx = values_data.sel->get_index(i);
+
+		if (keys_entries[keys_idx] != values_entries[values_idx]) {
+			return false;
+		}
+	}
+	return true;
+}
+
 static void MapFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(result.GetType().id() == LogicalTypeId::MAP);
 
@@ -132,7 +178,7 @@ static void MapFunction(DataChunk &args, ExpressionState &state, Vector &result)
 	} else if (values_are_const && !keys_are_const) {
 		AlignVectorToReference(args.data[1], args.data[0], args.size(), value_vector);
 	} else {
-		if (key_count != value_count || memcmp(key_data, value_data, args.size() * sizeof(list_entry_t)) != 0) {
+		if (!ListEntriesEqual(args.data[0], args.data[1], args.size())) {
 			throw InvalidInputException("Error in MAP creation: key list and value list do not align. i.e. different "
 			                            "size or incompatible structure");
 		}

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

@@ -0,0 +1,61 @@
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/parser/expression/bound_expression.hpp"
+#include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/common/pair.hpp"
+
+namespace duckdb {
+
+// Reverse of map_from_entries
+static void MapEntriesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	idx_t count = args.size();
+
+	result.Reinterpret(args.data[0]);
+
+	if (args.AllConstant()) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+	result.Verify(count);
+}
+
+static unique_ptr<FunctionData> MapEntriesBind(ClientContext &context, ScalarFunction &bound_function,
+                                               vector<unique_ptr<Expression>> &arguments) {
+	child_list_t<LogicalType> child_types;
+
+	if (arguments.size() != 1) {
+		throw InvalidInputException("Too many arguments provided, only expecting a single map");
+	}
+	auto &map = arguments[0]->return_type;
+
+	if (map.id() == LogicalTypeId::UNKNOWN) {
+		// Prepared statement
+		bound_function.arguments.emplace_back(LogicalTypeId::UNKNOWN);
+		bound_function.return_type = LogicalType(LogicalTypeId::SQLNULL);
+		return nullptr;
+	}
+
+	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("k", key_type));
+	child_types.push_back(make_pair("v", value_type));
+
+	auto row_type = LogicalType::STRUCT(child_types);
+
+	bound_function.return_type = LogicalType::LIST(row_type);
+	return make_unique<VariableReturnBindData>(bound_function.return_type);
+}
+
+void MapEntriesFun::RegisterFunction(BuiltinFunctions &set) {
+	//! the arguments and return types are actually set in the binder function
+	ScalarFunction fun("map_entries", {}, LogicalTypeId::LIST, MapEntriesFunction, MapEntriesBind);
+	fun.null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING;
+	fun.varargs = LogicalType::ANY;
+	set.AddFunction(fun);
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/scalar/map/map_extract.cpp

@@ -5,19 +5,55 @@
 #include "duckdb/common/types/data_chunk.hpp"
 
 namespace duckdb {
-void FillResult(Value &values, Vector &result, idx_t row) {
-	//! First Initialize List Vector
-	idx_t current_offset = ListVector::GetListSize(result);
-	//! Push Values to List Vector
-	auto &list_values = ListValue::GetChildren(values);
-	for (idx_t i = 0; i < list_values.size(); i++) {
-		ListVector::PushBack(result, list_values[i]);
+void FillResult(Vector &map, Vector &offsets, Vector &result, idx_t count) {
+	UnifiedVectorFormat map_data;
+	map.ToUnifiedFormat(count, map_data);
+
+	UnifiedVectorFormat offset_data;
+	offsets.ToUnifiedFormat(count, offset_data);
+
+	UnifiedVectorFormat result_data;
+	result.ToUnifiedFormat(count, result_data);
+
+	auto entry_count = ListVector::GetListSize(map);
+	auto &values_entries = MapVector::GetValues(map);
+	UnifiedVectorFormat values_entry_data;
+	// Note: this vector can have a different size than the map
+	values_entries.ToUnifiedFormat(entry_count, values_entry_data);
+
+	for (idx_t row = 0; row < count; row++) {
+		idx_t offset_idx = offset_data.sel->get_index(row);
+		auto offset = ((int32_t *)offset_data.data)[offset_idx];
+
+		// Get the current size of the list, for the offset
+		idx_t current_offset = ListVector::GetListSize(result);
+		if (!offset_data.validity.RowIsValid(offset_idx) || !offset) {
+			// Set the entry data for this result row
+			idx_t result_index = result_data.sel->get_index(row);
+			auto &entry = ((list_entry_t *)result_data.data)[result_index];
+			entry.length = 0;
+			entry.offset = current_offset;
+			continue;
+		}
+		// All list indices start at 1, reduce by 1 to get the actual index
+		offset--;
+
+		// Get the 'values' list entry corresponding to the offset
+		idx_t value_index = map_data.sel->get_index(row);
+		auto &value_list_entry = ((list_entry_t *)map_data.data)[value_index];
+
+		// Add the values to the result
+		idx_t list_offset = value_list_entry.offset + offset;
+		// All keys are unique, only one will ever match
+		idx_t length = 1;
+		ListVector::Append(result, values_entries, length + list_offset, list_offset);
+
+		// Set the entry data for this result row
+		idx_t result_index = result_data.sel->get_index(row);
+		auto &entry = ((list_entry_t *)result_data.data)[result_index];
+		entry.length = length;
+		entry.offset = current_offset;
 	}
-
-	//! now set the pointer
-	auto &entry = ListVector::GetData(result)[row];
-	entry.length = list_values.size();
-	entry.offset = current_offset;
 }
 
 static void MapExtractFunction(DataChunk &args, ExpressionState &state, Vector &result) {
@@ -25,6 +61,8 @@ static void MapExtractFunction(DataChunk &args, ExpressionState &state, Vector &
 	D_ASSERT(args.data[0].GetType().id() == LogicalTypeId::MAP);
 	result.SetVectorType(VectorType::FLAT_VECTOR);
 
+	idx_t tuple_count = args.size();
+	// Optimization: because keys are not allowed to be NULL, we can early-out
 	if (args.data[1].GetType().id() == LogicalTypeId::SQLNULL) {
 		//! We don't need to look through the map if the 'key' to look for is NULL
 		ListVector::SetListSize(result, 0);
@@ -32,7 +70,7 @@ static void MapExtractFunction(DataChunk &args, ExpressionState &state, Vector &
 		auto list_data = ConstantVector::GetData<list_entry_t>(result);
 		list_data->offset = 0;
 		list_data->length = 0;
-		result.Verify(args.size());
+		result.Verify(tuple_count);
 		return;
 	}
 
@@ -41,26 +79,30 @@ static void MapExtractFunction(DataChunk &args, ExpressionState &state, Vector &
 
 	UnifiedVectorFormat map_data;
 
-	auto &map_keys = MapVector::GetKeys(map);
-	auto &map_values = MapVector::GetValues(map);
+	// Create the chunk we'll feed to ListPosition
+	DataChunk list_position_chunk;
+	vector<LogicalType> chunk_types;
+	chunk_types.reserve(2);
+	chunk_types.push_back(map.GetType());
+	chunk_types.push_back(key.GetType());
+	list_position_chunk.InitializeEmpty(chunk_types.begin(), chunk_types.end());
 
-	map.ToUnifiedFormat(args.size(), map_data);
+	// Populate it with the map keys list and the key vector
+	list_position_chunk.data[0].Reference(map);
+	list_position_chunk.data[1].Reference(key);
+	list_position_chunk.SetCardinality(tuple_count);
 
-	for (idx_t row = 0; row < args.size(); row++) {
-		idx_t row_index = map_data.sel->get_index(row);
-		auto key_value = key.GetValue(row);
+	Vector position_vector(LogicalType::LIST(LogicalType::INTEGER), tuple_count);
+	// We can pass around state as it's not used by ListPositionFunction anyways
+	ListContainsOrPosition<int32_t, PositionFunctor, MapKeyArgFunctor>(list_position_chunk, position_vector);
 
-		list_entry_t entry = ListVector::GetData(map)[row_index];
-		auto offsets = MapVector::Search(map_keys, args.size(), key_value, entry);
-		auto values = FlatVector::GetValuesFromOffsets(map_values, offsets);
-		FillResult(values, result, row);
-	}
+	FillResult(map, position_vector, result, tuple_count);
 
-	if (args.size() == 1) {
+	if (tuple_count == 1) {
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
 	}
 
-	result.Verify(args.size());
+	result.Verify(tuple_count);
 }
 
 static unique_ptr<FunctionData> MapExtractBind(ClientContext &context, ScalarFunction &bound_function,

package/src/duckdb/src/function/scalar/map/map_keys_values.cpp

@@ -0,0 +1,97 @@
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/parser/expression/bound_expression.hpp"
+#include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/common/pair.hpp"
+
+namespace duckdb {
+
+static void MapKeyValueFunction(DataChunk &args, ExpressionState &state, Vector &result,
+                                Vector &(*get_child_vector)(Vector &)) {
+	D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
+	auto count = args.size();
+
+	auto &map = args.data[0];
+	D_ASSERT(map.GetType().id() == LogicalTypeId::MAP);
+	auto child = get_child_vector(map);
+
+	auto &entries = ListVector::GetEntry(result);
+	entries.Reference(child);
+
+	UnifiedVectorFormat map_data;
+	map.ToUnifiedFormat(count, map_data);
+
+	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
+	FlatVector::SetData(result, map_data.data);
+	FlatVector::SetValidity(result, map_data.validity);
+	auto list_size = ListVector::GetListSize(map);
+	ListVector::SetListSize(result, list_size);
+	if (map.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
+		result.Slice(*map_data.sel, count);
+	}
+	if (args.AllConstant()) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
+	result.Verify(count);
+}
+
+static void MapKeysFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	MapKeyValueFunction(args, state, result, MapVector::GetKeys);
+}
+
+static void MapValuesFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	MapKeyValueFunction(args, state, result, MapVector::GetValues);
+}
+
+static unique_ptr<FunctionData> MapKeyValueBind(ClientContext &context, ScalarFunction &bound_function,
+                                                vector<unique_ptr<Expression>> &arguments,
+                                                const LogicalType &(*type_func)(const LogicalType &)) {
+	if (arguments.size() != 1) {
+		throw InvalidInputException("Too many arguments provided, only expecting a single map");
+	}
+	auto &map = arguments[0]->return_type;
+
+	if (map.id() == LogicalTypeId::UNKNOWN) {
+		// Prepared statement
+		bound_function.arguments.emplace_back(LogicalTypeId::UNKNOWN);
+		bound_function.return_type = LogicalType(LogicalTypeId::SQLNULL);
+		return nullptr;
+	}
+
+	if (map.id() != LogicalTypeId::MAP) {
+		throw InvalidInputException("The provided argument is not a map");
+	}
+
+	auto &type = type_func(map);
+
+	bound_function.return_type = LogicalType::LIST(type);
+	return make_unique<VariableReturnBindData>(bound_function.return_type);
+}
+
+static unique_ptr<FunctionData> MapKeysBind(ClientContext &context, ScalarFunction &bound_function,
+                                            vector<unique_ptr<Expression>> &arguments) {
+	return MapKeyValueBind(context, bound_function, arguments, MapType::KeyType);
+}
+
+static unique_ptr<FunctionData> MapValuesBind(ClientContext &context, ScalarFunction &bound_function,
+                                              vector<unique_ptr<Expression>> &arguments) {
+	return MapKeyValueBind(context, bound_function, arguments, MapType::ValueType);
+}
+
+void MapKeysFun::RegisterFunction(BuiltinFunctions &set) {
+	//! the arguments and return types are actually set in the binder function
+	ScalarFunction fun("map_keys", {}, LogicalTypeId::LIST, MapKeysFunction, MapKeysBind);
+	fun.null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING;
+	fun.varargs = LogicalType::ANY;
+	set.AddFunction(fun);
+}
+
+void MapValuesFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunction fun("map_values", {}, LogicalTypeId::LIST, MapValuesFunction, MapValuesBind);
+	fun.null_handling = FunctionNullHandling::DEFAULT_NULL_HANDLING;
+	fun.varargs = LogicalType::ANY;
+	set.AddFunction(fun);
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/scalar/math/numeric.cpp

@@ -2,13 +2,13 @@
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/function/scalar/trigonometric_functions.hpp"
 #include "duckdb/common/operator/abs.hpp"
+#include "duckdb/common/operator/multiply.hpp"
 #include "duckdb/common/types/hugeint.hpp"
 #include "duckdb/common/types/cast_helpers.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/common/algorithm.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/common/likely.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
 #include "duckdb/common/types/bit.hpp"
 #include <cmath>
 #include <errno.h>
@@ -77,25 +77,22 @@ static unique_ptr<BaseStatistics> PropagateAbsStats(ClientContext &context, Func
 	auto &expr = input.expr;
 	D_ASSERT(child_stats.size() == 1);
 	// can only propagate stats if the children have stats
-	if (!child_stats[0]) {
-		return nullptr;
-	}
-	auto &lstats = (NumericStatistics &)*child_stats[0];
+	auto &lstats = child_stats[0];
 	Value new_min, new_max;
 	bool potential_overflow = true;
-	if (!lstats.min.IsNull() && !lstats.max.IsNull()) {
+	if (NumericStats::HasMinMax(lstats)) {
 		switch (expr.return_type.InternalType()) {
 		case PhysicalType::INT8:
-			potential_overflow = lstats.min.GetValue<int8_t>() == NumericLimits<int8_t>::Minimum();
+			potential_overflow = NumericStats::Min(lstats).GetValue<int8_t>() == NumericLimits<int8_t>::Minimum();
 			break;
 		case PhysicalType::INT16:
-			potential_overflow = lstats.min.GetValue<int16_t>() == NumericLimits<int16_t>::Minimum();
+			potential_overflow = NumericStats::Min(lstats).GetValue<int16_t>() == NumericLimits<int16_t>::Minimum();
 			break;
 		case PhysicalType::INT32:
-			potential_overflow = lstats.min.GetValue<int32_t>() == NumericLimits<int32_t>::Minimum();
+			potential_overflow = NumericStats::Min(lstats).GetValue<int32_t>() == NumericLimits<int32_t>::Minimum();
 			break;
 		case PhysicalType::INT64:
-			potential_overflow = lstats.min.GetValue<int64_t>() == NumericLimits<int64_t>::Minimum();
+			potential_overflow = NumericStats::Min(lstats).GetValue<int64_t>() == NumericLimits<int64_t>::Minimum();
 			break;
 		default:
 			return nullptr;
@@ -108,8 +105,8 @@ static unique_ptr<BaseStatistics> PropagateAbsStats(ClientContext &context, Func
 		// no potential overflow
 
 		// compute stats
-		auto current_min = lstats.min.GetValue<int64_t>();
-		auto current_max = lstats.max.GetValue<int64_t>();
+		auto current_min = NumericStats::Min(lstats).GetValue<int64_t>();
+		auto current_max = NumericStats::Max(lstats).GetValue<int64_t>();
 
 		int64_t min_val, max_val;
 
@@ -125,16 +122,17 @@ static unique_ptr<BaseStatistics> PropagateAbsStats(ClientContext &context, Func
 		} else {
 			// if both current_min and current_max are > 0, then the abs is a no-op and can be removed entirely
 			*input.expr_ptr = std::move(input.expr.children[0]);
-			return std::move(child_stats[0]);
+			return child_stats[0].ToUnique();
 		}
 		new_min = Value::Numeric(expr.return_type, min_val);
 		new_max = Value::Numeric(expr.return_type, max_val);
 		expr.function.function = ScalarFunction::GetScalarUnaryFunction<AbsOperator>(expr.return_type);
 	}
-	auto stats = make_unique<NumericStatistics>(expr.return_type, std::move(new_min), std::move(new_max),
-	                                            StatisticsType::LOCAL_STATS);
-	stats->validity_stats = lstats.validity_stats->Copy();
-	return std::move(stats);
+	auto stats = NumericStats::CreateEmpty(expr.return_type);
+	NumericStats::SetMin(stats, new_min);
+	NumericStats::SetMax(stats, new_max);
+	stats.CopyValidity(lstats);
+	return stats.ToUnique();
 }
 
 template <class OP>
@@ -1164,4 +1162,90 @@ void EvenFun::RegisterFunction(BuiltinFunctions &set) {
 	                               ScalarFunction::UnaryFunction<double, double, EvenOperator>));
 }
 
+//===--------------------------------------------------------------------===//
+// gcd
+//===--------------------------------------------------------------------===//
+
+// should be replaced with std::gcd in a newer C++ standard
+template <class TA>
+TA GreatestCommonDivisor(TA left, TA right) {
+	TA a = left;
+	TA b = right;
+
+	// This protects the following modulo operations from a corner case,
+	// where we would get a runtime error due to an integer overflow.
+	if ((left == NumericLimits<TA>::Minimum() && right == -1) ||
+	    (left == -1 && right == NumericLimits<TA>::Minimum())) {
+		return 1;
+	}
+
+	while (true) {
+		if (a == 0) {
+			return TryAbsOperator::Operation<TA, TA>(b);
+		}
+		b %= a;
+
+		if (b == 0) {
+			return TryAbsOperator::Operation<TA, TA>(a);
+		}
+		a %= b;
+	}
+}
+
+struct GreatestCommonDivisorOperator {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA left, TB right) {
+		return GreatestCommonDivisor(left, right);
+	}
+};
+
+void GreatestCommonDivisorFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet funcs("gcd");
+
+	funcs.AddFunction(
+	    ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT}, LogicalType::BIGINT,
+	                   ScalarFunction::BinaryFunction<int64_t, int64_t, int64_t, GreatestCommonDivisorOperator>));
+	funcs.AddFunction(
+	    ScalarFunction({LogicalType::HUGEINT, LogicalType::HUGEINT}, LogicalType::HUGEINT,
+	                   ScalarFunction::BinaryFunction<hugeint_t, hugeint_t, hugeint_t, GreatestCommonDivisorOperator>));
+
+	set.AddFunction(funcs);
+	funcs.name = "greatest_common_divisor";
+	set.AddFunction(funcs);
+}
+
+//===--------------------------------------------------------------------===//
+// lcm
+//===--------------------------------------------------------------------===//
+
+// should be replaced with std::lcm in a newer C++ standard
+struct LeastCommonMultipleOperator {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA left, TB right) {
+		if (left == 0 || right == 0) {
+			return 0;
+		}
+		TR result;
+		if (!TryMultiplyOperator::Operation<TA, TB, TR>(left, right / GreatestCommonDivisor(left, right), result)) {
+			throw OutOfRangeException("lcm value is out of range");
+		}
+		return TryAbsOperator::Operation<TR, TR>(result);
+	}
+};
+
+void LeastCommonMultipleFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunctionSet funcs("lcm");
+
+	funcs.AddFunction(
+	    ScalarFunction({LogicalType::BIGINT, LogicalType::BIGINT}, LogicalType::BIGINT,
+	                   ScalarFunction::BinaryFunction<int64_t, int64_t, int64_t, LeastCommonMultipleOperator>));
+	funcs.AddFunction(
+	    ScalarFunction({LogicalType::HUGEINT, LogicalType::HUGEINT}, LogicalType::HUGEINT,
+	                   ScalarFunction::BinaryFunction<hugeint_t, hugeint_t, hugeint_t, LeastCommonMultipleOperator>));
+
+	set.AddFunction(funcs);
+	funcs.name = "least_common_multiple";
+	set.AddFunction(funcs);
+}
+
 } // namespace duckdb

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

@@ -41,6 +41,9 @@ void BuiltinFunctions::RegisterMathFunctions() {
 	Register<SignBitFun>();
 	Register<IsInfiniteFun>();
 	Register<IsFiniteFun>();
+
+	Register<GreatestCommonDivisorFun>();
+	Register<LeastCommonMultipleFun>();
 }
 
 } // namespace duckdb

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

@@ -22,6 +22,9 @@ void BuiltinFunctions::RegisterNestedFunctions() {
 	Register<ListFlattenFun>();
 	Register<MapFun>();
 	Register<MapFromEntriesFun>();
+	Register<MapEntriesFun>();
+	Register<MapValuesFun>();
+	Register<MapKeysFun>();
 	Register<MapExtractFun>();
 	Register<UnionValueFun>();
 	Register<UnionExtractFun>();