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

package/src/duckdb/src/include/duckdb/planner/expression/bound_subquery_expression.hpp

@@ -55,7 +55,7 @@ public:
 
 	string ToString() const override;
 
-	bool Equals(const BaseExpression *other) const override;
+	bool Equals(const BaseExpression &other) const override;
 
 	unique_ptr<Expression> Copy() override;
 

package/src/duckdb/src/include/duckdb/planner/expression/bound_unnest_expression.hpp

@@ -27,7 +27,7 @@ public:
 	string ToString() const override;
 
 	hash_t Hash() const override;
-	bool Equals(const BaseExpression *other) const override;
+	bool Equals(const BaseExpression &other) const override;
 
 	unique_ptr<Expression> Copy() override;
 

package/src/duckdb/src/include/duckdb/planner/expression/bound_window_expression.hpp

@@ -61,7 +61,7 @@ public:
 	string ToString() const override;
 
 	bool KeysAreCompatible(const BoundWindowExpression &other) const;
-	bool Equals(const BaseExpression *other) const override;
+	bool Equals(const BaseExpression &other) const override;
 
 	unique_ptr<Expression> Copy() override;
 

package/src/duckdb/src/include/duckdb/planner/expression.hpp

@@ -41,19 +41,17 @@ public:
 
 	hash_t Hash() const override;
 
