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

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

@@ -0,0 +1,100 @@
+#include "duckdb/common/types/bit.hpp"
+#include "duckdb/function/scalar/bit_functions.hpp"
+#include "duckdb/common/types/cast_helpers.hpp"
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// BitStringFunction
+//===--------------------------------------------------------------------===//
+
+static void BitStringFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	BinaryExecutor::Execute<string_t, int32_t, string_t>(
+	    args.data[0], args.data[1], result, args.size(), [&](string_t input, int32_t n) {
+		    if (n < 0) {
+			    throw InvalidInputException("The bitstring length cannot be negative");
+		    }
+		    if (idx_t(n) < input.GetSize()) {
+			    throw InvalidInputException("Length must be equal or larger than input string");
+		    }
+		    idx_t len;
+		    Bit::TryGetBitStringSize(input, len, nullptr); // string verification
+
+		    len = Bit::ComputeBitstringLen(n);
+		    string_t target = StringVector::EmptyString(result, len);
+		    Bit::BitString(input, n, target);
+		    target.Finalize();
+		    return target;
+	    });
+}
+
+void BitStringFun::RegisterFunction(BuiltinFunctions &set) {
+	// bitstring creates a new bitstring from varchar with a fixed-length
+	set.AddFunction(
+	    ScalarFunction("bitstring", {LogicalType::VARCHAR, LogicalType::INTEGER}, LogicalType::BIT, BitStringFunction));
+}
+
+//===--------------------------------------------------------------------===//
+// get_bit
+//===--------------------------------------------------------------------===//
+struct GetBitOperator {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA input, TB n) {
+		if (n < 0 || (idx_t)n > Bit::BitLength(input) - 1) {
+			throw OutOfRangeException("bit index %s out of valid range (0..%s)", NumericHelper::ToString(n),
+			                          NumericHelper::ToString(Bit::BitLength(input) - 1));
+		}
+		return Bit::GetBit(input, n);
+	}
+};
+
+void GetBitFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(ScalarFunction("get_bit", {LogicalType::BIT, LogicalType::INTEGER}, LogicalType::INTEGER,
+	                               ScalarFunction::BinaryFunction<string_t, int32_t, int32_t, GetBitOperator>));
+}
+
+//===--------------------------------------------------------------------===//
+// set_bit
+//===--------------------------------------------------------------------===//
+static void SetBitOperation(DataChunk &args, ExpressionState &state, Vector &result) {
+	TernaryExecutor::Execute<string_t, int32_t, int32_t, string_t>(
+	    args.data[0], args.data[1], args.data[2], result, args.size(),
+	    [&](string_t input, int32_t n, int32_t new_value) {
+		    if (new_value != 0 && new_value != 1) {
+			    throw InvalidInputException("The new bit must be 1 or 0");
+		    }
+		    if (n < 0 || (idx_t)n > Bit::BitLength(input) - 1) {
+			    throw OutOfRangeException("bit index %s out of valid range (0..%s)", NumericHelper::ToString(n),
+			                              NumericHelper::ToString(Bit::BitLength(input) - 1));
+		    }
+		    string_t target = StringVector::EmptyString(result, input.GetSize());
+		    memcpy(target.GetDataWriteable(), input.GetDataUnsafe(), input.GetSize());
+		    Bit::SetBit(target, n, new_value);
+		    return target;
+	    });
+}
+
+void SetBitFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(ScalarFunction("set_bit", {LogicalType::BIT, LogicalType::INTEGER, LogicalType::INTEGER},
+	                               LogicalType::BIT, SetBitOperation));
+}
+
+//===--------------------------------------------------------------------===//
+// bit_position
+//===--------------------------------------------------------------------===//
+struct BitPositionOperator {
+	template <class TA, class TB, class TR>
+	static inline TR Operation(TA substring, TB input) {
+		if (substring.GetSize() > input.GetSize()) {
+			return 0;
+		}
+		return Bit::BitPosition(substring, input);
+	}
+};
+
+void BitPositionFun::RegisterFunction(BuiltinFunctions &set) {
+	set.AddFunction(ScalarFunction("bit_position", {LogicalType::BIT, LogicalType::BIT}, LogicalType::INTEGER,
+	                               ScalarFunction::BinaryFunction<string_t, string_t, int32_t, BitPositionOperator>));
+}
+
+} // namespace duckdb

