YTMPV/lib/Database/database.cpp

#include "database.hpp"
#include <iostream>

namespace db {
    // Объект работы с БД
    static sqlite3* DB;
    
    void databaseInit(std::string filename) {
        db_path = filename;
    }

    int databaseOpen() {
        return sqlite3_open(db_path.c_str(), &DB);
    }

    void databaseClose() {
        sqlite3_close(DB);
    }

    // Для каждого запроса на создание таблиц из массива quieries мы вызываем
    // sqlite3_exec. Если запрос провалится, выводим сообщение об ошибке 
    void createTables() {
        char* message_error;
        int status;
        std::array<std::string, 3> queries = {
            "CREATE TABLE IF NOT EXISTS \"author\" (\
                \"id\"	INTEGER,\
                \"ytid\"	TEXT,\
                \"name\"	TEXT,\
                PRIMARY KEY(\"id\" AUTOINCREMENT)\
            )",

            "CREATE TABLE IF NOT EXISTS \"video\" (\
                \"id\"	INTEGER,\
                \"ytid\"	TEXT,\
                \"title\"	TEXT NOT NULL,\
                \"description\"	TEXT NOT NULL,\
                \"author_id\"	INTEGER NOT NULL,\
                \"published_at\"	DATETIME NOT NULL,\
                \"dur_h\"	INTEGER NOT NULL DEFAULT 0,\
                \"dur_m\"	INTEGER NOT NULL DEFAULT 0,\
                \"dur_s\"	INTEGER NOT NULL DEFAULT 0,\
                \"views_count\"	INTEGER NOT NULL DEFAULT 0,\
                \"likes_count\"	INTEGER NOT NULL DEFAULT 0,\
                \"rate_status\"	INTEGER NOT NULL DEFAULT 0,\
                \"big_thumbnail\"	TEXT NOT NULL,\
                PRIMARY KEY(\"id\" AUTOINCREMENT)\
            )",

            "PRAGMA journal_mode=WAL"
        };

        databaseOpen();
        for (int i = 0; i < 3; i++) {
            status = sqlite3_exec(DB, queries[i].c_str(), NULL, 0, &message_error);

            if (status != SQLITE_OK) {
                std::cerr << "Error creating tables: " << status << std::endl; 
                sqlite3_free(message_error);
                databaseClose();
                return;
            }
        }
        databaseClose();
    }

    bool getVideoByYTID(std::string ytid, video* output) {
        sqlite3_stmt* stmt;
        std::string query =
        "SELECT v.id, v.ytid, v.title, v.description, a.id, a.ytid, a.name,"
        " v.published_at, v.views_count, v.rate_status, v.big_thumbnail"
        " FROM video v LEFT JOIN author a ON v.author_id=a.id"
        " WHERE v.ytid=?";
        databaseOpen();
        author video_author;

        // Подготовка
        sqlite3_prepare_v2(DB, query.c_str(), query.length(), &stmt, nullptr);

        // Привязка данных
        sqlite3_bind_text(stmt, 1, ytid.c_str(), ytid.length(), SQLITE_STATIC);

        // Выполнение
        int result = sqlite3_step(stmt);
        if (result == SQLITE_DONE) {
            // Видео не найдено
            databaseClose();
            return false;
        }

        // Заполнение данными
        // unsigned const char* конвертируется в std::string
        // https://stackoverflow.com/a/804131
        video_author.id = sqlite3_column_int(stmt, 4);
        video_author.ytid = std::string(reinterpret_cast<const char*>(
            sqlite3_column_text(stmt, 5)
        ));
        video_author.name = Glib::ustring(reinterpret_cast<const char*>(
            sqlite3_column_text(stmt, 6)
        ));

        output->id = sqlite3_column_int(stmt, 0);
        output->ytid = std::string(reinterpret_cast<const char*>(
            sqlite3_column_text(stmt, 1)
        ));
        output->title = Glib::ustring(reinterpret_cast<const char*>(
            sqlite3_column_text(stmt, 2)
        ));
        output->description = Glib::ustring(reinterpret_cast<const char*>(
            sqlite3_column_text(stmt, 3)
        ));
        output->published_at = std::string(reinterpret_cast<const char*>(
            sqlite3_column_text(stmt, 7)
        ));
        output->views_count = sqlite3_column_int(stmt, 8);
        output->rate_status = sqlite3_column_int(stmt, 9);
        output->big_thumbnail = std::string(reinterpret_cast<const char*>(
            sqlite3_column_text(stmt, 10)
        ));
        output->author_obj = video_author;

        // Завершение
        sqlite3_finalize(stmt);
        databaseClose();
        return true;
    }

