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

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

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

@@ -4,7 +4,7 @@ static bool AssertLogicalTypeId(duckdb_logical_type type, duckdb::LogicalTypeId
 	if (!type) {
 		return false;
 	}
-	auto &ltype = *((duckdb::LogicalType *)type);
+	auto &ltype = *(reinterpret_cast<duckdb::LogicalType *>(type));
 	if (ltype.id() != type_id) {
 		return false;
 	}
@@ -15,7 +15,7 @@ static bool AssertInternalType(duckdb_logical_type type, duckdb::PhysicalType ph
 	if (!type) {
 		return false;
 	}
-	auto &ltype = *((duckdb::LogicalType *)type);
+	auto &ltype = *(reinterpret_cast<duckdb::LogicalType *>(type));
 	if (ltype.InternalType() != physical_type) {
 		return false;
 	}
@@ -31,7 +31,7 @@ duckdb_logical_type duckdb_create_list_type(duckdb_logical_type type) {
 		return nullptr;
 	}
 	duckdb::LogicalType *ltype = new duckdb::LogicalType;
-	*ltype = duckdb::LogicalType::LIST(*(duckdb::LogicalType *)type);
+	*ltype = duckdb::LogicalType::LIST(*reinterpret_cast<duckdb::LogicalType *>(type));
 	return reinterpret_cast<duckdb_logical_type>(ltype);
 }
 
@@ -40,7 +40,7 @@ duckdb_logical_type duckdb_create_union_type(duckdb_logical_type member_types_p,
 	if (!member_types_p || !member_names) {
 		return nullptr;
 	}
-	duckdb::LogicalType *member_types = (duckdb::LogicalType *)member_types_p;
+	duckdb::LogicalType *member_types = reinterpret_cast<duckdb::LogicalType *>(member_types_p);
 	duckdb::LogicalType *mtype = new duckdb::LogicalType;
 	duckdb::child_list_t<duckdb::LogicalType> members;
 
@@ -56,7 +56,8 @@ duckdb_logical_type duckdb_create_map_type(duckdb_logical_type key_type, duckdb_
 		return nullptr;
 	}
 	duckdb::LogicalType *mtype = new duckdb::LogicalType;
-	*mtype = duckdb::LogicalType::MAP(*(duckdb::LogicalType *)key_type, *(duckdb::LogicalType *)value_type);
+	*mtype = duckdb::LogicalType::MAP(*reinterpret_cast<duckdb::LogicalType *>(key_type),
+	                                  *reinterpret_cast<duckdb::LogicalType *>(value_type));
 	return reinterpret_cast<duckdb_logical_type>(mtype);
 }
 
@@ -68,13 +69,13 @@ duckdb_type duckdb_get_type_id(duckdb_logical_type type) {
 	if (!type) {
 		return DUCKDB_TYPE_INVALID;
 	}
-	auto ltype = (duckdb::LogicalType *)type;
+	auto ltype = reinterpret_cast<duckdb::LogicalType *>(type);
 	return duckdb::ConvertCPPTypeToC(*ltype);
 }
 
 void duckdb_destroy_logical_type(duckdb_logical_type *type) {
 	if (type && *type) {
-		auto ltype = (duckdb::LogicalType *)*type;
+		auto ltype = reinterpret_cast<duckdb::LogicalType *>(*type);
 		delete ltype;
 		*type = nullptr;
 	}
@@ -84,7 +85,7 @@ uint8_t duckdb_decimal_width(duckdb_logical_type type) {
 	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::DECIMAL)) {
 		return 0;
 	}
-	auto &ltype = *((duckdb::LogicalType *)type);
+	auto &ltype = *(reinterpret_cast<duckdb::LogicalType *>(type));
 	return duckdb::DecimalType::GetWidth(ltype);
 }
 
@@ -92,7 +93,7 @@ uint8_t duckdb_decimal_scale(duckdb_logical_type type) {
 	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::DECIMAL)) {
 		return 0;
 	}
