sqlitestatement.h

Go to the documentation of this file.

 
#ifndef SQLITESTATEMENT_H
#define SQLITESTATEMENT_H
 
#include "sqlite.h"
#include "sqlitestepresult.h"
 
namespace Nickvision::Database
{
    class SqliteStatement
    {
    public:
        SqliteStatement(sqlite3* database, const std::string& command);
        SqliteStatement(const SqliteStatement&) = delete;
        SqliteStatement(SqliteStatement&& other) noexcept;
        ~SqliteStatement() noexcept;
        SqliteStepResult step() noexcept;
        template<SupportedSqliteValue T>
        bool bind(int index, T value) noexcept
        {
            if(!m_statement)
            {
                return false;
            }
            if constexpr (std::is_same_v<T, int>)
            {
                return sqlite3_bind_int(m_statement, index, value) == SQLITE_OK;
            }
            else if constexpr (std::is_same_v<T, std::int64_t>)
            {
                return sqlite3_bind_int64(m_statement, index, value) == SQLITE_OK;
            }
            else if constexpr (std::is_same_v<T, double>)
            {
                return sqlite3_bind_double(m_statement, index, value) == SQLITE_OK;
            }
            else if constexpr (std::is_same_v<T, bool>)
            {
                return sqlite3_bind_int(m_statement, index, value ? 1 : 0) == SQLITE_OK;
            }
            else if constexpr (std::is_same_v<T, std::string>)
            {
                return sqlite3_bind_text(m_statement, index, value.c_str(), -1, SQLITE_TRANSIENT) == SQLITE_OK;
            }
        }

        template<SupportedSqliteValue T>
        T getColumn(int index) noexcept
        {
            if constexpr (std::is_same_v<T, int>)
            {
                if(!m_statement)
                {
                    return 0;
                }
                return sqlite3_column_int(m_statement, index);
            }
            else if constexpr (std::is_same_v<T, std::int64_t>)
            {
                if(!m_statement)
                {
                    return 0;
                }
                return sqlite3_column_int64(m_statement, index);
            }
            else if constexpr (std::is_same_v<T, double>)
            {
                if(!m_statement)
                {
                    return 0.0;
                }
                return sqlite3_column_double(m_statement, index);
            }
            else if constexpr (std::is_same_v<T, bool>)
            {
                if(!m_statement)
                {
                    return false;
                }
                return static_cast<bool>(sqlite3_column_int(m_statement, index));
            }
            else if constexpr (std::is_same_v<T, std::string>)
            {
                if(!m_statement)
                {
                    return "";
                }
                return { reinterpret_cast<const char*>(sqlite3_column_text(m_statement, index)), static_cast<size_t>(sqlite3_column_bytes(m_statement, index)) };
            }
        }
        SqliteStatement& operator=(const SqliteStatement&) = delete;
        SqliteStatement& operator=(SqliteStatement&& other) noexcept;
        operator bool() const noexcept;
 
    private:
        sqlite3_stmt* m_statement;
    };
}
 
#endif //SQLITESTATEMENT_H