Added numeric casting

Author: liuzicheng1987

include/sqlgen/duckdb/cast_duckdb_type.hpp

@@ -0,0 +1,69 @@
+#ifndef SQLGEN_DUCKDB_CASTDUCKDBTYPE_HPP_
+#define SQLGEN_DUCKDB_CASTDUCKDBTYPE_HPP_
+
+#include <duckdb.h>
+
+#include <rfl.hpp>
+#include <type_traits>
+
+#include "../Ref.hpp"
+#include "../Result.hpp"
+
+namespace sqlgen::duckdb {
+
+template <class T, class U>
+Ref<std::vector<T>> cast_as_vector(const size_t _size, U* _ptr) {
+  auto vec = Ref<std::vector<T>>::make(_size);
+  for (size_t i = 0; i < _size; ++i) {
+    (*vec)[i] = static_cast<T>(_ptr[i]);
+  }
+  return vec;
+}
+
+template <class T>
+Result<Ref<std::vector<T>>> cast_duckdb_type(const duckdb_type _type,
+                                             const size_t _size,
+                                             void* _raw_ptr) {
+  if constexpr (!std::is_floating_point_v<T> && !std::is_integral_v<T>) {
+    return error("Could not cast");
+
+  } else {
+    if (_type == DUCKDB_TYPE_TINYINT) {
+      return cast_as_vector<T>(_size, static_cast<int8_t*>(_raw_ptr));
+
+    } else if (_type == DUCKDB_TYPE_UTINYINT) {
+      return cast_as_vector<T>(_size, static_cast<uint8_t*>(_raw_ptr));
+
+    } else if (_type == DUCKDB_TYPE_SMALLINT) {
+      return cast_as_vector<T>(_size, static_cast<int16_t*>(_raw_ptr));
+
+    } else if (_type == DUCKDB_TYPE_USMALLINT) {
+      return cast_as_vector<T>(_size, static_cast<uint16_t*>(_raw_ptr));
+
+    } else if (_type == DUCKDB_TYPE_INTEGER) {
+      return cast_as_vector<T>(_size, static_cast<int32_t*>(_raw_ptr));
+
+    } else if (_type == DUCKDB_TYPE_UINTEGER) {
+      return cast_as_vector<T>(_size, static_cast<uint32_t*>(_raw_ptr));
+
+    } else if (_type == DUCKDB_TYPE_BIGINT) {
+      return cast_as_vector<T>(_size, static_cast<int64_t*>(_raw_ptr));
+
+    } else if (_type == DUCKDB_TYPE_UBIGINT) {
+      return cast_as_vector<T>(_size, static_cast<uint64_t*>(_raw_ptr));
+
+    } else if (_type == DUCKDB_TYPE_FLOAT) {
+      return cast_as_vector<T>(_size, static_cast<float*>(_raw_ptr));
+
+    } else if (_type == DUCKDB_TYPE_DOUBLE) {
+      return cast_as_vector<T>(_size, static_cast<double*>(_raw_ptr));
+
+    } else {
+      return error("Could not cast");
+    }
+  }
+}
+
+}  // namespace sqlgen::duckdb
+
+#endif

include/sqlgen/duckdb/make_chunk_ptrs.hpp

@@ -11,6 +11,7 @@
 #include "../Ref.hpp"
 #include "ColumnData.hpp"
 #include "DuckDBResult.hpp"
+#include "cast_duckdb_type.hpp"
 #include "chunk_ptrs_t.hpp"
 #include "get_duckdb_type.hpp"
 
@@ -36,17 +37,40 @@ struct MakeChunkPtrs<rfl::Tuple<ColumnData<Ts, ColNames>...>> {
   template <class T, class ColName, int _i>
   static auto make_column_data(const Ref<DuckDBResult>& _res,
                                duckdb_data_chunk _chunk) {
-    if (duckdb_column_type(&_res->res(), _i) != get_duckdb_type<T>()) {
+    const auto actual_duckdb_type = duckdb_column_type(&_res->res(), _i);
+
+    auto vec = duckdb_data_chunk_get_vector(_chunk, _i);
+
+    if (actual_duckdb_type == get_duckdb_type<T>()) {
+      return ColumnData<T, ColName>{
+          .vec = vec,
+          .data = static_cast<T*>(duckdb_vector_get_data(vec)),
+          .validity = duckdb_vector_get_validity(vec)};
+    }
+
+    if constexpr (std::is_same_v<T, bool>) {
       throw std::runtime_error(
-          "Wrong type in field " + std::to_string(_i) + ". Expected " +
+          "Wrong type in field '" + ColName().str() + "'. Expected " +
           rfl::enum_to_string(get_duckdb_type<T>()) + ", got " +
-          rfl::enum_to_string(duckdb_column_type(&_res->res(), _i)) + ".");
+          rfl::enum_to_string(actual_duckdb_type) + ".");
+
+    } else {
+      const auto ptr_res = cast_duckdb_type<T>(
+          actual_duckdb_type, duckdb_data_chunk_get_size(_chunk),
+          duckdb_vector_get_data(vec));
+
+      if (!ptr_res) {
+        throw std::runtime_error(
+            "Wrong type in field '" + ColName().str() + "'. Expected " +
+            rfl::enum_to_string(get_duckdb_type<T>()) + ", got " +
+            rfl::enum_to_string(actual_duckdb_type) + ".");
+      }
+
+      return ColumnData<T, ColName>{.vec = vec,
+                                    .data = (*ptr_res)->data(),
+                                    .validity = duckdb_vector_get_validity(vec),
+                                    .ptr = ptr_res->ptr()};
     }
-    auto vec = duckdb_data_chunk_get_vector(_chunk, _i);
-    return ColumnData<T, ColName>{
-        .vec = vec,
-        .data = static_cast<T*>(duckdb_vector_get_data(vec)),
-        .validity = duckdb_vector_get_validity(vec)};
   }
 };