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

package/src/duckdb/src/common/adbc/adbc.cpp

@@ -12,7 +12,7 @@
 #include <string.h>
 #include <stdlib.h>
 
-// We gotta leak the symbols of the init function
+// We must leak the symbols of the init function
 duckdb_adbc::AdbcStatusCode duckdb_adbc_init(size_t count, struct duckdb_adbc::AdbcDriver *driver,
                                              struct duckdb_adbc::AdbcError *error) {
 	if (!driver) {
@@ -41,23 +41,16 @@ duckdb_adbc::AdbcStatusCode duckdb_adbc_init(size_t count, struct duckdb_adbc::A
 }
 
 namespace duckdb_adbc {
-#define CHECK_TRUE(p, e, m)                                                                                            \
-	if (!(p)) {                                                                                                        \
-		if (e) {                                                                                                       \
-			e->message = strdup(m); /* TODO Set cleanup callback */                                                    \
-		}                                                                                                              \
-		return ADBC_STATUS_INVALID_ARGUMENT;                                                                           \
+AdbcStatusCode SetErrorMaybe(const void *result, AdbcError *error, const std::string &error_message) {
+	if (!error) {
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
-
-#define CHECK_RES(res, e, m)                                                                                           \
-	if (res != DuckDBSuccess) {                                                                                        \
-		if (e) {                                                                                                       \
-			e->message = strdup(m);                                                                                    \
-		}                                                                                                              \
-		return ADBC_STATUS_INTERNAL;                                                                                   \
-	} else {                                                                                                           \
-		return ADBC_STATUS_OK;                                                                                         \
+	if (!result) {
+		SetError(error, error_message);
+		return ADBC_STATUS_INVALID_ARGUMENT;
 	}
+	return ADBC_STATUS_OK;
+}
 
 struct DuckDBAdbcDatabaseWrapper {
 	//! The DuckDB Database Configuration
@@ -68,25 +61,58 @@ struct DuckDBAdbcDatabaseWrapper {
 	std::string path;
 };
 
-AdbcStatusCode DatabaseNew(struct AdbcDatabase *database, struct AdbcError *error) {
-	CHECK_TRUE(database, error, "Missing database object");
+void InitiliazeADBCError(AdbcError *error) {
+	if (!error) {
+		return;
+	}
+	error->message = nullptr;
+	error->release = nullptr;
+	std::memset(error->sqlstate, '\0', sizeof(error->sqlstate));
+	error->vendor_code = -1;
+}
 
+AdbcStatusCode CheckResult(duckdb_state &res, AdbcError *error, const char *error_msg) {
+	if (!error) {
+		// Error should be a non-null pointer
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
+	if (res != DuckDBSuccess) {
+		duckdb_adbc::SetError(error, error_msg);
+		return ADBC_STATUS_INTERNAL;
+	}
+	return ADBC_STATUS_OK;
+}
+
+AdbcStatusCode DatabaseNew(struct AdbcDatabase *database, struct AdbcError *error) {
+	auto status = SetErrorMaybe(database, error, "Missing database object");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
 	database->private_data = nullptr;
 	// you can't malloc a struct with a non-trivial C++ constructor
 	// and std::string has a non-trivial constructor. so we need
 	// to use new and delete rather than malloc and free.
 	auto wrapper = new DuckDBAdbcDatabaseWrapper;
-	CHECK_TRUE(wrapper, error, "Allocation error");
-
+	status = SetErrorMaybe(wrapper, error, "Allocation error");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
 	database->private_data = wrapper;
 	auto res = duckdb_create_config(&wrapper->config);
-	CHECK_RES(res, error, "Failed to allocate");
+	return CheckResult(res, error, "Failed to allocate");
 }
 
 AdbcStatusCode DatabaseSetOption(struct AdbcDatabase *database, const char *key, const char *value,
                                  struct AdbcError *error) {
-	CHECK_TRUE(database, error, "Missing database object");
-	CHECK_TRUE(key, error, "Missing key");
+	auto status = SetErrorMaybe(database, error, "Missing database object");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
+
+	status = SetErrorMaybe(key, error, "Missing key");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
 
 	auto wrapper = (DuckDBAdbcDatabaseWrapper *)database->private_data;
 	if (strcmp(key, "path") == 0) {
@@ -95,17 +121,22 @@ AdbcStatusCode DatabaseSetOption(struct AdbcDatabase *database, const char *key,
 	}
 	auto res = duckdb_set_config(wrapper->config, key, value);
 
-	CHECK_RES(res, error, "Failed to set configuration option");
+	return CheckResult(res, error, "Failed to set configuration option");
 }
 
 AdbcStatusCode DatabaseInit(struct AdbcDatabase *database, struct AdbcError *error) {
+	if (!error) {
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
+	if (!database) {
+		duckdb_adbc::SetError(error, "ADBC Database has an invalid pointer");
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
 	char *errormsg;
 	// TODO can we set the database path via option, too? Does not look like it...
 	auto wrapper = (DuckDBAdbcDatabaseWrapper *)database->private_data;
 	auto res = duckdb_open_ext(wrapper->path.c_str(), &wrapper->database, wrapper->config, &errormsg);
-
-	// TODO this leaks memory because errormsg is malloc-ed
-	CHECK_RES(res, error, errormsg);
+	return CheckResult(res, error, errormsg);
 }
 
 AdbcStatusCode DatabaseRelease(struct AdbcDatabase *database, struct AdbcError *error) {
@@ -122,8 +153,11 @@ AdbcStatusCode DatabaseRelease(struct AdbcDatabase *database, struct AdbcError *
 }
 
 AdbcStatusCode ConnectionNew(struct AdbcConnection *connection, struct AdbcError *error) {
+	auto status = SetErrorMaybe(connection, error, "Missing connection object");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
 
-	CHECK_TRUE(connection, error, "Missing connection object");
 	connection->private_data = nullptr;
 	return ADBC_STATUS_OK;
 }
@@ -136,14 +170,23 @@ AdbcStatusCode ConnectionSetOption(struct AdbcConnection *connection, const char
 
 AdbcStatusCode ConnectionInit(struct AdbcConnection *connection, struct AdbcDatabase *database,
                               struct AdbcError *error) {
-	CHECK_TRUE(database, error, "Missing database");
-	CHECK_TRUE(database->private_data, error, "Invalid database");
-	CHECK_TRUE(connection, error, "Missing connection");
+	auto status = SetErrorMaybe(database, error, "Missing database");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
+	status = SetErrorMaybe(database->private_data, error, "Invalid database");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
+	status = SetErrorMaybe(connection, error, "Missing connection");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
 	auto database_wrapper = (DuckDBAdbcDatabaseWrapper *)database->private_data;
 
 	connection->private_data = nullptr;
 	auto res = duckdb_connect(database_wrapper->database, (duckdb_connection *)&connection->private_data);
-	CHECK_RES(res, error, "Failed to connect to Database");
+	return CheckResult(res, error, "Failed to connect to Database");
 }
 
 AdbcStatusCode ConnectionRelease(struct AdbcConnection *connection, struct AdbcError *error) {
@@ -213,9 +256,20 @@ void stream_schema(uintptr_t factory_ptr, duckdb::ArrowSchemaWrapper &schema) {
 AdbcStatusCode Ingest(duckdb_connection connection, const char *table_name, struct ArrowArrayStream *input,
                       struct AdbcError *error) {
 
-	CHECK_TRUE(connection, error, "Invalid connection");
-	CHECK_TRUE(input, error, "Missing input arrow stream pointer");
-	CHECK_TRUE(table_name, error, "Missing database object name");
+	auto status = SetErrorMaybe(connection, error, "Invalid connection");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
+
+	status = SetErrorMaybe(input, error, "Missing input arrow stream pointer");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
+
+	status = SetErrorMaybe(table_name, error, "Missing database object name");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
 
 	try {
 		// TODO evil cast, do we need a way to do this from the C api?
@@ -251,14 +305,28 @@ struct DuckDBAdbcStatementWrapper {
 AdbcStatusCode StatementNew(struct AdbcConnection *connection, struct AdbcStatement *statement,
                             struct AdbcError *error) {
 
-	CHECK_TRUE(connection, error, "Missing connection object");
-	CHECK_TRUE(connection->private_data, error, "Invalid connection object");
-	CHECK_TRUE(statement, error, "Missing statement object");
+	auto status = SetErrorMaybe(connection, error, "Missing connection object");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
+
+	status = SetErrorMaybe(connection->private_data, error, "Invalid connection object");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
+
+	status = SetErrorMaybe(statement, error, "Missing statement object");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
 
 	statement->private_data = nullptr;
 
 	auto statement_wrapper = (DuckDBAdbcStatementWrapper *)malloc(sizeof(DuckDBAdbcStatementWrapper));
-	CHECK_TRUE(statement_wrapper, error, "Allocation error");
+	status = SetErrorMaybe(statement_wrapper, error, "Allocation error");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
 
 	statement->private_data = statement_wrapper;
 	statement_wrapper->connection = (duckdb_connection)connection->private_data;
@@ -298,8 +366,16 @@ AdbcStatusCode StatementRelease(struct AdbcStatement *statement, struct AdbcErro
 
 AdbcStatusCode StatementExecuteQuery(struct AdbcStatement *statement, struct ArrowArrayStream *out,
                                      int64_t *rows_affected, struct AdbcError *error) {
-	CHECK_TRUE(statement, error, "Missing statement object");
-	CHECK_TRUE(statement->private_data, error, "Invalid statement object");
+	auto status = SetErrorMaybe(statement, error, "Missing statement object");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
+
+	status = SetErrorMaybe(statement->private_data, error, "Invalid statement object");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
+
 	auto wrapper = (DuckDBAdbcStatementWrapper *)statement->private_data;
 
 	// TODO: Set affected rows, careful with early return
@@ -314,7 +390,10 @@ AdbcStatusCode StatementExecuteQuery(struct AdbcStatement *statement, struct Arr
 	}
 
 	auto res = duckdb_execute_prepared_arrow(wrapper->statement, &wrapper->result);
-	CHECK_TRUE(res == DuckDBSuccess, error, duckdb_query_arrow_error(wrapper->result));
+	if (res != DuckDBSuccess) {
+		SetError(error, duckdb_query_arrow_error(wrapper->result));
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
 
 	if (out) {
 		out->private_data = wrapper->result;
@@ -333,25 +412,45 @@ AdbcStatusCode StatementExecuteQuery(struct AdbcStatement *statement, struct Arr
 
 // this is a nop for us
 AdbcStatusCode StatementPrepare(struct AdbcStatement *statement, struct AdbcError *error) {
-	CHECK_TRUE(statement, error, "Missing statement object");
-	CHECK_TRUE(statement->private_data, error, "Invalid statement object");
+	auto status = SetErrorMaybe(statement, error, "Missing statement object");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
+
+	status = SetErrorMaybe(statement->private_data, error, "Invalid statement object");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
+
 	return ADBC_STATUS_OK;
 }
 
 AdbcStatusCode StatementSetSqlQuery(struct AdbcStatement *statement, const char *query, struct AdbcError *error) {
-	CHECK_TRUE(statement, error, "Missing statement object");
-	CHECK_TRUE(query, error, "Missing query");
+	auto status = SetErrorMaybe(statement, error, "Missing statement object");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
+	status = SetErrorMaybe(query, error, "Missing query");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
 
 	auto wrapper = (DuckDBAdbcStatementWrapper *)statement->private_data;
 	auto res = duckdb_prepare(wrapper->connection, query, &wrapper->statement);
-
-	CHECK_RES(res, error, duckdb_prepare_error(wrapper->statement));
+	auto error_msg = duckdb_prepare_error(wrapper->statement);
+	return CheckResult(res, error, error_msg);
 }
 
 AdbcStatusCode StatementBindStream(struct AdbcStatement *statement, struct ArrowArrayStream *values,
                                    struct AdbcError *error) {
-	CHECK_TRUE(statement, error, "Missing statement object");
-	CHECK_TRUE(values, error, "Missing stream object");
+	auto status = SetErrorMaybe(statement, error, "Missing statement object");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
+	status = SetErrorMaybe(values, error, "Missing stream object");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
 	auto wrapper = (DuckDBAdbcStatementWrapper *)statement->private_data;
 	wrapper->ingestion_stream = values;
 	return ADBC_STATUS_OK;
@@ -359,8 +458,14 @@ AdbcStatusCode StatementBindStream(struct AdbcStatement *statement, struct Arrow
 
 AdbcStatusCode StatementSetOption(struct AdbcStatement *statement, const char *key, const char *value,
                                   struct AdbcError *error) {
-	CHECK_TRUE(statement, error, "Missing statement object");
-	CHECK_TRUE(key, error, "Missing key object");
+	auto status = SetErrorMaybe(statement, error, "Missing statement object");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
+	status = SetErrorMaybe(key, error, "Missing key object");
+	if (status != ADBC_STATUS_OK) {
+		return status;
+	}
 	auto wrapper = (DuckDBAdbcStatementWrapper *)statement->private_data;
 
 	if (strcmp(key, ADBC_INGEST_OPTION_TARGET_TABLE) == 0) {
@@ -372,17 +477,23 @@ AdbcStatusCode StatementSetOption(struct AdbcStatement *statement, const char *k
 
 static AdbcStatusCode QueryInternal(struct AdbcConnection *connection, struct ArrowArrayStream *out, const char *query,
                                     struct AdbcError *error) {
-	AdbcStatusCode res;
 	AdbcStatement statement;
 
-	res = StatementNew(connection, &statement, error);
-	CHECK_TRUE(!res, error, "unable to initialize statement");
-
-	res = StatementSetSqlQuery(&statement, query, error);
-	CHECK_TRUE(!res, error, "unable to initialize statement");
-
-	res = StatementExecuteQuery(&statement, out, NULL, error);
-	CHECK_TRUE(!res, error, "unable to execute statement");
+	auto status = StatementNew(connection, &statement, error);
+	if (status != ADBC_STATUS_OK) {
+		SetError(error, "unable to initialize statement");
+		return status;
+	}
+	status = StatementSetSqlQuery(&statement, query, error);
+	if (status != ADBC_STATUS_OK) {
+		SetError(error, "unable to initialize statement");
+		return status;
+	}
+	status = StatementExecuteQuery(&statement, out, nullptr, error);
+	if (status != ADBC_STATUS_OK) {
+		SetError(error, "unable to initialize statement");
+		return status;
+	}
 
 	return ADBC_STATUS_OK;
 }
@@ -390,8 +501,17 @@ static AdbcStatusCode QueryInternal(struct AdbcConnection *connection, struct Ar
 AdbcStatusCode ConnectionGetObjects(struct AdbcConnection *connection, int depth, const char *catalog,
                                     const char *db_schema, const char *table_name, const char **table_type,
                                     const char *column_name, struct ArrowArrayStream *out, struct AdbcError *error) {
-	CHECK_TRUE(catalog == nullptr || strcmp(catalog, "duckdb") == 0, error, "catalog must be NULL or 'duckdb'");
-	CHECK_TRUE(table_type == nullptr, error, "table types parameter not yet supported");
+	if (catalog != nullptr) {
+		if (strcmp(catalog, "duckdb") == 0) {
+			SetError(error, "catalog must be NULL or 'duckdb'");
+			return ADBC_STATUS_INVALID_ARGUMENT;
+		}
+	}
+
+	if (table_type != nullptr) {
+		SetError(error, "Table types parameter not yet supported");
+		return ADBC_STATUS_NOT_IMPLEMENTED;
+	}
 
 	auto q = duckdb::StringUtil::Format(R"(
 SELECT table_schema db_schema_name, LIST(table_schema_list) db_schema_tables FROM (
@@ -404,41 +524,10 @@ SELECT table_schema db_schema_name, LIST(table_schema_list) db_schema_tables FRO
 	return QueryInternal(connection, out, q.c_str(), error);
 }
 
-//
-// AdbcStatusCode ConnectionGetCatalogs(struct AdbcConnection *connection, struct AdbcStatement *statement,
-//                                         struct AdbcError *error) {
-//	const char *q = "SELECT 'duckdb' catalog_name";
-//
-//	return QueryInternal(connection, statement, q, error);
-//}
-//
-// AdbcStatusCode ConnectionGetDbSchemas(struct AdbcConnection *connection, struct AdbcStatement *statement,
-//                                          struct AdbcError *error) {
-//	const char *q = "SELECT 'duckdb' catalog_name, schema_name db_schema_name FROM information_schema.schemata ORDER "
-//	                "BY schema_name";
-//	return QueryInternal(connection, statement, q, error);
-//}
 AdbcStatusCode ConnectionGetTableTypes(struct AdbcConnection *connection, struct ArrowArrayStream *out,
                                        struct AdbcError *error) {
 	const char *q = "SELECT DISTINCT table_type FROM information_schema.tables ORDER BY table_type";
 	return QueryInternal(connection, out, q, error);
 }
-//
-// AdbcStatusCode ConnectionGetTables(struct AdbcConnection *connection, const char *catalog, const char *db_schema,
-//                                       const char *table_name, const char **table_types,
-//                                       struct AdbcStatement *statement, struct AdbcError *error) {
-//
-//	CHECK_TRUE(catalog == nullptr || strcmp(catalog, "duckdb") == 0, error, "catalog must be NULL or 'duckdb'");
-//
-//	// let's wait for https://github.com/lidavidm/arrow/issues/6
-//	CHECK_TRUE(table_types == nullptr, error, "table types parameter not yet supported");
-//	auto q = duckdb::StringUtil::Format(
-//	    "SELECT 'duckdb' catalog_name, table_schema db_schema_name, table_name, table_type FROM "
-//	    "information_schema.tables WHERE table_schema LIKE '%s' AND table_name LIKE '%s' ORDER BY table_schema, "
-//	    "table_name",
-//	    db_schema ? db_schema : "%", table_name ? table_name : "%");
-//
-//	return QueryInternal(connection, statement, q.c_str(), error);
-//}
 
 } // namespace duckdb_adbc

package/src/duckdb/src/common/adbc/driver_manager.cpp

@@ -61,16 +61,18 @@ void GetWinError(std::string *buffer) {
 
 void ReleaseError(struct AdbcError *error) {
 	if (error) {
-		if (error->message)
+		if (error->message) {
 			delete[] error->message;
+		}
 		error->message = nullptr;
 		error->release = nullptr;
 	}
 }
 
 void SetError(struct AdbcError *error, const std::string &message) {
-	if (!error)
+	if (!error) {
 		return;
+	}
 	if (error->message) {
 		// Append
 		std::string buffer = error->message;
@@ -466,6 +468,9 @@ AdbcStatusCode AdbcStatementExecutePartitions(struct AdbcStatement *statement, A
 
 AdbcStatusCode AdbcStatementExecuteQuery(struct AdbcStatement *statement, struct ArrowArrayStream *out,
                                          int64_t *rows_affected, struct AdbcError *error) {
+	if (!statement) {
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
 	if (!statement->private_driver) {
 		return ADBC_STATUS_INVALID_STATE;
 	}
@@ -482,6 +487,9 @@ AdbcStatusCode AdbcStatementGetParameterSchema(struct AdbcStatement *statement,
 
 AdbcStatusCode AdbcStatementNew(struct AdbcConnection *connection, struct AdbcStatement *statement,
                                 struct AdbcError *error) {
+	if (!connection) {
+		return ADBC_STATUS_INVALID_ARGUMENT;
+	}
 	if (!connection->private_driver) {
 		return ADBC_STATUS_INVALID_STATE;
 	}

package/src/duckdb/src/common/arrow/arrow_appender.cpp

@@ -162,8 +162,8 @@ struct ArrowScalarBaseData {
 
 		// append the main data
 		append_data.main_buffer.resize(append_data.main_buffer.size() + sizeof(TGT) * size);
-		auto data = (SRC *)format.data;
-		auto result_data = (TGT *)append_data.main_buffer.data();
+		auto data = UnifiedVectorFormat::GetData<SRC>(format);
+		auto result_data = append_data.main_buffer.GetData<TGT>();
 
 		for (idx_t i = from; i < to; i++) {
 			auto source_idx = format.sel->get_index(i);
@@ -210,8 +210,8 @@ struct ArrowEnumData : public ArrowScalarBaseData<TGT> {
 
 		// resize the offset buffer - the offset buffer holds the offsets into the child array
 		append_data.main_buffer.resize(append_data.main_buffer.size() + sizeof(uint32_t) * (size + 1));
-		auto data = (string_t *)FlatVector::GetData<string_t>(input);
-		auto offset_data = (uint32_t *)append_data.main_buffer.data();
+		auto data = FlatVector::GetData<string_t>(input);
+		auto offset_data = append_data.main_buffer.GetData<uint32_t>();
 		if (append_data.row_count == 0) {
 			// first entry
 			offset_data[0] = 0;
@@ -269,10 +269,10 @@ struct ArrowBoolData {
 		// we initialize both the validity and the bit set to 1's
 		ResizeValidity(append_data.validity, append_data.row_count + size);
 		ResizeValidity(append_data.main_buffer, append_data.row_count + size);
-		auto data = (bool *)format.data;
+		auto data = UnifiedVectorFormat::GetData<bool>(format);
 
-		auto result_data = (uint8_t *)append_data.main_buffer.data();
-		auto validity_data = (uint8_t *)append_data.validity.data();
+		auto result_data = append_data.main_buffer.GetData<uint8_t>();
+		auto validity_data = append_data.validity.GetData<uint8_t>();
 		uint8_t current_bit;
 		idx_t current_byte;
 		GetBitPosition(append_data.row_count, current_byte, current_bit);
@@ -318,7 +318,7 @@ struct ArrowUUIDConverter {
 
 	template <class SRC>
 	static void WriteData(data_ptr_t target, SRC input) {
-		UUID::ToString(input, (char *)target);
+		UUID::ToString(input, char_ptr_cast(target));
 	}
 };
 
@@ -341,8 +341,8 @@ struct ArrowVarcharData {
 
 		// resize the offset buffer - the offset buffer holds the offsets into the child array
 		append_data.main_buffer.resize(append_data.main_buffer.size() + sizeof(BUFTYPE) * (size + 1));
-		auto data = (SRC *)format.data;
-		auto offset_data = (BUFTYPE *)append_data.main_buffer.data();
+		auto data = UnifiedVectorFormat::GetData<SRC>(format);
+		auto offset_data = append_data.main_buffer.GetData<BUFTYPE>();
 		if (append_data.row_count == 0) {
 			// first entry
 			offset_data[0] = 0;
@@ -441,8 +441,8 @@ void AppendListOffsets(ArrowAppendData &append_data, UnifiedVectorFormat &format
 	// resize the offset buffer - the offset buffer holds the offsets into the child array
 	idx_t size = to - from;
 	append_data.main_buffer.resize(append_data.main_buffer.size() + sizeof(uint32_t) * (size + 1));
-	auto data = (list_entry_t *)format.data;
-	auto offset_data = (uint32_t *)append_data.main_buffer.data();
+	auto data = UnifiedVectorFormat::GetData<list_entry_t>(format);
+	auto offset_data = append_data.main_buffer.GetData<uint32_t>();
 	if (append_data.row_count == 0) {
 		// first entry
 		offset_data[0] = 0;

package/src/duckdb/src/common/arrow/arrow_wrapper.cpp

@@ -77,7 +77,7 @@ int ResultArrowArrayStreamWrapper::MyStreamGetSchema(struct ArrowArrayStream *st
 	if (!stream->release) {
 		return -1;
 	}
-	auto my_stream = (ResultArrowArrayStreamWrapper *)stream->private_data;
+	auto my_stream = reinterpret_cast<ResultArrowArrayStreamWrapper *>(stream->private_data);
 	if (!my_stream->column_types.empty()) {
 		ArrowConverter::ToArrowSchema(out, my_stream->column_types, my_stream->column_names,
 		                              my_stream->timezone_config);
@@ -90,7 +90,7 @@ int ResultArrowArrayStreamWrapper::MyStreamGetSchema(struct ArrowArrayStream *st
 		return -1;
 	}
 	if (result.type == QueryResultType::STREAM_RESULT) {
-		auto &stream_result = (StreamQueryResult &)result;
+		auto &stream_result = result.Cast<StreamQueryResult>();
 		if (!stream_result.IsOpen()) {
 			my_stream->last_error = PreservedError("Query Stream is closed");
 			return -1;
@@ -108,14 +108,14 @@ int ResultArrowArrayStreamWrapper::MyStreamGetNext(struct ArrowArrayStream *stre
 	if (!stream->release) {
 		return -1;
 	}
-	auto my_stream = (ResultArrowArrayStreamWrapper *)stream->private_data;
+	auto my_stream = reinterpret_cast<ResultArrowArrayStreamWrapper *>(stream->private_data);
 	auto &result = *my_stream->result;
 	if (result.HasError()) {
 		my_stream->last_error = result.GetErrorObject();
 		return -1;
 	}
 	if (result.type == QueryResultType::STREAM_RESULT) {
-		auto &stream_result = (StreamQueryResult &)result;
+		auto &stream_result = result.Cast<StreamQueryResult>();
 		if (!stream_result.IsOpen()) {
 			// Nothing to output
 			out->release = nullptr;
@@ -145,7 +145,7 @@ void ResultArrowArrayStreamWrapper::MyStreamRelease(struct ArrowArrayStream *str
 		return;
 	}
 	stream->release = nullptr;
-	delete (ResultArrowArrayStreamWrapper *)stream->private_data;
+	delete reinterpret_cast<ResultArrowArrayStreamWrapper *>(stream->private_data);
 }
 
 const char *ResultArrowArrayStreamWrapper::MyStreamGetLastError(struct ArrowArrayStream *stream) {
@@ -153,7 +153,7 @@ const char *ResultArrowArrayStreamWrapper::MyStreamGetLastError(struct ArrowArra
 		return "stream was released";
 	}
 	D_ASSERT(stream->private_data);
-	auto my_stream = (ResultArrowArrayStreamWrapper *)stream->private_data;
+	auto my_stream = reinterpret_cast<ResultArrowArrayStreamWrapper *>(stream->private_data);
 	return my_stream->last_error.Message().c_str();
 }
 
@@ -175,7 +175,7 @@ ResultArrowArrayStreamWrapper::ResultArrowArrayStreamWrapper(unique_ptr<QueryRes
 
 bool ArrowUtil::TryFetchNext(QueryResult &result, unique_ptr<DataChunk> &chunk, PreservedError &error) {
 	if (result.type == QueryResultType::STREAM_RESULT) {
-		auto &stream_result = (StreamQueryResult &)result;
+		auto &stream_result = result.Cast<StreamQueryResult>();
 		if (!stream_result.IsOpen()) {
 			return true;
 		}

package/src/duckdb/src/common/checksum.cpp

@@ -9,7 +9,7 @@ hash_t Checksum(uint64_t x) {
 
 uint64_t Checksum(uint8_t *buffer, size_t size) {
 	uint64_t result = 5381;
-	uint64_t *ptr = (uint64_t *)buffer;
+	uint64_t *ptr = reinterpret_cast<uint64_t *>(buffer);
 	size_t i;
 	// for efficiency, we first checksum uint64_t values
 	for (i = 0; i < size / 8; i++) {

package/src/duckdb/src/common/compressed_file_system.cpp

@@ -115,28 +115,28 @@ void CompressedFile::Close() {
 }
 
 int64_t CompressedFileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	auto &compressed_file = (CompressedFile &)handle;
+	auto &compressed_file = handle.Cast<CompressedFile>();
 	return compressed_file.ReadData(buffer, nr_bytes);
 }
 
 int64_t CompressedFileSystem::Write(FileHandle &handle, void *buffer, int64_t nr_bytes) {
-	auto &compressed_file = (CompressedFile &)handle;
-	return compressed_file.WriteData((data_ptr_t)buffer, nr_bytes);
+	auto &compressed_file = handle.Cast<CompressedFile>();
+	return compressed_file.WriteData(data_ptr_cast(buffer), nr_bytes);
 }
 
 void CompressedFileSystem::Reset(FileHandle &handle) {
-	auto &compressed_file = (CompressedFile &)handle;
+	auto &compressed_file = handle.Cast<CompressedFile>();
 	compressed_file.child_handle->Reset();
 	compressed_file.Initialize(compressed_file.write);
 }
 
 int64_t CompressedFileSystem::GetFileSize(FileHandle &handle) {
-	auto &compressed_file = (CompressedFile &)handle;
+	auto &compressed_file = handle.Cast<CompressedFile>();
 	return compressed_file.child_handle->GetFileSize();
 }
 
 bool CompressedFileSystem::OnDiskFile(FileHandle &handle) {
-	auto &compressed_file = (CompressedFile &)handle;
+	auto &compressed_file = handle.Cast<CompressedFile>();
 	return compressed_file.child_handle->OnDiskFile();
 }