duckdb 0.8.2-dev4711.0 → 0.8.2-dev5002.0

package/src/duckdb/src/common/types/row/tuple_data_scatter_gather.cpp

@@ -66,7 +66,7 @@ inline string_t TupleDataWithinListValueLoad(const data_ptr_t &location, data_pt
 static void ResetCombinedListData(vector<TupleDataVectorFormat> &vector_data) {
 	for (auto &vd : vector_data) {
 		vd.combined_list_data = nullptr;
-		ResetCombinedListData(vd.child_formats);
+		ResetCombinedListData(vd.children);
 	}
 }
 #endif
@@ -102,7 +102,7 @@ void TupleDataCollection::ComputeHeapSizes(Vector &heap_sizes_v, const Vector &s
 
 	auto heap_sizes = FlatVector::GetData<idx_t>(heap_sizes_v);
 
-	const auto &source_vector_data = source_format.data;
+	const auto &source_vector_data = source_format.unified;
 	const auto &source_sel = *source_vector_data.sel;
 	const auto &source_validity = source_vector_data.validity;
 
@@ -125,7 +125,7 @@ void TupleDataCollection::ComputeHeapSizes(Vector &heap_sizes_v, const Vector &s
 		auto &struct_sources = StructVector::GetEntries(source_v);
 		for (idx_t struct_col_idx = 0; struct_col_idx < struct_sources.size(); struct_col_idx++) {
 			const auto &struct_source = struct_sources[struct_col_idx];
-			auto &struct_format = source_format.child_formats[struct_col_idx];
+			auto &struct_format = source_format.children[struct_col_idx];
 			TupleDataCollection::ComputeHeapSizes(heap_sizes_v, *struct_source, struct_format, append_sel,
 			                                      append_count);
 		}
@@ -141,9 +141,9 @@ void TupleDataCollection::ComputeHeapSizes(Vector &heap_sizes_v, const Vector &s
 		}
 
 		// Recurse
-		D_ASSERT(source_format.child_formats.size() == 1);
+		D_ASSERT(source_format.children.size() == 1);
 		auto &child_source_v = ListVector::GetEntry(source_v);
-		auto &child_format = source_format.child_formats[0];
+		auto &child_format = source_format.children[0];
 		TupleDataCollection::WithinListHeapComputeSizes(heap_sizes_v, child_source_v, child_format, append_sel,
 		                                                append_count, source_vector_data);
 		break;
@@ -217,8 +217,8 @@ void TupleDataCollection::StringWithinListComputeHeapSizes(Vector &heap_sizes_v,
                                                            const SelectionVector &append_sel, const idx_t append_count,
                                                            const UnifiedVectorFormat &list_data) {
 	// Source
-	const auto &source_data = source_format.data;
-	const auto source_sel = *source_data.sel;
+	const auto &source_data = source_format.unified;
+	const auto &source_sel = *source_data.sel;
 	const auto data = UnifiedVectorFormat::GetData<string_t>(source_data);
 	const auto &source_validity = source_data.validity;
 
@@ -285,7 +285,7 @@ void TupleDataCollection::StructWithinListComputeHeapSizes(Vector &heap_sizes_v,
 	auto &struct_sources = StructVector::GetEntries(source_v);
 	for (idx_t struct_col_idx = 0; struct_col_idx < struct_sources.size(); struct_col_idx++) {
 		auto &struct_source = *struct_sources[struct_col_idx];
-		auto &struct_format = source_format.child_formats[struct_col_idx];
+		auto &struct_format = source_format.children[struct_col_idx];
 		TupleDataCollection::WithinListHeapComputeSizes(heap_sizes_v, struct_source, struct_format, append_sel,
 		                                                append_count, list_data);
 	}
@@ -297,22 +297,22 @@ static void ApplySliceRecursive(const Vector &source_v, TupleDataVectorFormat &s
 	auto &combined_list_data = *source_format.combined_list_data;
 
 	combined_list_data.selection_data = source_format.original_sel->Slice(combined_sel, count);
-	source_format.data.owned_sel.Initialize(combined_list_data.selection_data);
-	source_format.data.sel = &source_format.data.owned_sel;
+	source_format.unified.owned_sel.Initialize(combined_list_data.selection_data);
+	source_format.unified.sel = &source_format.unified.owned_sel;
 
 	if (source_v.GetType().InternalType() == PhysicalType::STRUCT) {
 		// We have to apply it to the child vectors too
 		auto &struct_sources = StructVector::GetEntries(source_v);
 		for (idx_t struct_col_idx = 0; struct_col_idx < struct_sources.size(); struct_col_idx++) {
 			auto &struct_source = *struct_sources[struct_col_idx];
-			auto &struct_format = source_format.child_formats[struct_col_idx];
+			auto &struct_format = source_format.children[struct_col_idx];
 #ifdef DEBUG
 			D_ASSERT(!struct_format.combined_list_data);
 #endif
 			if (!struct_format.combined_list_data) {
 				struct_format.combined_list_data = make_uniq<CombinedListData>();
 			}
-			ApplySliceRecursive(struct_source, struct_format, *source_format.data.sel, count);
+			ApplySliceRecursive(struct_source, struct_format, *source_format.unified.sel, count);
 		}
 	}
 }
@@ -327,7 +327,7 @@ void TupleDataCollection::ListWithinListComputeHeapSizes(Vector &heap_sizes_v, c
 	const auto &list_validity = list_data.validity;
 
 	// Child list ("source_v")
-	const auto &child_list_data = source_format.data;
+	const auto &child_list_data = source_format.unified;
 	const auto child_list_sel = *child_list_data.sel;
 	const auto child_list_entries = UnifiedVectorFormat::GetData<list_entry_t>(child_list_data);
 	const auto &child_list_validity = child_list_data.validity;
@@ -362,7 +362,7 @@ void TupleDataCollection::ListWithinListComputeHeapSizes(Vector &heap_sizes_v, c
 	auto heap_sizes = FlatVector::GetData<idx_t>(heap_sizes_v);
 
 	// Construct combined list entries and a selection vector for the child list child
-	auto &child_format = source_format.child_formats[0];
+	auto &child_format = source_format.children[0];
 #ifdef DEBUG
 	// In debug mode this should be deleted by ResetCombinedListData
 	D_ASSERT(!child_format.combined_list_data);
@@ -425,7 +425,7 @@ void TupleDataCollection::ListWithinListComputeHeapSizes(Vector &heap_sizes_v, c
 	combined_child_list_data.validity = list_data.validity;
 
 	// Combine the selection vectors
-	D_ASSERT(source_format.child_formats.size() == 1);
+	D_ASSERT(source_format.children.size() == 1);
 	auto &child_source = ListVector::GetEntry(source_v);
 	ApplySliceRecursive(child_source, child_format, combined_sel, child_list_child_count);
 
@@ -464,18 +464,18 @@ void TupleDataCollection::Scatter(TupleDataChunkState &chunk_state, const Vector
 	const auto &scatter_function = scatter_functions[column_id];
 	scatter_function.function(source, chunk_state.vector_data[column_id], append_sel, append_count, layout,
 	                          chunk_state.row_locations, chunk_state.heap_locations, column_id,
-	                          chunk_state.vector_data[column_id].data, scatter_function.child_functions);
+	                          chunk_state.vector_data[column_id].unified, scatter_function.child_functions);
 }
 
 template <class T>
 static void TupleDataTemplatedScatter(const Vector &source, const TupleDataVectorFormat &source_format,
                                       const SelectionVector &append_sel, const idx_t append_count,
-                                      const TupleDataLayout &layout, Vector &row_locations, Vector &heap_locations,
-                                      const idx_t col_idx, const UnifiedVectorFormat &dummy_arg,
+                                      const TupleDataLayout &layout, const Vector &row_locations,
+                                      Vector &heap_locations, const idx_t col_idx, const UnifiedVectorFormat &dummy_arg,
                                       const vector<TupleDataScatterFunction> &child_functions) {
 	// Source
-	const auto &source_data = source_format.data;
-	const auto source_sel = *source_data.sel;
+	const auto &source_data = source_format.unified;
+	const auto &source_sel = *source_data.sel;
 	const auto data = UnifiedVectorFormat::GetData<T>(source_data);
 	const auto &validity = source_data.validity;
 
@@ -509,12 +509,12 @@ static void TupleDataTemplatedScatter(const Vector &source, const TupleDataVecto
 
 static void TupleDataStructScatter(const Vector &source, const TupleDataVectorFormat &source_format,
                                    const SelectionVector &append_sel, const idx_t append_count,
-                                   const TupleDataLayout &layout, Vector &row_locations, Vector &heap_locations,
+                                   const TupleDataLayout &layout, const Vector &row_locations, Vector &heap_locations,
                                    const idx_t col_idx, const UnifiedVectorFormat &dummy_arg,
                                    const vector<TupleDataScatterFunction> &child_functions) {
 	// Source
-	const auto &source_data = source_format.data;
-	const auto source_sel = *source_data.sel;
+	const auto &source_data = source_format.unified;
+	const auto &source_sel = *source_data.sel;
 	const auto &validity = source_data.validity;
 
 	// Target
@@ -556,7 +556,7 @@ static void TupleDataStructScatter(const Vector &source, const TupleDataVectorFo
 	// Recurse through the struct children
 	for (idx_t struct_col_idx = 0; struct_col_idx < struct_layout.ColumnCount(); struct_col_idx++) {
 		auto &struct_source = *struct_sources[struct_col_idx];
-		const auto &struct_source_format = source_format.child_formats[struct_col_idx];
+		const auto &struct_source_format = source_format.children[struct_col_idx];
 		const auto &struct_scatter_function = child_functions[struct_col_idx];
 		struct_scatter_function.function(struct_source, struct_source_format, append_sel, append_count, struct_layout,
 		                                 struct_row_locations, heap_locations, struct_col_idx, dummy_arg,
@@ -566,12 +566,12 @@ static void TupleDataStructScatter(const Vector &source, const TupleDataVectorFo
 
 static void TupleDataListScatter(const Vector &source, const TupleDataVectorFormat &source_format,
                                  const SelectionVector &append_sel, const idx_t append_count,
-                                 const TupleDataLayout &layout, Vector &row_locations, Vector &heap_locations,
+                                 const TupleDataLayout &layout, const Vector &row_locations, Vector &heap_locations,
                                  const idx_t col_idx, const UnifiedVectorFormat &dummy_arg,
                                  const vector<TupleDataScatterFunction> &child_functions) {
 	// Source
-	const auto &source_data = source_format.data;
-	const auto source_sel = *source_data.sel;
+	const auto &source_data = source_format.unified;
+	const auto &source_sel = *source_data.sel;
 	const auto data = UnifiedVectorFormat::GetData<list_entry_t>(source_data);
 	const auto &validity = source_data.validity;
 
@@ -603,22 +603,22 @@ static void TupleDataListScatter(const Vector &source, const TupleDataVectorForm
 	// Recurse
 	D_ASSERT(child_functions.size() == 1);
 	auto &child_source = ListVector::GetEntry(source);
-	auto &child_format = source_format.child_formats[0];
+	auto &child_format = source_format.children[0];
 	const auto &child_function = child_functions[0];
 	child_function.function(child_source, child_format, append_sel, append_count, layout, row_locations, heap_locations,
-	                        col_idx, source_format.data, child_function.child_functions);
+	                        col_idx, source_format.unified, child_function.child_functions);
 }
 
 template <class T>
 static void TupleDataTemplatedWithinListScatter(const Vector &source, const TupleDataVectorFormat &source_format,
                                                 const SelectionVector &append_sel, const idx_t append_count,
-                                                const TupleDataLayout &layout, Vector &row_locations,
+                                                const TupleDataLayout &layout, const Vector &row_locations,
                                                 Vector &heap_locations, const idx_t col_idx,
                                                 const UnifiedVectorFormat &list_data,
                                                 const vector<TupleDataScatterFunction> &child_functions) {
 	// Source
-	const auto &source_data = source_format.data;
-	const auto source_sel = *source_data.sel;
+	const auto &source_data = source_format.unified;
+	const auto &source_sel = *source_data.sel;
 	const auto data = UnifiedVectorFormat::GetData<T>(source_data);
 	const auto &source_validity = source_data.validity;
 
@@ -667,13 +667,13 @@ static void TupleDataTemplatedWithinListScatter(const Vector &source, const Tupl
 
 static void TupleDataStructWithinListScatter(const Vector &source, const TupleDataVectorFormat &source_format,
                                              const SelectionVector &append_sel, const idx_t append_count,
-                                             const TupleDataLayout &layout, Vector &row_locations,
+                                             const TupleDataLayout &layout, const Vector &row_locations,
                                              Vector &heap_locations, const idx_t col_idx,
                                              const UnifiedVectorFormat &list_data,
                                              const vector<TupleDataScatterFunction> &child_functions) {
 	// Source
-	const auto &source_data = source_format.data;
-	const auto source_sel = *source_data.sel;
+	const auto &source_data = source_format.unified;
+	const auto &source_sel = *source_data.sel;
 	const auto &source_validity = source_data.validity;
 
 	// List data
@@ -715,7 +715,7 @@ static void TupleDataStructWithinListScatter(const Vector &source, const TupleDa
 	auto &struct_sources = StructVector::GetEntries(source);
 	for (idx_t struct_col_idx = 0; struct_col_idx < struct_sources.size(); struct_col_idx++) {
 		auto &struct_source = *struct_sources[struct_col_idx];
-		auto &struct_format = source_format.child_formats[struct_col_idx];
+		auto &struct_format = source_format.children[struct_col_idx];
 		const auto &struct_scatter_function = child_functions[struct_col_idx];
 		struct_scatter_function.function(struct_source, struct_format, append_sel, append_count, layout, row_locations,
 		                                 heap_locations, struct_col_idx, list_data,
@@ -725,8 +725,9 @@ static void TupleDataStructWithinListScatter(const Vector &source, const TupleDa
 
 static void TupleDataListWithinListScatter(const Vector &child_list, const TupleDataVectorFormat &child_list_format,
                                            const SelectionVector &append_sel, const idx_t append_count,
-                                           const TupleDataLayout &layout, Vector &row_locations, Vector &heap_locations,
-                                           const idx_t col_idx, const UnifiedVectorFormat &list_data,
+                                           const TupleDataLayout &layout, const Vector &row_locations,
+                                           Vector &heap_locations, const idx_t col_idx,
+                                           const UnifiedVectorFormat &list_data,
                                            const vector<TupleDataScatterFunction> &child_functions) {
 	// List data (of the list Vector that "child_list" is in)
 	const auto list_sel = *list_data.sel;
@@ -734,7 +735,7 @@ static void TupleDataListWithinListScatter(const Vector &child_list, const Tuple
 	const auto &list_validity = list_data.validity;
 
 	// Child list
-	const auto &child_list_data = child_list_format.data;
+	const auto &child_list_data = child_list_format.unified;
 	const auto child_list_sel = *child_list_data.sel;
 	const auto child_list_entries = UnifiedVectorFormat::GetData<list_entry_t>(child_list_data);
 	const auto &child_list_validity = child_list_data.validity;
@@ -777,7 +778,7 @@ static void TupleDataListWithinListScatter(const Vector &child_list, const Tuple
 	// Recurse
 	D_ASSERT(child_functions.size() == 1);
 	auto &child_vec = ListVector::GetEntry(child_list);
-	auto &child_format = child_list_format.child_formats[0];
+	auto &child_format = child_list_format.children[0];
 	auto &combined_child_list_data = child_format.combined_list_data->combined_data;
 	const auto &child_function = child_functions[0];
 	child_function.function(child_vec, child_format, append_sel, append_count, layout, row_locations, heap_locations,
@@ -899,7 +900,7 @@ static void TupleDataTemplatedGather(const TupleDataLayout &layout, Vector &row_
 		const auto &source_row = source_locations[scan_sel.get_index(i)];
 		const auto target_idx = target_sel.get_index(i);
 		ValidityBytes row_mask(source_row);
-		if (row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry)) {
+		if (row_mask.RowIsValid(row_mask.GetValidityEntryUnsafe(entry_idx), idx_in_entry)) {
 			target_data[target_idx] = Load<T>(source_row + offset_in_row);
 		} else {
 			target_validity.SetInvalid(target_idx);
@@ -932,7 +933,7 @@ static void TupleDataStructGather(const TupleDataLayout &layout, Vector &row_loc
 
 		// Set the validity
 		ValidityBytes row_mask(source_row);
-		if (!row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry)) {
+		if (!row_mask.RowIsValid(row_mask.GetValidityEntryUnsafe(entry_idx), idx_in_entry)) {
 			const auto target_idx = target_sel.get_index(i);
 			target_validity.SetInvalid(target_idx);
 		}
@@ -985,7 +986,7 @@ static void TupleDataListGather(const TupleDataLayout &layout, Vector &row_locat
 
 		const auto &source_row = source_locations[source_idx];
 		ValidityBytes row_mask(source_row);
-		if (row_mask.RowIsValid(row_mask.GetValidityEntry(entry_idx), idx_in_entry)) {
+		if (row_mask.RowIsValid(row_mask.GetValidityEntryUnsafe(entry_idx), idx_in_entry)) {
 			auto &source_heap_location = source_heap_locations[source_idx];
 			source_heap_location = Load<data_ptr_t>(source_row + offset_in_row);
 

package/src/duckdb/src/common/types/vector.cpp

@@ -960,7 +960,6 @@ void Vector::Serialize(Serializer &serializer, idx_t count) {
 			break;
 		}
 		case PhysicalType::STRUCT: {
-			Flatten(count);
 			auto &entries = StructVector::GetEntries(*this);
 
 			// Serialize entries as a list

package/src/duckdb/src/common/types.cpp

@@ -434,7 +434,7 @@ LogicalType TransformStringToLogicalType(const string &str) {
 
 LogicalType GetUserTypeRecursive(const LogicalType &type, ClientContext &context) {
 	if (type.id() == LogicalTypeId::USER && type.HasAlias()) {
-		return Catalog::GetSystemCatalog(context).GetType(context, SYSTEM_CATALOG, DEFAULT_SCHEMA, type.GetAlias());
+		return Catalog::GetType(context, INVALID_CATALOG, INVALID_SCHEMA, type.GetAlias());
 	}
 	// Look for LogicalTypeId::USER in nested types
 	if (type.id() == LogicalTypeId::STRUCT) {

package/src/duckdb/src/common/vector_operations/vector_hash.cpp

@@ -103,6 +103,7 @@ static inline void ListLoopHash(Vector &input, Vector &hashes, const SelectionVe
 	Vector child_hashes(LogicalType::HASH, child_count);
 	if (child_count > 0) {
 		VectorOperations::Hash(child, child_hashes, child_count);
+		child_hashes.Flatten(child_count);
 	}
 	auto chdata = FlatVector::GetData<hash_t>(child_hashes);
 

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

@@ -274,7 +274,7 @@ static StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_AGGREGATE_FUNCTION(RegrSXXFun),
 	DUCKDB_AGGREGATE_FUNCTION(RegrSXYFun),
 	DUCKDB_AGGREGATE_FUNCTION(RegrSYYFun),
-	DUCKDB_SCALAR_FUNCTION(RepeatFun),
+	DUCKDB_SCALAR_FUNCTION_SET(RepeatFun),
 	DUCKDB_SCALAR_FUNCTION(ReplaceFun),
 	DUCKDB_AGGREGATE_FUNCTION_SET(ReservoirQuantileFun),
 	DUCKDB_SCALAR_FUNCTION(ReverseFun),

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

@@ -35,6 +35,7 @@ DatePartSpecifier GetDateTypePartSpecifier(const string &specifier, LogicalType
 		case DatePartSpecifier::DOY:
 		case DatePartSpecifier::YEARWEEK:
 		case DatePartSpecifier::ERA:
+		case DatePartSpecifier::EPOCH:
 		case DatePartSpecifier::JULIAN_DAY:
 			return part;
 		default:
@@ -465,7 +466,7 @@ struct DatePart {
 
 		template <class T>
 		static unique_ptr<BaseStatistics> PropagateStatistics(ClientContext &context, FunctionStatisticsInput &input) {
-			return PropagateDatePartStatistics<T, EpochOperator>(input.child_stats);
+			return PropagateDatePartStatistics<T, EpochOperator, double>(input.child_stats, LogicalType::DOUBLE);
 		}
 	};
 
@@ -574,6 +575,8 @@ struct DatePart {
 				case DatePartSpecifier::TIMEZONE_MINUTE:
 					mask |= ZONE;
 					break;
+				case DatePartSpecifier::INVALID:
+					throw InternalException("Invalid DatePartSpecifier for STRUCT mask!");
 				}
 			}
 			return mask;
@@ -581,12 +584,11 @@ struct DatePart {
 
 		template <typename P>
 		static inline P HasPartValue(vector<P> part_values, DatePartSpecifier part) {
-			static const auto BEGIN_DOUBLE = size_t(DatePartSpecifier::JULIAN_DAY);
 			auto idx = size_t(part);
 			if (IsBigintDatepart(part)) {
-				return part_values[idx];
+				return part_values[idx - size_t(DatePartSpecifier::BEGIN_BIGINT)];
 			} else {
-				return part_values[idx - BEGIN_DOUBLE];
+				return part_values[idx - size_t(DatePartSpecifier::BEGIN_DOUBLE)];
 			}
 		}
 
@@ -670,9 +672,9 @@ struct DatePart {
 			}
 
 			if (mask & EPOCH) {
-				bigint_data = HasPartValue(bigint_values, DatePartSpecifier::EPOCH);
-				if (bigint_data) {
-					bigint_data[idx] = Date::Epoch(input);
+				auto double_data = HasPartValue(double_values, DatePartSpecifier::EPOCH);
+				if (double_data) {
+					double_data[idx] = Date::Epoch(input);
 				}
 			}
 			if (mask & DOY) {
@@ -1016,12 +1018,12 @@ int64_t DatePart::HoursOperator::Operation(dtime_t input) {
 }
 
 template <>
-int64_t DatePart::EpochOperator::Operation(timestamp_t input) {
-	return Timestamp::GetEpochSeconds(input);
+double DatePart::EpochOperator::Operation(timestamp_t input) {
+	return Timestamp::GetEpochMicroSeconds(input) / double(Interval::MICROS_PER_SEC);
 }
 
 template <>
-int64_t DatePart::EpochOperator::Operation(interval_t input) {
+double DatePart::EpochOperator::Operation(interval_t input) {
 	int64_t interval_years = input.months / Interval::MONTHS_PER_YEAR;
 	int64_t interval_days;
 	interval_days = Interval::DAYS_PER_YEAR * interval_years;
@@ -1031,20 +1033,29 @@ int64_t DatePart::EpochOperator::Operation(interval_t input) {
 	interval_epoch = interval_days * Interval::SECS_PER_DAY;
 	// we add 0.25 days per year to sort of account for leap days
 	interval_epoch += interval_years * (Interval::SECS_PER_DAY / 4);
-	interval_epoch += input.micros / Interval::MICROS_PER_SEC;
-	return interval_epoch;
+	return interval_epoch + input.micros / double(Interval::MICROS_PER_SEC);
+}
+
+//	TODO: We can't propagate interval statistics because we can't easily compare interval_t for order.
+template <>
+unique_ptr<BaseStatistics> DatePart::EpochOperator::PropagateStatistics<interval_t>(ClientContext &context,
+                                                                                    FunctionStatisticsInput &input) {
+	return nullptr;
 }
 
 template <>
-int64_t DatePart::EpochOperator::Operation(dtime_t input) {
-	return input.micros / Interval::MICROS_PER_SEC;
+double DatePart::EpochOperator::Operation(dtime_t input) {
+	return input.micros / double(Interval::MICROS_PER_SEC);
 }
 
 template <>
 unique_ptr<BaseStatistics> DatePart::EpochOperator::PropagateStatistics<dtime_t>(ClientContext &context,
                                                                                  FunctionStatisticsInput &input) {
-	// time seconds range over a single day
-	return PropagateSimpleDatePartStatistics<0, 86400>(input.child_stats);
+	auto result = NumericStats::CreateEmpty(LogicalType::DOUBLE);
+	result.CopyValidity(input.child_stats[0]);
+	NumericStats::SetMin(result, Value::DOUBLE(0));
+	NumericStats::SetMax(result, Value::DOUBLE(Interval::SECS_PER_DAY));
+	return result.ToUnique();
 }
 
 template <>
@@ -1121,9 +1132,9 @@ void DatePart::StructOperator::Operation(bigint_vec &bigint_values, double_vec &
 	}
 
 	if (mask & EPOCH) {
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::EPOCH);
+		auto part_data = HasPartValue(double_values, DatePartSpecifier::EPOCH);
 		if (part_data) {
-			part_data[idx] = EpochOperator::Operation<dtime_t, int64_t>(input);
+			part_data[idx] = EpochOperator::Operation<dtime_t, double>(input);
 			;
 		}
 	}
@@ -1157,9 +1168,9 @@ void DatePart::StructOperator::Operation(bigint_vec &bigint_values, double_vec &
 	Operation(bigint_values, double_values, t, idx, mask & ~EPOCH);
 
 	if (mask & EPOCH) {
-		auto part_data = HasPartValue(bigint_values, DatePartSpecifier::EPOCH);
+		auto part_data = HasPartValue(double_values, DatePartSpecifier::EPOCH);
 		if (part_data) {
-			part_data[idx] = EpochOperator::Operation<timestamp_t, int64_t>(input);
+			part_data[idx] = EpochOperator::Operation<timestamp_t, double>(input);
 		}
 	}
 
@@ -1232,9 +1243,9 @@ void DatePart::StructOperator::Operation(bigint_vec &bigint_values, double_vec &
 	}
 
 	if (mask & EPOCH) {
-		part_data = HasPartValue(bigint_values, DatePartSpecifier::EPOCH);
+		auto part_data = HasPartValue(double_values, DatePartSpecifier::EPOCH);
 		if (part_data) {
-			part_data[idx] = EpochOperator::Operation<interval_t, int64_t>(input);
+			part_data[idx] = EpochOperator::Operation<interval_t, double>(input);
 		}
 	}
 }
@@ -1268,8 +1279,6 @@ static int64_t ExtractElement(DatePartSpecifier type, T element) {
 		return DatePart::ISOYearOperator::template Operation<T, int64_t>(element);
 	case DatePartSpecifier::YEARWEEK:
 		return DatePart::YearWeekOperator::template Operation<T, int64_t>(element);
-	case DatePartSpecifier::EPOCH:
-		return DatePart::EpochOperator::template Operation<T, int64_t>(element);
 	case DatePartSpecifier::MICROSECONDS:
 		return DatePart::MicrosecondsOperator::template Operation<T, int64_t>(element);
 	case DatePartSpecifier::MILLISECONDS:
@@ -1317,9 +1326,6 @@ static unique_ptr<FunctionData> DatePartBind(ClientContext &context, ScalarFunct
 	}
 
 	Value part_value = ExpressionExecutor::EvaluateScalar(context, *arguments[0]);
-	if (part_value.IsNull()) {
-		return nullptr;
-	}
 	const auto part_name = part_value.ToString();
 	switch (GetDatePartSpecifier(part_name)) {
 	case DatePartSpecifier::JULIAN_DAY:
@@ -1340,6 +1346,32 @@ static unique_ptr<FunctionData> DatePartBind(ClientContext &context, ScalarFunct
 			throw BinderException("%s can only take DATE or TIMESTAMP arguments", bound_function.name);
 		}
 		break;
+	case DatePartSpecifier::EPOCH:
+		arguments.erase(arguments.begin());
+		bound_function.arguments.erase(bound_function.arguments.begin());
+		bound_function.name = "epoch";
+		bound_function.return_type = LogicalType::DOUBLE;
+		switch (arguments[0]->return_type.id()) {
+		case LogicalType::TIMESTAMP:
+			bound_function.function = DatePart::UnaryFunction<timestamp_t, double, DatePart::EpochOperator>;
+			bound_function.statistics = DatePart::EpochOperator::template PropagateStatistics<timestamp_t>;
+			break;
+		case LogicalType::DATE:
+			bound_function.function = DatePart::UnaryFunction<date_t, double, DatePart::EpochOperator>;
+			bound_function.statistics = DatePart::EpochOperator::template PropagateStatistics<date_t>;
+			break;
+		case LogicalType::INTERVAL:
+			bound_function.function = DatePart::UnaryFunction<interval_t, double, DatePart::EpochOperator>;
+			bound_function.statistics = DatePart::EpochOperator::template PropagateStatistics<interval_t>;
+			break;
+		case LogicalType::TIME:
+			bound_function.function = DatePart::UnaryFunction<dtime_t, double, DatePart::EpochOperator>;
+			bound_function.statistics = DatePart::EpochOperator::template PropagateStatistics<dtime_t>;
+			break;
+		default:
+			throw BinderException("%s can only take temporal arguments", bound_function.name);
+		}
+		break;
 	default:
 		break;
 	}
@@ -1367,26 +1399,26 @@ static ScalarFunctionSet GetDatePartFunction() {
 	    OP::template PropagateStatistics<timestamp_t>);
 }
 
-ScalarFunctionSet GetGenericTimePartFunction(scalar_function_t date_func, scalar_function_t ts_func,
-                                             scalar_function_t interval_func, scalar_function_t time_func,
-                                             function_statistics_t date_stats, function_statistics_t ts_stats,
-                                             function_statistics_t time_stats) {
+ScalarFunctionSet GetGenericTimePartFunction(const LogicalType &result_type, scalar_function_t date_func,
+                                             scalar_function_t ts_func, scalar_function_t interval_func,
+                                             scalar_function_t time_func, function_statistics_t date_stats,
+                                             function_statistics_t ts_stats, function_statistics_t time_stats) {
 	ScalarFunctionSet operator_set;
 	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::DATE}, LogicalType::BIGINT, std::move(date_func), nullptr, nullptr, date_stats));
+	    ScalarFunction({LogicalType::DATE}, result_type, std::move(date_func), nullptr, nullptr, date_stats));
 	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::TIMESTAMP}, LogicalType::BIGINT, std::move(ts_func), nullptr, nullptr, ts_stats));
-	operator_set.AddFunction(ScalarFunction({LogicalType::INTERVAL}, LogicalType::BIGINT, std::move(interval_func)));
+	    ScalarFunction({LogicalType::TIMESTAMP}, result_type, std::move(ts_func), nullptr, nullptr, ts_stats));
+	operator_set.AddFunction(ScalarFunction({LogicalType::INTERVAL}, result_type, std::move(interval_func)));
 	operator_set.AddFunction(
-	    ScalarFunction({LogicalType::TIME}, LogicalType::BIGINT, std::move(time_func), nullptr, nullptr, time_stats));
+	    ScalarFunction({LogicalType::TIME}, result_type, std::move(time_func), nullptr, nullptr, time_stats));
 	return operator_set;
 }
 
-template <class OP>
-static ScalarFunctionSet GetTimePartFunction() {
+template <class OP, class TR = int64_t>
+static ScalarFunctionSet GetTimePartFunction(const LogicalType &result_type = LogicalType::BIGINT) {
 	return GetGenericTimePartFunction(
-	    DatePart::UnaryFunction<date_t, int64_t, OP>, DatePart::UnaryFunction<timestamp_t, int64_t, OP>,
-	    ScalarFunction::UnaryFunction<interval_t, int64_t, OP>, ScalarFunction::UnaryFunction<dtime_t, int64_t, OP>,
+	    result_type, DatePart::UnaryFunction<date_t, TR, OP>, DatePart::UnaryFunction<timestamp_t, TR, OP>,
+	    ScalarFunction::UnaryFunction<interval_t, TR, OP>, ScalarFunction::UnaryFunction<dtime_t, TR, OP>,
 	    OP::template PropagateStatistics<date_t>, OP::template PropagateStatistics<timestamp_t>,
 	    OP::template PropagateStatistics<dtime_t>);
 }
@@ -1425,10 +1457,6 @@ struct DayNameOperator {
 struct StructDatePart {
 	using part_codes_t = vector<DatePartSpecifier>;
 
-	static const auto BEGIN_BIGINT = size_t(DatePartSpecifier::YEAR);
-	static const auto BEGIN_DOUBLE = size_t(DatePartSpecifier::JULIAN_DAY);
-	static const auto BEGIN_INVALID = size_t(DatePartSpecifier::JULIAN_DAY) + 1;
-
 	struct BindData : public VariableReturnBindData {
 		part_codes_t part_codes;
 
@@ -1492,8 +1520,12 @@ struct StructDatePart {
 
 		const auto count = args.size();
 		Vector &input = args.data[0];
-		DatePart::StructOperator::bigint_vec bigint_values(size_t(BEGIN_DOUBLE), nullptr);
-		DatePart::StructOperator::double_vec double_values(BEGIN_INVALID - size_t(BEGIN_DOUBLE), nullptr);
+
+		//	Type counts
+		const auto BIGINT_COUNT = size_t(DatePartSpecifier::BEGIN_DOUBLE) - size_t(DatePartSpecifier::BEGIN_BIGINT);
+		const auto DOUBLE_COUNT = size_t(DatePartSpecifier::BEGIN_INVALID) - size_t(DatePartSpecifier::BEGIN_DOUBLE);
+		DatePart::StructOperator::bigint_vec bigint_values(BIGINT_COUNT, nullptr);
+		DatePart::StructOperator::double_vec double_values(DOUBLE_COUNT, nullptr);
 		const auto part_mask = DatePart::StructOperator::GetMask(info.part_codes);
 
 		auto &child_entries = StructVector::GetEntries(result);
@@ -1521,9 +1553,11 @@ struct StructDatePart {
 					const auto part_index = size_t(info.part_codes[col]);
 					if (owners[part_index] == col) {
 						if (IsBigintDatepart(info.part_codes[col])) {
-							bigint_values[part_index - BEGIN_BIGINT] = ConstantVector::GetData<int64_t>(*child_entry);
+							bigint_values[part_index - size_t(DatePartSpecifier::BEGIN_BIGINT)] =
+							    ConstantVector::GetData<int64_t>(*child_entry);
 						} else {
-							double_values[part_index - BEGIN_DOUBLE] = ConstantVector::GetData<double>(*child_entry);
+							double_values[part_index - size_t(DatePartSpecifier::BEGIN_DOUBLE)] =
+							    ConstantVector::GetData<double>(*child_entry);
 						}
 					}
 				}
@@ -1563,9 +1597,11 @@ struct StructDatePart {
 				const auto part_index = size_t(info.part_codes[col]);
 				if (owners[part_index] == col) {
 					if (IsBigintDatepart(info.part_codes[col])) {
-						bigint_values[part_index - BEGIN_BIGINT] = FlatVector::GetData<int64_t>(*child_entry);
+						bigint_values[part_index - size_t(DatePartSpecifier::BEGIN_BIGINT)] =
+						    FlatVector::GetData<int64_t>(*child_entry);
 					} else {
-						double_values[part_index - BEGIN_DOUBLE] = FlatVector::GetData<double>(*child_entry);
+						double_values[part_index - size_t(DatePartSpecifier::BEGIN_DOUBLE)] =
+						    FlatVector::GetData<double>(*child_entry);
 					}
 				}
 			}
@@ -1694,7 +1730,7 @@ ScalarFunctionSet TimezoneMinuteFun::GetFunctions() {
 }
 
 ScalarFunctionSet EpochFun::GetFunctions() {
-	return GetTimePartFunction<DatePart::EpochOperator>();
+	return GetTimePartFunction<DatePart::EpochOperator, double>(LogicalType::DOUBLE);
 }
 
 ScalarFunctionSet EpochNsFun::GetFunctions() {

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

@@ -4,6 +4,9 @@ namespace duckdb {
 
 static void HashFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	args.Hash(result);
+	if (args.AllConstant()) {
+		result.SetVectorType(VectorType::CONSTANT_VECTOR);
+	}
 }
 
 ScalarFunction HashFun::GetFunction() {

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

@@ -191,9 +191,11 @@ static void ExecuteConstantSlice(Vector &result, Vector &str_vector, Vector &beg
 	}
 
 	auto sel_length = 0;
+	bool sel_valid = false;
 	if (step_vector && step_valid && str_valid && begin_valid && end_valid && step != 1 && end - begin > 0) {
 		sel_length = CalculateSliceLength(begin, end, step, step_valid);
 		sel.Initialize(sel_length);
+		sel_valid = true;
 	}
 
 	// Try to slice
@@ -205,8 +207,9 @@ static void ExecuteConstantSlice(Vector &result, Vector &str_vector, Vector &beg
 		result_data[0] = SliceValueWithSteps<INPUT_TYPE, INDEX_TYPE>(result, sel, str, begin, end, step, sel_idx);
 	}
 
-	if (step_vector && step != 0 && end - begin > 0) {
+	if (sel_valid) {
 		result_child_vector->Slice(sel, sel_length);
+		ListVector::SetListSize(result, sel_length);
 	}
 }
 
@@ -276,6 +279,7 @@ static void ExecuteFlatSlice(Vector &result, Vector &list_vector, Vector &begin_
 			new_sel.set_index(i, sel.get_index(i));
 		}
 		result_child_vector->Slice(new_sel, sel_length);
+		ListVector::SetListSize(result, sel_length);
 	}
 }