duckdb 0.8.1-dev26.0 → 0.8.1-dev287.0

package/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_compress.hpp

@@ -127,7 +127,7 @@ public:
 	}
 
 	void Append(UnifiedVectorFormat &vdata, idx_t count) {
-		auto data = (CHIMP_TYPE *)vdata.data;
+		auto data = UnifiedVectorFormat::GetData<CHIMP_TYPE>(vdata);
 
 		for (idx_t i = 0; i < count; i++) {
 			auto idx = vdata.sel->get_index(i);
@@ -145,7 +145,7 @@ public:
 		current_segment->count++;
 
 		if (is_valid) {
-			T floating_point_value = Load<T>((const_data_ptr_t)&value);
+			T floating_point_value = Load<T>(const_data_ptr_cast(&value));
 			NumericStats::Update<T>(current_segment->stats.statistics, floating_point_value);
 		} else {
 			//! FIXME: find a cheaper alternative to storing a NULL

package/src/duckdb/src/include/duckdb/storage/compression/patas/patas_analyze.hpp

@@ -102,7 +102,7 @@ struct EmptyPatasWriter {
 		using EXACT_TYPE = typename FloatingToExact<VALUE_TYPE>::type;
 
 		auto state_wrapper = (PatasAnalyzeState<VALUE_TYPE> *)state_p;
-		state_wrapper->WriteValue(Load<EXACT_TYPE>((const_data_ptr_t)&uncompressed_value), is_valid);
+		state_wrapper->WriteValue(Load<EXACT_TYPE>(const_data_ptr_cast(&uncompressed_value)), is_valid);
 	}
 };
 
@@ -117,7 +117,7 @@ bool PatasAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
 	UnifiedVectorFormat vdata;
 	input.ToUnifiedFormat(count, vdata);
 
-	auto 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);
 		analyze_state.state.template Update<EmptyPatasWriter>(data[idx], vdata.validity.RowIsValid(idx));

package/src/duckdb/src/include/duckdb/storage/compression/patas/patas_compress.hpp

@@ -52,7 +52,7 @@ public:
 				NumericStats::Update<VALUE_TYPE>(state_wrapper->current_segment->stats.statistics, value);
 			}
 
-			state_wrapper->WriteValue(Load<EXACT_TYPE>((const_data_ptr_t)&value));
+			state_wrapper->WriteValue(Load<EXACT_TYPE>(const_data_ptr_cast(&value)));
 		}
 	};
 
@@ -138,7 +138,7 @@ public:
 	}
 
 	void Append(UnifiedVectorFormat &vdata, idx_t count) {
-		auto 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);

package/src/duckdb/src/include/duckdb/storage/index.hpp

@@ -153,13 +153,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/storage/partial_block_manager.hpp

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

package/src/duckdb/src/include/duckdb/storage/storage_manager.hpp

@@ -82,6 +82,18 @@ protected:
 	unique_ptr<WriteAheadLog> wal;
 	//! Whether or not the database is opened in read-only mode
 	bool read_only;
+
+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);
+	}
 };
 
 //! Stores database in a single file.

package/src/duckdb/src/include/duckdb/storage/string_uncompressed.hpp