-	bool Equals(const BaseExpression *other) const override {
+	bool Equals(const BaseExpression &other) const override {
 		if (!BaseExpression::Equals(other)) {
 			return false;
 		}
-		return return_type == ((Expression *)other)->return_type;
-	}
-
-	static bool Equals(const Expression *left, const Expression *right) {
-		return BaseExpression::Equals((const BaseExpression *)left, (const BaseExpression *)right);
+		return return_type == ((Expression &)other).return_type;
 	}
 	static bool Equals(const Expression &left, const Expression &right) {
-		return left.Equals(&right);
+		return left.Equals(right);
 	}
+	static bool Equals(const unique_ptr<Expression> &left, const unique_ptr<Expression> &right);
+	static bool ListEquals(const vector<unique_ptr<Expression>> &left, const vector<unique_ptr<Expression>> &right);
 	//! Create a copy of this expression
 	virtual unique_ptr<Expression> Copy() = 0;
 

package/src/duckdb/src/include/duckdb/planner/filter/conjunction_filter.hpp

@@ -33,6 +33,9 @@ public:
 };
 
 class ConjunctionOrFilter : public ConjunctionFilter {
+public:
+	static constexpr const TableFilterType TYPE = TableFilterType::CONJUNCTION_OR;
+
 public:
 	ConjunctionOrFilter();
 
@@ -45,6 +48,9 @@ public:
 };
 
 class ConjunctionAndFilter : public ConjunctionFilter {
+public:
+	static constexpr const TableFilterType TYPE = TableFilterType::CONJUNCTION_AND;
+
 public:
 	ConjunctionAndFilter();
 

package/src/duckdb/src/include/duckdb/planner/filter/constant_filter.hpp

@@ -15,6 +15,9 @@
 namespace duckdb {
 
 class ConstantFilter : public TableFilter {
+public:
+	static constexpr const TableFilterType TYPE = TableFilterType::CONSTANT_COMPARISON;
+
 public:
 	ConstantFilter(ExpressionType comparison_type, Value constant);
 

package/src/duckdb/src/include/duckdb/planner/filter/null_filter.hpp

@@ -13,6 +13,9 @@
 namespace duckdb {
 
 class IsNullFilter : public TableFilter {
+public:
+	static constexpr const TableFilterType TYPE = TableFilterType::IS_NULL;
+
 public:
 	IsNullFilter();
 
@@ -24,6 +27,9 @@ public:
 };
 
 class IsNotNullFilter : public TableFilter {
+public:
+	static constexpr const TableFilterType TYPE = TableFilterType::IS_NOT_NULL;
+
 public:
 	IsNotNullFilter();
 

package/src/duckdb/src/include/duckdb/planner/logical_operator.hpp

@@ -96,7 +96,7 @@ public:
 		if (TARGET::TYPE != LogicalOperatorType::LOGICAL_INVALID && type != TARGET::TYPE) {
 			throw InternalException("Failed to cast logical operator to type - logical operator type mismatch");
 		}
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 
 	template <class TARGET>
@@ -104,7 +104,7 @@ public:
 		if (TARGET::TYPE != LogicalOperatorType::LOGICAL_INVALID && type != TARGET::TYPE) {
 			throw InternalException("Failed to cast logical operator to type - logical operator type mismatch");
 		}
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_pivot.hpp

@@ -17,6 +17,9 @@
 namespace duckdb {
 
 class LogicalPivot : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_PIVOT;
+
 public:
 	LogicalPivot(idx_t pivot_idx, unique_ptr<LogicalOperator> plan, BoundPivotInfo info);
 

package/src/duckdb/src/include/duckdb/planner/table_binding.hpp

@@ -55,9 +55,29 @@ public:
 	virtual string ColumnNotFoundError(const string &column_name) const;
 	virtual BindResult Bind(ColumnRefExpression &colref, idx_t depth);
 	virtual optional_ptr<StandardEntry> GetStandardEntry();
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		if (binding_type != TARGET::TYPE) {
+			throw InternalException("Failed to cast binding to type - binding type mismatch");
+		}
+		return reinterpret_cast<TARGET &>(*this);
+	}
+
+	template <class TARGET>
+	const TARGET &Cast() const {
+		if (binding_type != TARGET::TYPE) {
+			throw InternalException("Failed to cast binding to type - binding type mismatch");
+		}
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 };
 
 struct EntryBinding : public Binding {
+public:
+	static constexpr const BindingType TYPE = BindingType::CATALOG_ENTRY;
+
 public:
 	EntryBinding(const string &alias, vector<LogicalType> types, vector<string> names, idx_t index,
 	             StandardEntry &entry);
@@ -70,6 +90,10 @@ public:
 //! TableBinding is exactly like the Binding, except it keeps track of which columns were bound in the linked LogicalGet
 //! node for projection pushdown purposes.
 struct TableBinding : public Binding {
+public:
+	static constexpr const BindingType TYPE = BindingType::TABLE;
+
+public:
 	TableBinding(const string &alias, vector<LogicalType> types, vector<string> names,
 	             vector<column_t> &bound_column_ids, optional_ptr<StandardEntry> entry, idx_t index,
 	             bool add_row_id = false);
@@ -94,6 +118,8 @@ protected:
 //! DummyBinding is like the Binding, except the alias and index are set by default. Used for binding lambdas and macro
 //! parameters.
 struct DummyBinding : public Binding {
+public:
+	static constexpr const BindingType TYPE = BindingType::DUMMY;
 	// NOTE: changing this string conflicts with the storage version
 	static constexpr const char *DUMMY_NAME = "0_macro_parameters";
 

package/src/duckdb/src/include/duckdb/planner/table_filter.hpp

@@ -47,6 +47,23 @@ public:
 	void Serialize(Serializer &serializer) const;
 	virtual void Serialize(FieldWriter &writer) const = 0;
 	static unique_ptr<TableFilter> Deserialize(Deserializer &source);
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		if (filter_type != TARGET::TYPE) {
+			throw InternalException("Failed to cast table to type - table filter type mismatch");
+		}
+		return reinterpret_cast<TARGET &>(*this);
+	}
+
+	template <class TARGET>
+	const TARGET &Cast() const {
+		if (filter_type != TARGET::TYPE) {
+			throw InternalException("Failed to cast table to type - table filter type mismatch");
+		}
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 };
 
 class TableFilterSet {

package/src/duckdb/src/include/duckdb/planner/tableref/bound_pivotref.hpp

@@ -28,6 +28,9 @@ struct BoundPivotInfo {
 };
 
 class BoundPivotRef : public BoundTableRef {
+public:
+	static constexpr const TableReferenceType TYPE = TableReferenceType::PIVOT;
+
 public:
 	explicit BoundPivotRef() : BoundTableRef(TableReferenceType::PIVOT) {
 	}

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

@@ -113,7 +113,7 @@ bool ChimpAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
 	UnifiedVectorFormat vdata;
 	input.ToUnifiedFormat(count, vdata);
 
-	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);
 		analyze_state.WriteValue(data[idx], vdata.validity.RowIsValid(idx));

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;
 }