duckdb 0.7.2-dev12.0 → 0.7.2-dev1238.0

package/src/duckdb/src/function/cast/struct_cast.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/function/cast/default_casts.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
+#include "duckdb/function/cast/bound_cast_data.hpp"
 
 namespace duckdb {
 
@@ -18,8 +19,24 @@ unique_ptr<BoundCastData> StructBoundCastData::BindStructToStructCast(BindCastIn
 	return make_unique<StructBoundCastData>(std::move(child_cast_info), target);
 }
 
+unique_ptr<FunctionLocalState> StructBoundCastData::InitStructCastLocalState(CastLocalStateParameters &parameters) {
+	auto &cast_data = (StructBoundCastData &)*parameters.cast_data;
+	auto result = make_unique<StructCastLocalState>();
+
+	for (auto &entry : cast_data.child_cast_info) {
+		unique_ptr<FunctionLocalState> child_state;
+		if (entry.init_local_state) {
+			CastLocalStateParameters child_params(parameters, entry.cast_data);
+			child_state = entry.init_local_state(child_params);
+		}
+		result->local_states.push_back(std::move(child_state));
+	}
+	return std::move(result);
+}
+
 static bool StructToStructCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	auto &cast_data = (StructBoundCastData &)*parameters.cast_data;
+	auto &lstate = (StructCastLocalState &)*parameters.local_state;
 	auto &source_child_types = StructType::GetChildTypes(source.GetType());
 	auto &source_children = StructVector::GetEntries(source);
 	D_ASSERT(source_children.size() == StructType::GetChildTypes(result.GetType()).size());
@@ -29,7 +46,8 @@ static bool StructToStructCast(Vector &source, Vector &result, idx_t count, Cast
 	for (idx_t c_idx = 0; c_idx < source_child_types.size(); c_idx++) {
 		auto &result_child_vector = *result_children[c_idx];
 		auto &source_child_vector = *source_children[c_idx];
-		CastParameters child_parameters(parameters, cast_data.child_cast_info[c_idx].cast_data.get());
+		CastParameters child_parameters(parameters, cast_data.child_cast_info[c_idx].cast_data,
+		                                lstate.local_states[c_idx]);
 		if (!cast_data.child_cast_info[c_idx].function(source_child_vector, result_child_vector, count,
 		                                               child_parameters)) {
 			all_converted = false;
@@ -121,7 +139,8 @@ BoundCastInfo DefaultCasts::StructCastSwitch(BindCastInput &input, const Logical
                                              const LogicalType &target) {
 	switch (target.id()) {
 	case LogicalTypeId::STRUCT:
-		return BoundCastInfo(StructToStructCast, StructBoundCastData::BindStructToStructCast(input, source, target));
+		return BoundCastInfo(StructToStructCast, StructBoundCastData::BindStructToStructCast(input, source, target),
+		                     StructBoundCastData::InitStructCastLocalState);
 	case LogicalTypeId::VARCHAR: {
 		// bind a cast in which we convert all child entries to VARCHAR entries
 		auto &struct_children = StructType::GetChildTypes(source);
@@ -129,9 +148,10 @@ BoundCastInfo DefaultCasts::StructCastSwitch(BindCastInput &input, const Logical
 		for (auto &child_entry : struct_children) {
 			varchar_children.push_back(make_pair(child_entry.first, LogicalType::VARCHAR));
 		}
-		auto varchar_type = LogicalType::STRUCT(std::move(varchar_children));
+		auto varchar_type = LogicalType::STRUCT(varchar_children);
 		return BoundCastInfo(StructToVarcharCast,
-		                     StructBoundCastData::BindStructToStructCast(input, source, varchar_type));
+		                     StructBoundCastData::BindStructToStructCast(input, source, varchar_type),
+		                     StructBoundCastData::InitStructCastLocalState);
 	}
 	default:
 		return TryVectorNullCast;

package/src/duckdb/src/function/cast/time_casts.cpp

@@ -69,7 +69,7 @@ BoundCastInfo DefaultCasts::TimestampCastSwitch(BindCastInput &input, const Logi
 		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_t, duckdb::Cast>);
 	case LogicalTypeId::TIMESTAMP_TZ:
 		// timestamp (us) to timestamp with time zone
-		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::Cast>);
+		return ReinterpretCast;
 	case LogicalTypeId::TIMESTAMP_NS:
 		// timestamp (us) to timestamp (ns)
 		return BoundCastInfo(
@@ -100,7 +100,7 @@ BoundCastInfo DefaultCasts::TimestampTzCastSwitch(BindCastInput &input, const Lo
 		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, dtime_t, duckdb::Cast>);
 	case LogicalTypeId::TIMESTAMP:
 		// timestamp with time zone to timestamp (us)
-		return BoundCastInfo(&VectorCastHelpers::TemplatedCastLoop<timestamp_t, timestamp_t, duckdb::Cast>);
+		return ReinterpretCast;
 	default:
 		return TryVectorNullCast;
 	}

package/src/duckdb/src/function/cast/union_casts.cpp

@@ -1,6 +1,6 @@
 #include "duckdb/function/cast/cast_function_set.hpp"
 #include "duckdb/function/cast/default_casts.hpp"
-#include "duckdb/function/cast/vector_cast_helpers.hpp"
+#include "duckdb/function/cast/bound_cast_data.hpp"
 
 #include <algorithm> // for std::sort
 
@@ -98,12 +98,21 @@ unique_ptr<BoundCastData> BindToUnionCast(BindCastInput &input, const LogicalTyp
 	return make_unique<ToUnionBoundCastData>(std::move(selected_cast));
 }
 
+unique_ptr<FunctionLocalState> InitToUnionLocalState(CastLocalStateParameters &parameters) {
+	auto &cast_data = (ToUnionBoundCastData &)*parameters.cast_data;
+	if (!cast_data.member_cast_info.init_local_state) {
+		return nullptr;
+	}
+	CastLocalStateParameters child_parameters(parameters, cast_data.member_cast_info.cast_data);
+	return cast_data.member_cast_info.init_local_state(child_parameters);
+}
+
 static bool ToUnionCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	D_ASSERT(result.GetType().id() == LogicalTypeId::UNION);
 	auto &cast_data = (ToUnionBoundCastData &)*parameters.cast_data;
 	auto &selected_member_vector = UnionVector::GetMember(result, cast_data.tag);
 
-	CastParameters child_parameters(parameters, cast_data.member_cast_info.cast_data.get());
+	CastParameters child_parameters(parameters, cast_data.member_cast_info.cast_data, parameters.local_state);
 	if (!cast_data.member_cast_info.function(source, selected_member_vector, count, child_parameters)) {
 		return false;
 	}
@@ -118,7 +127,7 @@ static bool ToUnionCast(Vector &source, Vector &result, idx_t count, CastParamet
 
 BoundCastInfo DefaultCasts::ImplicitToUnionCast(BindCastInput &input, const LogicalType &source,
                                                 const LogicalType &target) {
-	return BoundCastInfo(&ToUnionCast, BindToUnionCast(input, source, target));
+	return BoundCastInfo(&ToUnionCast, BindToUnionCast(input, source, target), InitToUnionLocalState);
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -197,8 +206,24 @@ unique_ptr<BoundCastData> BindUnionToUnionCast(BindCastInput &input, const Logic
 	return make_unique<UnionToUnionBoundCastData>(tag_map, std::move(member_casts), target);
 }
 
+unique_ptr<FunctionLocalState> InitUnionToUnionLocalState(CastLocalStateParameters &parameters) {
+	auto &cast_data = (UnionToUnionBoundCastData &)*parameters.cast_data;
+	auto result = make_unique<StructCastLocalState>();
+
+	for (auto &entry : cast_data.member_casts) {
+		unique_ptr<FunctionLocalState> child_state;
+		if (entry.init_local_state) {
+			CastLocalStateParameters child_params(parameters, entry.cast_data);
+			child_state = entry.init_local_state(child_params);
+		}
+		result->local_states.push_back(std::move(child_state));
+	}
+	return std::move(result);
+}
+
 static bool UnionToUnionCast(Vector &source, Vector &result, idx_t count, CastParameters &parameters) {
 	auto &cast_data = (UnionToUnionBoundCastData &)*parameters.cast_data;
+	auto &lstate = (StructCastLocalState &)*parameters.local_state;
 
 	auto source_member_count = UnionType::GetMemberCount(source.GetType());
 	auto target_member_count = UnionType::GetMemberCount(result.GetType());
@@ -213,7 +238,7 @@ static bool UnionToUnionCast(Vector &source, Vector &result, idx_t count, CastPa
 		auto &target_member_vector = UnionVector::GetMember(result, target_member_idx);
 		auto &member_cast = cast_data.member_casts[member_idx];
 
-		CastParameters child_parameters(parameters, member_cast.cast_data.get());
+		CastParameters child_parameters(parameters, member_cast.cast_data, lstate.local_states[member_idx]);
 		if (!member_cast.function(source_member_vector, target_member_vector, count, child_parameters)) {
 			return false;
 		}
@@ -339,10 +364,11 @@ BoundCastInfo DefaultCasts::UnionCastSwitch(BindCastInput &input, const LogicalT
 			varchar_members.push_back(make_pair(UnionType::GetMemberName(source, member_idx), LogicalType::VARCHAR));
 		}
 		auto varchar_type = LogicalType::UNION(std::move(varchar_members));
-		return BoundCastInfo(UnionToVarcharCast, BindUnionToUnionCast(input, source, varchar_type));
-	} break;
+		return BoundCastInfo(UnionToVarcharCast, BindUnionToUnionCast(input, source, varchar_type),
+		                     InitUnionToUnionLocalState);
+	}
 	case LogicalTypeId::UNION:
-		return BoundCastInfo(UnionToUnionCast, BindUnionToUnionCast(input, source, target));
+		return BoundCastInfo(UnionToUnionCast, BindUnionToUnionCast(input, source, target), InitUnionToUnionLocalState);
 	default:
 		return TryVectorNullCast;
 	}

package/src/duckdb/src/function/cast_rules.cpp

@@ -207,6 +207,15 @@ int64_t CastRules::ImplicitCast(const LogicalType &from, const LogicalType &to)
 		// if aliases are different, an implicit cast is not possible
 		return -1;
 	}
+	if (from.id() == LogicalTypeId::LIST && to.id() == LogicalTypeId::LIST) {
+		// Lists can be cast if their child types can be cast
+		auto child_cost = ImplicitCast(ListType::GetChildType(from), ListType::GetChildType(to));
+		if (child_cost >= 100) {
+			// subtract one from the cost because we prefer LIST[X] -> LIST[VARCHAR] over LIST[X] -> VARCHAR
+			child_cost--;
+		}
+		return child_cost;
+	}
 	if (from.id() == to.id()) {
 		// arguments match: do nothing
 		return 0;
@@ -219,10 +228,6 @@ int64_t CastRules::ImplicitCast(const LogicalType &from, const LogicalType &to)
 		// everything can be cast to VARCHAR, but this cast has a high cost
 		return TargetTypeCost(to);
 	}
-	if (from.id() == LogicalTypeId::LIST && to.id() == LogicalTypeId::LIST) {
-		// Lists can be cast if their child types can be cast
-		return ImplicitCast(ListType::GetChildType(from), ListType::GetChildType(to));
-	}
 
 	if (from.id() == LogicalTypeId::UNION && to.id() == LogicalTypeId::UNION) {
 		// Unions can be cast if the source tags are a subset of the target tags

package/src/duckdb/src/function/function_binder.cpp

@@ -294,8 +294,7 @@ unique_ptr<BoundFunctionExpression> FunctionBinder::BindScalarFunction(ScalarFun
 unique_ptr<BoundAggregateExpression> FunctionBinder::BindAggregateFunction(AggregateFunction bound_function,
                                                                            vector<unique_ptr<Expression>> children,
                                                                            unique_ptr<Expression> filter,
-                                                                           AggregateType aggr_type,
-                                                                           unique_ptr<BoundOrderModifier> order_bys) {
+                                                                           AggregateType aggr_type) {
 	unique_ptr<FunctionData> bind_info;
 	if (bound_function.bind) {
 		bind_info = bound_function.bind(context, bound_function, children);
@@ -306,12 +305,6 @@ unique_ptr<BoundAggregateExpression> FunctionBinder::BindAggregateFunction(Aggre
 	// check if we need to add casts to the children
 	CastToFunctionArguments(bound_function, children);
 
-	// Special case: for ORDER BY aggregates, we wrap the aggregate function in a SortedAggregateFunction
-	// The children are the sort clauses and the binding contains the ordering data.
-	if (order_bys && !order_bys->orders.empty()) {
-		bind_info = BindSortedAggregate(bound_function, children, std::move(bind_info), std::move(order_bys));
-	}
-
 	return make_unique<BoundAggregateExpression>(std::move(bound_function), std::move(children), std::move(filter),
 	                                             std::move(bind_info), aggr_type);
 }

package/src/duckdb/src/function/pragma/pragma_queries.cpp

@@ -1,8 +1,11 @@
+#include "duckdb/catalog/catalog_search_path.hpp"
 #include "duckdb/common/constants.hpp"
 #include "duckdb/common/file_system.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/function/pragma/pragma_functions.hpp"
 #include "duckdb/main/config.hpp"
+#include "duckdb/main/database_manager.hpp"
+#include "duckdb/main/client_data.hpp"
 #include "duckdb/parser/parser.hpp"
 #include "duckdb/parser/qualified_name.hpp"
 #include "duckdb/parser/statement/copy_statement.hpp"
@@ -15,7 +18,27 @@ string PragmaTableInfo(ClientContext &context, const FunctionParameters &paramet
 }
 
 string PragmaShowTables(ClientContext &context, const FunctionParameters &parameters) {
-	return "SELECT name FROM sqlite_master ORDER BY name;";
+	auto catalog = DatabaseManager::GetDefaultDatabase(context);
+	auto schema = ClientData::Get(context).catalog_search_path->GetDefault().schema;
+	schema = (schema == INVALID_SCHEMA) ? DEFAULT_SCHEMA : schema; // NOLINT
+
+	auto where_clause =
+	    StringUtil::Join({"where database_name = '", catalog, "' and schema_name = '", schema, "'"}, "");
+	// clang-format off
+	auto pragma_query = StringUtil::Join(
+	    {"with tables as (", 
+						"	SELECT table_name as name FROM duckdb_tables ", where_clause, 
+			 "), views as (",
+						"	SELECT view_name as name FROM duckdb_views ", where_clause, 
+			 "), indexes as (",
+						"	SELECT index_name as name FROM duckdb_indexes ", where_clause, 
+			 "), db_objects as (",
+						"	SELECT name FROM tables UNION ALL SELECT name FROM views UNION ALL SELECT name FROM indexes",
+	     ") SELECT name FROM db_objects ORDER BY name;"
+			}, "");
+	// clang-format on
+
+	return pragma_query;
 }
 
 string PragmaShowTablesExpanded(ClientContext &context, const FunctionParameters &parameters) {

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;
 }