duckdb 0.8.1-dev0.0 → 0.8.1-dev111.0

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

@@ -24,7 +24,7 @@ bool IsRegularCharacter(data_t c) {
 }
 
 idx_t Blob::GetStringSize(string_t blob) {
-	auto data = (const_data_ptr_t)blob.GetData();
+	auto data = const_data_ptr_cast(blob.GetData());
 	auto len = blob.GetSize();
 	idx_t str_len = 0;
 	for (idx_t i = 0; i < len; i++) {
@@ -40,7 +40,7 @@ idx_t Blob::GetStringSize(string_t blob) {
 }
 
 void Blob::ToString(string_t blob, char *output) {
-	auto data = (const_data_ptr_t)blob.GetData();
+	auto data = const_data_ptr_cast(blob.GetData());
 	auto len = blob.GetSize();
 	idx_t str_idx = 0;
 	for (idx_t i = 0; i < len; i++) {
@@ -70,7 +70,7 @@ string Blob::ToString(string_t blob) {
 }
 
 bool Blob::TryGetBlobSize(string_t str, idx_t &str_len, string *error_message) {
-	auto data = (const_data_ptr_t)str.GetData();
+	auto data = const_data_ptr_cast(str.GetData());
 	auto len = str.GetSize();
 	str_len = 0;
 	for (idx_t i = 0; i < len; i++) {
@@ -84,7 +84,7 @@ bool Blob::TryGetBlobSize(string_t str, idx_t &str_len, string *error_message) {
 			if (data[i + 1] != 'x' || Blob::HEX_MAP[data[i + 2]] < 0 || Blob::HEX_MAP[data[i + 3]] < 0) {
 				string error =
 				    StringUtil::Format("Invalid hex escape code encountered in string -> blob conversion: %s",
-				                       string((char *)data + i, 4));
+				                       string(const_char_ptr_cast(data) + i, 4));
 				HandleCastError::AssignError(error, error_message);
 				return false;
 			}
@@ -112,7 +112,7 @@ idx_t Blob::GetBlobSize(string_t str) {
 }
 
 void Blob::ToBlob(string_t str, data_ptr_t output) {
-	auto data = (const_data_ptr_t)str.GetData();
+	auto data = const_data_ptr_cast(str.GetData());
 	auto len = str.GetSize();
 	idx_t blob_idx = 0;
 	for (idx_t i = 0; i < len; i++) {
@@ -137,7 +137,7 @@ void Blob::ToBlob(string_t str, data_ptr_t output) {
 string Blob::ToBlob(string_t str) {
 	auto blob_len = GetBlobSize(str);
 	auto buffer = make_unsafe_uniq_array<char>(blob_len);
-	Blob::ToBlob(str, (data_ptr_t)buffer.get());
+	Blob::ToBlob(str, data_ptr_cast(buffer.get()));
 	return string(buffer.get(), blob_len);
 }
 
@@ -149,7 +149,7 @@ idx_t Blob::ToBase64Size(string_t blob) {
 }
 
 void Blob::ToBase64(string_t blob, char *output) {
-	auto input_data = (const_data_ptr_t)blob.GetData();
+	auto input_data = const_data_ptr_cast(blob.GetData());
 	auto input_size = blob.GetSize();
 	idx_t out_idx = 0;
 	idx_t i;
@@ -239,7 +239,7 @@ uint32_t DecodeBase64Bytes(const string_t &str, const_data_ptr_t input_data, idx
 
 void Blob::FromBase64(string_t str, data_ptr_t output, idx_t output_size) {
 	D_ASSERT(output_size == FromBase64Size(str));
-	auto input_data = (const_data_ptr_t)str.GetData();
+	auto input_data = const_data_ptr_cast(str.GetData());
 	auto input_size = str.GetSize();
 	if (input_size == 0) {
 		return;

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

@@ -71,7 +71,7 @@ BufferHandle ColumnDataAllocator::AllocateBlock(idx_t size) {
 void ColumnDataAllocator::AllocateEmptyBlock(idx_t size) {
 	auto allocation_amount = MaxValue<idx_t>(NextPowerOfTwo(size), 4096);
 	if (!blocks.empty()) {
-		auto last_capacity = blocks.back().capacity;
+		idx_t last_capacity = blocks.back().capacity;
 		auto next_capacity = MinValue<idx_t>(last_capacity * 2, last_capacity + Storage::BLOCK_SIZE);
 		allocation_amount = MaxValue<idx_t>(next_capacity, allocation_amount);
 	}
@@ -162,10 +162,10 @@ data_ptr_t ColumnDataAllocator::GetDataPointer(ChunkManagementState &state, uint
 		// in-memory allocator: construct pointer from block_id and offset
 		if (sizeof(uintptr_t) == sizeof(uint32_t)) {
 			uintptr_t pointer_value = uintptr_t(block_id);
-			return (data_ptr_t)pointer_value;
+			return (data_ptr_t)pointer_value; // NOLINT - convert from pointer value back to pointer
 		} else if (sizeof(uintptr_t) == sizeof(uint64_t)) {
 			uintptr_t pointer_value = (uintptr_t(offset) << 32) | uintptr_t(block_id);
-			return (data_ptr_t)pointer_value;
+			return (data_ptr_t)pointer_value; // NOLINT - convert from pointer value back to pointer
 		} else {
 			throw InternalException("ColumnDataCollection: Architecture not supported!?");
 		}
@@ -196,7 +196,7 @@ void ColumnDataAllocator::UnswizzlePointers(ChunkManagementState &state, Vector
 	// at least one string must be non-inlined, otherwise this function should not be called
 	D_ASSERT(i < end);
 
-	auto base_ptr = (char *)GetDataPointer(state, block_id, offset);
+	auto base_ptr = char_ptr_cast(GetDataPointer(state, block_id, offset));
 	if (strings[i].GetData() == base_ptr) {
 		// pointers are still valid
 		return;

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

@@ -454,7 +454,7 @@ void ColumnDataCopy<string_t>(ColumnDataMetaData &meta_data, const UnifiedVector
 		// 'append_count' is less if we cannot fit that amount of non-inlined strings on one buffer-managed block
 		idx_t append_count;
 		idx_t heap_size = 0;
-		const auto source_entries = (string_t *)source_data.data;
+		const auto source_entries = UnifiedVectorFormat::GetData<string_t>(source_data);
 		for (append_count = 0; append_count < vector_remaining; append_count++) {
 			auto source_idx = source_data.sel->get_index(offset + append_count);
 			if (!source_data.validity.RowIsValid(source_idx)) {
@@ -505,7 +505,7 @@ void ColumnDataCopy<string_t>(ColumnDataMetaData &meta_data, const UnifiedVector
 			target_validity.SetAllValid(STANDARD_VECTOR_SIZE);
 		}
 
-		auto target_entries = (string_t *)base_ptr;
+		auto target_entries = reinterpret_cast<string_t *>(base_ptr);
 		for (idx_t i = 0; i < append_count; i++) {
 			auto source_idx = source_data.sel->get_index(offset + i);
 			auto target_idx = current_segment.count + i;
@@ -520,7 +520,7 @@ void ColumnDataCopy<string_t>(ColumnDataMetaData &meta_data, const UnifiedVector
 			} else {
 				D_ASSERT(heap_ptr != nullptr);
 				memcpy(heap_ptr, source_entry.GetData(), source_entry.GetSize());
-				target_entry = string_t((const char *)heap_ptr, source_entry.GetSize());
+				target_entry = string_t(const_char_ptr_cast(heap_ptr), source_entry.GetSize());
 				heap_ptr += source_entry.GetSize();
 			}
 		}

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

@@ -14,7 +14,7 @@ idx_t ColumnDataCollectionSegment::GetDataSize(idx_t type_size) {
 }
 
 validity_t *ColumnDataCollectionSegment::GetValidityPointer(data_ptr_t base_ptr, idx_t type_size) {
-	return (validity_t *)(base_ptr + GetDataSize(type_size));
+	return reinterpret_cast<validity_t *>(base_ptr + GetDataSize(type_size));
 }
 
 VectorDataIndex ColumnDataCollectionSegment::AllocateVectorInternal(const LogicalType &type, ChunkMetaData &chunk_meta,

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

@@ -19,9 +19,9 @@ PartitionedColumnData::PartitionedColumnData(const PartitionedColumnData &other)
 unique_ptr<PartitionedColumnData> PartitionedColumnData::CreateShared() {
 	switch (type) {
 	case PartitionedColumnDataType::RADIX:
-		return make_uniq<RadixPartitionedColumnData>((RadixPartitionedColumnData &)*this);
+		return make_uniq<RadixPartitionedColumnData>(Cast<RadixPartitionedColumnData>());
 	case PartitionedColumnDataType::HIVE:
-		return make_uniq<HivePartitionedColumnData>((HivePartitionedColumnData &)*this);
+		return make_uniq<HivePartitionedColumnData>(Cast<HivePartitionedColumnData>());
 	default:
 		throw NotImplementedException("CreateShared for this type of PartitionedColumnData");
 	}

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

@@ -40,7 +40,7 @@ template <>
 hash_t Hash(float val) {
 	static_assert(sizeof(float) == sizeof(uint32_t), "");
 	FloatingPointEqualityTransform<float>::OP(val);
-	uint32_t uval = Load<uint32_t>((const_data_ptr_t)&val);
+	uint32_t uval = Load<uint32_t>(const_data_ptr_cast(&val));
 	return murmurhash64(uval);
 }
 
@@ -48,7 +48,7 @@ template <>
 hash_t Hash(double val) {
 	static_assert(sizeof(double) == sizeof(uint64_t), "");
 	FloatingPointEqualityTransform<double>::OP(val);
-	uint64_t uval = Load<uint64_t>((const_data_ptr_t)&val);
+	uint64_t uval = Load<uint64_t>(const_data_ptr_cast(&val));
 	return murmurhash64(uval);
 }
 

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

@@ -9,18 +9,18 @@ namespace duckdb {
 HyperLogLog::HyperLogLog() : hll(nullptr) {
 	hll = duckdb_hll::hll_create();
 	// Insert into a dense hll can be vectorized, sparse cannot, so we immediately convert
-	duckdb_hll::hllSparseToDense((duckdb_hll::robj *)hll);
+	duckdb_hll::hllSparseToDense(hll);
 }
 
-HyperLogLog::HyperLogLog(void *hll) : hll(hll) {
+HyperLogLog::HyperLogLog(duckdb_hll::robj *hll) : hll(hll) {
 }
 
 HyperLogLog::~HyperLogLog() {
-	duckdb_hll::hll_destroy((duckdb_hll::robj *)hll);
+	duckdb_hll::hll_destroy(hll);
 }
 
 void HyperLogLog::Add(data_ptr_t element, idx_t size) {
-	if (duckdb_hll::hll_add((duckdb_hll::robj *)hll, element, size) == HLL_C_ERR) {
+	if (duckdb_hll::hll_add(hll, element, size) == HLL_C_ERR) {
 		throw InternalException("Could not add to HLL?");
 	}
 }
@@ -29,7 +29,7 @@ idx_t HyperLogLog::Count() const {
 	// exception from size_t ban
 	size_t result;
 
-	if (duckdb_hll::hll_count((duckdb_hll::robj *)hll, &result) != HLL_C_OK) {
+	if (duckdb_hll::hll_count(hll, &result) != HLL_C_OK) {
 		throw InternalException("Could not count HLL?");
 	}
 	return result;
@@ -37,24 +37,24 @@ idx_t HyperLogLog::Count() const {
 
 unique_ptr<HyperLogLog> HyperLogLog::Merge(HyperLogLog &other) {
 	duckdb_hll::robj *hlls[2];
-	hlls[0] = (duckdb_hll::robj *)hll;
-	hlls[1] = (duckdb_hll::robj *)other.hll;
+	hlls[0] = hll;
+	hlls[1] = other.hll;
 	auto new_hll = duckdb_hll::hll_merge(hlls, 2);
 	if (!new_hll) {
 		throw InternalException("Could not merge HLLs");
 	}
-	return unique_ptr<HyperLogLog>(new HyperLogLog((void *)new_hll));
+	return unique_ptr<HyperLogLog>(new HyperLogLog(new_hll));
 }
 
 HyperLogLog *HyperLogLog::MergePointer(HyperLogLog &other) {
 	duckdb_hll::robj *hlls[2];
-	hlls[0] = (duckdb_hll::robj *)hll;
-	hlls[1] = (duckdb_hll::robj *)other.hll;
+	hlls[0] = hll;
+	hlls[1] = other.hll;
 	auto new_hll = duckdb_hll::hll_merge(hlls, 2);
 	if (!new_hll) {
 		throw Exception("Could not merge HLLs");
 	}
-	return new HyperLogLog((void *)new_hll);
+	return new HyperLogLog(new_hll);
 }
 
 unique_ptr<HyperLogLog> HyperLogLog::Merge(HyperLogLog logs[], idx_t count) {
@@ -63,13 +63,13 @@ unique_ptr<HyperLogLog> HyperLogLog::Merge(HyperLogLog logs[], idx_t count) {
 	};
 	auto hlls = hlls_uptr.get();
 	for (idx_t i = 0; i < count; i++) {
-		hlls[i] = (duckdb_hll::robj *)logs[i].hll;
+		hlls[i] = logs[i].hll;
 	}
 	auto new_hll = duckdb_hll::hll_merge(hlls, count);
 	if (!new_hll) {
 		throw InternalException("Could not merge HLLs");
 	}
-	return unique_ptr<HyperLogLog>(new HyperLogLog((void *)new_hll));
+	return unique_ptr<HyperLogLog>(new HyperLogLog(new_hll));
 }
 
 idx_t HyperLogLog::GetSize() {
@@ -77,7 +77,7 @@ idx_t HyperLogLog::GetSize() {
 }
 
 data_ptr_t HyperLogLog::GetPtr() const {
-	return (data_ptr_t)((duckdb_hll::robj *)hll)->ptr;
+	return data_ptr_cast((hll)->ptr);
 }
 
 unique_ptr<HyperLogLog> HyperLogLog::Copy() {
@@ -123,21 +123,22 @@ inline uint64_t TemplatedHash(const T &elem) {
 
 template <>
 inline uint64_t TemplatedHash(const hugeint_t &elem) {
-	return TemplatedHash<uint64_t>(Load<uint64_t>((data_ptr_t)&elem.upper)) ^ TemplatedHash<uint64_t>(elem.lower);
+	return TemplatedHash<uint64_t>(Load<uint64_t>(const_data_ptr_cast(&elem.upper))) ^
+	       TemplatedHash<uint64_t>(elem.lower);
 }
 
 template <idx_t rest>
-inline void CreateIntegerRecursive(const data_ptr_t &data, uint64_t &x) {
+inline void CreateIntegerRecursive(const_data_ptr_t &data, uint64_t &x) {
 	x ^= (uint64_t)data[rest - 1] << ((rest - 1) * 8);
 	return CreateIntegerRecursive<rest - 1>(data, x);
 }
 
 template <>
-inline void CreateIntegerRecursive<1>(const data_ptr_t &data, uint64_t &x) {
+inline void CreateIntegerRecursive<1>(const_data_ptr_t &data, uint64_t &x) {
 	x ^= (uint64_t)data[0];
 }
 
-inline uint64_t HashOtherSize(const data_ptr_t &data, const idx_t &len) {
+inline uint64_t HashOtherSize(const_data_ptr_t &data, const idx_t &len) {
 	uint64_t x = 0;
 	switch (len & 7) {
 	case 7:
@@ -169,7 +170,7 @@ inline uint64_t HashOtherSize(const data_ptr_t &data, const idx_t &len) {
 
 template <>
 inline uint64_t TemplatedHash(const string_t &elem) {
-	data_ptr_t data = (data_ptr_t)elem.GetData();
+	auto data = const_data_ptr_cast(elem.GetData());
 	const auto &len = elem.GetSize();
 	uint64_t h = 0;
 	for (idx_t i = 0; i + sizeof(uint64_t) <= len; i += sizeof(uint64_t)) {
@@ -194,7 +195,7 @@ inline uint64_t TemplatedHash(const string_t &elem) {
 
 template <class T>
 void TemplatedComputeHashes(UnifiedVectorFormat &vdata, const idx_t &count, uint64_t hashes[]) {
-	T *data = (T *)vdata.data;
+	auto data = UnifiedVectorFormat::GetData<T>(vdata);
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = vdata.sel->get_index(i);
 		if (vdata.validity.RowIsValid(idx)) {
@@ -262,7 +263,7 @@ void HyperLogLog::ProcessEntries(UnifiedVectorFormat &vdata, const LogicalType &
 
 void HyperLogLog::AddToLogs(UnifiedVectorFormat &vdata, idx_t count, uint64_t indices[], uint8_t counts[],
                             HyperLogLog **logs[], const SelectionVector *log_sel) {
-	AddToLogsInternal(vdata, count, indices, counts, (void ****)logs, log_sel);
+	AddToLogsInternal(vdata, count, indices, counts, reinterpret_cast<void ****>(logs), log_sel);
 }
 
 void HyperLogLog::AddToLog(UnifiedVectorFormat &vdata, idx_t count, uint64_t indices[], uint8_t counts[]) {