summaryrefslogtreecommitdiffstats
path: root/src/sqlitepp.client.hh
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-05-04 17:44:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-05-04 17:44:55 +0000
commit5068d34c08f951a7ea6257d305a1627b09a95817 (patch)
tree08213e2be853396a3b07ce15dbe222644dcd9a89 /src/sqlitepp.client.hh
parentInitial commit. (diff)
downloadlnav-5068d34c08f951a7ea6257d305a1627b09a95817.tar.xz
lnav-5068d34c08f951a7ea6257d305a1627b09a95817.zip
Adding upstream version 0.11.1.upstream/0.11.1upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r--src/sqlitepp.client.hh209
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