From 38c17f093615a16a4b4ec6dc2b5d3edb5c1d3895 Mon Sep 17 00:00:00 2001
From: Kelly Rauchenberger <fefferburbia@gmail.com>
Date: Thu, 27 Sep 2018 21:40:52 -0400
Subject: More hkutil refactoring

All database access goes through hatkirby::database now.

verbly::token, verbly::statement::condition, and verbly::part have been converted to use mpark::variant now. verbly::binding has been deleted, and replaced with a mpark::variant typedef in statement.h. This means that the only remaining tagged union class is verbly::generator::part.

refs #5
---
 lib/query.h | 107 ++++++++++++++++--------------------------------------------
 1 file changed, 29 insertions(+), 78 deletions(-)

(limited to 'lib/query.h')

diff --git a/lib/query.h b/lib/query.h
index 0f490ed..65b4e9d 100644
--- a/lib/query.h
+++ b/lib/query.h
@@ -5,10 +5,8 @@
 #include <stdexcept>
 #include <string>
 #include <list>
-#include <sqlite3.h>
-#include <iostream>
+#include <hkutil/database.h>
 #include "statement.h"
-#include "binding.h"
 #include "order.h"
 
 namespace verbly {
@@ -16,7 +14,10 @@ namespace verbly {
   class database_error : public std::logic_error {
   public:
 
-    database_error(std::string msg, std::string sqlMsg) : std::logic_error(msg + " (" + sqlMsg + ")")
+    database_error(
+      std::string msg,
+      std::string sqlMsg) :
+        std::logic_error(msg + " (" + sqlMsg + ")")
     {
     }
   };
@@ -25,107 +26,57 @@ namespace verbly {
   class query {
   public:
 
-    query(const database& db, sqlite3* ppdb, filter queryFilter, order sortOrder, int limit) : db_(&db)
+    query(
+      const database& db,
+      hatkirby::database& ppdb,
+      filter queryFilter,
+      order sortOrder,
+      int limit) :
+        db_(db),
+        ppdb_(ppdb)
     {
       if ((sortOrder.getType() == order::type::field)
         && (sortOrder.getSortField().getObject() != Object::objectType))
       {
-        throw std::invalid_argument("Can only sort query by a field in the result table");
+        throw std::invalid_argument(
+          "Can only sort query by a field in the result table");
       }
 
       statement stmt(Object::objectType, std::move(queryFilter));
 
-      std::string queryString = stmt.getQueryString(Object::select, std::move(sortOrder), limit);
-      std::list<binding> bindings = stmt.getBindings();
+      queryString_ =
+        stmt.getQueryString(Object::select, std::move(sortOrder), limit);
 
-      if (sqlite3_prepare_v2(ppdb, queryString.c_str(), queryString.length(), &ppstmt_, NULL) != SQLITE_OK)
-      {
-        std::string errorMsg = sqlite3_errmsg(ppdb);
-        sqlite3_finalize(ppstmt_);
-
-        throw database_error("Error preparing query", errorMsg);
-      }
-
-      int i = 1;
-      for (const binding& value : bindings)
-      {
-        switch (value.getType())
-        {
-          case binding::type::integer:
-          {
-            if (sqlite3_bind_int(ppstmt_, i, value.getInteger()) != SQLITE_OK)
-            {
-              std::string errorMsg = sqlite3_errmsg(ppdb);
-              sqlite3_finalize(ppstmt_);
-
-              throw database_error("Error binding value to query", errorMsg);
-            }
-
-            break;
-          }
-
-          case binding::type::string:
-          {
-            if (sqlite3_bind_text(ppstmt_, i, value.getString().c_str(), value.getString().length(), SQLITE_TRANSIENT) != SQLITE_OK)
-            {
-              std::string errorMsg = sqlite3_errmsg(ppdb);
-              sqlite3_finalize(ppstmt_);
-
-              throw database_error("Error binding value to query", errorMsg);
-            }
-
-            break;
-          }
-
-          case binding::type::invalid:
-          {
-            throw std::logic_error("Cannot use invalid bindings");
-          }
-
-          case binding::type::field:
-          {
-            throw std::logic_error("Compare field binding made it past statement generation");
-          }
-        }
-
-        i++;
-      }
-    }
-
-    ~query()
-    {
-      sqlite3_finalize(ppstmt_);
+      bindings_ = stmt.getBindings();
     }
 
     std::vector<Object> all() const
     {
+      std::vector<hatkirby::row> rows =
+        ppdb_.queryAll(queryString_, bindings_);
+
       std::vector<Object> result;
 
-      while (sqlite3_step(ppstmt_) == SQLITE_ROW)
+      for (hatkirby::row& r : rows)
       {
-        result.emplace_back(*db_, ppstmt_);
+        result.emplace_back(db_, std::move(r));
       }
 
-      sqlite3_reset(ppstmt_);
-
       return result;
     }
 
     Object first() const
     {
-      std::vector<Object> results = all();
-      if (!results.empty())
-      {
-        return results.front();
-      } else {
-        throw std::logic_error("query returned empty dataset");
-      }
+      return { db_, ppdb_.queryFirst(queryString_, bindings_) };
     }
 
   private:
-    const database* db_;
-    sqlite3_stmt* ppstmt_;
 
+    const database& db_;
+    hatkirby::database& ppdb_;
+
+    std::string queryString_;
+    std::list<hatkirby::binding> bindings_;
   };
 
 };
-- 
cgit 1.4.1