-	auto &ltype = *((duckdb::LogicalType *)type);
+	auto &ltype = *(reinterpret_cast<duckdb::LogicalType *>(type));
 	return duckdb::DecimalType::GetScale(ltype);
 }
 
@@ -100,7 +101,7 @@ duckdb_type duckdb_decimal_internal_type(duckdb_logical_type type) {
 	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::DECIMAL)) {
 		return DUCKDB_TYPE_INVALID;
 	}
-	auto &ltype = *((duckdb::LogicalType *)type);
+	auto &ltype = *(reinterpret_cast<duckdb::LogicalType *>(type));
 	switch (ltype.InternalType()) {
 	case duckdb::PhysicalType::INT16:
 		return DUCKDB_TYPE_SMALLINT;
@@ -119,7 +120,7 @@ duckdb_type duckdb_enum_internal_type(duckdb_logical_type type) {
 	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::ENUM)) {
 		return DUCKDB_TYPE_INVALID;
 	}
-	auto &ltype = *((duckdb::LogicalType *)type);
+	auto &ltype = *(reinterpret_cast<duckdb::LogicalType *>(type));
 	switch (ltype.InternalType()) {
 	case duckdb::PhysicalType::UINT8:
 		return DUCKDB_TYPE_UTINYINT;
@@ -136,7 +137,7 @@ uint32_t duckdb_enum_dictionary_size(duckdb_logical_type type) {
 	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::ENUM)) {
 		return 0;
 	}
-	auto &ltype = *((duckdb::LogicalType *)type);
+	auto &ltype = *(reinterpret_cast<duckdb::LogicalType *>(type));
 	return duckdb::EnumType::GetSize(ltype);
 }
 
@@ -144,7 +145,7 @@ char *duckdb_enum_dictionary_value(duckdb_logical_type type, idx_t index) {
 	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::ENUM)) {
 		return nullptr;
 	}
-	auto &ltype = *((duckdb::LogicalType *)type);
+	auto &ltype = *(reinterpret_cast<duckdb::LogicalType *>(type));
 	auto &vector = duckdb::EnumType::GetValuesInsertOrder(ltype);
 	auto value = vector.GetValue(index);
 	return strdup(duckdb::StringValue::Get(value).c_str());
@@ -155,7 +156,7 @@ duckdb_logical_type duckdb_list_type_child_type(duckdb_logical_type type) {
 	    !AssertLogicalTypeId(type, duckdb::LogicalTypeId::MAP)) {
 		return nullptr;
 	}
-	auto &ltype = *((duckdb::LogicalType *)type);
+	auto &ltype = *(reinterpret_cast<duckdb::LogicalType *>(type));
 	if (ltype.id() != duckdb::LogicalTypeId::LIST && ltype.id() != duckdb::LogicalTypeId::MAP) {
 		return nullptr;
 	}
@@ -166,7 +167,7 @@ duckdb_logical_type duckdb_map_type_key_type(duckdb_logical_type type) {
 	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::MAP)) {
 		return nullptr;
 	}
-	auto &mtype = *((duckdb::LogicalType *)type);
+	auto &mtype = *(reinterpret_cast<duckdb::LogicalType *>(type));
 	if (mtype.id() != duckdb::LogicalTypeId::MAP) {
 		return nullptr;
 	}
@@ -177,7 +178,7 @@ duckdb_logical_type duckdb_map_type_value_type(duckdb_logical_type type) {
 	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::MAP)) {
 		return nullptr;
 	}
-	auto &mtype = *((duckdb::LogicalType *)type);
+	auto &mtype = *(reinterpret_cast<duckdb::LogicalType *>(type));
 	if (mtype.id() != duckdb::LogicalTypeId::MAP) {
 		return nullptr;
 	}
