duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

package/src/duckdb/src/include/duckdb/common/types/column/partitioned_column_data.hpp

@@ -8,6 +8,8 @@
 
 #pragma once
 
+#include "duckdb/common/fixed_size_map.hpp"
+#include "duckdb/common/optional_idx.hpp"
 #include "duckdb/common/perfect_map_set.hpp"
 #include "duckdb/common/types/column/column_data_allocator.hpp"
 #include "duckdb/common/types/column/column_data_collection.hpp"
@@ -23,13 +25,47 @@ public:
 public:
 	Vector partition_indices;
 	SelectionVector partition_sel;
+
+	static constexpr idx_t MAP_THRESHOLD = 256;
 	perfect_map_t<list_entry_t> partition_entries;
+	fixed_size_map_t<list_entry_t> fixed_partition_entries;
+
 	DataChunk slice_chunk;
 
 	vector<unique_ptr<DataChunk>> partition_buffers;
 	vector<unique_ptr<ColumnDataAppendState>> partition_append_states;
+
+public:
+	template <bool fixed>
+	typename std::conditional<fixed, fixed_size_map_t<list_entry_t>, perfect_map_t<list_entry_t>>::type &GetMap() {
+		throw NotImplementedException("PartitionedColumnDataAppendState::GetMap for boolean value");
+	}
+
+	optional_idx GetPartitionIndexIfSinglePartition(const bool use_fixed_size_map) {
+		optional_idx result;
+		if (use_fixed_size_map) {
+			if (fixed_partition_entries.size() == 1) {
+				result = fixed_partition_entries.begin().GetKey();
+			}
+		} else {
+			if (partition_entries.size() == 1) {
+				result = partition_entries.begin()->first;
+			}
+		}
+		return result;
+	}
 };
 
+template <>
+inline perfect_map_t<list_entry_t> &PartitionedColumnDataAppendState::GetMap<false>() {
+	return partition_entries;
+}
+
+template <>
+inline fixed_size_map_t<list_entry_t> &PartitionedColumnDataAppendState::GetMap<true>() {
+	return fixed_partition_entries;
+}
+
 enum class PartitionedColumnDataType : uint8_t {
 	INVALID,
 	//! Radix partitioning on a hash column
@@ -80,6 +116,12 @@ protected:
 	virtual void ComputePartitionIndices(PartitionedColumnDataAppendState &state, DataChunk &input) {
 		throw NotImplementedException("ComputePartitionIndices for this type of PartitionedColumnData");
 	}
+	//!
+
+	//! Maximum partition index (optional)
+	virtual idx_t MaxPartitionIndex() const {
+		return DConstants::INVALID_INDEX;
+	}
 
 protected:
 	//! PartitionedColumnData can only be instantiated by derived classes
@@ -93,6 +135,16 @@ protected:
 	}
 	//! Create a new shared allocator
 	void CreateAllocator();
