Adding upstream version 0.11.1.upstream/0.11.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 209 insertions, 0 deletions

diff --git a/src/sqlitepp.client.hh b/src/sqlitepp.client.hh
new file mode 100644
index 0000000..5a82756
--- /dev/null
+++ b/src/sqlitepp.client.hh
@@ -0,0 +1,209 @@
+/**
+ * Copyright (c) 2022, Timothy Stack
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * * Neither the name of Timothy Stack nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ''AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef lnav_sqlitepp_client_hh
+#define lnav_sqlitepp_client_hh
+
+#include <sqlite3.h>
+
+#include "base/auto_mem.hh"
+#include "base/intern_string.hh"
+#include "base/lnav_log.hh"
+#include "sql_util.hh"
+#include "vtab_module.hh"
+
+inline int
+bind_to_sqlite(sqlite3_stmt* stmt, int index, const struct timeval& tv)
+{
+    char timestamp[64];
+
+    sql_strftime(timestamp, sizeof(timestamp), tv, 'T');
+
+    return sqlite3_bind_text(stmt, index, timestamp, -1, SQLITE_TRANSIENT);
+}
+
+inline int
+bind_to_sqlite(sqlite3_stmt* stmt, int index, const char* str)
+{
+    return sqlite3_bind_text(stmt, index, str, -1, SQLITE_TRANSIENT);
+}
+
+inline int
+bind_to_sqlite(sqlite3_stmt* stmt, int index, intern_string_t ist)
+{
+    return sqlite3_bind_text(
+        stmt, index, ist.get(), ist.size(), SQLITE_TRANSIENT);
+}
+
+inline int
+bind_to_sqlite(sqlite3_stmt* stmt, int index, const std::string& str)
+{
+    return sqlite3_bind_text(
+        stmt, index, str.c_str(), str.size(), SQLITE_TRANSIENT);
+}
+
+inline int
+bind_to_sqlite(sqlite3_stmt* stmt, int index, int64_t i)
+{
+    return sqlite3_bind_int64(stmt, index, i);
+}
+
+template<typename... Args, std::size_t... Idx>
+int
+bind_values_helper(sqlite3_stmt* stmt,
+                   std::index_sequence<Idx...> idxs,
+                   Args... args)
+{
+    int rcs[] = {bind_to_sqlite(stmt, Idx + 1, args)...};
+
+    for (size_t lpc = 0; lpc < idxs.size(); lpc++) {
+        if (rcs[lpc] != SQLITE_OK) {
+            log_error("Failed to bind column %d in statement: %s",
+                      lpc,
+                      sqlite3_sql(stmt));
+            return rcs[lpc];
+        }
+    }
+
+    return SQLITE_OK;
+}
+
+template<typename... Args>
+int
+bind_values(sqlite3_stmt* stmt, Args... args)
+{
+    return bind_values_helper(
+        stmt, std::make_index_sequence<sizeof...(Args)>(), args...);
+}
+
+struct prepared_stmt {
+    prepared_stmt(auto_mem<sqlite3_stmt> stmt) : ps_stmt(std::move(stmt)) {}
+
+    Result<void, std::string> execute()
+    {
+        auto rc = sqlite3_reset(this->ps_stmt.in());
+        if (rc != SQLITE_OK) {
+            return Err(std::string(
+                sqlite3_errmsg(sqlite3_db_handle(this->ps_stmt.in()))));
+        }
+
+        rc = sqlite3_step(this->ps_stmt.in());
+        if (rc == SQLITE_OK || rc == SQLITE_DONE) {
+            return Ok();
+        }
+
+        auto msg = std::string(
+            sqlite3_errmsg(sqlite3_db_handle(this->ps_stmt.in())));
+        return Err(msg);
+    }
+
+    struct end_of_rows {};
+    struct fetch_error {
+        std::string fe_msg;
+    };
+
+    void reset() { sqlite3_reset(this->ps_stmt.in()); }
+
+    template<typename T>
+    using fetch_result = mapbox::util::variant<T, end_of_rows, fetch_error>;
+
+    template<typename T>
+    fetch_result<T> fetch_row()
+    {
+        auto rc = sqlite3_step(this->ps_stmt.in());
+        if (rc == SQLITE_OK || rc == SQLITE_DONE) {
+            return end_of_rows{};
+        }
+
+        if (rc == SQLITE_ROW) {
+            const auto argc = sqlite3_column_count(this->ps_stmt.in());
+            sqlite3_value* argv[argc];
+
+            for (int lpc = 0; lpc < argc; lpc++) {
+                argv[lpc] = sqlite3_column_value(this->ps_stmt.in(), lpc);
+            }
+
+            return from_sqlite<T>()(argc, argv, 0);
+        }
+
+        return fetch_error{
+            sqlite3_errmsg(sqlite3_db_handle(this->ps_stmt.in())),
+        };
+    }
+
+    template<typename T, typename F>
+    Result<void, fetch_error> for_each_row(F func)
+    {
+        nonstd::optional<fetch_error> err;
+        auto done = false;
+
+        while (!done) {
+            done = this->template fetch_row<T>().match(
+                func,
+                [](end_of_rows) { return true; },
+                [&err](const fetch_error& fe) {
+                    err = fe;
+                    return true;
+                });
+        }
+
+        if (err) {
+            return Err(err.value());
+        }
+
+        return Ok();
+    }
+
+    auto_mem<sqlite3_stmt> ps_stmt;
+};
+
+template<typename... Args>
+static Result<prepared_stmt, std::string>
+prepare_stmt(sqlite3* db, const char* sql, Args... args)
+{
+    auto_mem<sqlite3_stmt> retval(sqlite3_finalize);
+
+    if (sqlite3_prepare_v2(db, sql, -1, retval.out(), nullptr) != SQLITE_OK) {
+        return Err(
+            fmt::format(FMT_STRING("unable to prepare SQL statement: {}"),
+                        sqlite3_errmsg(db)));
+    }
+
+    if (bind_values(retval.in(), args...) != SQLITE_OK) {
+        return Err(
+            fmt::format(FMT_STRING("unable to prepare SQL statement: {}"),
+                        sqlite3_errmsg(db)));
+    }
+
+    return Ok(prepared_stmt{
+        std::move(retval),
+    });
+}
+
+#endif