Older/Server/Database/Database.cpp

367 lines
14 KiB
C++
Raw Normal View History

2024-01-03 22:44:36 +08:00
#include "Database.h"
#include "BoostLog.h"
#include <sqlite3.h>
#include <sstream>
bool Database::open(const std::string &path) {
bool ret = true;
int result = sqlite3_open(path.c_str(), &m_sqlite3);
if (result != SQLITE_OK) {
ret = false;
LOG(error) << "open database failed.";
}
initialize();
return ret;
}
static int selectTaskCallback(void *data, int argc, char **argv, char **columnName) {
auto tasks = reinterpret_cast<Tasks *>(data);
Task task;
for (int i = 0; i < argc; i++) {
if (argv[i] == nullptr) continue;
if (strcmp(columnName[i], "id") == 0) {
task.id = std::atol(argv[i]);
} else if (strcmp(columnName[i], "create_time") == 0) {
task.createTime = std::atol(argv[i]);
} else if (strcmp(columnName[i], "content") == 0) {
task.content = argv[i];
} else if (strcmp(columnName[i], "comment") == 0) {
task.comment = argv[i];
} else if (strcmp(columnName[i], "finished") == 0) {
task.finished = std::atol(argv[i]);
2024-01-04 23:32:07 +08:00
} else if (strcmp(columnName[i], "parent_id") == 0) {
task.parentId = std::atol(argv[i]);
2024-01-03 22:44:36 +08:00
}
}
tasks->push_back(task);
return 0;
}
Tasks Database::tasks() {
Tasks ret;
char *error = nullptr;
if (sqlite3_exec(m_sqlite3, "select * from tasks", selectTaskCallback, &ret, &error) != SQLITE_OK) {
LOG(error) << "sqlite3_exec() failed: " << error << std::endl;
sqlite3_free(error);
}
2024-01-04 23:32:07 +08:00
std::unordered_map<int, Task *> tasks;
for (auto iterator = ret.begin(); iterator != ret.end();) {
if (iterator->parentId >= 0) {
2024-02-17 23:21:19 +08:00
if (tasks.count(iterator->parentId) > 0) {
auto parentTask = tasks.at(iterator->parentId);
parentTask->children.push_back(*iterator);
tasks.insert({iterator->id, &parentTask->children.back()});
} else {
LOG(warning) << "task`s parent id " << iterator->parentId << " not existed.";
}
2024-01-04 23:32:07 +08:00
iterator = ret.erase(iterator);
} else {
tasks.insert({iterator->id, &(*iterator)});
++iterator;
}
}
2024-01-03 22:44:36 +08:00
return ret;
}
2024-01-04 23:32:07 +08:00
bool Database::addTask(uint64_t createTime, const std::string &content, const std::string &comment, int parentId,
bool finished) {
2024-01-03 22:44:36 +08:00
bool ret = true;
std::ostringstream oss;
2024-01-04 23:32:07 +08:00
oss << "INSERT INTO tasks (create_time,content,comment,parent_id,finished) VALUES (" << createTime << ",\""
<< content << "\",\"" << comment << "\"," << parentId << "," << finished << ");";
2024-01-03 22:44:36 +08:00
auto sql = oss.str();
char *error = nullptr;
int result = sqlite3_exec(m_sqlite3, sql.c_str(), NULL, NULL, &error);
if (result != SQLITE_OK) {
LOG(error) << "add task failed: " << error << ", sql: " << sql;
sqlite3_free(error);
ret = false;
}
return ret;
}
bool Database::removeTask(int id) {
bool ret = true;
std::ostringstream oss;
oss << "DELETE FROM tasks WHERE id = " << id << ";";
auto sql = oss.str();
char *error = nullptr;
int result = sqlite3_exec(m_sqlite3, sql.c_str(), NULL, NULL, &error);
if (result != SQLITE_OK) {
LOG(error) << "add task failed: " << error << ", sql: " << sql;
sqlite3_free(error);
ret = false;
}
return ret;
}
void Database::setTaskFinished(int id, bool finished, uint64_t finishedTime) {
std::ostringstream oss;
oss << "UPDATE tasks SET finished = " << finished << ", finished_time = " << finishedTime << " WHERE id = " << id;
auto sql = oss.str();
int result = sqlite3_exec(m_sqlite3, sql.c_str(), NULL, NULL, NULL);
if (result != SQLITE_OK) {
LOG(error) << "add task failed: " << sqlite3_errmsg(m_sqlite3) << ", sql: " << sql;
return;
}
}
2024-07-31 22:28:05 +08:00
void Database::updateVisitCount(const std::string &url, const std::string &visitorUuid, const std::string &userAgent,
int64_t time) {
sqlite3_stmt *stmt;
2024-08-05 23:01:19 +08:00
auto strippedUrl = url;
if (strippedUrl.size() > 1 && strippedUrl.back() == '/') {
strippedUrl.pop_back();
}
2024-07-31 22:28:05 +08:00
const char *query = "SELECT id, page_view_count FROM visit_analysis WHERE url = ? AND visitor_uuid = ?";
if (sqlite3_prepare_v2(m_sqlite3, query, -1, &stmt, 0) != SQLITE_OK) {
2024-07-29 00:46:11 +08:00
LOG(error) << "Failed to prepare statement: " << sqlite3_errmsg(m_sqlite3);
}
2024-08-05 23:01:19 +08:00
sqlite3_bind_text(stmt, 1, strippedUrl.c_str(), -1, SQLITE_STATIC);
2024-07-29 00:46:11 +08:00
sqlite3_bind_text(stmt, 2, visitorUuid.c_str(), -1, SQLITE_STATIC);
2024-07-31 22:28:05 +08:00
int id = -1;
int page_view_count = 0;
if (sqlite3_step(stmt) == SQLITE_ROW) {
id = sqlite3_column_int(stmt, 0);
page_view_count = sqlite3_column_int(stmt, 1);
}
sqlite3_finalize(stmt);
if (id != -1) { // 更新记录
const char *updateQuery =
"UPDATE visit_analysis SET last_user_agent = ?, last_view_time = ?, page_view_count = ? WHERE id = ?";
if (sqlite3_prepare_v2(m_sqlite3, updateQuery, -1, &stmt, 0) != SQLITE_OK) {
LOG(error) << "Failed to prepare update statement: " << sqlite3_errmsg(m_sqlite3);
2024-07-29 00:46:11 +08:00
}
2024-07-31 22:28:05 +08:00
sqlite3_bind_text(stmt, 1, userAgent.c_str(), -1, SQLITE_STATIC);
sqlite3_bind_int64(stmt, 2, time);
sqlite3_bind_int(stmt, 3, page_view_count + 1);
sqlite3_bind_int(stmt, 4, id);
2024-07-29 00:46:11 +08:00
if (sqlite3_step(stmt) != SQLITE_DONE) {
2024-07-31 22:28:05 +08:00
LOG(error) << "Failed to update record: " << sqlite3_errmsg(m_sqlite3);
2024-07-29 00:46:11 +08:00
}
2024-07-31 22:28:05 +08:00
sqlite3_finalize(stmt);
} else { // 插入新记录
const char *insertQuery = "INSERT INTO visit_analysis (url, visitor_uuid, last_user_agent, last_view_time, "
"page_view_count) VALUES (?, ?, ?, ?, 1)";
if (sqlite3_prepare_v2(m_sqlite3, insertQuery, -1, &stmt, 0) != SQLITE_OK) {
LOG(error) << "Failed to prepare insert statement: " << sqlite3_errmsg(m_sqlite3);
2024-07-29 00:46:11 +08:00
}
2024-08-05 23:01:19 +08:00
sqlite3_bind_text(stmt, 1, strippedUrl.c_str(), -1, SQLITE_STATIC);
2024-07-29 00:46:11 +08:00
sqlite3_bind_text(stmt, 2, visitorUuid.c_str(), -1, SQLITE_STATIC);
2024-07-31 22:28:05 +08:00
sqlite3_bind_text(stmt, 3, userAgent.c_str(), -1, SQLITE_STATIC);
sqlite3_bind_int64(stmt, 4, time);
if (sqlite3_step(stmt) != SQLITE_DONE) {
LOG(error) << "Failed to insert record: " << sqlite3_errmsg(m_sqlite3) << std::endl;
2024-07-29 00:46:11 +08:00
}
2024-07-31 22:28:05 +08:00
sqlite3_finalize(stmt);
2024-07-29 00:46:11 +08:00
}
}
2024-07-30 23:17:42 +08:00
void Database::clearVisitRecord() {
2024-07-29 22:41:57 +08:00
char *message = nullptr;
2024-07-30 23:17:42 +08:00
constexpr auto sql = "DELETE FROM visit_analysis";
2024-07-29 22:41:57 +08:00
int rc = sqlite3_exec(m_sqlite3, sql, nullptr, nullptr, &message);
if (rc != SQLITE_OK) {
LOG(error) << "SQL error: " << message;
sqlite3_free(message);
}
}
2024-07-30 23:17:42 +08:00
VisitAnalysis Database::siteVisitAnalysisData() {
VisitAnalysis ret;
2024-08-05 23:01:19 +08:00
sqlite3_stmt *stmt = nullptr;
2024-07-30 23:17:42 +08:00
const char *sql = "SELECT COUNT(DISTINCT visitor_uuid) as unique_visitors, SUM(page_view_count) as "
"total_page_views FROM visit_analysis";
if (sqlite3_prepare_v2(m_sqlite3, sql, -1, &stmt, nullptr) != SQLITE_OK) {
2024-07-29 22:41:57 +08:00
LOG(error) << "Failed to prepare statement: " << sqlite3_errmsg(m_sqlite3);
2024-07-30 23:17:42 +08:00
return ret;
2024-07-29 22:41:57 +08:00
}
2024-07-30 23:17:42 +08:00
if (sqlite3_step(stmt) == SQLITE_ROW) {
ret.uniqueVisitorCount = sqlite3_column_int(stmt, 0);
ret.pageViewCount = sqlite3_column_int(stmt, 1);
} else {
LOG(error) << "Failed to execute query: " << sqlite3_errmsg(m_sqlite3);
2024-07-29 22:41:57 +08:00
}
sqlite3_finalize(stmt);
2024-07-30 23:17:42 +08:00
return ret;
2024-07-29 22:41:57 +08:00
}
2024-08-06 09:48:25 +08:00
static std::vector<std::string> urlFilter = {
"/",
"/LoginPage",
"/我的笔记",
"/我的博客",
};
2024-08-05 23:01:19 +08:00
std::list<VisitAnalysis> Database::mostViewedUrls(int size) {
const char *sql = "SELECT url, SUM(page_view_count) AS total_page_view_count "
"FROM visit_analysis "
"GROUP BY url "
"ORDER BY total_page_view_count DESC "
"LIMIT ?";
sqlite3_stmt *stmt = nullptr;
std::list<VisitAnalysis> ret;
auto rc = sqlite3_prepare_v2(m_sqlite3, sql, -1, &stmt, nullptr);
if (rc != SQLITE_OK) {
LOG(error) << "Failed to prepare statement: " << sqlite3_errmsg(m_sqlite3);
return ret;
}
2024-08-06 09:48:25 +08:00
sqlite3_bind_int(stmt, 1, size + urlFilter.size());
2024-08-05 23:01:19 +08:00
while ((rc = sqlite3_step(stmt)) == SQLITE_ROW) {
VisitAnalysis pv;
pv.url = reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0));
2024-08-06 09:48:25 +08:00
if (std::find(urlFilter.cbegin(), urlFilter.cend(), pv.url) != urlFilter.cend()) continue;
2024-08-05 23:01:19 +08:00
pv.pageViewCount = sqlite3_column_int(stmt, 1);
2024-08-07 15:47:30 +08:00
if (ret.size() < size) {
ret.push_back(pv);
}
2024-08-05 23:01:19 +08:00
}
if (rc != SQLITE_DONE) {
LOG(error) << "Failed to execute statement: " << sqlite3_errmsg(m_sqlite3);
}
sqlite3_finalize(stmt);
return ret;
}
2024-08-06 09:48:25 +08:00
std::list<VisitAnalysis> Database::latestViewedUrls(int size) {
std::list<VisitAnalysis> ret;
sqlite3_stmt *stmt;
const char *sql = R"(
SELECT url, MAX(last_view_time) as last_view_time
FROM visit_analysis
GROUP BY url
ORDER BY last_view_time DESC
LIMIT ?
)";
if (sqlite3_prepare_v2(m_sqlite3, sql, -1, &stmt, nullptr) != SQLITE_OK) {
LOG(error) << "Failed to prepare statement: " << sqlite3_errmsg(m_sqlite3);
return ret;
}
if (sqlite3_bind_int(stmt, 1, size + urlFilter.size()) != SQLITE_OK) {
LOG(error) << "Failed to bind parameter: " << sqlite3_errmsg(m_sqlite3);
sqlite3_finalize(stmt);
return ret;
}
while (sqlite3_step(stmt) == SQLITE_ROW) {
VisitAnalysis visit;
visit.url = reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0));
if (std::find(urlFilter.cbegin(), urlFilter.cend(), visit.url) != urlFilter.cend()) continue;
visit.lastViewTime = sqlite3_column_int64(stmt, 1);
2024-08-07 15:47:30 +08:00
if (ret.size() < size) {
ret.push_back(visit);
}
2024-08-06 09:48:25 +08:00
}
return ret;
}
2024-07-30 22:17:55 +08:00
VisitAnalysis Database::visitAnalysisData(const std::string &url) {
VisitAnalysis ret;
sqlite3_stmt *stmt;
2024-07-30 23:17:42 +08:00
std::string query =
"SELECT SUM(page_view_count), COUNT(DISTINCT visitor_uuid) FROM visit_analysis WHERE url = '" + url + "';";
if (sqlite3_prepare_v2(m_sqlite3, query.c_str(), -1, &stmt, nullptr) == SQLITE_OK) {
2024-07-30 22:17:55 +08:00
if (sqlite3_step(stmt) == SQLITE_ROW) {
ret.pageViewCount = sqlite3_column_int(stmt, 0);
ret.uniqueVisitorCount = sqlite3_column_int(stmt, 1);
}
sqlite3_finalize(stmt);
} else {
LOG(error) << "Failed to execute query: " << sqlite3_errmsg(m_sqlite3);
}
return ret;
}
2024-07-10 22:37:40 +08:00
bool Database::addHomeBoxItem(const std::string &name, const std::string &location, int cost) {
bool ret = true;
std::ostringstream oss;
oss << "INSERT INTO homebox (name,location,cost) VALUES (\"" << name << "\",\"" << location << "\"," << cost
<< ");";
auto sql = oss.str();
char *error = nullptr;
int result = sqlite3_exec(m_sqlite3, sql.c_str(), NULL, NULL, &error);
if (result != SQLITE_OK) {
LOG(error) << "add task failed: " << error << ", sql: " << sql;
sqlite3_free(error);
ret = false;
}
return ret;
}
static int selectHomeBoxItemCallback(void *data, int argc, char **argv, char **columnName) {
auto items = reinterpret_cast<HomeBox::Items *>(data);
HomeBox::Item item;
for (int i = 0; i < argc; i++) {
if (argv[i] == nullptr) continue;
if (strcmp(columnName[i], "id") == 0) {
item.id = std::atol(argv[i]);
2024-07-29 00:46:11 +08:00
} else if (strcmp(columnName[i], "name") == 0) {
2024-07-10 22:37:40 +08:00
item.name = argv[i];
} else if (strcmp(columnName[i], "location") == 0) {
item.location = argv[i];
} else if (strcmp(columnName[i], "cost") == 0) {
item.cost = std::atol(argv[i]);
}
}
items->push_back(item);
return 0;
}
HomeBox::Items Database::homeBoxItems() {
HomeBox::Items ret;
char *error = nullptr;
if (sqlite3_exec(m_sqlite3, "select * from homebox", selectHomeBoxItemCallback, &ret, &error) != SQLITE_OK) {
LOG(error) << "sqlite3_exec() failed: " << error << std::endl;
sqlite3_free(error);
}
return ret;
}
2024-01-03 22:44:36 +08:00
void Database::initialize() {
const char *sql =
"CREATE TABLE IF NOT EXISTS tasks (id INTEGER PRIMARY KEY AUTOINCREMENT, create_time INTEGER NOT NULL, "
"parent_id INTEGER, content VARCHAR(512) NOT NULL, comment VARCHAR(512) NOT NULL, finished BOLL, finished_time "
"INTEGER);";
int result = sqlite3_exec(m_sqlite3, sql, NULL, NULL, NULL);
if (result != SQLITE_OK) {
LOG(error) << "Failed to create table: " << sqlite3_errmsg(m_sqlite3);
return;
}
2024-07-10 22:37:40 +08:00
const char *homeBoxSql = "CREATE TABLE IF NOT EXISTS homebox (id INTEGER PRIMARY KEY AUTOINCREMENT, "
"name VARCHAR(512) NOT NULL, location VARCHAR(512) NOT NULL, cost INTEGER);";
result = sqlite3_exec(m_sqlite3, homeBoxSql, NULL, NULL, NULL);
if (result != SQLITE_OK) {
LOG(error) << "Failed to create table: " << sqlite3_errmsg(m_sqlite3);
return;
}
2024-07-29 00:46:11 +08:00
char *message = nullptr;
2024-07-31 22:28:05 +08:00
sql = R"(
2024-07-30 23:17:42 +08:00
CREATE TABLE IF NOT EXISTS visit_analysis (
2024-07-31 22:28:05 +08:00
id INTEGER PRIMARY KEY AUTOINCREMENT,
2024-07-29 00:46:11 +08:00
url TEXT NOT NULL,
visitor_uuid TEXT NOT NULL,
2024-07-31 22:28:05 +08:00
last_user_agent TEXT NOT NULL,
last_view_time INTEGER NOT NULL,
page_view_count INTEGER NOT NULL
2024-07-29 00:46:11 +08:00
);
)";
2024-07-31 22:28:05 +08:00
result = sqlite3_exec(m_sqlite3, sql, 0, 0, &message);
2024-07-29 00:46:11 +08:00
if (result != SQLITE_OK) {
LOG(error) << "Failed to create table: " << message << std::endl;
sqlite3_free(message);
}
2024-01-03 22:44:36 +08:00
}
Database::~Database() {
if (m_sqlite3 != nullptr) {
sqlite3_close(m_sqlite3);
m_sqlite3 = nullptr;
}
}