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 "zserio/RebindAlloc.h"
#include "zserio/SqliteConnection.h"
#include "zserio/SqliteFinalizer.h"
#include "zserio/String.h"
#include "zserio/StringView.h"
 
namespace zserio
{
 
template <typename ALLOC>
struct ValidationSqliteUtil
{
    using string_type = string<ALLOC>;
    using Statement = std::unique_ptr<sqlite3_stmt, SqliteFinalizer>;
 
    struct ColumnDescription
    {
        string_type name; 
        string_type type; 
        bool isNotNull; 
        bool isPrimaryKey; 
    };
 
    using TableSchema = std::map<string_type, ColumnDescription, std::less<string_type>,
            RebindAlloc<ALLOC, std::pair<const string_type, ColumnDescription>>>;
 
    static size_t getNumberOfTableRows(SqliteConnection& connection, StringView attachedDbName,
            StringView tableName, const ALLOC& allocator)
    {
        string_type 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, StringView attachedDbName, StringView tableName,
            TableSchema& tableSchema, const ALLOC& allocator)
    {
        string_type 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 unsigned char* columnNameText = sqlite3_column_text(statement.get(), 1);
            const char* columnName = static_cast<const char*>(static_cast<const void*>(columnNameText));
            const unsigned char* columnTypeText = sqlite3_column_text(statement.get(), 2);
            const char* columnType = static_cast<const char*>(static_cast<const void*>(columnTypeText));
            tableSchema.emplace(string_type(columnName, allocator),
                    ColumnDescription{
                            string_type(columnName, allocator), string_type(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, StringView attachedDbName, StringView tableName,
            StringView columnName, const ALLOC& allocator)
    {
        // try select to check if hidden column exists
        string_type 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