Add initial sqlite class

CMakeLists.txt

@@ -38,8 +38,6 @@ check_type_size("half_float::detail::expr" HALF_EXPR LANGUAGE CXX)
 set(CMAKE_REQUIRED_INCLUDES)
 set(CMAKE_EXTRA_INCLUDE_FILES)
 
-find_package(nlohmann_json 3.8.0 REQUIRED)
-
 include(ROCMSetupVersion)
 
 rocm_setup_version(VERSION 2.3)

dev-requirements.txt

-pfultz2/rocm-recipes
+ROCmSoftwarePlatform/rocm-recipes
 facebook/zstd@v1.4.5 -X subdir -DCMAKE_DIR=build/cmake
 ccache@v4.1
 pcre,pfultz2/pcre@8.45 -H sha256:d6f7182602a775a7d500a0cedca6449af0400c6493951513046d17615ed0bf11

rbuild.ini

@@ -2,7 +2,7 @@
 cxx = ${rocm_path}/llvm/bin/clang++
 cc = ${rocm_path}/llvm/bin/clang
 deps =
-    pfultz2/rocm-recipes
+    ROCmSoftwarePlatform/rocm-recipes
     -f requirements.txt
 
 [gh]

requirements.txt

@@ -4,3 +4,4 @@ blaze,https://bitbucket.org/blaze-lib/blaze/get/f0755dea0e03.tar.gz -X header -D
 half,https://github.com/pfultz2/half/archive/1.12.0.tar.gz -X header -H sha256:0a08660b68abb176ebc2a0cdf8de46e3182a7f46c66443bb80dbfaaec98cf969
 pybind/pybind11@d159a563383d10c821ba7b2a71905d1207db6de4 --build
 msgpack/msgpack-c@cpp-3.3.0 -DMSGPACK_BUILD_TESTS=Off
+sqlite3@3.17 -DCMAKE_POSITION_INDEPENDENT_CODE=On

src/CMakeLists.txt

@@ -56,6 +56,7 @@ add_library(migraphx
     register_target.cpp
     replace_allocate.cpp
     simplify_qdq.cpp
+    sqlite.cpp
     rewrite_batchnorm.cpp
     rewrite_pooling.cpp
     rewrite_quantization.cpp
@@ -215,6 +216,13 @@ target_include_directories(migraphx SYSTEM PUBLIC $<BUILD_INTERFACE:${HALF_INCLU
 find_package(Threads)
 target_link_libraries(migraphx PUBLIC Threads::Threads)
 
+find_package(nlohmann_json 3.8.0 REQUIRED)
+target_link_libraries(migraphx PRIVATE nlohmann_json::nlohmann_json)
+
+find_package(PkgConfig)
+pkg_check_modules(SQLITE3 REQUIRED IMPORTED_TARGET sqlite3)
+target_link_libraries(migraphx PRIVATE PkgConfig::SQLITE3)
+
 find_package(msgpack REQUIRED)
 target_link_libraries(migraphx PRIVATE msgpackc-cxx)
 # Make this available to the tests

src/include/migraphx/sqlite.hpp

+#ifndef MIGRAPHX_GUARD_MIGRAPHX_SQLITE_HPP
+#define MIGRAPHX_GUARD_MIGRAPHX_SQLITE_HPP
+
+#include <migraphx/config.hpp>
+#include <migraphx/filesystem.hpp>
+#include <memory>
+#include <unordered_map>
+#include <vector>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+
+struct sqlite_impl;
+
+struct sqlite
+{
+    sqlite() = default;
+    static sqlite read(const fs::path& p);
+    static sqlite write(const fs::path& p);
+    std::vector<std::unordered_map<std::string, std::string>> execute(const std::string& s);
+private:
+    std::shared_ptr<sqlite_impl> impl;
+};
+
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+#endif // MIGRAPHX_GUARD_MIGRAPHX_SQLITE_HPP

src/sqlite.cpp

+#include <migraphx/sqlite.hpp>
+#include <migraphx/manage_ptr.hpp>
+#include <migraphx/errors.hpp>
+#include <sqlite3.h>
+#include <algorithm>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+
+using sqlite3_ptr = MIGRAPHX_MANAGE_PTR(sqlite3*, sqlite3_close);
+
+struct sqlite_impl
+{
+    sqlite3* get() const { return ptr.get(); }
+    void open(const fs::path& p, int flags)
+    {
+        sqlite3* ptr_tmp = nullptr;
+        int rc = sqlite3_open_v2(p.string().c_str(), &ptr_tmp, flags, nullptr);
+        ptr = sqlite3_ptr{ptr_tmp};
+        if (rc != 0)
+            MIGRAPHX_THROW("error opening " + p.string() + ": " + error_message());
+    }
+
+    template<class F>
+    void exec(const char*sql, F f)
+    {
+        auto callback = [](void* obj, auto... xs) -> int {
+            try
+            {
+                auto g = static_cast<const F*>(obj);
+                (*g)(xs...);
+                return 0;
+            }
+            catch(...)
+            {
+                return -1;
+            }
+        };
+        int rc = sqlite3_exec(get(), sql, callback, &f, nullptr);
+        if (rc != 0)
+            MIGRAPHX_THROW(error_message());
+    }
+
+    std::string error_message() const
+    {
+        std::string msg = "sqlite3: ";
+        return msg + sqlite3_errmsg(get());
+    }
+    sqlite3_ptr ptr;
+};
+
+sqlite sqlite::read(const fs::path& p)
+{
+    sqlite r;
+    r.impl = std::make_shared<sqlite_impl>();
+    r.impl->open(p, SQLITE_OPEN_READONLY);
+    return r;
+}
+
+sqlite sqlite::write(const fs::path& p)
+{
+    sqlite r;
+    r.impl = std::make_shared<sqlite_impl>();
+    r.impl->open(p, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
+    return r;
+}
+
+std::vector<std::unordered_map<std::string, std::string>> sqlite::execute(const std::string& s)
+{
+    std::vector<std::unordered_map<std::string, std::string>> result;
+    impl->exec(s.c_str(), [&](int n, char** texts, char** names) {
+        std::unordered_map<std::string, std::string> row;
+        row.reserve(n);
+        std::transform(names, names+n, texts, std::inserter(row, row.begin()), [&](const char* name, const char* text) {
+            return std::make_pair(name, text);
+        });
+        result.push_back(row);
+    });
+    return result;
+}
+
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx

test/sqlite.cpp

+#include <migraphx/sqlite.hpp>
+#include <migraphx/tmp_dir.hpp>
+#include <test.hpp>
+
+const std::string create_table = R"__migraphx__(
+CREATE TABLE IF NOT EXISTS test_db (
+    id INTEGER PRIMARY KEY ASC,
+    data TEXT NOT NULL
+);
+INSERT INTO test_db (id, data) VALUES (1, "a");
+)__migraphx__";
+
+const std::string select_all = R"__migraphx__(
+SELECT * FROM test_db;
+)__migraphx__";
+
+
+TEST_CASE(read_write)
+{
+    migraphx::tmp_dir td{};
+    auto db_path = td.path / "test.db";
+    {
+        auto db = migraphx::sqlite::write(db_path);
+        db.execute(create_table);
+    }
+    {
+        auto db = migraphx::sqlite::read(db_path);
+        auto rows = db.execute(select_all);
+        EXPECT(rows.size() == 1);
+        auto row = rows.front();
+        EXPECT(row.at("data") == "a");
+        EXPECT(row.at("id") == "1");
+    }
+}
+
+int main(int argc, const char* argv[]) { test::run(argc, argv); }