alex/cpp-opds
1
0
Fork 0
Code Issues Pull Requests 2 Actions Projects Wiki Activity

Попытка раскидать по библиотекам

Browse Source
This commit is contained in:
Алексейка
2025-03-16 10:46:06 +05:00
parent d47988adda
commit 394c55ae5c
15 changed files with 129 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
src/database/author_s.h Normal file
View File

@@ -0,0 +1,65 @@
// file : hello/person.hxx
// copyright : not copyrighted - public domain
#ifndef AUTHOR_S_H
#define AUTHOR_S_H
// #include <QtCore/QObject>
#include <cstddef> // std::size_t
#include <memory>
#include <string>
#include <odb/core.hxx>
#include <odb/database.hxx>
#include <odb/query.hxx>
#pragma db object
class __attribute__((visibility("default"))) Author_S
{
public:
Author_S() = default;
Author_S(const std::string& first,
const std::string& last,
const unsigned short age) :
m_first(first),
m_last(last),
m_age(age)
{
}
unsigned long long id() const { return m_id; }
std::string first() const { return m_first; }
std::string last() const { return m_last; }
unsigned short age() const { return m_age; }
std::string full_name() const { return m_first + " " + m_last; }
void age(unsigned short age) { m_age = age; }
private:
friend class odb::access;
#pragma db id auto
unsigned long long m_id;
std::string m_first;
std::string m_last;
unsigned short m_age;
};
#pragma db view object(Author_S)
struct person_stat
{
#pragma db column("count(" + Author_S::m_id + ")")
std::size_t count;
#pragma db column("min(" + Author_S::m_age + ")")
unsigned short min_age;
#pragma db column("max(" + Author_S::m_age + ")")
unsigned short max_age;
};
#endif // AUTHOR_S_H

48
src/database/book_s.h Normal file
View File

@@ -0,0 +1,48 @@
// file : hello/person.hxx
// copyright : not copyrighted - public domain
#ifndef BOOK_S_H
#define BOOK_S_H
// #include <QtCore/QObject>
#include <memory>
#include <string>
#include <odb/core.hxx>
#include "author_s.h"
#pragma db object
class __attribute__((visibility("default"))) Book_S
{
public:
Book_S() = default;
Book_S(const std::string& name,
const std::shared_ptr<Author_S>& author,
const int year)
{
m_author = author;
m_name = name;
m_year = year;
};
unsigned long long id() const { return m_id; }
std::shared_ptr<Author_S> author() const { return m_author; }
std::string name() const { return m_name; }
int year() const { return m_year; }
private:
friend class odb::access;
private:
#pragma db id auto
unsigned long long m_id;
std::shared_ptr<Author_S> m_author;
std::string m_name;
int m_year;
};
#endif // BOOK_S_H

177
src/database/database.hxx Normal file
View File