@@ -80,7 +80,7 @@ public:
 	                              UnifiedVectorFormat &data, idx_t offset, idx_t count) {
 		D_ASSERT(segment.GetBlockOffset() == 0);
 		auto handle_ptr = handle.Ptr();
-		auto source_data = (string_t *)data.data;
+		auto source_data = UnifiedVectorFormat::GetData<string_t>(data);
 		auto result_data = (int32_t *)(handle_ptr + DICTIONARY_HEADER_SIZE);
 		uint32_t *dictionary_size = (uint32_t *)handle_ptr;
 		uint32_t *dictionary_end = (uint32_t *)(handle_ptr + sizeof(uint32_t));

package/src/duckdb/src/include/duckdb/storage/table/chunk_info.hpp

@@ -44,11 +44,31 @@ public:
 
 	virtual void Serialize(Serializer &serialize) = 0;
 	static unique_ptr<ChunkInfo> Deserialize(Deserializer &source);
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		if (type != TARGET::TYPE) {
+			throw InternalException("Failed to cast chunk info to type - query result type mismatch");
+		}
+		return reinterpret_cast<TARGET &>(*this);
+	}
+
+	template <class TARGET>
+	const TARGET &Cast() const {
+		if (type != TARGET::TYPE) {
+			throw InternalException("Failed to cast chunk info to type - query result type mismatch");
+		}
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 };
 
 class ChunkConstantInfo : public ChunkInfo {
 public:
-	ChunkConstantInfo(idx_t start);
+	static constexpr const ChunkInfoType TYPE = ChunkInfoType::CONSTANT_INFO;
+
+public:
+	explicit ChunkConstantInfo(idx_t start);
 
 	atomic<transaction_t> insert_id;
 	atomic<transaction_t> delete_id;
@@ -71,7 +91,10 @@ private:
 
 class ChunkVectorInfo : public ChunkInfo {
 public:
-	ChunkVectorInfo(idx_t start);
+	static constexpr const ChunkInfoType TYPE = ChunkInfoType::VECTOR_INFO;
+
+public:
+	explicit ChunkVectorInfo(idx_t start);
 
 	//! The transaction ids of the transactions that inserted the tuples (if any)
 	atomic<transaction_t> inserted[STANDARD_VECTOR_SIZE];

package/src/duckdb/src/include/duckdb/storage/table/column_checkpoint_state.hpp

@@ -42,6 +42,18 @@ public:
 
 	virtual void FlushSegment(unique_ptr<ColumnSegment> segment, idx_t segment_size);
 	virtual void WriteDataPointers(RowGroupWriter &writer);
+
+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);
+	}
 };
 
 struct PartialBlockForCheckpoint : public PartialBlock {

package/src/duckdb/src/include/duckdb/storage/table/scan_state.hpp

@@ -35,11 +35,33 @@ class RowGroupSegmentTree;
 struct SegmentScanState {
 	virtual ~SegmentScanState() {
 	}
+
+	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);
+	}
 };
 
 struct IndexScanState {
 	virtual ~IndexScanState() {
 	}
+
+	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 unordered_map<block_id_t, BufferHandle> buffer_handle_set_t;

package/src/duckdb/src/include/duckdb/transaction/duck_transaction_manager.hpp

@@ -46,9 +46,9 @@ public:
 	}
 
 private:
-	bool CanCheckpoint(DuckTransaction *current = nullptr);
+	bool CanCheckpoint(optional_ptr<DuckTransaction> current = nullptr);
 	//! Remove the given transaction from the list of active transactions
-	void RemoveTransaction(DuckTransaction *transaction) noexcept;
+	void RemoveTransaction(DuckTransaction &transaction) noexcept;
 	void LockClients(vector<ClientLockWrapper> &client_locks, ClientContext &context);
 
 private:

package/src/duckdb/src/include/duckdb/transaction/transaction.hpp

@@ -62,12 +62,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/main/capi/appender-c.cpp