@@ -188,7 +189,7 @@ idx_t duckdb_struct_type_child_count(duckdb_logical_type type) {
 	if (!AssertInternalType(type, duckdb::PhysicalType::STRUCT)) {
 		return 0;
 	}
-	auto &ltype = *((duckdb::LogicalType *)type);
+	auto &ltype = *(reinterpret_cast<duckdb::LogicalType *>(type));
 	return duckdb::StructType::GetChildCount(ltype);
 }
 
@@ -210,7 +211,7 @@ char *duckdb_union_type_member_name(duckdb_logical_type type, idx_t index) {
 	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::UNION)) {
 		return nullptr;
 	}
-	auto &ltype = *((duckdb::LogicalType *)type);
+	auto &ltype = *(reinterpret_cast<duckdb::LogicalType *>(type));
 	return strdup(duckdb::UnionType::GetMemberName(ltype, index).c_str());
 }
 
@@ -221,7 +222,7 @@ duckdb_logical_type duckdb_union_type_member_type(duckdb_logical_type type, idx_
 	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::UNION)) {
 		return nullptr;
 	}
-	auto &ltype = *((duckdb::LogicalType *)type);
+	auto &ltype = *(reinterpret_cast<duckdb::LogicalType *>(type));
 	return reinterpret_cast<duckdb_logical_type>(
 	    new duckdb::LogicalType(duckdb::UnionType::GetMemberType(ltype, index)));
 }
@@ -230,7 +231,7 @@ char *duckdb_struct_type_child_name(duckdb_logical_type type, idx_t index) {
 	if (!AssertInternalType(type, duckdb::PhysicalType::STRUCT)) {
 		return nullptr;
 	}
-	auto &ltype = *((duckdb::LogicalType *)type);
+	auto &ltype = *(reinterpret_cast<duckdb::LogicalType *>(type));
 	return strdup(duckdb::StructType::GetChildName(ltype, index).c_str());
 }
 