@@ -0,0 +1,177 @@
// file : hello/database.hxx
// copyright : not copyrighted - public domain
//
// Create concrete database instance based on the DATABASE_* macros.
//
#ifndef DATABASE_HXX
#define DATABASE_HXX
#include <cstdlib> // std::exit
#include <iostream>
#include <memory> // std::unique_ptr
#include <string>
#include <odb/database.hxx>
#if defined(DATABASE_MYSQL)
#include <odb/mysql/database.hxx>
#elif defined(DATABASE_SQLITE)
#include <odb/connection.hxx>
#include <odb/schema-catalog.hxx>
#include <odb/sqlite/database.hxx>
#include <odb/transaction.hxx>
#elif defined(DATABASE_PGSQL)
#include <odb/pgsql/database.hxx>
#elif defined(DATABASE_ORACLE)
#include <odb/oracle/database.hxx>
#elif defined(DATABASE_MSSQL)
#include <odb/mssql/database.hxx>
#else
#error unknown database; did you forget to define the DATABASE_* macros?
#endif
#include <filesystem>
#include <random>
struct testData
{
std::string first;
std::string last;
int age;
};
// Функция для генерации случайной строки (имени или фамилии)
std::string generate_random_string(const std::vector<std::string>& pool)
{
static std::random_device rd;
static std::mt19937 gen(rd());
std::uniform_int_distribution<> dis(0, pool.size() - 1);
return pool[dis(gen)];
}
// Функция для генерации случайного года
int generate_random_year(int min_year = 1900, int max_year = 2020)
{
static std::random_device rd;
static std::mt19937 gen(rd());
std::uniform_int_distribution<> dis(min_year, max_year);
return dis(gen);
}
std::vector<testData> fillDB()
{
std::vector<std::string> first_names = {
"John", "Jane", "Alex", "Chris", "Robert", "Emily", "James", "Linda", "David", "Sarah",
"Michael", "Elizabeth", "Daniel", "Samantha", "William", "Olivia", "Ethan", "Sophia", "Joshua", "Charlotte",
"Daniel", "Grace", "Benjamin", "Isabella", "Matthew", "Victoria", "Henry", "Abigail", "Samuel", "Megan",
"Lucas", "Lily", "Andrew", "Madison", "Jackson", "Chloe", "Aiden", "Amelia", "Thomas", "Natalie",
"Ryan", "Zoe", "Jack", "Harper", "Elijah", "Ava", "Isaac", "Mia", "Caleb", "Ella"
};
std::vector<std::string> last_names = {
"Doe", "Smith", "Johnson", "Williams", "Jones", "Brown", "Davis", "Miller", "Wilson", "Moore",
"Taylor", "Anderson", "Thomas", "Jackson", "White", "Harris", "Martin", "Thompson", "Garcia", "Martinez",
"Roberts", "Clark", "Lewis", "Walker", "Young", "Allen", "King", "Wright", "Scott", "Adams",
"Baker", "Gonzalez", "Nelson", "Carter", "Mitchell", "Perez", "Robinson", "Hughes", "Flores", "Cook",
"Rogers", "Gutierrez", "Ramirez", "Diaz", "Perez", "Ross", "Sanders", "Price", "Howard", "Cooper"
};
std::vector<testData> vecTest;
for (int i = 0; i < 50; ++i)
{
std::string first_name = generate_random_string(first_names);
std::string last_name = generate_random_string(last_names);
int birth_year = generate_random_year(1900, 2000);
vecTest.push_back({ first_name, last_name, birth_year });
}
return vecTest;
}
inline std::unique_ptr<odb::database> openDB(std::string path_db)
{
// Открыть БД, если она существует
if (std::filesystem::is_regular_file(path_db))
return std::unique_ptr<odb::core::database>(new odb::sqlite::database(path_db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE));
// И создать новую, если не существует
std::unique_ptr<odb::core::database> db(new odb::sqlite::database(path_db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE));
odb::core::connection_ptr connect_ptr(db->connection());
connect_ptr->execute("PRAGMA foreign_keys=OFF");
odb::core::transaction tans(db->begin());
odb::core::schema_catalog::create_schema(*db);
tans.commit();
connect_ptr->execute("PRAGMA foreign_keys=ON");
return db;
}
inline std::unique_ptr<odb::database> create_database(int& argc, char* argv[])
{
using namespace std;
using namespace odb::core;
if (argc > 1 && argv[1] == string("--help"))
{
cout << "Usage: " << argv[0] << " [options]" << endl
<< "Options:" << endl;
#if defined(DATABASE_MYSQL)
odb::mysql::database::print_usage(cout);
#elif defined(DATABASE_SQLITE)
odb::sqlite::database::print_usage(cout);
#elif defined(DATABASE_PGSQL)
odb::pgsql::database::print_usage(cout);
#elif defined(DATABASE_ORACLE)
odb::oracle::database::print_usage(cout);
#elif defined(DATABASE_MSSQL)
odb::mssql::database::print_usage(cout);
#endif
exit(0);
}
#if defined(DATABASE_MYSQL)
unique_ptr<database> db(new odb::mysql::database(argc, argv));
#elif defined(DATABASE_SQLITE)
unique_ptr<database> db(new odb::sqlite::database(argc,
argv,
false,
SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE));
// Create the database schema. Due to bugs in SQLite foreign key
// support for DDL statements, we need to temporarily disable
// foreign keys.
//
{
connection_ptr connect_ptr(db->connection());
connect_ptr->execute("PRAGMA foreign_keys=OFF");
transaction tans(connect_ptr->begin());
schema_catalog::create_schema(*db);
tans.commit();
connect_ptr->execute("PRAGMA foreign_keys=ON");
}
#elif defined(DATABASE_PGSQL)
unique_ptr<database> db(new odb::pgsql::database(argc, argv));
#elif defined(DATABASE_ORACLE)
unique_ptr<database> db(new odb::oracle::database(argc, argv));
#elif defined(DATABASE_MSSQL)
unique_ptr<database> db(
new odb::mssql::database(argc, argv, false, "TrustServerCertificate=yes"));
#endif
return db;
}
#endif // DATABASE_HXX

52
src/database/database.qbs Normal file
View File