package/src/duckdb/src/function/scalar/date/current.cpp

@@ -35,14 +35,12 @@ static void CurrentTimestampFunction(DataChunk &input, ExpressionState &state, V
 
 void CurrentTimeFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunction current_time("get_current_time", {}, LogicalType::TIME, CurrentTimeFunction);
-	;
 	current_time.side_effects = FunctionSideEffects::HAS_SIDE_EFFECTS;
 	set.AddFunction(current_time);
 }
 
 void CurrentDateFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunction current_date({}, LogicalType::DATE, CurrentDateFunction);
-	;
 	current_date.side_effects = FunctionSideEffects::HAS_SIDE_EFFECTS;
 	set.AddFunction({"today", "current_date"}, current_date);
 }

package/src/duckdb/src/function/scalar/date/date_diff.cpp

@@ -9,7 +9,6 @@
 #include "duckdb/common/vector_operations/ternary_executor.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
 
 namespace duckdb {
 

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

@@ -9,7 +9,7 @@
 #include "duckdb/function/scalar/date_functions.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
+
 #include "duckdb/common/field_writer.hpp"
 
 namespace duckdb {
@@ -161,34 +161,27 @@ DatePartSpecifier GetDateTypePartSpecifier(const string &specifier, LogicalType
 }
 
 template <int64_t MIN, int64_t MAX>
-static unique_ptr<BaseStatistics> PropagateSimpleDatePartStatistics(vector<unique_ptr<BaseStatistics>> &child_stats) {
+static unique_ptr<BaseStatistics> PropagateSimpleDatePartStatistics(vector<BaseStatistics> &child_stats) {
 	// we can always propagate simple date part statistics
 	// since the min and max can never exceed these bounds
-	auto result = make_unique<NumericStatistics>(LogicalType::BIGINT, Value::BIGINT(MIN), Value::BIGINT(MAX),
-	                                             StatisticsType::LOCAL_STATS);
-	if (!child_stats[0]) {
-		// if there are no child stats, we don't know
-		result->validity_stats = make_unique<ValidityStatistics>(true);
-	} else if (child_stats[0]->validity_stats) {
-		result->validity_stats = child_stats[0]->validity_stats->Copy();
-	}
-	return std::move(result);
+	auto result = NumericStats::CreateEmpty(LogicalType::BIGINT);
+	result.CopyValidity(child_stats[0]);
+	NumericStats::SetMin(result, Value::BIGINT(MIN));
+	NumericStats::SetMax(result, Value::BIGINT(MAX));
+	return result.ToUnique();
 }
 
 struct DatePart {
 	template <class T, class OP>
-	static unique_ptr<BaseStatistics> PropagateDatePartStatistics(vector<unique_ptr<BaseStatistics>> &child_stats) {
+	static unique_ptr<BaseStatistics> PropagateDatePartStatistics(vector<BaseStatistics> &child_stats) {
 		// we can only propagate complex date part stats if the child has stats
-		if (!child_stats[0]) {
-			return nullptr;
-		}
-		auto &nstats = (NumericStatistics &)*child_stats[0];
-		if (nstats.min.IsNull() || nstats.max.IsNull()) {
+		auto &nstats = child_stats[0];
+		if (!NumericStats::HasMinMax(nstats)) {
 			return nullptr;
 		}
 		// run the operator on both the min and the max, this gives us the [min, max] bound
-		auto min = nstats.min.GetValueUnsafe<T>();
-		auto max = nstats.max.GetValueUnsafe<T>();
+		auto min = NumericStats::GetMin<T>(nstats);
+		auto max = NumericStats::GetMax<T>(nstats);
 		if (min > max) {
 			return nullptr;
 		}
@@ -198,12 +191,11 @@ struct DatePart {
 		}
 		auto min_part = OP::template Operation<T, int64_t>(min);
 		auto max_part = OP::template Operation<T, int64_t>(max);
-		auto result = make_unique<NumericStatistics>(LogicalType::BIGINT, Value::BIGINT(min_part),
-		                                             Value::BIGINT(max_part), StatisticsType::LOCAL_STATS);
-		if (child_stats[0]->validity_stats) {
-			result->validity_stats = child_stats[0]->validity_stats->Copy();
-		}
-		return std::move(result);
+		auto result = NumericStats::CreateEmpty(LogicalType::BIGINT);
+		NumericStats::SetMin(result, Value::BIGINT(min_part));
+		NumericStats::SetMax(result, Value::BIGINT(max_part));
+		result.CopyValidity(child_stats[0]);
+		return result.ToUnique();
 	}
 
 	template <typename OP>
@@ -1340,7 +1332,7 @@ struct StructDatePart {
 		}
 
 		Function::EraseArgument(bound_function, arguments, 0);
-		bound_function.return_type = LogicalType::STRUCT(std::move(struct_children));
+		bound_function.return_type = LogicalType::STRUCT(struct_children);
 		return make_unique<BindData>(bound_function.return_type, part_codes);
 	}
 

package/src/duckdb/src/function/scalar/date/date_sub.cpp

@@ -9,7 +9,6 @@
 #include "duckdb/common/vector_operations/ternary_executor.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/function/scalar/date/date_trunc.cpp

@@ -8,7 +8,6 @@
 #include "duckdb/common/types/value.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
 
 namespace duckdb {
 
@@ -588,18 +587,15 @@ static void DateTruncFunction(DataChunk &args, ExpressionState &state, Vector &r
 }
 
 template <class TA, class TR, class OP>
-static unique_ptr<BaseStatistics> DateTruncStatistics(vector<unique_ptr<BaseStatistics>> &child_stats) {
+static unique_ptr<BaseStatistics> DateTruncStatistics(vector<BaseStatistics> &child_stats) {
 	// we can only propagate date stats if the child has stats
-	if (!child_stats[1]) {
-		return nullptr;
-	}
-	auto &nstats = (NumericStatistics &)*child_stats[1];
-	if (nstats.min.IsNull() || nstats.max.IsNull()) {
+	auto &nstats = child_stats[1];
+	if (!NumericStats::HasMinMax(nstats)) {
 		return nullptr;
 	}
 	// run the operator on both the min and the max, this gives us the [min, max] bound
-	auto min = nstats.min.GetValueUnsafe<TA>();
-	auto max = nstats.max.GetValueUnsafe<TA>();
+	auto min = NumericStats::GetMin<TA>(nstats);
+	auto max = NumericStats::GetMax<TA>(nstats);
 	if (min > max) {
 		return nullptr;
 	}
@@ -610,11 +606,11 @@ static unique_ptr<BaseStatistics> DateTruncStatistics(vector<unique_ptr<BaseStat
 
 	auto min_value = Value::CreateValue(min_part);
 	auto max_value = Value::CreateValue(max_part);
-	auto result = make_unique<NumericStatistics>(min_value.type(), min_value, max_value, StatisticsType::LOCAL_STATS);
-	if (child_stats[0]->validity_stats) {
-		result->validity_stats = child_stats[1]->validity_stats->Copy();
-	}
-	return std::move(result);
+	auto result = NumericStats::CreateEmpty(min_value.type());
+	NumericStats::SetMin(result, min_value);
+	NumericStats::SetMax(result, max_value);
+	result.CopyValidity(child_stats[0]);
+	return result.ToUnique();
 }
 
 template <class TA, class TR, class OP>

package/src/duckdb/src/function/scalar/generic/stats.cpp

@@ -38,10 +38,8 @@ unique_ptr<FunctionData> StatsBind(ClientContext &context, ScalarFunction &bound
 static unique_ptr<BaseStatistics> StatsPropagateStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	auto &bind_data = input.bind_data;
-	if (child_stats[0]) {
-		auto &info = (StatsBindData &)*bind_data;
-		info.stats = child_stats[0]->ToString();
-	}
+	auto &info = (StatsBindData &)*bind_data;
+	info.stats = child_stats[0].ToString();
 	return nullptr;
 }
 

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

@@ -5,156 +5,14 @@
 
 namespace duckdb {
 
-struct ContainsFunctor {
-	static inline bool Initialize() {
-		return false;
-	}
-	static inline bool UpdateResultEntries(idx_t child_idx) {
-		return true;
-	}
-};
-
-struct PositionFunctor {
-	static inline int32_t Initialize() {
-		return 0;
-	}
-	static inline int32_t UpdateResultEntries(idx_t child_idx) {
-		return child_idx + 1;
-	}
-};
-
-template <class CHILD_TYPE, class RETURN_TYPE, class OP>
-static void TemplatedContainsOrPosition(DataChunk &args, ExpressionState &state, Vector &result,
-                                        bool is_nested = false) {
-	D_ASSERT(args.ColumnCount() == 2);
-	auto count = args.size();
-	Vector &list = args.data[0];
-	Vector &value_vector = args.data[1];
-
-	// Create a result vector of type RETURN_TYPE
-	result.SetVectorType(VectorType::FLAT_VECTOR);
-	auto result_entries = FlatVector::GetData<RETURN_TYPE>(result);
-	auto &result_validity = FlatVector::Validity(result);
-
-	if (list.GetType().id() == LogicalTypeId::SQLNULL) {
-		result_validity.SetInvalid(0);
-		return;
-	}
-
-	auto list_size = ListVector::GetListSize(list);
-	auto &child_vector = ListVector::GetEntry(list);
-
-	UnifiedVectorFormat child_data;
-	child_vector.ToUnifiedFormat(list_size, child_data);
-
-	UnifiedVectorFormat list_data;
-	list.ToUnifiedFormat(count, list_data);
-	auto list_entries = (list_entry_t *)list_data.data;
-
-	UnifiedVectorFormat value_data;
-	value_vector.ToUnifiedFormat(count, value_data);
-
-	// not required for a comparison of nested types
-	auto child_value = (CHILD_TYPE *)child_data.data;
-	auto values = (CHILD_TYPE *)value_data.data;
-
-	for (idx_t i = 0; i < count; i++) {
-		auto list_index = list_data.sel->get_index(i);
-		auto value_index = value_data.sel->get_index(i);
-
-		if (!list_data.validity.RowIsValid(list_index) || !value_data.validity.RowIsValid(value_index)) {
-			result_validity.SetInvalid(i);
-			continue;
-		}
-
-		const auto &list_entry = list_entries[list_index];
-
-		result_entries[i] = OP::Initialize();
-		for (idx_t child_idx = 0; child_idx < list_entry.length; child_idx++) {
-
-			auto child_value_idx = child_data.sel->get_index(list_entry.offset + child_idx);
-			if (!child_data.validity.RowIsValid(child_value_idx)) {
-				continue;
-			}
-
-			if (!is_nested) {
-				if (Equals::Operation(child_value[child_value_idx], values[value_index])) {
-					result_entries[i] = OP::UpdateResultEntries(child_idx);
-					break; // Found value in list, no need to look further
-				}
-			} else {
-				// FIXME: using Value is less efficient than modifying the vector comparison code
-				// to more efficiently compare nested types
-				auto lvalue = child_vector.GetValue(child_value_idx);
-				auto rvalue = value_vector.GetValue(value_index);
-				if (Value::NotDistinctFrom(lvalue, rvalue)) {
-					result_entries[i] = OP::UpdateResultEntries(child_idx);
-					break; // Found value in list, no need to look further
-				}
-			}
-		}
-	}
-
-	if (args.AllConstant()) {
-		result.SetVectorType(VectorType::CONSTANT_VECTOR);
-	}
-}
-
-template <class T, class OP>
-static void ListContainsOrPosition(DataChunk &args, ExpressionState &state, Vector &result) {
-	switch (args.data[1].GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedContainsOrPosition<int8_t, T, OP>(args, state, result);
-		break;
-	case PhysicalType::INT16:
-		TemplatedContainsOrPosition<int16_t, T, OP>(args, state, result);
-		break;
-	case PhysicalType::INT32:
-		TemplatedContainsOrPosition<int32_t, T, OP>(args, state, result);
-		break;
-	case PhysicalType::INT64:
-		TemplatedContainsOrPosition<int64_t, T, OP>(args, state, result);
-		break;
-	case PhysicalType::INT128:
-		TemplatedContainsOrPosition<hugeint_t, T, OP>(args, state, result);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedContainsOrPosition<uint8_t, T, OP>(args, state, result);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedContainsOrPosition<uint16_t, T, OP>(args, state, result);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedContainsOrPosition<uint32_t, T, OP>(args, state, result);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedContainsOrPosition<uint64_t, T, OP>(args, state, result);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedContainsOrPosition<float, T, OP>(args, state, result);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedContainsOrPosition<double, T, OP>(args, state, result);
-		break;
-	case PhysicalType::VARCHAR:
-		TemplatedContainsOrPosition<string_t, T, OP>(args, state, result);
-		break;
-	case PhysicalType::STRUCT:
-	case PhysicalType::LIST:
-		TemplatedContainsOrPosition<int8_t, T, OP>(args, state, result, true);
-		break;
-	default:
-		throw NotImplementedException("This function has not been implemented for this type");
-	}
-}
-
 static void ListContainsFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	return ListContainsOrPosition<bool, ContainsFunctor>(args, state, result);
+	(void)state;
+	return ListContainsOrPosition<bool, ContainsFunctor, ListArgFunctor>(args, result);
 }
 
 static void ListPositionFunction(DataChunk &args, ExpressionState &state, Vector &result) {
-	return ListContainsOrPosition<int32_t, PositionFunctor>(args, state, result);
+	(void)state;
+	return ListContainsOrPosition<int32_t, PositionFunctor, ListArgFunctor>(args, result);
 }
 
 template <LogicalTypeId RETURN_TYPE>

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

@@ -1,7 +1,7 @@
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/storage/statistics/list_statistics.hpp"
+#include "duckdb/storage/statistics/list_stats.hpp"
 
 namespace duckdb {
 
@@ -121,17 +121,10 @@ static unique_ptr<FunctionData> ListFlattenBind(ClientContext &context, ScalarFu
 
 static unique_ptr<BaseStatistics> ListFlattenStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
-	if (!child_stats[0]) {
-		return nullptr;
-	}
-	auto &list_stats = (ListStatistics &)*child_stats[0];
-	if (!list_stats.child_stats || list_stats.child_stats->type == LogicalTypeId::SQLNULL) {
-		return nullptr;
-	}
-
-	auto child_copy = list_stats.child_stats->Copy();
-	child_copy->validity_stats = make_unique<ValidityStatistics>(true);
-	return child_copy;
+	auto &list_child_stats = ListStats::GetChildStats(child_stats[0]);
+	auto child_copy = list_child_stats.Copy();
+	child_copy.Set(StatsInfo::CAN_HAVE_NULL_VALUES);
+	return child_copy.ToUnique();
 }
 
 void ListFlattenFun::RegisterFunction(BuiltinFunctions &set) {

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

@@ -507,7 +507,7 @@ ScalarFunction ListUniqueFun::GetFunction() {
 }
 
 void ListAggregateFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction({"list_aggregate", "array_aggregate", "list_aggr", "array_aggr"}, GetFunction());
+	set.AddFunction({"list_aggregate", "array_aggregate", "list_aggr", "array_aggr", "aggregate"}, GetFunction());
 }
 
 void ListDistinctFun::RegisterFunction(BuiltinFunctions &set) {

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

@@ -3,8 +3,6 @@
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
 #include "duckdb/planner/expression_binder.hpp"
-#include "duckdb/storage/statistics/list_statistics.hpp"
-#include "duckdb/storage/statistics/validity_statistics.hpp"
 
 namespace duckdb {
 
@@ -84,9 +82,10 @@ static unique_ptr<FunctionData> ListConcatBind(ClientContext &context, ScalarFun
 		throw ParameterNotResolvedException();
 	} else if (lhs.id() == LogicalTypeId::SQLNULL || rhs.id() == LogicalTypeId::SQLNULL) {
 		// we mimic postgres behaviour: list_concat(NULL, my_list) = my_list
-		bound_function.arguments[0] = lhs;
-		bound_function.arguments[1] = rhs;
-		bound_function.return_type = rhs.id() == LogicalTypeId::SQLNULL ? lhs : rhs;
+		auto return_type = rhs.id() == LogicalTypeId::SQLNULL ? lhs : rhs;
+		bound_function.arguments[0] = return_type;
+		bound_function.arguments[1] = return_type;
+		bound_function.return_type = return_type;
 	} else {
 		D_ASSERT(lhs.id() == LogicalTypeId::LIST);
 		D_ASSERT(rhs.id() == LogicalTypeId::LIST);
@@ -96,7 +95,7 @@ static unique_ptr<FunctionData> ListConcatBind(ClientContext &context, ScalarFun
 		for (const auto &argument : arguments) {
 			child_type = LogicalType::MaxLogicalType(child_type, ListType::GetChildType(argument->return_type));
 		}
-		auto list_type = LogicalType::LIST(std::move(child_type));
+		auto list_type = LogicalType::LIST(child_type);
 
 		bound_function.arguments[0] = list_type;
 		bound_function.arguments[1] = list_type;
@@ -108,14 +107,11 @@ static unique_ptr<FunctionData> ListConcatBind(ClientContext &context, ScalarFun
 static unique_ptr<BaseStatistics> ListConcatStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
 	D_ASSERT(child_stats.size() == 2);
-	if (!child_stats[0] || !child_stats[1]) {
-		return nullptr;
-	}
 
-	auto &left_stats = (ListStatistics &)*child_stats[0];
-	auto &right_stats = (ListStatistics &)*child_stats[1];
+	auto &left_stats = child_stats[0];
+	auto &right_stats = child_stats[1];
 
-	auto stats = left_stats.Copy();
+	auto stats = left_stats.ToUnique();
 	stats->Merge(right_stats);
 
 	return stats;

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

@@ -7,8 +7,7 @@
 #include "duckdb/function/scalar/string_functions.hpp"
 #include "duckdb/parser/expression/bound_expression.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
-#include "duckdb/storage/statistics/list_statistics.hpp"
-#include "duckdb/storage/statistics/validity_statistics.hpp"
+#include "duckdb/storage/statistics/list_stats.hpp"
 
 namespace duckdb {
 
@@ -212,17 +211,11 @@ static unique_ptr<FunctionData> ListExtractBind(ClientContext &context, ScalarFu
 
 static unique_ptr<BaseStatistics> ListExtractStats(ClientContext &context, FunctionStatisticsInput &input) {
 	auto &child_stats = input.child_stats;
-	if (!child_stats[0]) {
-		return nullptr;
-	}
-	auto &list_stats = (ListStatistics &)*child_stats[0];
-	if (!list_stats.child_stats) {
-		return nullptr;
-	}
-	auto child_copy = list_stats.child_stats->Copy();
+	auto &list_child_stats = ListStats::GetChildStats(child_stats[0]);
+	auto child_copy = list_child_stats.Copy();
 	// list_extract always pushes a NULL, since if the offset is out of range for a list it inserts a null
-	child_copy->validity_stats = make_unique<ValidityStatistics>(true);
-	return child_copy;
+	child_copy.Set(StatsInfo::CAN_HAVE_NULL_VALUES);
+	return child_copy.ToUnique();
 }
 
 void ListExtractFun::RegisterFunction(BuiltinFunctions &set) {

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

@@ -124,7 +124,7 @@ static void ExecuteExpression(vector<LogicalType> &types, vector<LogicalType> &r
 	// set the other vectors
 	vector<Vector> slices;
 	for (idx_t col_idx = 0; col_idx < args.ColumnCount() - 1; col_idx++) {
-		slices.emplace_back(Vector(args.data[col_idx + 1], sel_vectors[col_idx], elem_cnt));
+		slices.emplace_back(args.data[col_idx + 1], sel_vectors[col_idx], elem_cnt);
 		slices[col_idx].Flatten(elem_cnt);
 		input_chunk.data[col_idx + 2].Reference(slices[col_idx]);
 	}
@@ -195,10 +195,10 @@ static void ListLambdaFunction(DataChunk &args, ExpressionState &state, Vector &
 
 	// skip the list column
 	for (idx_t i = 1; i < args.ColumnCount(); i++) {
-		columns.emplace_back(UnifiedVectorFormat());
+		columns.emplace_back();
 		args.data[i].ToUnifiedFormat(count, columns[i - 1]);
 		indexes.push_back(0);
-		sel_vectors.emplace_back(SelectionVector(STANDARD_VECTOR_SIZE));
+		sel_vectors.emplace_back(STANDARD_VECTOR_SIZE);
 		types.push_back(args.data[i].GetType());
 	}
 
@@ -392,6 +392,8 @@ void ListTransformFun::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(fun);
 	fun.name = "array_apply";
 	set.AddFunction(fun);
+	fun.name = "apply";
+	set.AddFunction(fun);
 }
 
 void ListFilterFun::RegisterFunction(BuiltinFunctions &set) {
@@ -405,6 +407,8 @@ void ListFilterFun::RegisterFunction(BuiltinFunctions &set) {
 
 	fun.name = "array_filter";
 	set.AddFunction(fun);
+	fun.name = "filter";
+	set.AddFunction(fun);
 }
 
 } // namespace duckdb