Implemented the first reader

Author: liuzicheng1987

include/sqlgen/duckdb/Connection.hpp

@@ -11,11 +11,13 @@
 #include <stdexcept>
 #include <string>
 
+#include "../Range.hpp"
 #include "../Ref.hpp"
 #include "../Result.hpp"
 #include "../Transaction.hpp"
 #include "../dynamic/Write.hpp"
 #include "../internal/iterator_t.hpp"
+#include "../internal/to_container.hpp"
 #include "../is_connection.hpp"
 #include "../transpilation/get_tablename.hpp"
 #include "../transpilation/has_reflection_method.hpp"
@@ -51,7 +53,11 @@ class Connection {
 
   template <class ContainerType>
   Result<ContainerType> read(const dynamic::SelectFrom& _query) {
-    return error("TODO");
+    using ValueType = transpilation::value_t<ContainerType>;
+    auto res = Ref<duckdb_result>();
+    duckdb_query(conn_->conn(), to_sql(_query).c_str(), res.get());
+    return internal::to_container<ContainerType, Iterator<ValueType>>(
+        Iterator<ValueType>(res, conn_));
   }
 
   Result<Nothing> rollback() noexcept;

include/sqlgen/duckdb/Iterator.hpp

@@ -11,6 +11,7 @@
 #include "../Ref.hpp"
 #include "../Result.hpp"
 #include "DuckDBConnection.hpp"
+#include "from_chunk_ptrs.hpp"
 #include "make_chunk_ptrs.hpp"
 
 namespace sqlgen::duckdb {
@@ -20,6 +21,7 @@ class Iterator {
   using ConnPtr = Ref<DuckDBConnection>;
   using ResultPtr = Ref<duckdb_result>;
 
+ public:
   struct End {
     bool operator==(const Iterator<T>& _it) const noexcept {
       return _it == *this;
@@ -34,9 +36,13 @@ class Iterator {
   using difference_type = std::ptrdiff_t;
   using value_type = Result<T>;
 
-  Iterator(const ResultPtr& _res, const ConnPtr& _conn);
+  Iterator(const ResultPtr& _res, const ConnPtr& _conn)
+      : res_(_res),
+        conn_(_conn),
+        current_batch_(get_next_batch(_res, _conn)),
+        ix_(0) {}
 
-  ~Iterator();
+  ~Iterator() = default;
 
   Result<T>& operator*() const noexcept { return (*current_batch_)[ix_]; }
 
@@ -75,8 +81,10 @@ class Iterator {
           }
           return batch;
         })
-        .or_else(
-            [](auto _err) { return Ref<std::vector<Result<T>>>::make({_err}); })
+        .or_else([](auto _err) {
+          return Ref<std::vector<Result<T>>>::make(
+              std::vector<Result<T>>({Result<T>(_err)}));
+        })
         .value();
   }
 

include/sqlgen/duckdb/from_chunk_ptrs.hpp

@@ -8,7 +8,6 @@
 #include <utility>
 
 #include "../Result.hpp"
-#include "../Tuple.hpp"
 #include "ColumnData.hpp"
 #include "chunk_ptrs_t.hpp"
 
@@ -18,8 +17,9 @@ template <class T, class ChunkPtrsT>
 struct FromChunkPtrs;
 
 template <class T, class... Ts>
-struct FromChunkPtrs<T, Tuple<ColumnData<Ts>...>> {
-  Result<T> operator(const Tuple<ColumnData<Ts>...>& _chunk_ptrs, idx_t _i) {
+struct FromChunkPtrs<T, rfl::Tuple<ColumnData<Ts>...>> {
+  Result<T> operator()(const rfl::Tuple<ColumnData<Ts>...>& _chunk_ptrs,
+                       idx_t _i) {
     return [&]<int... _is>(std::integer_sequence<int, _is...>) {
       // TODO: Integrate this into the parser logic.
       return T{*(rfl::get<_is>(_chunk_ptrs).data + _i)...};

tests/duckdb/test_write_and_read.cpp

@@ -8,31 +8,35 @@
 namespace test_write_and_read {
 
 struct Person {
-  sqlgen::PrimaryKey<uint32_t> id;
-  std::string first_name;
-  std::string last_name;
+  // sqlgen::PrimaryKey<uint32_t> id;
+  // std::string first_name;
+  // std::string last_name;
   int age;
 };
 
 TEST(duckdb, test_write_and_read) {
-  const auto people1 = std::vector<Person>(
+  /*const auto people1 = std::vector<Person>(
       {Person{
            .id = 0, .first_name = "Homer", .last_name = "Simpson", .age = 45},
        Person{.id = 1, .first_name = "Bart", .last_name = "Simpson", .age = 10},
        Person{.id = 2, .first_name = "Lisa", .last_name = "Simpson", .age = 8},
        Person{
-           .id = 3, .first_name = "Maggie", .last_name = "Simpson", .age = 0}});
+           .id = 3, .first_name = "Maggie", .last_name = "Simpson", .age =
+     0}});*/
 
-  using namespace sqlgen;
+  const auto people1 = std::vector<Person>({Person{.age = 45}});
 
-  duckdb::connect().and_then(write(std::ref(people1))).value();
+  using namespace sqlgen;
 
-  /*const auto people2 = sqlgen::read<std::vector<Person>>(conn).value();
+  const auto people2 = duckdb::connect()
+                           .and_then(write(std::ref(people1)))
+                           .and_then(sqlgen::read<std::vector<Person>>)
+                           .value();
 
   const auto json1 = rfl::json::write(people1);
   const auto json2 = rfl::json::write(people2);
 
-  EXPECT_EQ(json1, json2);*/
+  EXPECT_EQ(json1, json2);
 }
 
 }  // namespace test_write_and_read