duckdb 0.8.1-dev23.0 → 0.8.1-dev253.0

package/src/duckdb/src/function/table/repeat_row.cpp

@@ -25,7 +25,14 @@ static unique_ptr<FunctionData> RepeatRowBind(ClientContext &context, TableFunct
 		return_types.push_back(inputs[input_idx].type());
 		names.push_back("column" + std::to_string(input_idx));
 	}
-	return make_uniq<RepeatRowFunctionData>(inputs, input.named_parameters["num_rows"].GetValue<int64_t>());
+	auto entry = input.named_parameters.find("num_rows");
+	if (entry == input.named_parameters.end()) {
+		throw BinderException("repeat_rows requires num_rows to be specified");
+	}
+	if (inputs.empty()) {
+		throw BinderException("repeat_rows requires at least one column to be specified");
+	}
+	return make_uniq<RepeatRowFunctionData>(inputs, entry->second.GetValue<int64_t>());
 }
 
 static unique_ptr<GlobalTableFunctionState> RepeatRowInit(ClientContext &context, TableFunctionInitInput &input) {
@@ -33,7 +40,7 @@ static unique_ptr<GlobalTableFunctionState> RepeatRowInit(ClientContext &context
 }
 
 static void RepeatRowFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &bind_data = (const RepeatRowFunctionData &)*data_p.bind_data;
+	auto &bind_data = data_p.bind_data->Cast<RepeatRowFunctionData>();
 	auto &state = data_p.global_state->Cast<RepeatRowOperatorData>();
 
 	idx_t remaining = MinValue<idx_t>(bind_data.target_count - state.current_count, STANDARD_VECTOR_SIZE);
@@ -45,7 +52,7 @@ static void RepeatRowFunction(ClientContext &context, TableFunctionInput &data_p
 }
 
 static unique_ptr<NodeStatistics> RepeatRowCardinality(ClientContext &context, const FunctionData *bind_data_p) {
-	auto &bind_data = (const RepeatRowFunctionData &)*bind_data_p;
+	auto &bind_data = bind_data_p->Cast<RepeatRowFunctionData>();
 	return make_uniq<NodeStatistics>(bind_data.target_count, bind_data.target_count);
 }
 

package/src/duckdb/src/function/table/system/duckdb_functions.cpp

@@ -456,7 +456,7 @@ bool ExtractFunctionData(FunctionEntry &entry, idx_t function_idx, DataChunk &ou
 }
 
 void DuckDBFunctionsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (DuckDBFunctionsData &)*data_p.global_state;
+	auto &data = data_p.global_state->Cast<DuckDBFunctionsData>();
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;

package/src/duckdb/src/function/table/system/test_vector_types.cpp

@@ -233,7 +233,7 @@ unique_ptr<GlobalTableFunctionState> TestVectorTypesInit(ClientContext &context,
 }
 
 void TestVectorTypesFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (TestVectorTypesData &)*data_p.global_state;
+	auto &data = data_p.global_state->Cast<TestVectorTypesData>();
 	if (data.offset >= data.entries.size()) {
 		// finished returning values
 		return;

package/src/duckdb/src/function/table/table_scan.cpp

@@ -215,7 +215,7 @@ static unique_ptr<GlobalTableFunctionState> IndexScanInitGlobal(ClientContext &c
 	auto &bind_data = input.bind_data->Cast<TableScanBindData>();
 	data_ptr_t row_id_data = nullptr;
 	if (!bind_data.result_ids.empty()) {
-		row_id_data = (data_ptr_t)&bind_data.result_ids[0];
+		row_id_data = (data_ptr_t)&bind_data.result_ids[0]; // NOLINT - this is not pretty
 	}
 	auto result = make_uniq<IndexScanGlobalState>(row_id_data);
 	auto &local_storage = LocalStorage::Get(context, bind_data.table.catalog);
@@ -350,7 +350,7 @@ void TableScanPushdownComplexFilter(ClientContext &context, LogicalGet &get, Fun
 			} else if (expr.type == ExpressionType::COMPARE_BETWEEN) {
 				// BETWEEN expression
 				auto &between = expr.Cast<BoundBetweenExpression>();
-				if (!between.input->Equals(index_expression.get())) {
+				if (!between.input->Equals(*index_expression)) {
 					// expression doesn't match the current index expression
 					continue;
 				}

package/src/duckdb/src/function/table/unnest.cpp

@@ -18,7 +18,7 @@ public:
 	}
 
 	bool Equals(const FunctionData &other_p) const override {
-		auto &other = (const UnnestBindData &)other_p;
+		auto &other = other_p.Cast<UnnestBindData>();
 		return input_type == other.input_type;
 	}
 };

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.1-dev23"
+#define DUCKDB_VERSION "0.8.1-dev253"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "950d3d9532"
+#define DUCKDB_SOURCE_ID "0d946c04df"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"
@@ -32,7 +32,7 @@ static unique_ptr<GlobalTableFunctionState> PragmaVersionInit(ClientContext &con
 }
 
 static void PragmaVersionFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
-	auto &data = (PragmaVersionData &)*data_p.global_state;
+	auto &data = data_p.global_state->Cast<PragmaVersionData>();
 	if (data.finished) {
 		// finished returning values
 		return;

package/src/duckdb/src/include/duckdb/catalog/catalog.hpp

@@ -229,9 +229,6 @@ public:
 	DUCKDB_API static LogicalType GetType(ClientContext &context, const string &catalog_name, const string &schema,
 	                                      const string &name);
 
-	static bool TypeExists(ClientContext &context, const string &catalog_name, const string &schema,
-	                       const string &name);
-
 	template <class T>
 	optional_ptr<T> GetEntry(ClientContext &context, const string &schema_name, const string &name,
 	                         OnEntryNotFound if_not_found, QueryErrorContext error_context = QueryErrorContext()) {
@@ -333,13 +330,13 @@ public:
 	template <class TARGET>
 	TARGET &Cast() {
 		D_ASSERT(dynamic_cast<TARGET *>(this));
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 
 	template <class TARGET>
 	const TARGET &Cast() const {
 		D_ASSERT(dynamic_cast<const TARGET *>(this));
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/duck_table_entry.hpp

@@ -45,6 +45,8 @@ public:
 		return true;
 	}
 
+	void BindUpdateConstraints(LogicalGet &get, LogicalProjection &proj, LogicalUpdate &update) override;
+
 private:
 	unique_ptr<CatalogEntry> RenameColumn(ClientContext &context, RenameColumnInfo &info);
 	unique_ptr<CatalogEntry> AddColumn(ClientContext &context, AddColumnInfo &info);

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_catalog_entry.hpp

@@ -40,6 +40,10 @@ class TableColumnInfo;
 class TableIndexInfo;
 class TableStorageInfo;
 
+class LogicalGet;
+class LogicalProjection;
+class LogicalUpdate;
+
 //! A table catalog entry
 class TableCatalogEntry : public StandardEntry {
 public:
@@ -102,6 +106,8 @@ public:
 	//! Returns the storage info of this table
 	virtual TableStorageInfo GetStorageInfo(ClientContext &context) = 0;
 
+	DUCKDB_API virtual void BindUpdateConstraints(LogicalGet &get, LogicalProjection &proj, LogicalUpdate &update);
+
 protected:
 	// This is used to serialize the entry by #Serialize(Serializer& ). It is virtual to allow
 	// Custom catalog implementations to override the default implementation. We can not make

package/src/duckdb/src/include/duckdb/catalog/catalog_entry.hpp

@@ -72,12 +72,12 @@ public:
 	template <class TARGET>
 	TARGET &Cast() {
 		D_ASSERT(dynamic_cast<TARGET *>(this));
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>
 	const TARGET &Cast() const {
 		D_ASSERT(dynamic_cast<const TARGET *>(this));
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 

package/src/duckdb/src/include/duckdb/catalog/catalog_search_path.hpp

@@ -35,14 +35,16 @@ private:
 	static string WriteOptionallyQuoted(const string &input);
 };
 
+enum class CatalogSetPathType { SET_SCHEMA, SET_SCHEMAS };
+
 //! The schema search path, in order by which entries are searched if no schema entry is provided
 class CatalogSearchPath {
 public:
 	DUCKDB_API explicit CatalogSearchPath(ClientContext &client_p);
 	CatalogSearchPath(const CatalogSearchPath &other) = delete;
 
-	DUCKDB_API void Set(CatalogSearchEntry new_value, bool is_set_schema);
-	DUCKDB_API void Set(vector<CatalogSearchEntry> new_paths, bool is_set_schema = false);
+	DUCKDB_API void Set(CatalogSearchEntry new_value, CatalogSetPathType set_type);
+	DUCKDB_API void Set(vector<CatalogSearchEntry> new_paths, CatalogSetPathType set_type);
 	DUCKDB_API void Reset();
 
 	DUCKDB_API const vector<CatalogSearchEntry> &Get();
@@ -56,9 +58,13 @@ public:
 	DUCKDB_API vector<string> GetSchemasForCatalog(const string &catalog);
 	DUCKDB_API vector<string> GetCatalogsForSchema(const string &schema);
 
+	DUCKDB_API bool SchemaInSearchPath(ClientContext &context, const string &catalog_name, const string &schema_name);
+
 private:
 	void SetPaths(vector<CatalogSearchEntry> new_paths);
 
+	string GetSetName(CatalogSetPathType set_type);
+
 private:
 	ClientContext &context;
 	vector<CatalogSearchEntry> paths;

package/src/duckdb/src/include/duckdb/catalog/default/builtin_types/types.hpp

@@ -0,0 +1,97 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/default/builtin_types/types.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+// This file is generated by scripts/generate_builtin_types.py
+
+#pragma once
+
+#include "duckdb/common/types.hpp"
+#include "duckdb/common/array.hpp"
+
+namespace duckdb {
+
+struct DefaultType {
+	const char *name;
+	LogicalTypeId type;
+};
+
+using builtin_type_array = std::array<DefaultType, 70>;
+
+static constexpr const builtin_type_array BUILTIN_TYPES{{
+	{"decimal", LogicalTypeId::DECIMAL},
+	{"dec", LogicalTypeId::DECIMAL},
+	{"numeric", LogicalTypeId::DECIMAL},
+	{"time", LogicalTypeId::TIME},
+	{"date", LogicalTypeId::DATE},
+	{"timestamp", LogicalTypeId::TIMESTAMP},
+	{"datetime", LogicalTypeId::TIMESTAMP},
+	{"timestamp_us", LogicalTypeId::TIMESTAMP},
+	{"timestamp_ms", LogicalTypeId::TIMESTAMP_MS},
+	{"timestamp_ns", LogicalTypeId::TIMESTAMP_NS},
+	{"timestamp_s", LogicalTypeId::TIMESTAMP_SEC},
+	{"timestamptz", LogicalTypeId::TIMESTAMP_TZ},
+	{"timetz", LogicalTypeId::TIME_TZ},
+	{"interval", LogicalTypeId::INTERVAL},
+	{"varchar", LogicalTypeId::VARCHAR},
+	{"bpchar", LogicalTypeId::VARCHAR},
+	{"string", LogicalTypeId::VARCHAR},
+	{"char", LogicalTypeId::VARCHAR},
+	{"nvarchar", LogicalTypeId::VARCHAR},
+	{"text", LogicalTypeId::VARCHAR},
+	{"blob", LogicalTypeId::BLOB},
+	{"bytea", LogicalTypeId::BLOB},
+	{"varbinary", LogicalTypeId::BLOB},
+	{"binary", LogicalTypeId::BLOB},
+	{"hugeint", LogicalTypeId::HUGEINT},
+	{"int128", LogicalTypeId::HUGEINT},
+	{"bigint", LogicalTypeId::BIGINT},
+	{"oid", LogicalTypeId::BIGINT},
+	{"long", LogicalTypeId::BIGINT},
+	{"int8", LogicalTypeId::BIGINT},
+	{"int64", LogicalTypeId::BIGINT},
+	{"ubigint", LogicalTypeId::UBIGINT},
+	{"uint64", LogicalTypeId::UBIGINT},
+	{"integer", LogicalTypeId::INTEGER},
+	{"int", LogicalTypeId::INTEGER},
+	{"int4", LogicalTypeId::INTEGER},
+	{"signed", LogicalTypeId::INTEGER},
+	{"integral", LogicalTypeId::INTEGER},
+	{"int32", LogicalTypeId::INTEGER},
+	{"uinteger", LogicalTypeId::UINTEGER},
+	{"uint32", LogicalTypeId::UINTEGER},
+	{"smallint", LogicalTypeId::SMALLINT},
+	{"int2", LogicalTypeId::SMALLINT},
+	{"short", LogicalTypeId::SMALLINT},
+	{"int16", LogicalTypeId::SMALLINT},
+	{"usmallint", LogicalTypeId::USMALLINT},
+	{"uint16", LogicalTypeId::USMALLINT},
+	{"tinyint", LogicalTypeId::TINYINT},
+	{"int1", LogicalTypeId::TINYINT},
+	{"utinyint", LogicalTypeId::UTINYINT},
+	{"uint8", LogicalTypeId::UTINYINT},
+	{"struct", LogicalTypeId::STRUCT},
+	{"row", LogicalTypeId::STRUCT},
+	{"list", LogicalTypeId::LIST},
+	{"map", LogicalTypeId::MAP},
+	{"union", LogicalTypeId::UNION},
+	{"bit", LogicalTypeId::BIT},
+	{"bitstring", LogicalTypeId::BIT},
+	{"boolean", LogicalTypeId::BOOLEAN},
+	{"bool", LogicalTypeId::BOOLEAN},
+	{"logical", LogicalTypeId::BOOLEAN},
+	{"uuid", LogicalTypeId::UUID},
+	{"guid", LogicalTypeId::UUID},
+	{"enum", LogicalTypeId::ENUM},
+	{"null", LogicalTypeId::SQLNULL},
+	{"float", LogicalTypeId::FLOAT},
+	{"real", LogicalTypeId::FLOAT},
+	{"float4", LogicalTypeId::FLOAT},
+	{"double", LogicalTypeId::DOUBLE},
+	{"float8", LogicalTypeId::DOUBLE}
+}};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/adbc/adbc.hpp

@@ -10,6 +10,8 @@
 
 #include "duckdb/common/adbc/adbc.h"
 
+#include <string>
+
 namespace duckdb_adbc {
 
 AdbcStatusCode DatabaseNew(struct AdbcDatabase *database, struct AdbcError *error);
@@ -82,4 +84,7 @@ AdbcStatusCode StatementExecutePartitions(struct AdbcStatement *statement, struc
                                           struct AdbcPartitions *partitions, int64_t *rows_affected,
                                           struct AdbcError *error);
 
+void SetError(struct AdbcError *error, const std::string &message);
+
+void InitiliazeADBCError(AdbcError *error);
 } // namespace duckdb_adbc

package/src/duckdb/src/include/duckdb/common/allocator.hpp

@@ -26,6 +26,17 @@ struct PrivateAllocatorData {
 	virtual ~PrivateAllocatorData();
 
 	unique_ptr<AllocatorDebugInfo> debug_info;
+
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 };
 
 typedef data_ptr_t (*allocate_function_ptr_t)(PrivateAllocatorData *private_data, idx_t size);
@@ -85,14 +96,14 @@ public:
 		return AllocatedData(*this, AllocateData(size), size);
 	}
 	static data_ptr_t DefaultAllocate(PrivateAllocatorData *private_data, idx_t size) {
-		return (data_ptr_t)malloc(size);
+		return data_ptr_cast(malloc(size));
 	}
 	static void DefaultFree(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t size) {
 		free(pointer);
 	}
 	static data_ptr_t DefaultReallocate(PrivateAllocatorData *private_data, data_ptr_t pointer, idx_t old_size,
 	                                    idx_t size) {
-		return (data_ptr_t)realloc(pointer, size);
+		return data_ptr_cast(realloc(pointer, size));
 	}
 	static Allocator &Get(ClientContext &context);
 	static Allocator &Get(DatabaseInstance &db);
@@ -120,7 +131,7 @@ T *AllocateArray(idx_t size) {
 
 template <class T>
 void DeleteArray(T *ptr, idx_t size) {
-	Allocator::DefaultAllocator().FreeData((data_ptr_t)ptr, size * sizeof(T));
+	Allocator::DefaultAllocator().FreeData(data_ptr_cast(ptr), size * sizeof(T));
 }
 
 template <typename T, typename... ARGS>
@@ -132,7 +143,7 @@ T *AllocateObject(ARGS &&... args) {
 template <typename T>
 void DestroyObject(T *ptr) {
 	ptr->~T();
-	Allocator::DefaultAllocator().FreeData((data_ptr_t)ptr, sizeof(T));
+	Allocator::DefaultAllocator().FreeData(data_ptr_cast(ptr), sizeof(T));
 }
 
 //! The BufferAllocator is a wrapper around the global allocator class that sends any allocations made through the

package/src/duckdb/src/include/duckdb/common/arrow/arrow_buffer.hpp

@@ -73,12 +73,17 @@ struct ArrowBuffer {
 		return dataptr;
 	}
 
+	template <class T>
+	T *GetData() {
+		return reinterpret_cast<T *>(data());
+	}
+
 private:
 	void ReserveInternal(idx_t bytes) {
 		if (dataptr) {
-			dataptr = (data_ptr_t)realloc(dataptr, bytes);
+			dataptr = data_ptr_cast(realloc(dataptr, bytes));
 		} else {
-			dataptr = (data_ptr_t)malloc(bytes);
+			dataptr = data_ptr_cast(malloc(bytes));
 		}
 		capacity = bytes;
 	}

package/src/duckdb/src/include/duckdb/common/crypto/md5.hpp

@@ -26,10 +26,10 @@ public:
 	}
 	void Add(const char *data);
 	void Add(string_t string) {
-		MD5Update((const_data_ptr_t)string.GetData(), string.GetSize());
+		MD5Update(const_data_ptr_cast(string.GetData()), string.GetSize());
 	}
 	void Add(const string &data) {
-		MD5Update((const_data_ptr_t)data.c_str(), data.size());
+		MD5Update(const_data_ptr_cast(data.c_str()), data.size());
 	}
 
 	//! Write the 16-byte (binary) digest to the specified location

package/src/duckdb/src/include/duckdb/common/exception.hpp

@@ -22,8 +22,8 @@ enum class PhysicalType : uint8_t;
 struct LogicalType;
 struct hugeint_t;
 
-inline void assert_restrict_function(void *left_start, void *left_end, void *right_start, void *right_end,
-                                     const char *fname, int linenr) {
+inline void assert_restrict_function(const void *left_start, const void *left_end, const void *right_start,
+                                     const void *right_end, const char *fname, int linenr) {
 	// assert that the two pointers do not overlap
 #ifdef DEBUG
 	if (!(left_end <= right_start || right_end <= left_start)) {
@@ -105,6 +105,9 @@ public:
 
 	template <typename... Args>
 	static string ConstructMessage(const string &msg, Args... params) {
+		const std::size_t num_args = sizeof...(Args);
+		if (num_args == 0)
+			return msg;
 		std::vector<ExceptionFormatValue> values;
 		return ConstructMessageRecursive(msg, values, params...);
 	}

package/src/duckdb/src/include/duckdb/common/field_writer.hpp

@@ -34,12 +34,12 @@ public:
 		static_assert(std::is_trivially_destructible<T>(), "WriteField object must be trivially destructible");
 
 		AddField();
-		WriteData((const_data_ptr_t)&element, sizeof(T));
+		WriteData(const_data_ptr_cast(&element), sizeof(T));
 	}
 
 	//! Write a string with a length prefix
 	void WriteString(const string &val) {
-		WriteStringLen((const_data_ptr_t)val.c_str(), val.size());
+		WriteStringLen(const_data_ptr_cast(val.c_str()), val.size());
 	}
 	void WriteStringLen(const_data_ptr_t val, idx_t len) {
 		AddField();
@@ -135,7 +135,7 @@ public:
 private:
 	template <class T>
 	void Write(const T &element) {
-		WriteData((const_data_ptr_t)&element, sizeof(T));
+		WriteData(const_data_ptr_cast(&element), sizeof(T));
 	}
 
 	DUCKDB_API void WriteData(const_data_ptr_t buffer, idx_t write_size);

package/src/duckdb/src/include/duckdb/common/file_system.hpp

@@ -77,6 +77,17 @@ public:
 		return path;
 	}
 
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
+
 public:
 	FileSystem &file_system;
 	string path;

package/src/duckdb/src/include/duckdb/common/fsst.hpp

@@ -12,9 +12,8 @@ namespace duckdb {
 
 class FSSTPrimitives {
 public:
-	static string_t DecompressValue(void *duckdb_fsst_decoder, Vector &result, unsigned char *compressed_string,
+	static string_t DecompressValue(void *duckdb_fsst_decoder, Vector &result, const char *compressed_string,
 	                                idx_t compressed_string_len);
-	static Value DecompressValue(void *duckdb_fsst_decoder, unsigned char *compressed_string,
-	                             idx_t compressed_string_len);
+	static Value DecompressValue(void *duckdb_fsst_decoder, const char *compressed_string, idx_t compressed_string_len);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/radix.hpp

@@ -36,7 +36,7 @@ struct Radix {
 public:
 	static inline bool IsLittleEndian() {
 		int n = 1;
-		if (*(char *)&n == 1) {
+		if (*char_ptr_cast(&n) == 1) {
 			return true;
 		} else {
 			return false;
@@ -81,7 +81,7 @@ public:
 		if (x < -FLT_MAX) {
 			return 0;
 		}
-		buff = Load<uint32_t>((const_data_ptr_t)&x);
+		buff = Load<uint32_t>(const_data_ptr_cast(&x));
 		if ((buff & (1u << 31)) == 0) { //! +0 and positive numbers
 			buff |= (1u << 31);
 		} else {          //! negative numbers
@@ -111,7 +111,7 @@ public:
 		if (x < -DBL_MAX) {
 			return 0;
 		}
-		buff = Load<uint64_t>((const_data_ptr_t)&x);
+		buff = Load<uint64_t>(const_data_ptr_cast(&x));
 		if (buff < (1ull << 63)) { //! +0 and positive numbers
 			buff += (1ull << 63);
 		} else {          //! negative numbers

package/src/duckdb/src/include/duckdb/common/serializer/binary_deserializer.hpp

@@ -35,7 +35,7 @@ private:
 	template <class T>
 	T ReadPrimitive() {
 		T value;
-		ReadData((data_ptr_t)&value, sizeof(T));
+		ReadData(data_ptr_cast(&value), sizeof(T));
 		return value;
 	}
 

package/src/duckdb/src/include/duckdb/common/serializer/binary_serializer.hpp

@@ -24,12 +24,15 @@ private:
 	template <class T>
 	void Write(T element) {
 		static_assert(std::is_trivially_destructible<T>(), "Write element must be trivially destructible");
-		WriteData((const_data_ptr_t)&element, sizeof(T));
+		WriteData(const_data_ptr_cast(&element), sizeof(T));
 	}
 	void WriteData(const_data_ptr_t buffer, idx_t write_size) {
 		data.insert(data.end(), buffer, buffer + write_size);
 		stack.back().size += write_size;
 	}
+	void WriteData(const char *ptr, idx_t write_size) {
+		WriteData(const_data_ptr_cast(ptr), write_size);
+	}
 
 	explicit BinarySerializer() {
 		serialize_enum_as_string = false;

package/src/duckdb/src/include/duckdb/common/serializer.hpp

@@ -46,16 +46,16 @@ public:
 	void Write(T element) {
 		static_assert(std::is_trivially_destructible<T>(), "Write element must be trivially destructible");
 
-		WriteData((const_data_ptr_t)&element, sizeof(T));
+		WriteData(const_data_ptr_cast(&element), sizeof(T));
 	}
 
 	//! Write data from a string buffer directly (without length prefix)
 	void WriteBufferData(const string &str) {
-		WriteData((const_data_ptr_t)str.c_str(), str.size());
+		WriteData(const_data_ptr_cast(str.c_str()), str.size());
 	}
 	//! Write a string with a length prefix
 	void WriteString(const string &val) {
-		WriteStringLen((const_data_ptr_t)val.c_str(), val.size());
+		WriteStringLen(const_data_ptr_cast(val.c_str()), val.size());
 	}
 	void WriteStringLen(const_data_ptr_t val, idx_t len) {
 		Write<uint32_t>((uint32_t)len);
@@ -127,7 +127,7 @@ public:
 	template <class T>
 	T Read() {
 		T value;
-		ReadData((data_ptr_t)&value, sizeof(T));
+		ReadData(data_ptr_cast(&value), sizeof(T));
 		return value;
 	}
 

package/src/duckdb/src/include/duckdb/common/typedefs.hpp

@@ -28,4 +28,34 @@ typedef idx_t column_t;
 //! Type used for storage (column) identifiers
 typedef idx_t storage_t;
 
+template <class SRC>
+data_ptr_t data_ptr_cast(SRC *src) {
+	return reinterpret_cast<data_ptr_t>(src);
+}
+
+template <class SRC>
+const_data_ptr_t const_data_ptr_cast(const SRC *src) {
+	return reinterpret_cast<const_data_ptr_t>(src);
+}
+
+template <class SRC>
+char *char_ptr_cast(SRC *src) {
+	return reinterpret_cast<char *>(src);
+}
+
+template <class SRC>
+const char *const_char_ptr_cast(const SRC *src) {
+	return reinterpret_cast<const char *>(src);
+}
+
+template <class SRC>
+const unsigned char *const_uchar_ptr_cast(const SRC *src) {
+	return reinterpret_cast<const unsigned char *>(src);
+}
+
+template <class SRC>
+uintptr_t CastPointerToValue(SRC *src) {
+	return uintptr_t(src);
+}
+
 } // namespace duckdb

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

@@ -108,6 +108,18 @@ protected:
 	mutex lock;
 	shared_ptr<PartitionColumnDataAllocators> allocators;
 	vector<unique_ptr<ColumnDataCollection>> partitions;
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 };
 
 } // namespace duckdb

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

@@ -12,6 +12,10 @@
 #include "duckdb/common/types/vector.hpp"
 #include "hyperloglog.hpp"
 
+namespace duckdb_hll {
+struct robj;
+}
+
 namespace duckdb {
 
 enum class HLLStorageType { UNCOMPRESSED = 1 };
@@ -58,9 +62,9 @@ public:
 	void AddToLog(UnifiedVectorFormat &vdata, idx_t count, uint64_t indices[], uint8_t counts[]);
 
 private:
-	explicit HyperLogLog(void *hll);
+	explicit HyperLogLog(duckdb_hll::robj *hll);
 
-	void *hll;
+	duckdb_hll::robj *hll;
 	mutex lock;
 };
 } // namespace duckdb