@@ -12,7 +12,7 @@ using duckdb::timestamp_t;
 
 duckdb_state duckdb_appender_create(duckdb_connection connection, const char *schema, const char *table,
                                     duckdb_appender *out_appender) {
-	Connection *conn = (Connection *)connection;
+	Connection *conn = reinterpret_cast<Connection *>(connection);
 
 	if (!connection || !table || !out_appender) {
 		return DuckDBError;
@@ -39,7 +39,7 @@ duckdb_state duckdb_appender_destroy(duckdb_appender *appender) {
 		return DuckDBError;
 	}
 	duckdb_appender_close(*appender);
-	auto wrapper = (AppenderWrapper *)*appender;
+	auto wrapper = reinterpret_cast<AppenderWrapper *>(*appender);
 	if (wrapper) {
 		delete wrapper;
 	}
@@ -52,7 +52,7 @@ duckdb_state duckdb_appender_run_function(duckdb_appender appender, FUN &&functi
 	if (!appender) {
 		return DuckDBError;
 	}
-	auto wrapper = (AppenderWrapper *)appender;
+	auto wrapper = reinterpret_cast<AppenderWrapper *>(appender);
 	if (!wrapper->appender) {
 		return DuckDBError;
 	}
@@ -72,7 +72,7 @@ const char *duckdb_appender_error(duckdb_appender appender) {
 	if (!appender) {
 		return nullptr;
 	}
-	auto wrapper = (AppenderWrapper *)appender;
+	auto wrapper = reinterpret_cast<AppenderWrapper *>(appender);
 	if (wrapper->error.empty()) {
 		return nullptr;
 	}
@@ -92,7 +92,7 @@ duckdb_state duckdb_append_internal(duckdb_appender appender, T value) {
 	if (!appender) {
 		return DuckDBError;
 	}
-	auto *appender_instance = (AppenderWrapper *)appender;
+	auto *appender_instance = reinterpret_cast<AppenderWrapper *>(appender);
 	try {
 		appender_instance->appender->Append<T>(value);
 	} catch (std::exception &ex) {

package/src/duckdb/src/main/capi/arrow-c.cpp

@@ -23,7 +23,7 @@ duckdb_state duckdb_query_arrow_schema(duckdb_arrow result, duckdb_arrow_schema
 	if (!out_schema) {
 		return DuckDBSuccess;
 	}
-	auto wrapper = (ArrowResultWrapper *)result;
+	auto wrapper = reinterpret_cast<ArrowResultWrapper *>(result);
 	ArrowConverter::ToArrowSchema((ArrowSchema *)*out_schema, wrapper->result->types, wrapper->result->names,
 	                              wrapper->timezone_config);
 	return DuckDBSuccess;
@@ -33,7 +33,7 @@ duckdb_state duckdb_query_arrow_array(duckdb_arrow result, duckdb_arrow_array *o
 	if (!out_array) {
 		return DuckDBSuccess;
 	}
-	auto wrapper = (ArrowResultWrapper *)result;
+	auto wrapper = reinterpret_cast<ArrowResultWrapper *>(result);
 	auto success = wrapper->result->TryFetch(wrapper->current_chunk, wrapper->result->GetErrorObject());
 	if (!success) { // LCOV_EXCL_START
 		return DuckDBError;
@@ -41,12 +41,12 @@ duckdb_state duckdb_query_arrow_array(duckdb_arrow result, duckdb_arrow_array *o
 	if (!wrapper->current_chunk || wrapper->current_chunk->size() == 0) {
 		return DuckDBSuccess;
 	}
-	ArrowConverter::ToArrowArray(*wrapper->current_chunk, (ArrowArray *)*out_array);
+	ArrowConverter::ToArrowArray(*wrapper->current_chunk, reinterpret_cast<ArrowArray *>(*out_array));
 	return DuckDBSuccess;
 }
 
 idx_t duckdb_arrow_row_count(duckdb_arrow result) {
-	auto wrapper = (ArrowResultWrapper *)result;
+	auto wrapper = reinterpret_cast<ArrowResultWrapper *>(result);
 	if (wrapper->result->HasError()) {
 		return 0;
 	}
@@ -54,12 +54,12 @@ idx_t duckdb_arrow_row_count(duckdb_arrow result) {
 }
 
 idx_t duckdb_arrow_column_count(duckdb_arrow result) {
-	auto wrapper = (ArrowResultWrapper *)result;
+	auto wrapper = reinterpret_cast<ArrowResultWrapper *>(result);
 	return wrapper->result->ColumnCount();
 }
 
 idx_t duckdb_arrow_rows_changed(duckdb_arrow result) {
-	auto wrapper = (ArrowResultWrapper *)result;
+	auto wrapper = reinterpret_cast<ArrowResultWrapper *>(result);
 	if (wrapper->result->HasError()) {
 		return 0;
 	}
@@ -76,20 +76,20 @@ idx_t duckdb_arrow_rows_changed(duckdb_arrow result) {
 }
 
 const char *duckdb_query_arrow_error(duckdb_arrow result) {
-	auto wrapper = (ArrowResultWrapper *)result;
+	auto wrapper = reinterpret_cast<ArrowResultWrapper *>(result);
 	return wrapper->result->GetError().c_str();
 }
 
 void duckdb_destroy_arrow(duckdb_arrow *result) {
 	if (*result) {
-		auto wrapper = (ArrowResultWrapper *)*result;
+		auto wrapper = reinterpret_cast<ArrowResultWrapper *>(*result);
 		delete wrapper;
 		*result = nullptr;
 	}
 }
 
 duckdb_state duckdb_execute_prepared_arrow(duckdb_prepared_statement prepared_statement, duckdb_arrow *out_result) {
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
+	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
 	if (!wrapper || !wrapper->statement || wrapper->statement->HasError() || !out_result) {
 		return DuckDBError;
 	}
@@ -105,6 +105,6 @@ duckdb_state duckdb_execute_prepared_arrow(duckdb_prepared_statement prepared_st
 	auto result = wrapper->statement->Execute(wrapper->values, false);
 	D_ASSERT(result->type == QueryResultType::MATERIALIZED_RESULT);
 	arrow_wrapper->result = duckdb::unique_ptr_cast<QueryResult, MaterializedQueryResult>(std::move(result));
-	*out_result = (duckdb_arrow)arrow_wrapper;
+	*out_result = reinterpret_cast<duckdb_arrow>(arrow_wrapper);
 	return !arrow_wrapper->result->HasError() ? DuckDBSuccess : DuckDBError;
 }

package/src/duckdb/src/main/capi/cast/from_decimal-c.cpp

@@ -34,7 +34,7 @@ bool CastDecimalCInternal(duckdb_result *source, duckdb_string &result, idx_t co
 	default:
 		throw duckdb::InternalException("Unimplemented internal type for decimal");
 	}
-	result.data = (char *)duckdb_malloc(sizeof(char) * (result_string.GetSize() + 1));
+	result.data = reinterpret_cast<char *>(duckdb_malloc(sizeof(char) * (result_string.GetSize() + 1)));
 	memcpy(result.data, result_string.GetData(), result_string.GetSize());
 	result.data[result_string.GetSize()] = '\0';
 	result.size = result_string.GetSize();

package/src/duckdb/src/main/capi/cast/utils-c.cpp

@@ -68,7 +68,7 @@ duckdb_blob FetchDefaultValue::Operation() {
 
 template <>
 bool FromCBlobCastWrapper::Operation(duckdb_blob input, duckdb_string &result) {
-	string_t input_str((const char *)input.data, input.size);
+	string_t input_str(const_char_ptr_cast(input.data), input.size);
 	return ToCStringCastWrapper<duckdb::CastFromBlob>::template Operation<string_t, duckdb_string>(input_str, result);
 }
 

package/src/duckdb/src/main/capi/config-c.cpp

@@ -16,7 +16,7 @@ duckdb_state duckdb_create_config(duckdb_config *out_config) {
 	} catch (...) { // LCOV_EXCL_START
 		return DuckDBError;
 	} // LCOV_EXCL_STOP
-	*out_config = (duckdb_config)config;
+	*out_config = reinterpret_cast<duckdb_config>(config);
 	return DuckDBSuccess;
 }
 
@@ -42,13 +42,10 @@ duckdb_state duckdb_set_config(duckdb_config config, const char *name, const cha
 	if (!config || !name || !option) {
 		return DuckDBError;
 	}
-	auto config_option = DBConfig::GetOptionByName(name);
-	if (!config_option) {
-		return DuckDBError;
-	}
+
 	try {
 		auto db_config = (DBConfig *)config;
-		db_config->SetOption(*config_option, Value(option));
+		db_config->SetOptionByName(name, Value(option));
 	} catch (...) {
 		return DuckDBError;
 	}

package/src/duckdb/src/main/capi/data_chunk-c.cpp

@@ -10,7 +10,7 @@ duckdb_data_chunk duckdb_create_data_chunk(duckdb_logical_type *ctypes, idx_t co
 	}
 	duckdb::vector<duckdb::LogicalType> types;
 	for (idx_t i = 0; i < column_count; i++) {
-		auto ltype = (duckdb::LogicalType *)ctypes[i];
+		auto ltype = reinterpret_cast<duckdb::LogicalType *>(ctypes[i]);
 		types.push_back(*ltype);
 	}
 
@@ -21,7 +21,7 @@ duckdb_data_chunk duckdb_create_data_chunk(duckdb_logical_type *ctypes, idx_t co
 
 void duckdb_destroy_data_chunk(duckdb_data_chunk *chunk) {
 	if (chunk && *chunk) {
-		auto dchunk = (duckdb::DataChunk *)*chunk;
+		auto dchunk = reinterpret_cast<duckdb::DataChunk *>(*chunk);
 		delete dchunk;
 		*chunk = nullptr;
 	}
@@ -31,7 +31,7 @@ void duckdb_data_chunk_reset(duckdb_data_chunk chunk) {
 	if (!chunk) {
 		return;
 	}
-	auto dchunk = (duckdb::DataChunk *)chunk;
+	auto dchunk = reinterpret_cast<duckdb::DataChunk *>(chunk);
 	dchunk->Reset();
 }
 
@@ -39,7 +39,7 @@ idx_t duckdb_data_chunk_get_column_count(duckdb_data_chunk chunk) {
 	if (!chunk) {
 		return 0;
 	}
-	auto dchunk = (duckdb::DataChunk *)chunk;
+	auto dchunk = reinterpret_cast<duckdb::DataChunk *>(chunk);
 	return dchunk->ColumnCount();
 }
 
@@ -47,7 +47,7 @@ duckdb_vector duckdb_data_chunk_get_vector(duckdb_data_chunk chunk, idx_t col_id
 	if (!chunk || col_idx >= duckdb_data_chunk_get_column_count(chunk)) {
 		return nullptr;
 	}
-	auto dchunk = (duckdb::DataChunk *)chunk;
+	auto dchunk = reinterpret_cast<duckdb::DataChunk *>(chunk);
 	return reinterpret_cast<duckdb_vector>(&dchunk->data[col_idx]);
 }
 
@@ -55,7 +55,7 @@ idx_t duckdb_data_chunk_get_size(duckdb_data_chunk chunk) {
 	if (!chunk) {
 		return 0;
 	}
-	auto dchunk = (duckdb::DataChunk *)chunk;
+	auto dchunk = reinterpret_cast<duckdb::DataChunk *>(chunk);
 	return dchunk->size();
 }
 
@@ -63,7 +63,7 @@ void duckdb_data_chunk_set_size(duckdb_data_chunk chunk, idx_t size) {
 	if (!chunk) {
 		return;
 	}
-	auto dchunk = (duckdb::DataChunk *)chunk;
+	auto dchunk = reinterpret_cast<duckdb::DataChunk *>(chunk);
 	dchunk->SetCardinality(size);
 }
 
@@ -71,7 +71,7 @@ duckdb_logical_type duckdb_vector_get_column_type(duckdb_vector vector) {
 	if (!vector) {
 		return nullptr;
 	}
-	auto v = (duckdb::Vector *)vector;
+	auto v = reinterpret_cast<duckdb::Vector *>(vector);
 	return reinterpret_cast<duckdb_logical_type>(new duckdb::LogicalType(v->GetType()));
 }
 
@@ -79,7 +79,7 @@ void *duckdb_vector_get_data(duckdb_vector vector) {
 	if (!vector) {
 		return nullptr;
 	}
-	auto v = (duckdb::Vector *)vector;
+	auto v = reinterpret_cast<duckdb::Vector *>(vector);
 	return duckdb::FlatVector::GetData(*v);
 }
 
@@ -87,7 +87,7 @@ uint64_t *duckdb_vector_get_validity(duckdb_vector vector) {
 	if (!vector) {
 		return nullptr;
 	}
-	auto v = (duckdb::Vector *)vector;
+	auto v = reinterpret_cast<duckdb::Vector *>(vector);
 	return duckdb::FlatVector::Validity(*v).GetData();
 }
 
@@ -95,7 +95,7 @@ void duckdb_vector_ensure_validity_writable(duckdb_vector vector) {
 	if (!vector) {
 		return;
 	}
-	auto v = (duckdb::Vector *)vector;
+	auto v = reinterpret_cast<duckdb::Vector *>(vector);
 	auto &validity = duckdb::FlatVector::Validity(*v);
 	validity.EnsureWritable();
 }
@@ -108,7 +108,7 @@ void duckdb_vector_assign_string_element_len(duckdb_vector vector, idx_t index,
 	if (!vector) {
 		return;
 	}
-	auto v = (duckdb::Vector *)vector;
+	auto v = reinterpret_cast<duckdb::Vector *>(vector);
 	auto data = duckdb::FlatVector::GetData<duckdb::string_t>(*v);
 	data[index] = duckdb::StringVector::AddString(*v, str, str_len);
 }
@@ -117,7 +117,7 @@ duckdb_vector duckdb_list_vector_get_child(duckdb_vector vector) {
 	if (!vector) {
 		return nullptr;
 	}
-	auto v = (duckdb::Vector *)vector;
+	auto v = reinterpret_cast<duckdb::Vector *>(vector);
 	return reinterpret_cast<duckdb_vector>(&duckdb::ListVector::GetEntry(*v));
 }
 
@@ -125,7 +125,7 @@ idx_t duckdb_list_vector_get_size(duckdb_vector vector) {
 	if (!vector) {
 		return 0;
 	}
-	auto v = (duckdb::Vector *)vector;
+	auto v = reinterpret_cast<duckdb::Vector *>(vector);
 	return duckdb::ListVector::GetListSize(*v);
 }
 
@@ -133,7 +133,7 @@ duckdb_state duckdb_list_vector_set_size(duckdb_vector vector, idx_t size) {
 	if (!vector) {
 		return duckdb_state::DuckDBError;
 	}
-	auto v = (duckdb::Vector *)vector;
+	auto v = reinterpret_cast<duckdb::Vector *>(vector);
 	duckdb::ListVector::SetListSize(*v, size);
 	return duckdb_state::DuckDBSuccess;
 }
@@ -142,7 +142,7 @@ duckdb_state duckdb_list_vector_reserve(duckdb_vector vector, idx_t required_cap
 	if (!vector) {
 		return duckdb_state::DuckDBError;
 	}
-	auto v = (duckdb::Vector *)vector;
+	auto v = reinterpret_cast<duckdb::Vector *>(vector);
 	duckdb::ListVector::Reserve(*v, required_capacity);
 	return duckdb_state::DuckDBSuccess;
 }
@@ -151,7 +151,7 @@ duckdb_vector duckdb_struct_vector_get_child(duckdb_vector vector, idx_t index)
 	if (!vector) {
 		return nullptr;
 	}
-	auto v = (duckdb::Vector *)vector;
+	auto v = reinterpret_cast<duckdb::Vector *>(vector);
 	return reinterpret_cast<duckdb_vector>(duckdb::StructVector::GetEntries(*v)[index].get());
 }
 

package/src/duckdb/src/main/capi/duckdb-c.cpp

@@ -33,7 +33,7 @@ duckdb_state duckdb_open(const char *path, duckdb_database *out) {
 
 void duckdb_close(duckdb_database *database) {
 	if (database && *database) {
-		auto wrapper = (DatabaseData *)*database;
+		auto wrapper = reinterpret_cast<DatabaseData *>(*database);
 		delete wrapper;
 		*database = nullptr;
 	}
@@ -43,7 +43,7 @@ duckdb_state duckdb_connect(duckdb_database database, duckdb_connection *out) {
 	if (!database || !out) {
 		return DuckDBError;
 	}
-	auto wrapper = (DatabaseData *)database;
+	auto wrapper = reinterpret_cast<DatabaseData *>(database);
 	Connection *connection;
 	try {
 		connection = new Connection(*wrapper->database);
@@ -56,14 +56,14 @@ duckdb_state duckdb_connect(duckdb_database database, duckdb_connection *out) {
 
 void duckdb_disconnect(duckdb_connection *connection) {
 	if (connection && *connection) {
-		Connection *conn = (Connection *)*connection;
+		Connection *conn = reinterpret_cast<Connection *>(*connection);
 		delete conn;
 		*connection = nullptr;
 	}
 }
 
 duckdb_state duckdb_query(duckdb_connection connection, const char *query, duckdb_result *out) {
-	Connection *conn = (Connection *)connection;
+	Connection *conn = reinterpret_cast<Connection *>(connection);
 	auto result = conn->Query(query);
 	return duckdb_translate_result(std::move(result), out);
 }

package/src/duckdb/src/main/capi/duckdb_value-c.cpp

@@ -2,7 +2,7 @@
 
 void duckdb_destroy_value(duckdb_value *value) {
 	if (value && *value) {
-		auto val = (duckdb::Value *)*value;
+		auto val = reinterpret_cast<duckdb::Value *>(*value);
 		delete val;
 		*value = nullptr;
 	}
@@ -22,18 +22,18 @@ duckdb_value duckdb_create_int64(int64_t input) {
 }
 
 char *duckdb_get_varchar(duckdb_value value) {
-	auto val = (duckdb::Value *)value;
+	auto val = reinterpret_cast<duckdb::Value *>(value);
 	auto str_val = val->DefaultCastAs(duckdb::LogicalType::VARCHAR);
 	auto &str = duckdb::StringValue::Get(str_val);
 
-	auto result = (char *)malloc(sizeof(char *) * (str.size() + 1));
+	auto result = reinterpret_cast<char *>(malloc(sizeof(char *) * (str.size() + 1)));
 	memcpy(result, str.c_str(), str.size());
 	result[str.size()] = '\0';
 	return result;
 }
 
 int64_t duckdb_get_int64(duckdb_value value) {
-	auto val = (duckdb::Value *)value;
+	auto val = reinterpret_cast<duckdb::Value *>(value);
 	if (!val->DefaultTryCastAs(duckdb::LogicalType::BIGINT)) {
 		return 0;
 	}