Add SQLite interface.

6 files changed, 419 insertions, 3 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d5ebb4e..348cd36 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -13,6 +13,8 @@ set(CXX_CPPCHECK "project=build/compile_commands.json;enable=information;force")
 
 set(CMAKE_EXPORT_COMPILE_COMMANDS true)
 
+find_package(SQLite3 REQUIRED)
+
 add_library(fud SHARED
     source/libfud.cpp
     source/fud_assert.cpp
@@ -21,12 +23,15 @@ add_library(fud SHARED
     source/fud_string.cpp
     source/fud_utf8.cpp
     source/fud_utf8_iterator.cpp
+    source/fud_sqlite.cpp
 )
 
 include(cmake/warnings.cmake)
 target_compile_options(fud PRIVATE "${FUD_WARNINGS}")
 
-target_include_directories(fud PUBLIC include)
+target_include_directories(fud PUBLIC include ${SQLite3_INCLUDE_DIRS})
+
+target_link_libraries(fud ${SQLite3_LIBRARIES})
 
 set_target_properties(
     fud PROPERTIES
@@ -36,7 +41,6 @@ set_target_properties(
     C_EXTENSIONS OFF
     CXX_STANDARD_REQUIRED ON)
 
-
 if (FUD_TEST)
     add_subdirectory(test)
     # set(CVG_FLAGS -fsanitize=address -fsanitize=undefined --coverage)
@@ -79,6 +83,7 @@ install(FILES ${CMAKE_CURRENT_BINARY_DIR}/FudConfig.cmake
         DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/Fud )
 
 set(FUD_HEADERS
+    "include/libfud.hpp"
     "include/fud_array.hpp"
     "include/fud_assert.hpp"
     "include/fud_c_file.hpp"
@@ -90,7 +95,7 @@ set(FUD_HEADERS
     "include/fud_unique_array.hpp"
     "include/fud_utf8.hpp"
     "include/fud_utf8_iterator.hpp"
-    "include/libfud.hpp"
+    "include/fud_sqlite"
 )
 
 set_target_properties(fud PROPERTIES PUBLIC_HEADER "${FUD_HEADERS}")
diff --git a/include/fud_sqlite.hpp b/include/fud_sqlite.hpp
new file mode 100644
index 0000000..26e9de3
--- /dev/null
+++ b/include/fud_sqlite.hpp
@@ -0,0 +1,138 @@
+/*
+ * libfud
+ * Copyright 2024 Dominick Allen
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FUD_SQLITE_HPP
+#define FUD_SQLITE_HPP
+
+#include <fud_result.hpp>
+#include <fud_status.hpp>
+#include <fud_string.hpp>
+#include <sqlite3.h>
+
+namespace fud {
+
+class SqliteStatement;
+
+enum class SqliteOpenMode : int
+{
+    ReadOnly = SQLITE_OPEN_READONLY,
+    ReadWrite = SQLITE_OPEN_READWRITE,
+    ReadWriteCreate = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE
+};
+
+class SqliteDb {
+  public:
+    SqliteDb(const String& name, SqliteOpenMode mode, int extraFlags = 0);
+
+    SqliteDb(const char* name, SqliteOpenMode mode, int extraFlags = 0);
+
+    SqliteDb(const SqliteDb&) = delete;
+
+    SqliteDb(SqliteDb&& rhs);
+
+    ~SqliteDb();
+
+    SqliteDb& operator=(const SqliteDb&) = delete;
+
+    SqliteDb& operator=(SqliteDb&& rhs);
+
+    bool valid() const;
+
+    bool revalidate();
+
+    FudStatus exec(
+        const String& statement,
+        int (*callback)(void*, int, char**, char**),
+        void* context,
+        String* errorMessage);
+
+    constexpr int errorCode()
+    {
+        return m_errorCode;
+    }
+
+    constexpr sqlite3* handle() const
+    {
+        return m_dbHandle;
+    }
+
+    // private methods
+  private:
+    void initialize();
+
+    [[nodiscard]] int open();
+
+    Result<SqliteStatement, FudStatus> prepare(const String& sql);
+
+    // private data members
+  private:
+    String m_name{};
+
+    bool m_nameValid{false};
+
+    sqlite3* m_dbHandle{nullptr};
+
+    int m_errorCode{0};
+
+    SqliteOpenMode m_mode{};
+
+    int m_extraFlags{};
+};
+
+class SqliteStatement {
+  public:
+    SqliteStatement(const SqliteDb& sqliteDb, const String& input);
+
+    SqliteStatement(const SqliteStatement&) = delete;
+
+    SqliteStatement(SqliteStatement&& rhs);
+
+    ~SqliteStatement();
+
+    SqliteStatement& operator=(const SqliteStatement&) = delete;
+
+    SqliteStatement& operator=(SqliteStatement&& rhs);
+
+    bool valid() const;
+
+    sqlite3_stmt* statement();
+
+    int step();
+
+    FudStatus reset();
+
+    constexpr int errorCode()
+    {
+        return m_errorCode;
+    }
+
+    constexpr FudStatus status()
+    {
+        return m_status;
+    }
+
+  private:
+    String m_input{};
+    const char* m_tail{nullptr};
+    FudStatus m_status{FudStatus::ObjectInvalid};
+    int m_errorCode{0};
+    sqlite3_stmt* m_preparedStatement{nullptr};
+};
+
+} // namespace fud
+
+#endif
diff --git a/include/fud_status.hpp b/include/fud_status.hpp
index dd84429..6a9d653 100644
--- a/include/fud_status.hpp
+++ b/include/fud_status.hpp
@@ -25,6 +25,7 @@ enum class [[nodiscard]] FudStatus
     Success = 0,
     NullPointer,
     StringInvalid,
+    ObjectInvalid,
     OperationInvalid,
     AllocFailure,
     InvalidInput,
@@ -50,6 +51,8 @@ static inline const char* FudStatusToString(FudStatus status)
         return "NullPointer";
     case FudStatus::StringInvalid:
         return "StringInvalid";
+    case FudStatus::ObjectInvalid:
+        return "ObjectInvalid";
     case FudStatus::OperationInvalid:
         return "OperationInvalid";
     case FudStatus::AllocFailure:
diff --git a/source/fud_sqlite.cpp b/source/fud_sqlite.cpp
new file mode 100644
index 0000000..7ad8a12
--- /dev/null
+++ b/source/fud_sqlite.cpp
@@ -0,0 +1,220 @@
+/*
+ * libfud
+ * Copyright 2024 Dominick Allen
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "fud_sqlite.hpp"
+
+namespace fud {
+
+SqliteDb::SqliteDb(const String& name, SqliteOpenMode mode, int extraFlags) :
+    m_name{name}, m_mode{mode}, m_extraFlags{extraFlags}
+{
+    initialize();
+}
+
+SqliteDb::SqliteDb(const char* name, SqliteOpenMode mode, int extraFlags) :
+    m_name{name}, m_mode{mode}, m_extraFlags{extraFlags}
+{
+    initialize();
+}
+
+SqliteDb::SqliteDb(SqliteDb&& rhs) :
+    m_name{std::move(rhs.m_name)}, m_nameValid{rhs.m_nameValid}, m_dbHandle{rhs.m_dbHandle},
+    m_errorCode{rhs.m_errorCode}, m_mode{rhs.m_mode}, m_extraFlags{rhs.m_extraFlags}
+{
+    rhs.m_nameValid = false;
+    rhs.m_dbHandle = nullptr;
+}
+
+SqliteDb::~SqliteDb()
+{
+    if (m_dbHandle != nullptr) {
+        sqlite3_close(m_dbHandle);
+        m_dbHandle = nullptr;
+    }
+}
+
+SqliteDb& SqliteDb::operator=(SqliteDb&& rhs)
+{
+    m_name = std::move(rhs.m_name);
+    m_nameValid = rhs.m_nameValid;
+    m_dbHandle = rhs.m_dbHandle;
+    m_errorCode = rhs.m_errorCode;
+
+    rhs.m_nameValid = false;
+    rhs.m_dbHandle = nullptr;
+
+    return *this;
+}
+
+bool SqliteDb::valid() const
+{
+    return m_nameValid && m_dbHandle != nullptr && m_errorCode == SQLITE_OK;
+}
+
+bool SqliteDb::revalidate()
+{
+    if (m_nameValid && m_dbHandle != nullptr) {
+        m_errorCode = SQLITE_OK;
+        return true;
+    }
+    return false;
+}
+
+FudStatus SqliteDb::exec(
+    const String& statement,
+    int (*callback)(void*, int, char**, char**),
+    void* context,
+    String* errorMessage)
+{
+    if (!valid()) {
+        return FudStatus::ObjectInvalid;
+    }
+
+    if (!statement.utf8Valid()) {
+        return FudStatus::Utf8Invalid;
+    }
+
+    char* errorMsgPtr = nullptr;
+    char** errorMsgPtrAddress = &errorMsgPtr;
+    if (errorMessage == nullptr) {
+        errorMsgPtrAddress = nullptr;
+    }
+
+    m_errorCode = sqlite3_exec(
+        m_dbHandle,
+        statement.c_str(),
+        callback,
+        context,
+        errorMsgPtrAddress);
+
+    return m_errorCode == SQLITE_OK ? FudStatus::Success : FudStatus::Failure;
+}
+
+void SqliteDb::initialize()
+{
+    m_nameValid = m_name.utf8Valid();
+
+    if (!m_nameValid) {
+        return;
+    }
+
+    m_errorCode = open();
+}
+
+int SqliteDb::open()
+{
+    // use default vfs
+    return sqlite3_open_v2(m_name.c_str(), &m_dbHandle, static_cast<int>(m_mode) | m_extraFlags, nullptr);
+}
+
+Result<SqliteStatement, FudStatus> SqliteDb::prepare(const String& dql)
+{
+    using RetType = Result<SqliteStatement, FudStatus>;
+    SqliteStatement preparedStatement{*this, dql};
+
+    if (!preparedStatement.valid() || preparedStatement.status() != FudStatus::Success) {
+        m_errorCode = preparedStatement.errorCode();
+        return RetType::error(preparedStatement.status());
+    }
+
+    return RetType::okay(std::move(preparedStatement));
+}
+
+SqliteStatement::SqliteStatement(const SqliteDb& sqliteDb, const String& input)
+{
+    if (!sqliteDb.valid()) {
+        m_status = FudStatus::ObjectInvalid;
+        return;
+    }
+
+    if (!input.utf8Valid() || input.length() > INT_MAX) {
+        m_status = FudStatus::InvalidInput;
+        return;
+    }
+
+    int statementLength = static_cast<int>(input.length());
+    m_errorCode = sqlite3_prepare_v2(sqliteDb.handle(), input.c_str(), statementLength, &m_preparedStatement, &m_tail);
+    if (m_errorCode == SQLITE_OK) {
+        m_status = FudStatus::Success;
+    }
+}
+
+SqliteStatement::SqliteStatement(SqliteStatement&& rhs) :
+    m_input{std::move(rhs.m_input)}, m_tail{rhs.m_tail}, m_status{rhs.m_status}, m_errorCode{rhs.m_errorCode},
+    m_preparedStatement{rhs.m_preparedStatement}
+{
+    rhs.m_tail = nullptr;
+    rhs.m_status = FudStatus::ObjectInvalid;
+    rhs.m_preparedStatement = nullptr;
+}
+
+SqliteStatement& SqliteStatement::operator=(SqliteStatement&& rhs)
+{
+    m_input = std::move(rhs.m_input);
+    m_tail = rhs.m_tail;
+    m_status = rhs.m_status;
+    m_errorCode = rhs.m_errorCode;
+    m_preparedStatement = rhs.m_preparedStatement;
+
+    rhs.m_tail = nullptr;
+    rhs.m_status = FudStatus::ObjectInvalid;
+    rhs.m_preparedStatement = nullptr;
+
+    return *this;
+}
+
+SqliteStatement::~SqliteStatement()
+{
+    if (m_preparedStatement != nullptr) {
+        sqlite3_finalize(m_preparedStatement);
+        m_preparedStatement = nullptr;
+    }
+}
+
+bool SqliteStatement::valid() const
+{
+    return m_status == FudStatus::Success && m_preparedStatement != nullptr;
+}
+
+sqlite3_stmt* SqliteStatement::statement()
+{
+    return m_preparedStatement;
+}
+
+int SqliteStatement::step()
+{
+    if (!valid()) {
+        m_errorCode = SQLITE_MISUSE;
+    } else {
+        m_errorCode = sqlite3_step(m_preparedStatement);
+    }
+    return m_errorCode;
+}
+
+FudStatus SqliteStatement::reset()
+{
+    if (!valid()) {
+        return FudStatus::ObjectInvalid;
+    }
+    m_errorCode = sqlite3_reset(m_preparedStatement);
+    if (m_errorCode != SQLITE_OK) {
+        return FudStatus::Failure;
+    }
+    return FudStatus::Success;
+}
+
+} // namespace fud
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index dc48e1f..73968fe 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -53,6 +53,7 @@ endfunction()
 
 fud_add_test(test_result SOURCES test_result.cpp)
 fud_add_test(test_string SOURCES test_string.cpp)
+fud_add_test(test_sqlite SOURCES test_sqlite.cpp)
 # fud_add_test(test_deserialize_number SOURCES test_deserialize_number.cpp)
 # fud_add_test(test_ext_algorithm SOURCES test_algorithm.cpp)
 # fud_add_test(test_ext_array SOURCES
diff --git a/test/test_sqlite.cpp b/test/test_sqlite.cpp
new file mode 100644
index 0000000..8349324
--- /dev/null
+++ b/test/test_sqlite.cpp
@@ -0,0 +1,49 @@
+/*
+ * libfud
+ * Copyright 2024 Dominick Allen
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "fud_sqlite.hpp"
+#include "fud_string.hpp"
+#include "test_common.hpp"
+
+#include "gtest/gtest.h"
+#include <cerrno>
+#include <fcntl.h>
+
+namespace fud {
+
+TEST(FudSqlite, Basic)
+{
+    const String testName{"test.db.sqlite"};
+    auto result = unlink(testName.c_str());
+    if (result != 0) {
+        ASSERT_EQ(errno, ENOENT);
+    }
+
+    SqliteDb sqliteDb{testName, SqliteOpenMode::ReadOnly};
+    ASSERT_FALSE(sqliteDb.valid());
+    ASSERT_NE(sqliteDb.errorCode(), SQLITE_OK);
+
+    sqliteDb = SqliteDb{testName, SqliteOpenMode::ReadWrite};
+    ASSERT_FALSE(sqliteDb.valid());
+    ASSERT_NE(sqliteDb.errorCode(), SQLITE_OK);
+
+    sqliteDb = SqliteDb{testName, SqliteOpenMode::ReadWriteCreate};
+    ASSERT_TRUE(sqliteDb.valid());
+    ASSERT_EQ(sqliteDb.errorCode(), SQLITE_OK);
+}
+
+} // namespace fud