+	//! Whether to use fixed size map or regular map
+	bool UseFixedSizeMap() const;
+	//! Builds a selection vector in the Append state for the partitions
+	//! - returns true if everything belongs to the same partition - stores partition index in single_partition_idx
+	void BuildPartitionSel(PartitionedColumnDataAppendState &state, const idx_t append_count) const;
+	template <bool fixed>
+	static void BuildPartitionSel(PartitionedColumnDataAppendState &state, const idx_t append_count);
+	//! Appends a DataChunk to this PartitionedColumnData
+	template <bool fixed>
+	void AppendInternal(PartitionedColumnDataAppendState &state, DataChunk &input);
 	//! Create a collection for a specific a partition
 	unique_ptr<ColumnDataCollection> CreatePartitionCollection(idx_t partition_index) const {
 		return make_uniq<ColumnDataCollection>(allocators->allocators[partition_index], types);

package/src/duckdb/src/include/duckdb/common/types/data_chunk.hpp

@@ -73,6 +73,8 @@ public:
 	DUCKDB_API Value GetValue(idx_t col_idx, idx_t index) const;
 	DUCKDB_API void SetValue(idx_t col_idx, idx_t index, const Value &val);
 
+	idx_t GetAllocationSize() const;
+
 	//! Returns true if all vectors in the DataChunk are constant
 	DUCKDB_API bool AllConstant() const;
 

package/src/duckdb/src/include/duckdb/common/types/date.hpp

@@ -173,9 +173,6 @@ public:
 
 	//! Extract year of a date entry
 	DUCKDB_API static int32_t ExtractYear(date_t date);
-	//! Extract year of a date entry, but optimized to first try the last year found
-	DUCKDB_API static int32_t ExtractYear(date_t date, int32_t *last_year);
-	DUCKDB_API static int32_t ExtractYear(timestamp_t ts, int32_t *last_year);
 	//! Extract month of a date entry
 	DUCKDB_API static int32_t ExtractMonth(date_t date);
 	//! Extract day of a date entry

package/src/duckdb/src/include/duckdb/common/types/date_lookup_cache.hpp

@@ -0,0 +1,65 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/types/date_lookup_cache.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/types/date.hpp"
+#include "duckdb/common/types/timestamp.hpp"
+#include "duckdb/common/types/value.hpp"
+#include "duckdb/common/types/validity_mask.hpp"
+
+namespace duckdb {
+struct ValidityMask;
+
+template <class OP>
+class DateLookupCache {
+public:
+	using CACHE_TYPE = uint16_t;
+	constexpr static int32_t CACHE_MIN_DATE = 0;     // 1970-01-01
+	constexpr static int32_t CACHE_MAX_DATE = 29584; // 2050-12-31
+
+public:
+	DateLookupCache() {
+		BuildCache();
+	}
+
+	//! Extracts the component, or sets the validity mask to NULL if the date is infinite
+	int64_t ExtractElement(date_t date, ValidityMask &mask, idx_t idx) const {
+		if (DUCKDB_UNLIKELY(date.days < CACHE_MIN_DATE || date.days > CACHE_MAX_DATE)) {
+			if (DUCKDB_UNLIKELY(!Value::IsFinite(date))) {
+				mask.SetInvalid(idx);
+				return 0;
+			}
+			return OP::template Operation<date_t, int64_t>(date);
+		}
+		return cache[GetDateCacheEntry(date)];
+	}
+	int64_t ExtractElement(timestamp_t ts, ValidityMask &mask, idx_t idx) const {
+		return ExtractElement(Timestamp::GetDate(ts), mask, idx);
+	}
+
+private:
+	static idx_t GetDateCacheEntry(date_t day) {
+		return UnsafeNumericCast<idx_t>(day.days - DateLookupCache::CACHE_MIN_DATE);
+	}
+
+	void BuildCache() {
+		D_ASSERT(CACHE_MAX_DATE > CACHE_MIN_DATE);
+		cache = make_unsafe_uniq_array_uninitialized<CACHE_TYPE>(CACHE_MAX_DATE - CACHE_MIN_DATE);
+		for (int32_t d = CACHE_MIN_DATE; d < CACHE_MAX_DATE; d++) {
+			date_t date(d);
+			auto cache_entry = OP::template Operation<date_t, int64_t>(date);
+			cache[GetDateCacheEntry(date)] = UnsafeNumericCast<CACHE_TYPE>(cache_entry);
+		}
+	}
+
+private:
+	unsafe_unique_array<CACHE_TYPE> cache;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/datetime.hpp

@@ -24,7 +24,7 @@ struct dtime_t { // NOLINT
 		return micros;
 	}
 	explicit inline operator double() const {
-		return micros;
+		return static_cast<double>(micros);
 	}
 
 	// comparison operators
@@ -108,7 +108,10 @@ struct dtime_tz_t { // NOLINT
 	}
 
 	static inline uint64_t encode_micros(int64_t micros) { // NOLINT
-		return uint64_t(micros) << OFFSET_BITS;
+		return encode_micros(UnsafeNumericCast<uint64_t>(micros));
+	}
+	static inline uint64_t encode_micros(uint64_t micros) { // NOLINT
+		return micros << OFFSET_BITS;
 	}
 	static inline int64_t decode_micros(uint64_t bits) { // NOLINT
 		return int64_t(bits >> OFFSET_BITS);

package/src/duckdb/src/include/duckdb/common/types/hyperloglog.hpp

@@ -8,63 +8,72 @@
 
 #pragma once
 
-#include "duckdb/common/mutex.hpp"
+#include "duckdb/common/bit_utils.hpp"
 #include "duckdb/common/types/vector.hpp"
-#include "hyperloglog.hpp"
-
-namespace duckdb_hll {
-struct robj; // NOLINT
-}
 
 namespace duckdb {
 
-enum class HLLStorageType : uint8_t { UNCOMPRESSED = 1 };
+enum class HLLStorageType : uint8_t {
+	HLL_V1 = 1, //! Redis HLL
+	HLL_V2 = 2, //! Our own implementation
+};
 
 class Serializer;
 class Deserializer;
 
-//! The HyperLogLog class holds a HyperLogLog counter for approximate cardinality counting
+//! Algorithms from
+//! "New cardinality estimation algorithms for HyperLogLog sketches"
+//! Otmar Ertl, arXiv:1702.01284
 class HyperLogLog {
 public:
-	HyperLogLog();
-	~HyperLogLog();
-	// implicit copying of HyperLogLog is not allowed
-	HyperLogLog(const HyperLogLog &) = delete;
-
-	//! Adds an element of the specified size to the HyperLogLog counter
-	void Add(data_ptr_t element, idx_t size);
-	//! Return the count of this HyperLogLog counter
+	static constexpr idx_t P = 6;
+	static constexpr idx_t Q = 64 - P;
+	static constexpr idx_t M = 1 << P;
+	static constexpr double ALPHA = 0.721347520444481703680; // 1 / (2 log(2))
+
+public:
+	HyperLogLog() {
+		memset(k, 0, sizeof(k));
+	}
+
+	//! Algorithm 1
+	inline void InsertElement(hash_t h) {
+		const auto i = h & ((1 << P) - 1);
+		h >>= P;
+		h |= hash_t(1) << Q;
+		const uint8_t z = UnsafeNumericCast<uint8_t>(CountZeros<hash_t>::Trailing(h) + 1);
+		Update(i, z);
+	}
+
+	inline void Update(const idx_t &i, const uint8_t &z) {
+		k[i] = MaxValue<uint8_t>(k[i], z);
+	}
+
+	inline uint8_t GetRegister(const idx_t &i) const {
+		return k[i];
+	}
+
 	idx_t Count() const;
-	//! Merge this HyperLogLog counter with another counter to create a new one
-	unique_ptr<HyperLogLog> Merge(HyperLogLog &other);
-	HyperLogLog *MergePointer(HyperLogLog &other);
-	//! Merge a set of HyperLogLogs to create one big one
-	static unique_ptr<HyperLogLog> Merge(HyperLogLog logs[], idx_t count);
-	//! Get the size (in bytes) of a HLL
-	static idx_t GetSize();
-	//! Get pointer to the HLL
-	data_ptr_t GetPtr() const;
+
+	//! Algorithm 2
+	void Merge(const HyperLogLog &other);
+
+public:
+	//! Add data to this HLL
+	void Update(Vector &input, Vector &hashes, idx_t count);
 	//! Get copy of the HLL
-	unique_ptr<HyperLogLog> Copy();
+	unique_ptr<HyperLogLog> Copy() const;
 
 	void Serialize(Serializer &serializer) const;
 	static unique_ptr<HyperLogLog> Deserialize(Deserializer &deserializer);
 
-public:
-	//! Compute HLL hashes over vdata, and store them in 'hashes'
-	//! Then, compute register indices and prefix lengths, and also store them in 'hashes' as a pair of uint32_t
-	static void ProcessEntries(UnifiedVectorFormat &vdata, const LogicalType &type, uint64_t hashes[], uint8_t counts[],
-	                           idx_t count);
-	//! Add the indices and counts to the logs
-	static void AddToLogs(UnifiedVectorFormat &vdata, idx_t count, uint64_t indices[], uint8_t counts[],
-	                      HyperLogLog **logs[], const SelectionVector *log_sel);
-	//! Add the indices and counts to THIS log
-	void AddToLog(UnifiedVectorFormat &vdata, idx_t count, uint64_t indices[], uint8_t counts[]);
+	//! Algorithm 4
+	void ExtractCounts(uint32_t *c) const;
+	//! Algorithm 6
+	static int64_t EstimateCardinality(uint32_t *c);
 
 private:
-	explicit HyperLogLog(duckdb_hll::robj *hll);
-
-	duckdb_hll::robj *hll;
-	mutex lock;
+	uint8_t k[M];
 };
+
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/interval.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/types.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 
 namespace duckdb {
 
@@ -40,6 +41,9 @@ struct interval_t { // NOLINT
 
 		return lmonths == rmonths && ldays == rdays && lmicros == rmicros;
 	}
+	inline bool operator!=(const interval_t &right) const {
+		return !(*this == right);
+	}
 
 	inline bool operator>(const interval_t &right) const {
 		const auto &left = *this;
@@ -165,7 +169,7 @@ void interval_t::Normalize(int64_t &months, int64_t &days, int64_t &micros) cons
 	auto input = *this;
 	int64_t extra_months_d = input.days / Interval::DAYS_PER_MONTH;
 	int64_t extra_months_micros = input.micros / Interval::MICROS_PER_MONTH;
-	input.days -= extra_months_d * Interval::DAYS_PER_MONTH;
+	input.days -= UnsafeNumericCast<int32_t>(extra_months_d * Interval::DAYS_PER_MONTH);
 	input.micros -= extra_months_micros * Interval::MICROS_PER_MONTH;
 
 	int64_t extra_days_micros = input.micros / Interval::MICROS_PER_DAY;

package/src/duckdb/src/include/duckdb/common/types/list_segment.hpp

@@ -15,7 +15,7 @@
 namespace duckdb {
 
 struct ListSegment {
-	constexpr const static idx_t INITIAL_CAPACITY = 4;
+	constexpr const static uint16_t INITIAL_CAPACITY = 4;
 
 	uint16_t count;
 	uint16_t capacity;
@@ -46,6 +46,7 @@ struct ListSegmentFunctions {
 	create_segment_t create_segment;
 	write_data_to_segment_t write_data;
 	read_data_from_segment_t read_data;
+	uint16_t initial_capacity = ListSegment::INITIAL_CAPACITY;
 
 	vector<ListSegmentFunctions> child_functions;
 

package/src/duckdb/src/include/duckdb/common/types/row/partitioned_tuple_data.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/fixed_size_map.hpp"
+#include "duckdb/common/optional_idx.hpp"
 #include "duckdb/common/perfect_map_set.hpp"
 #include "duckdb/common/types/row/tuple_data_allocator.hpp"
 #include "duckdb/common/types/row/tuple_data_collection.hpp"
@@ -30,10 +31,40 @@ public:
 	perfect_map_t<list_entry_t> partition_entries;
 	fixed_size_map_t<list_entry_t> fixed_partition_entries;
 
-	vector<unique_ptr<TupleDataPinState>> partition_pin_states;
+	unsafe_vector<unsafe_unique_ptr<TupleDataPinState>> partition_pin_states;
 	TupleDataChunkState chunk_state;
+
+public:
+	template <bool fixed>
+	typename std::conditional<fixed, fixed_size_map_t<list_entry_t>, perfect_map_t<list_entry_t>>::type &GetMap() {
+		throw NotImplementedException("PartitionedTupleDataAppendState::GetMap for boolean value");
+	}
+
+	optional_idx GetPartitionIndexIfSinglePartition(const bool use_fixed_size_map) {
+		optional_idx result;
+		if (use_fixed_size_map) {
+			if (fixed_partition_entries.size() == 1) {
+				result = fixed_partition_entries.begin().GetKey();
+			}
+		} else {
+			if (partition_entries.size() == 1) {
+				result = partition_entries.begin()->first;
+			}
+		}
+		return result;
+	}
 };
 
+template <>
+inline perfect_map_t<list_entry_t> &PartitionedTupleDataAppendState::GetMap<false>() {
+	return partition_entries;
+}
+
+template <>
+inline fixed_size_map_t<list_entry_t> &PartitionedTupleDataAppendState::GetMap<true>() {
+	return fixed_partition_entries;
+}
+
 enum class PartitionedTupleDataType : uint8_t {
 	INVALID,
 	//! Radix partitioning on a hash column
@@ -109,7 +140,8 @@ protected:
 	//! Compute the partition indices for this type of partitioning for the input DataChunk and store them in the
 	//! `partition_data` of the local state. If this type creates partitions on the fly (for, e.g., hive), this
 	//! function is also in charge of creating new partitions and mapping the input data to a partition index
-	virtual void ComputePartitionIndices(PartitionedTupleDataAppendState &state, DataChunk &input) {
+	virtual void ComputePartitionIndices(PartitionedTupleDataAppendState &state, DataChunk &input,
+	                                     const SelectionVector &append_sel, const idx_t append_count) {
 		throw NotImplementedException("ComputePartitionIndices for this type of PartitionedTupleData");
 	}
 	//! Compute partition indices from rows (similar to function above)
@@ -138,19 +170,19 @@ protected:
 
 	//! Create a new shared allocator
 	void CreateAllocator();
-	//! Whether to use fixed size map or regular marp
+	//! Whether to use fixed size map or regular map
 	bool UseFixedSizeMap() const;
 	//! Builds a selection vector in the Append state for the partitions
 	//! - returns true if everything belongs to the same partition - stores partition index in single_partition_idx
 	void BuildPartitionSel(PartitionedTupleDataAppendState &state, const SelectionVector &append_sel,
-	                       const idx_t append_count);
-	template <class MAP_TYPE, class GETTER>
-	void BuildPartitionSel(PartitionedTupleDataAppendState &state, MAP_TYPE &partition_entries,
-	                       const SelectionVector &append_sel, const idx_t append_count);
+	                       const idx_t append_count) const;
+	template <bool fixed>
+	static void BuildPartitionSel(PartitionedTupleDataAppendState &state, const SelectionVector &append_sel,
+	                              const idx_t append_count);
 	//! Builds out the buffer space in the partitions
 	void BuildBufferSpace(PartitionedTupleDataAppendState &state);
-	template <class MAP_TYPE, class GETTER>
-	void BuildBufferSpace(PartitionedTupleDataAppendState &state, const MAP_TYPE &partition_entries);
+	template <bool fixed>
+	void BuildBufferSpace(PartitionedTupleDataAppendState &state);
 	//! Create a collection for a specific a partition
 	unique_ptr<TupleDataCollection> CreatePartitionCollection(idx_t partition_index) const {
 		if (allocators) {

package/src/duckdb/src/include/duckdb/common/types/row/row_data_collection.hpp

@@ -19,10 +19,11 @@ struct RowDataBlock {
 public:
 	RowDataBlock(MemoryTag tag, BufferManager &buffer_manager, idx_t capacity, idx_t entry_size)
 	    : capacity(capacity), entry_size(entry_size), count(0), byte_offset(0) {
-		idx_t size = MaxValue<idx_t>(Storage::BLOCK_SIZE, capacity * entry_size);
+		auto size = MaxValue<idx_t>(buffer_manager.GetBlockSize(), capacity * entry_size);
 		buffer_manager.Allocate(tag, size, false, &block);
 		D_ASSERT(BufferManager::GetAllocSize(size) == block->GetMemoryUsage());
 	}
+
 	explicit RowDataBlock(idx_t entry_size) : entry_size(entry_size) {
 	}
 	//! The buffer block handle
@@ -114,8 +115,8 @@ public:
 #endif
 	}
 
-	static inline idx_t EntriesPerBlock(idx_t width) {
-		return Storage::BLOCK_SIZE / width;
+	static inline idx_t EntriesPerBlock(const idx_t width, const idx_t block_size) {
+		return block_size / width;
 	}
 
 private:

package/src/duckdb/src/include/duckdb/common/types/row/row_data_collection_scanner.hpp

@@ -84,7 +84,7 @@ public:
 	//! we need to re-swizzle.
 	void ReSwizzle();
 
-	void SwizzleBlock(RowDataBlock &data_block, RowDataBlock &heap_block);
+	void SwizzleBlock(idx_t block_idx);
 
 	//! Scans the next data chunk from the sorted data
 	void Scan(DataChunk &chunk);
@@ -114,6 +114,8 @@ private:
 	//! Whether we are unswizzling the blocks
 	const bool unswizzling;
 
+	//! Swizzle a single block
+	void SwizzleBlockInternal(RowDataBlock &data_block, RowDataBlock &heap_block);
 	//! Checks that the newest block is valid
 	void ValidateUnscannedBlock() const;
 };

package/src/duckdb/src/include/duckdb/common/types/row/tuple_data_allocator.hpp

@@ -55,6 +55,8 @@ public:
 	TupleDataAllocator(BufferManager &buffer_manager, const TupleDataLayout &layout);
 	TupleDataAllocator(TupleDataAllocator &allocator);
 
+	~TupleDataAllocator();
+
 	//! Get the buffer manager
 	BufferManager &GetBufferManager();
 	//! Get the buffer allocator
@@ -81,6 +83,8 @@ public:
 	                           bool release_heap);
 	//! Releases or stores ALL handles in the management state
 	void ReleaseOrStoreHandles(TupleDataPinState &state, TupleDataSegment &segment);
+	//! Sets 'can_destroy' to true for all blocks so they aren't added to the eviction queue
+	void SetDestroyBufferUponUnpin();
 
 private:
 	//! Builds out a single part (grabs the lock)

package/src/duckdb/src/include/duckdb/common/types/row/tuple_data_collection.hpp

@@ -114,6 +114,8 @@ public:
 	static void ToUnifiedFormat(TupleDataChunkState &chunk_state, DataChunk &new_chunk);
 	//! Gets the UnifiedVectorFormat from the Chunk state as an array
 	static void GetVectorData(const TupleDataChunkState &chunk_state, UnifiedVectorFormat result[]);
+	//! Resets the cached cache vectors (used for ARRAY/LIST casts)
+	static void ResetCachedCastVectors(TupleDataChunkState &chunk_state, const vector<column_t> &column_ids);
 	//! Computes the heap sizes for the new DataChunk that will be appended
 	static void ComputeHeapSizes(TupleDataChunkState &chunk_state, const DataChunk &new_chunk,
 	                             const SelectionVector &append_sel, const idx_t append_count);
@@ -145,6 +147,8 @@ public:
 
 	//! Initializes a chunk with the correct types that can be used to call Append/Scan
 	void InitializeChunk(DataChunk &chunk) const;
+	//! Initializes a chunk with the correct types that can be used to call Append/Scan for the given columns
+	void InitializeChunk(DataChunk &chunk, const vector<column_t> &columns) const;
 	//! Initializes a chunk with the correct types for a given scan state
 	void InitializeScanChunk(TupleDataScanState &state, DataChunk &chunk) const;
 	//! Initializes a Scan state for scanning all columns

package/src/duckdb/src/include/duckdb/common/types/row/tuple_data_states.hpp

@@ -51,7 +51,7 @@ struct TupleDataVectorFormat {
 	unique_ptr<CombinedListData> combined_list_data;
 
 	// Optional: only used for ArrayVector to fake being a list vector
-	unique_array<list_entry_t> array_list_entries;
+	unsafe_unique_array<list_entry_t> array_list_entries;
 };
 
 struct TupleDataChunkState {

package/src/duckdb/src/include/duckdb/common/types/selection_vector.hpp

@@ -111,6 +111,10 @@ public:
 	inline sel_t &operator[](idx_t index) const {
 		return sel_vector[index];
 	}
+	inline bool IsSet() const {
+		return sel_vector;
+	}
+	void Verify(idx_t count, idx_t vector_size) const;
 
 private:
 	sel_t *sel_vector;

package/src/duckdb/src/include/duckdb/common/types/string_type.hpp

@@ -21,7 +21,6 @@ namespace duckdb {
 
 struct string_t {
 	friend struct StringComparisonOperators;
-	friend class StringSegment;
 
 public:
 	static constexpr idx_t PREFIX_BYTES = 4 * sizeof(char);
@@ -209,6 +208,10 @@ public:
 		return StringComparisonOperators::Equals(*this, r);
 	}
 
+	bool operator!=(const string_t &r) const {
+		return !(*this == r);
+	}
+
 	bool operator>(const string_t &r) const {
 		return StringComparisonOperators::GreaterThan(*this, r);
 	}

package/src/duckdb/src/include/duckdb/common/types/time.hpp

@@ -22,14 +22,17 @@ struct dtime_tz_t; // NOLINT
 class Time {
 public:
 	//! Convert a string in the format "hh:mm:ss" to a time object
-	DUCKDB_API static dtime_t FromString(const string &str, bool strict = false);
-	DUCKDB_API static dtime_t FromCString(const char *buf, idx_t len, bool strict = false);
-	DUCKDB_API static bool TryConvertTime(const char *buf, idx_t len, idx_t &pos, dtime_t &result, bool strict = false);
+	DUCKDB_API static dtime_t FromString(const string &str, bool strict = false, optional_ptr<int32_t> nanos = nullptr);
+	DUCKDB_API static dtime_t FromCString(const char *buf, idx_t len, bool strict = false,
+	                                      optional_ptr<int32_t> nanos = nullptr);
+	DUCKDB_API static bool TryConvertTime(const char *buf, idx_t len, idx_t &pos, dtime_t &result, bool strict = false,
+	                                      optional_ptr<int32_t> nanos = nullptr);
 	DUCKDB_API static bool TryConvertTimeTZ(const char *buf, idx_t len, idx_t &pos, dtime_tz_t &result,
-	                                        bool &has_offset, bool strict = false);
+	                                        bool &has_offset, bool strict = false,
+	                                        optional_ptr<int32_t> nanos = nullptr);
 	// No hour limit
 	DUCKDB_API static bool TryConvertInterval(const char *buf, idx_t len, idx_t &pos, dtime_t &result,
-	                                          bool strict = false);
+	                                          bool strict = false, optional_ptr<int32_t> nanos = nullptr);
 
 	//! Convert a time object to a string in the format "hh:mm:ss"
 	DUCKDB_API static string ToString(dtime_t time);
@@ -37,6 +40,7 @@ public:
 	DUCKDB_API static string ToUTCOffset(int hour_offset, int minute_offset);
 
 	DUCKDB_API static dtime_t FromTime(int32_t hour, int32_t minute, int32_t second, int32_t microseconds = 0);
+	DUCKDB_API static int64_t ToNanoTime(int32_t hour, int32_t minute, int32_t second, int32_t nanoseconds = 0);
 
 	//! Normalize a TIME_TZ by adding the offset to the time part and returning the TIME
 	DUCKDB_API static dtime_t NormalizeTimeTZ(dtime_tz_t timetz);
@@ -54,7 +58,8 @@ public:
 	DUCKDB_API static bool IsValidTime(int32_t hour, int32_t minute, int32_t second, int32_t microseconds);
 
 private:
-	static bool TryConvertInternal(const char *buf, idx_t len, idx_t &pos, dtime_t &result, bool strict);
+	static bool TryConvertInternal(const char *buf, idx_t len, idx_t &pos, dtime_t &result, bool strict,
+	                               optional_ptr<int32_t> nanos = nullptr);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/types/timestamp.hpp

@@ -106,9 +106,11 @@ public:
 	//! If has_offset is true, then the result is an instant that was offset from UTC
 	//! If the tz is not empty, the result is still an instant, but the parts can be extracted and applied to the TZ
 	DUCKDB_API static bool TryConvertTimestampTZ(const char *str, idx_t len, timestamp_t &result, bool &has_offset,
-	                                             string_t &tz);
-	DUCKDB_API static TimestampCastResult TryConvertTimestamp(const char *str, idx_t len, timestamp_t &result);
-	DUCKDB_API static timestamp_t FromCString(const char *str, idx_t len);
+	                                             string_t &tz, optional_ptr<int32_t> nanos = nullptr);
+	DUCKDB_API static TimestampCastResult TryConvertTimestamp(const char *str, idx_t len, timestamp_t &result,
+	                                                          optional_ptr<int32_t> nanos = nullptr);
+	DUCKDB_API static TimestampCastResult TryConvertTimestamp(const char *str, idx_t len, timestamp_ns_t &result);
+	DUCKDB_API static timestamp_t FromCString(const char *str, idx_t len, optional_ptr<int32_t> nanos = nullptr);
 	//! Convert a date object to a string in the format "YYYY-MM-DD hh:mm:ss"
 	DUCKDB_API static string ToString(timestamp_t timestamp);
 
@@ -119,6 +121,8 @@ public:
 	DUCKDB_API static timestamp_t FromDatetime(date_t date, dtime_t time);
 	DUCKDB_API static bool TryFromDatetime(date_t date, dtime_t time, timestamp_t &result);
 	DUCKDB_API static bool TryFromDatetime(date_t date, dtime_tz_t timetz, timestamp_t &result);
+	//! Scale up to ns
+	DUCKDB_API static bool TryFromTimestampNanos(timestamp_t ts, int32_t nanos, timestamp_ns_t &result);
 
 	//! Is the character a valid part of a time zone name?
 	static inline bool CharacterIsTimeZone(char c) {
@@ -133,6 +137,8 @@ public:
 
 	//! Extract the date and time from a given timestamp object
 	DUCKDB_API static void Convert(timestamp_t date, date_t &out_date, dtime_t &out_time);
+	//! Extract the date and time from a given timestamp object
+	DUCKDB_API static void Convert(timestamp_ns_t date, date_t &out_date, dtime_t &out_time, int32_t &out_nanos);
 	//! Returns current timestamp
 	DUCKDB_API static timestamp_t GetCurrentTimestamp();
 
@@ -148,6 +154,10 @@ public:
 	DUCKDB_API static timestamp_t FromEpochNanoSecondsPossiblyInfinite(int64_t nanos);
 	DUCKDB_API static timestamp_t FromEpochNanoSeconds(int64_t nanos);
 
+	//! Construct ns timestamps from various epoch units
+	DUCKDB_API static timestamp_ns_t TimestampNsFromEpochMicros(int64_t micros);
+	DUCKDB_API static timestamp_ns_t TimestampNsFromEpochMillis(int64_t millis);
+
 	//! Try convert a timestamp to epoch (in nanoseconds)
 	DUCKDB_API static bool TryGetEpochNanoSeconds(timestamp_t timestamp, int64_t &result);
 	//! Convert the epoch (in seconds) to a timestamp