@@ -0,0 +1,52 @@
/*!
\qmltype cpp-opds
\inherits Project
\brief Описание
*/
PSLibrary {
cpp.defines: [
// You can make your code fail to compile if it uses deprecated APIs.
// In order to do so, uncomment the following line.
//"QT_DISABLE_DEPRECATED_BEFORE=0x060000" // disables all the APIs deprecated before Qt 6.0.0
"DATABASE_SQLITE"
]
consoleApplication: true
Depends { name: "Qt"; submodules: [ "core", "sql", "network" ] }
Depends { name: "cpp" }
Depends { name: "odbModule"}
cpp.cxxLanguageVersion: "c++20"
Group {
name: "cpp"
files: [
"books.*",
"databasemanager.*",
]
}
Group {
name: "odb"
files: [
"author_s.h",
"book_s.h",
]
fileTags: ["odb"]
}
cpp.includePaths: [
"/usr/include", // Общие заголовки
"/usr/include/odb" // Заголовки ODB
]
// Подключаем библиотеки ODB
cpp.libraryPaths: [
"/usr/lib" // Путь к библиотекам
]
cpp.dynamicLibraries: [
"odb",
"odb-sqlite"
]
}

118
src/database/databasemanager.cpp Normal file
View File

@@ -0,0 +1,118 @@
#include "databasemanager.h"
// Singleton instance
DatabaseManager& DatabaseManager::instance()
{
static DatabaseManager instance;
return instance;
}
// Конструктор: создаем подключение
DatabaseManager::DatabaseManager()
{
db = QSqlDatabase::addDatabase("QSQLITE");
db.setDatabaseName("mydatabase.db");
if (!db.open())
{
qDebug() << "Ошибка открытия БД:" << db.lastError().text();
}
else
{
qDebug() << "База данных успешно открыта";
}
}
// Деструктор: закрываем подключение
DatabaseManager::~DatabaseManager()
{
if (db.isOpen())
{
db.close();
}
}
// Возвращает ссылку на объект БД
QSqlDatabase& DatabaseManager::database()
{
return db;
}
// Выполняет SQL-запрос (без параметров)
bool DatabaseManager::executeQuery(const QString& query)
{
QSqlQuery q;
if (!q.exec(query))
{
qDebug() << "Ошибка выполнения запроса:" << q.lastError().text();
return false;
}
return true;
}
// Выполняет подготовленный SQL-запрос с параметрами
bool DatabaseManager::executePreparedQuery(const QString& query, const QStringList& values)
{
QSqlQuery q;
q.prepare(query);
for (const auto& value : values)
q.addBindValue(value);
if (!q.exec())
{
qDebug() << "Ошибка выполнения подготовленного запроса:" << q.lastError().text();
return false;
}
return true;
}
QList<QVariantList> DatabaseManager::executeSelectQuery(const QString& query, const QStringList& values)
{
QSqlQuery q;
q.prepare(query);
for (const auto& value : values)
q.addBindValue(value);
if (!q.exec())
{
qDebug() << "Ошибка выполнения SELECT запроса:" << q.lastError().text();
return {};
}
QList<QVariantList> results;
while (q.next())
{
QVariantList row;
for (int i = 0; i < q.record().count(); ++i)
row.append(q.value(i));
results.append(row);
}
return results;
}
QList<QVariantList> DatabaseManager::executeSelect(const SelectBuilder& selectBuilder)
{
const auto queryString = selectBuilder.getSelect();
qDebug() << "Подготовленный запрос: " << queryString;
QSqlQuery q;
if (!q.prepare(queryString))
qDebug() << "Ошибка при подготовке запроса:" << q.lastError().text();
if (!q.exec())
qDebug() << "Ошибка при выполнении запроса:" << q.lastError().text();
QList<QVariantList> results;
while (q.next()) // Проходимся по строкам
{
QVariantList row;
for (int i = 0; i < q.record().count(); ++i) // Проходимся по столбцам
row.append(q.value(i));
results.append(row);
}
return results;
}

59
src/database/databasemanager.h Normal file
View File

@@ -0,0 +1,59 @@
#ifndef DATABASEMANAGER_H
#define DATABASEMANAGER_H
#include <QDebug>
#include <QtSql>
struct SelectBuilder
{
QString tableName;
QStringList rows = { "*" };
QString where;
QString getSelect() const
{
QString allRows;
auto ri = rows.begin();
while (ri != rows.end())
{
allRows += (*ri++);
if (ri != rows.end())
allRows += ", ";
}
QString queryString = QString("SELECT %1").arg(allRows);
queryString += QString(" FROM %1").arg(tableName);
if (!where.isEmpty())
queryString += QString(" WHERE %1").arg(where);
queryString += ';';
return queryString;
}
};
class Q_DECL_EXPORT DatabaseManager
{
public:
static DatabaseManager& instance(); // Singleton
QSqlDatabase& database();
bool executeQuery(const QString& query);
bool executePreparedQuery(const QString& query, const QStringList& values);
QList<QVariantList> executeSelectQuery(const QString& query, const QStringList& values = {});
QList<QVariantList> executeSelect(const SelectBuilder& selectBuilder);
private:
DatabaseManager();
~DatabaseManager();
QSqlDatabase db;
};
#endif // DATABASEMANAGER_H