@@ -238,7 +239,7 @@ duckdb_logical_type duckdb_struct_type_child_type(duckdb_logical_type type, idx_
 	if (!AssertInternalType(type, duckdb::PhysicalType::STRUCT)) {
 		return nullptr;
 	}
-	auto &ltype = *((duckdb::LogicalType *)type);
+	auto &ltype = *(reinterpret_cast<duckdb::LogicalType *>(type));
 	if (ltype.InternalType() != duckdb::PhysicalType::STRUCT) {
 		return nullptr;
 	}

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

@@ -14,7 +14,7 @@ duckdb_state duckdb_pending_prepared_internal(duckdb_prepared_statement prepared
 	if (!prepared_statement || !out_result) {
 		return DuckDBError;
 	}
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
+	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
 	auto result = new PendingStatementWrapper();
 	result->allow_streaming = allow_streaming;
 	try {
@@ -25,7 +25,7 @@ duckdb_state duckdb_pending_prepared_internal(duckdb_prepared_statement prepared
 		result->statement = make_uniq<PendingQueryResult>(duckdb::PreservedError(ex));
 	}
 	duckdb_state return_value = !result->statement->HasError() ? DuckDBSuccess : DuckDBError;
-	*out_result = (duckdb_pending_result)result;
+	*out_result = reinterpret_cast<duckdb_pending_result>(result);
 
 	return return_value;
 }
@@ -43,7 +43,7 @@ void duckdb_destroy_pending(duckdb_pending_result *pending_result) {
 	if (!pending_result || !*pending_result) {
 		return;
 	}
-	auto wrapper = (PendingStatementWrapper *)*pending_result;
+	auto wrapper = reinterpret_cast<PendingStatementWrapper *>(*pending_result);
 	if (wrapper->statement) {
 		wrapper->statement->Close();
 	}
@@ -55,7 +55,7 @@ const char *duckdb_pending_error(duckdb_pending_result pending_result) {
 	if (!pending_result) {
 		return nullptr;
 	}
-	auto wrapper = (PendingStatementWrapper *)pending_result;
+	auto wrapper = reinterpret_cast<PendingStatementWrapper *>(pending_result);
 	if (!wrapper->statement) {
 		return nullptr;
 	}
@@ -66,7 +66,7 @@ duckdb_pending_state duckdb_pending_execute_task(duckdb_pending_result pending_r
 	if (!pending_result) {
 		return DUCKDB_PENDING_ERROR;
 	}
-	auto wrapper = (PendingStatementWrapper *)pending_result;
+	auto wrapper = reinterpret_cast<PendingStatementWrapper *>(pending_result);
 	if (!wrapper->statement) {
 		return DUCKDB_PENDING_ERROR;
 	}
@@ -97,7 +97,7 @@ duckdb_state duckdb_execute_pending(duckdb_pending_result pending_result, duckdb
 	if (!pending_result || !out_result) {
 		return DuckDBError;
 	}
-	auto wrapper = (PendingStatementWrapper *)pending_result;
+	auto wrapper = reinterpret_cast<PendingStatementWrapper *>(pending_result);
 	if (!wrapper->statement) {
 		return DuckDBError;
 	}

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

@@ -21,7 +21,7 @@ idx_t duckdb_extract_statements(duckdb_connection connection, const char *query,
 		return 0;
 	}
 	auto wrapper = new ExtractStatementsWrapper();
-	Connection *conn = (Connection *)connection;
+	Connection *conn = reinterpret_cast<Connection *>(connection);
 	try {
 		wrapper->statements = conn->ExtractStatements(query);
 	} catch (const duckdb::ParserException &e) {
@@ -35,7 +35,7 @@ idx_t duckdb_extract_statements(duckdb_connection connection, const char *query,
 duckdb_state duckdb_prepare_extracted_statement(duckdb_connection connection,
                                                 duckdb_extracted_statements extracted_statements, idx_t index,
                                                 duckdb_prepared_statement *out_prepared_statement) {
-	Connection *conn = (Connection *)connection;
+	Connection *conn = reinterpret_cast<Connection *>(connection);
 	auto source_wrapper = (ExtractStatementsWrapper *)extracted_statements;
 
 	if (!connection || !out_prepared_statement || index >= source_wrapper->statements.size()) {
@@ -62,14 +62,14 @@ duckdb_state duckdb_prepare(duckdb_connection connection, const char *query,
 		return DuckDBError;
 	}
 	auto wrapper = new PreparedStatementWrapper();
-	Connection *conn = (Connection *)connection;
+	Connection *conn = reinterpret_cast<Connection *>(connection);
 	wrapper->statement = conn->Prepare(query);
 	*out_prepared_statement = (duckdb_prepared_statement)wrapper;
 	return !wrapper->statement->HasError() ? DuckDBSuccess : DuckDBError;
 }
 
 const char *duckdb_prepare_error(duckdb_prepared_statement prepared_statement) {
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
+	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
 	if (!wrapper || !wrapper->statement || !wrapper->statement->HasError()) {
 		return nullptr;
 	}
@@ -77,7 +77,7 @@ const char *duckdb_prepare_error(duckdb_prepared_statement prepared_statement) {
 }
 
 idx_t duckdb_nparams(duckdb_prepared_statement prepared_statement) {
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
+	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
 	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
 		return 0;
 	}
@@ -85,7 +85,7 @@ idx_t duckdb_nparams(duckdb_prepared_statement prepared_statement) {
 }
 
 duckdb_type duckdb_param_type(duckdb_prepared_statement prepared_statement, idx_t param_idx) {
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
+	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
 	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
 		return DUCKDB_TYPE_INVALID;
 	}
@@ -97,7 +97,7 @@ duckdb_type duckdb_param_type(duckdb_prepared_statement prepared_statement, idx_
 }
 
 duckdb_state duckdb_clear_bindings(duckdb_prepared_statement prepared_statement) {
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
+	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
 	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
 		return DuckDBError;
 	}
@@ -106,7 +106,7 @@ duckdb_state duckdb_clear_bindings(duckdb_prepared_statement prepared_statement)
 }
 
 static duckdb_state duckdb_bind_value(duckdb_prepared_statement prepared_statement, idx_t param_idx, Value val) {
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
+	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
 	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
 		return DuckDBError;
 	}
@@ -220,7 +220,7 @@ duckdb_state duckdb_bind_decimal(duckdb_prepared_statement prepared_statement, i
 
 duckdb_state duckdb_bind_blob(duckdb_prepared_statement prepared_statement, idx_t param_idx, const void *data,
                               idx_t length) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::BLOB((duckdb::const_data_ptr_t)data, length));
+	return duckdb_bind_value(prepared_statement, param_idx, Value::BLOB(duckdb::const_data_ptr_cast(data), length));
 }
 
 duckdb_state duckdb_bind_null(duckdb_prepared_statement prepared_statement, idx_t param_idx) {
@@ -228,7 +228,7 @@ duckdb_state duckdb_bind_null(duckdb_prepared_statement prepared_statement, idx_
 }
 
 duckdb_state duckdb_execute_prepared(duckdb_prepared_statement prepared_statement, duckdb_result *out_result) {
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
+	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
 	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
 		return DuckDBError;
 	}

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

@@ -30,7 +30,7 @@ struct CAPIReplacementScanInfo {
 
 unique_ptr<TableRef> duckdb_capi_replacement_callback(ClientContext &context, const string &table_name,
                                                       ReplacementScanData *data) {
-	auto &scan_data = (CAPIReplacementScanData &)*data;
+	auto &scan_data = reinterpret_cast<CAPIReplacementScanData &>(*data);
 
 	CAPIReplacementScanInfo info(&scan_data);
 	scan_data.callback((duckdb_replacement_scan_info)&info, table_name.c_str(), scan_data.extra_data);
@@ -57,7 +57,7 @@ void duckdb_add_replacement_scan(duckdb_database db, duckdb_replacement_callback
 	if (!db || !replacement) {
 		return;
 	}
-	auto wrapper = (duckdb::DatabaseData *)db;
+	auto wrapper = reinterpret_cast<duckdb::DatabaseData *>(db);
 	auto scan_info = duckdb::make_uniq<duckdb::CAPIReplacementScanData>();
 	scan_info->callback = replacement;
 	scan_info->extra_data = extra_data;
@@ -72,7 +72,7 @@ void duckdb_replacement_scan_set_function_name(duckdb_replacement_scan_info info
 	if (!info_p || !function_name) {
 		return;
 	}
-	auto info = (duckdb::CAPIReplacementScanInfo *)info_p;
+	auto info = reinterpret_cast<duckdb::CAPIReplacementScanInfo *>(info_p);
 	info->function_name = function_name;
 }
 
@@ -80,8 +80,8 @@ void duckdb_replacement_scan_add_parameter(duckdb_replacement_scan_info info_p,
 	if (!info_p || !parameter) {
 		return;
 	}
-	auto info = (duckdb::CAPIReplacementScanInfo *)info_p;
-	auto val = (duckdb::Value *)parameter;
+	auto info = reinterpret_cast<duckdb::CAPIReplacementScanInfo *>(info_p);
+	auto val = reinterpret_cast<duckdb::Value *>(parameter);
 	info->parameters.push_back(*val);
 }
 
@@ -89,6 +89,6 @@ void duckdb_replacement_scan_set_error(duckdb_replacement_scan_info info_p, cons
 	if (!info_p || !error) {
 		return;
 	}
-	auto info = (duckdb::CAPIReplacementScanInfo *)info_p;
+	auto info = reinterpret_cast<duckdb::CAPIReplacementScanInfo *>(info_p);
 	info->error = error;
 }