ValidationSqliteUtil.h

Go to the documentation of this file.

#ifndef ZSERIO_VALIDATION_SQLITE_UTIL_H_INC
#define ZSERIO_VALIDATION_SQLITE_UTIL_H_INC
 
#include <map>
#include <string_view>
 
#include "zserio/RebindAlloc.h"
#include "zserio/SqliteConnection.h"
#include "zserio/SqliteFinalizer.h"
#include "zserio/String.h"
 
namespace zserio
{
 
template <typename ALLOC>
struct ValidationSqliteUtil
{
    using StringType = BasicString<RebindAlloc<ALLOC, char>>;
    using Statement = std::unique_ptr<sqlite3_stmt, SqliteFinalizer>;
 
    struct ColumnDescription
    {
        StringType name; 
        StringType type; 
        bool isNotNull; 
        bool isPrimaryKey; 
    };
 
    using TableSchema = std::map<StringType, ColumnDescription, std::less<StringType>,
            RebindAlloc<ALLOC, std::pair<const StringType, ColumnDescription>>>;
 
    static size_t getNumberOfTableRows(SqliteConnection& connection, std::string_view attachedDbName,
            std::string_view tableName, const ALLOC& allocator)
    {
        StringType sqlQuery(allocator);
        sqlQuery += "SELECT count(*) FROM ";
        if (!attachedDbName.empty())
        {
            sqlQuery += attachedDbName;
            sqlQuery += ".";
        }
        sqlQuery += tableName;
 
        Statement statement(connection.prepareStatement(sqlQuery));
        const int result = sqlite3_step(statement.get());
        if (result != SQLITE_ROW)
        {
            throw SqliteException("ValidationSqliteUtils.getNumberOfTableRows: sqlite3_step() failed: ")
                    << SqliteErrorCode(result);
        }
 
        return static_cast<size_t>(sqlite3_column_int64(statement.get(), 0));
    }
 
    static void getTableSchema(SqliteConnection& connection, std::string_view attachedDbName,
            std::string_view tableName, TableSchema& tableSchema, const ALLOC& allocator)
    {
        StringType sqlQuery(allocator);
        sqlQuery += "PRAGMA ";
        if (!attachedDbName.empty())
        {
            sqlQuery += attachedDbName;
            sqlQuery += ".";
        }
        sqlQuery += "table_info(";
        sqlQuery += tableName;
        sqlQuery += ")";
 
        Statement statement(connection.prepareStatement(sqlQuery));
 
        int result = SQLITE_OK;
        while ((result = sqlite3_step(statement.get())) == SQLITE_ROW)
        {
            const char* columnName = reinterpret_cast<const char*>(sqlite3_column_text(statement.get(), 1));
            const char* columnType = reinterpret_cast<const char*>(sqlite3_column_text(statement.get(), 2));
            tableSchema.emplace(StringType(columnName, allocator),
                    ColumnDescription{
                            StringType(columnName, allocator), StringType(columnType, allocator),
                            sqlite3_column_int(statement.get(), 3) != 0, // is not null
                            sqlite3_column_int(statement.get(), 5) != 0 // is primary key
                    });
        }
 
        if (result != SQLITE_DONE)
        {
            throw SqliteException("ValidationSqliteUtils.getTableSchema: sqlite3_step() failed: ")
                    << SqliteErrorCode(result);
        }
    }
 
    static bool isColumnInTable(SqliteConnection& connection, std::string_view attachedDbName,
            std::string_view tableName, std::string_view columnName, const ALLOC& allocator)
    {
        // try select to check if hidden column exists
        StringType sqlQuery(allocator);
        sqlQuery += "SELECT ";
        sqlQuery += columnName;
        sqlQuery += " FROM ";
        if (!attachedDbName.empty())
        {
            sqlQuery += attachedDbName;
            sqlQuery += ".";
        }
        sqlQuery += tableName;
        sqlQuery += " LIMIT 0";
 
        try
        {
            Statement statement(connection.prepareStatement(sqlQuery));
            return sqlite3_step(statement.get()) == SQLITE_DONE;
        }
        catch (const SqliteException&)
        {
            return false;
        }
    }
 
    static const char* sqliteColumnTypeName(int columnType)
    {
        switch (columnType)
        {
        case SQLITE_INTEGER:
            return "INTEGER";
        case SQLITE_FLOAT:
            return "REAL";
        case SQLITE_TEXT:
            return "TEXT";
        case SQLITE_BLOB:
            return "BLOB";
        default:
            return "NULL";
        }
    }
};
 
} // namespace zserio
 
#endif // ZSERIO_VALIDATION_SQLITE_UTIL_H_INC