added enhanced where suport

repertory/repertory_test/src/database_test.cpp

@@ -27,7 +27,6 @@
 #include "database/db_select.hpp"
 #include "database/db_update.hpp"
 #include "utils/path.hpp"
-#include <variant>
 
 namespace repertory {
 class database_test : public ::testing::Test {
@@ -139,9 +138,11 @@ TEST_F(database_test, db_delete_where_query) {
   auto query = db::db_delete{*db3.get(), "table"}
                    .where("column1")
                    .equals("test1")
-                   .and_where("column2")
+                   .and_()
+                   .column("column2")
                    .equals("test2");
-  auto query_str = query.dump();
+  std::int64_t idx{};
+  auto query_str = query.dump(idx);
   std::cout << query_str << std::endl;
   EXPECT_STREQ(R"(DELETE FROM "table" WHERE ("column1"=?1 AND "column2"=?2);)",
                query_str.c_str());
@@ -180,9 +181,11 @@ TEST_F(database_test, db_select_where_query) {
   auto query = db::db_select{*db3.get(), "table"}
                    .where("column1")
                    .equals("test1")
-                   .and_where("column2")
+                   .and_()
+                   .column("column2")
                    .equals("test2");
-  auto query_str = query.dump();
+  std::int64_t idx{};
+  auto query_str = query.dump(idx);
   std::cout << query_str << std::endl;
   EXPECT_STREQ(
       R"(SELECT * FROM "table" WHERE ("column1"=?1 AND "column2"=?2);)",
@@ -195,9 +198,11 @@ TEST_F(database_test, db_select_columns_query) {
                    .column("column2")
                    .where("column1")
                    .equals("test1")
-                   .and_where("column2")
+                   .and_()
+                   .column("column2")
                    .equals("test2");
-  auto query_str = query.dump();
+  std::int64_t idx{};
+  auto query_str = query.dump(idx);
   std::cout << query_str << std::endl;
   EXPECT_STREQ(
       R"(SELECT column1, column2 FROM "table" WHERE ("column1"=?1 AND "column2"=?2);)",
@@ -209,9 +214,11 @@ TEST_F(database_test, db_update_query) {
                    .column_value("column1", "moose")
                    .where("column1")
                    .equals("test1")
-                   .and_where("column2")
+                   .and_()
+                   .column("column2")
                    .equals("test2");
-  auto query_str = query.dump();
+  std::int64_t idx{};
+  auto query_str = query.dump(idx);
   std::cout << query_str << std::endl;
   EXPECT_STREQ(
       R"(UPDATE "table" SET "column1"=?1 WHERE ("column1"=?2 AND "column2"=?3);)",
@@ -234,7 +241,8 @@ TEST_F(database_test, insert_update_delete) {
                      .column_value("column1", "moose")
                      .where("column1")
                      .equals("test0");
-    std::cout << query.dump() << std::endl;
+    std::int64_t idx{};
+    std::cout << query.dump(idx) << std::endl;
     auto res = query.go();
     EXPECT_TRUE(res.ok());
   }
@@ -262,176 +270,25 @@ TEST_F(database_test, insert_or_replace_and_delete) {
   common_delete(*db3.get());
 }
 
-struct comp_t final {
-  std::string column_name;
-  std::string comparison;
-  db::db_types_t data;
-};
-
-template <typename cn_t, typename w_t, typename wn_t> struct next_t final {
-  std::string action;
-  w_t &parent;
-  w_t next{&parent};
-
-  using group_func_t = std::function<void(w_t &)>;
-
-  [[nodiscard]] auto column(std::string column_name) -> cn_t {
-    return next.column(column_name);
-  }
-
-  [[nodiscard]] auto dump(std::int64_t &idx) const -> std::string {
-    return parent.dump(idx);
-  }
-
-  [[nodiscard]] auto group(group_func_t func) -> wn_t {
-    return next.group(std::move(func));
-  }
-};
-
-template <typename cn_t, typename w_t> struct where_next_t final {
-  w_t &owner;
-  w_t &parent;
-
-  using n_t = next_t<cn_t, w_t, where_next_t>;
-
-  [[nodiscard]] auto and_() -> n_t & {
-    owner.actions.emplace_back(n_t{
-        "AND",
-        parent,
-    });
-
-    return std::get<n_t>(*std::prev(owner.actions.end()));
-  }
-
-  [[nodiscard]] auto dump(std::int64_t &idx) const -> std::string {
-    return parent.dump(idx);
-  }
-
-  [[nodiscard]] auto or_() -> n_t & {
-    owner.actions.emplace_back(n_t{
-        "OR",
-        parent,
-    });
-
-    return std::get<n_t>(*std::prev(owner.actions.end()));
-  }
-};
-
-template <typename w_t> struct comp_next_t final {
-  w_t &owner;
-  w_t &parent;
-  std::string column_name;
-
-  using wn_t = where_next_t<comp_next_t, w_t>;
-
-  [[nodiscard]] auto create(std::string operation, db::db_types_t value) {
-    owner.actions.emplace_back(comp_t{
-        column_name,
-        operation,
-        value,
-    });
-
-    return wn_t{
-        owner,
-        parent,
-    };
-  }
-
-  auto equals(db::db_types_t value) -> wn_t { return create("=", value); };
-
-  auto gt(db::db_types_t value) -> wn_t { return create(">", value); }
-
-  auto gte(db::db_types_t value) -> wn_t { return create(">=", value); }
-
-  auto like(db::db_types_t value) -> wn_t { return create("LIKE", value); }
-
-  auto lt(db::db_types_t value) -> wn_t { return create("<", value); }
-
-  auto lte(db::db_types_t value) -> wn_t { return create("<=", value); }
-
-  auto not_equals(db::db_types_t value) -> wn_t { return create("!=", value); };
-};
-
-struct where_t final {
-  where_t *parent{this};
-
-  using cn_t = comp_next_t<where_t>;
-  using wn_t = where_next_t<cn_t, where_t>;
-  using n_t = next_t<cn_t, where_t, wn_t>;
-
-  using group_func_t = std::function<void(where_t &)>;
-
-  using action_t = std::variant<comp_t, n_t, where_t>;
-
-  std::vector<action_t> actions{};
-
-  [[nodiscard]] auto column(std::string column_name) -> cn_t {
-    return comp_next_t{
-        *this,
-        *parent,
-        column_name,
-    };
-  }
-
-  [[nodiscard]] static auto dump(std::int64_t &idx,
-                                 auto &&data) -> std::string {
-    std::stringstream stream;
-
-    for (auto &&action : data.actions) {
-      std::visit(overloaded{
-                     [&idx, &stream](const comp_t &comp) {
-                       stream << comp.column_name << comp.comparison
-                              << '?' + std::to_string(++idx);
-                     },
-                     [&idx, &stream](const n_t &next) {
-                       stream << ' ' << next.action << ' '
-                              << dump(idx, next.next);
-                     },
-                     [&idx, &stream](const where_t &where) {
-                       stream << '(' << dump(idx, where) << ')';
-                     },
-                 },
-                 action);
-    }
-
-    return stream.str();
-  }
-
-  [[nodiscard]] auto dump(std::int64_t &idx) const -> std::string {
-    return dump(idx, *this);
-  }
-
-  [[nodiscard]] auto group(group_func_t func) -> wn_t {
-    where_t where{parent};
-    func(where);
-
-    actions.emplace_back(std::move(where));
-    return wn_t{
-        *this,
-        *parent,
-    };
-  }
-};
-
 TEST(database, groups) {
-  // "s=a and r=t"
-  std::int64_t idx{0U};
-  auto str =
-      where_t().column("s").equals("a").and_().column("r").equals("t").dump(
-          idx);
-  std::cout << str << std::endl;
-
-  // "(s=a and r=t) OR (s=c or s=x)"
-  idx = 0U;
-  str = where_t()
-            .group([](where_t &where) {
-              where.column("s").equals("a").and_().column("r").equals("t");
-            })
-            .or_()
-            .group([](where_t &where) {
-              where.column("s").equals("c").or_().column("s").equals("x");
-            })
-            .dump(idx);
-  std::cout << str << std::endl;
+  // // "s=a and r=t"
+  // std::int64_t idx{0U};
+  // auto str =
+  //     db_where_t().column("s").equals("a").and_().column("r").equals("t").dump(
+  //         idx);
+  // std::cout << str << std::endl;
+  //
+  // // "(s=a and r=t) OR (s=c or s=x)"
+  // idx = 0U;
+  // str = db_where_t()
+  //           .group([](db_where_t &where) {
+  //             where.column("s").equals("a").and_().column("r").equals("t");
+  //           })
+  //           .or_()
+  //           .group([](db_where_t &where) {
+  //             where.column("s").equals("c").or_().column("s").equals("x");
+  //           })
+  //           .dump(idx);
+  // std::cout << str << std::endl;
 }
 } // namespace repertory