    bool getAuthorByYTID(std::string ytid, author* output) {
        sqlite3_stmt* stmt;
        std::string query =
        "SELECT a.id, a.name"
        " FROM author a"
        " WHERE a.ytid=?";
        databaseOpen();

        // Подготовка
        sqlite3_prepare_v2(DB, query.c_str(), query.length(), &stmt, nullptr);

        // Привязка данных
        sqlite3_bind_text(stmt, 1, ytid.c_str(), ytid.length(), SQLITE_STATIC);

        // Выполнение
        int result = sqlite3_step(stmt);
        if (result == SQLITE_DONE) {
            // Автор не найден
            databaseClose();
            return false;
        }

        // Заполнение данными
        output->id = sqlite3_column_int(stmt, 0);
        output->name = std::string(reinterpret_cast<const char*>(
            sqlite3_column_text(stmt, 1)
        ));

        // Завершение
        sqlite3_finalize(stmt);
        databaseClose();
        return true;
    }

    void addAuthor(author* a) {
        sqlite3_stmt* stmt;
        std::string query =
        "INSERT INTO author (ytid, name) VALUES(?, ?)";
        databaseOpen();

        sqlite3_prepare_v2(DB, query.c_str(), query.length(), &stmt, nullptr);
        sqlite3_bind_text(stmt, 1, a->ytid.c_str(), a->ytid.length(), SQLITE_STATIC);
        sqlite3_bind_text(stmt, 2, a->name.c_str(), a->name.bytes(), SQLITE_STATIC);
        sqlite3_step(stmt);

        a->id = sqlite3_last_insert_rowid(DB);

        sqlite3_finalize(stmt);
        databaseClose();
    }

    void addVideo(video* v)
    {
        sqlite3_stmt* stmt;
        std::string query =
        "INSERT INTO video (ytid, title, description, author_id, published_at,"
        " views_count, rate_status, big_thumbnail)"
        " VALUES(?, ?, ?, ?, ?, ?, ?, ?)";
        databaseOpen();

        sqlite3_prepare_v2(DB, query.c_str(), query.length(), &stmt, nullptr);
        sqlite3_bind_text(stmt, 1, v->ytid.c_str(), v->ytid.length(), SQLITE_STATIC);
        sqlite3_bind_text(stmt, 2, v->title.c_str(), v->title.bytes(), SQLITE_STATIC);
        sqlite3_bind_text(stmt, 3, v->description.c_str(), v->description.bytes(), SQLITE_STATIC);
        sqlite3_bind_int(stmt, 4, v->author_obj.id);
        sqlite3_bind_text(stmt, 5, v->published_at.c_str(), v->published_at.length(), SQLITE_STATIC);
        sqlite3_bind_int(stmt, 6, v->views_count);
        sqlite3_bind_int(stmt, 7, v->rate_status);
        sqlite3_bind_text(stmt, 8, v->big_thumbnail.c_str(), v->big_thumbnail.length(), SQLITE_STATIC);
        sqlite3_step(stmt);

        v->id = sqlite3_last_insert_rowid(DB);
        
        sqlite3_finalize(stmt);
        databaseClose();
    }

    void setVideoRating(std::string ytid, int rating)
    {
        sqlite3_stmt* stmt;
        std::string query =
        "UPDATE video SET rate_status=? WHERE ytid=?";
        databaseOpen();

        sqlite3_prepare_v2(DB, query.c_str(), query.length(), &stmt, nullptr);
        sqlite3_bind_int(stmt, 1, rating);
        sqlite3_bind_text(stmt, 2, ytid.c_str(), ytid.length(), SQLITE_STATIC);

        sqlite3_finalize(stmt);
        databaseClose();
    }

    int getVideoRating(std::string ytid)
    {
        sqlite3_stmt* stmt;
        std::string query =
        "SELECT v.rate_status"
        " FROM video v"
        " WHERE v.ytid=?";

        databaseOpen();
        sqlite3_prepare_v2(DB, query.c_str(), query.length(), &stmt, nullptr);
        sqlite3_bind_text(stmt, 1, ytid.c_str(), ytid.length(), SQLITE_STATIC);

        // Выполнение
        int output;
        int result = sqlite3_step(stmt);
        if (result == SQLITE_DONE) {
            // Видео не найдено
            output = 3;
        }
        output = sqlite3_column_int(stmt, 0);

        databaseClose();
        return output;
    }
}