235 lines
8.6 KiB
C++
235 lines
8.6 KiB
C++
#include "Database.h"
|
|
#include "BoostLog.h"
|
|
#include "Session.h"
|
|
#include <Wt/Dbo/FixedSqlConnectionPool.h>
|
|
#include <Wt/Dbo/SqlConnectionPool.h>
|
|
#include <Wt/Dbo/backend/Sqlite3.h>
|
|
#include <sqlite3.h>
|
|
#include <sstream>
|
|
|
|
std::unique_ptr<Session> Database::session() {
|
|
if (!m_sqlConnectionPool) return {};
|
|
return std::make_unique<Session>(*m_sqlConnectionPool);
|
|
}
|
|
|
|
bool Database::open(const std::string &path) {
|
|
try {
|
|
auto connection = std::make_unique<Wt::Dbo::backend::Sqlite3>(path);
|
|
connection->setProperty("show-queries", "true");
|
|
connection->setDateTimeStorage(Wt::Dbo::SqlDateTimeType::DateTime,
|
|
Wt::Dbo::backend::DateTimeStorage::PseudoISO8601AsText);
|
|
m_sqlConnectionPool = std::make_unique<Wt::Dbo::FixedSqlConnectionPool>(std::move(connection), 10);
|
|
session()->createTables();
|
|
} catch (const Wt::Dbo::Exception &e) {
|
|
LOG(error) << e.code() << ": " << e.what();
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
|
|
void Database::updateVisitCount(const std::string &url, const std::string &visitorUuid, const std::string &userAgent,
|
|
int64_t time) {
|
|
sqlite3_stmt *stmt;
|
|
auto strippedUrl = url;
|
|
if (strippedUrl.size() > 1 && strippedUrl.back() == '/') {
|
|
strippedUrl.pop_back();
|
|
}
|
|
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) {
|
|
LOG(error) << "Failed to prepare statement: " << sqlite3_errmsg(m_sqlite3);
|
|
}
|
|
sqlite3_bind_text(stmt, 1, strippedUrl.c_str(), -1, SQLITE_STATIC);
|
|
sqlite3_bind_text(stmt, 2, visitorUuid.c_str(), -1, SQLITE_STATIC);
|
|
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);
|
|
}
|
|
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);
|
|
if (sqlite3_step(stmt) != SQLITE_DONE) {
|
|
LOG(error) << "Failed to update record: " << sqlite3_errmsg(m_sqlite3);
|
|
}
|
|
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);
|
|
}
|
|
sqlite3_bind_text(stmt, 1, strippedUrl.c_str(), -1, SQLITE_STATIC);
|
|
sqlite3_bind_text(stmt, 2, visitorUuid.c_str(), -1, SQLITE_STATIC);
|
|
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;
|
|
}
|
|
sqlite3_finalize(stmt);
|
|
}
|
|
}
|
|
|
|
void Database::clearVisitRecord() {
|
|
char *message = nullptr;
|
|
constexpr auto sql = "DELETE FROM visit_analysis";
|
|
int rc = sqlite3_exec(m_sqlite3, sql, nullptr, nullptr, &message);
|
|
if (rc != SQLITE_OK) {
|
|
LOG(error) << "SQL error: " << message;
|
|
sqlite3_free(message);
|
|
}
|
|
}
|
|
|
|
VisitAnalysis Database::siteVisitAnalysisData() {
|
|
VisitAnalysis ret;
|
|
sqlite3_stmt *stmt = nullptr;
|
|
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) {
|
|
LOG(error) << "Failed to prepare statement: " << sqlite3_errmsg(m_sqlite3);
|
|
return ret;
|
|
}
|
|
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);
|
|
}
|
|
sqlite3_finalize(stmt);
|
|
return ret;
|
|
}
|
|
|
|
static std::vector<std::string> urlFilter = {
|
|
"/",
|
|
"/search",
|
|
"/LoginPage",
|
|
"/MessageBoard",
|
|
"/我的笔记",
|
|
"/我的博客",
|
|
};
|
|
|
|
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;
|
|
}
|
|
|
|
sqlite3_bind_int(stmt, 1, size + urlFilter.size());
|
|
while ((rc = sqlite3_step(stmt)) == SQLITE_ROW) {
|
|
VisitAnalysis pv;
|
|
pv.url = reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0));
|
|
if (std::find(urlFilter.cbegin(), urlFilter.cend(), pv.url) != urlFilter.cend()) continue;
|
|
pv.pageViewCount = sqlite3_column_int(stmt, 1);
|
|
if (ret.size() < size) {
|
|
ret.push_back(pv);
|
|
}
|
|
}
|
|
|
|
if (rc != SQLITE_DONE) {
|
|
LOG(error) << "Failed to execute statement: " << sqlite3_errmsg(m_sqlite3);
|
|
}
|
|
sqlite3_finalize(stmt);
|
|
return ret;
|
|
}
|
|
|
|
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);
|
|
if (ret.size() < size) {
|
|
ret.push_back(visit);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
VisitAnalysis Database::visitAnalysisData(const std::string &url) {
|
|
VisitAnalysis ret;
|
|
sqlite3_stmt *stmt;
|
|
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) {
|
|
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;
|
|
}
|
|
|
|
void Database::initialize() {
|
|
char *message = nullptr;
|
|
auto sql = R"(
|
|
CREATE TABLE IF NOT EXISTS visit_analysis (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
url TEXT NOT NULL,
|
|
visitor_uuid TEXT NOT NULL,
|
|
last_user_agent TEXT NOT NULL,
|
|
last_view_time INTEGER NOT NULL,
|
|
page_view_count INTEGER NOT NULL
|
|
);
|
|
)";
|
|
int result = sqlite3_exec(m_sqlite3, sql, 0, 0, &message);
|
|
if (result != SQLITE_OK) {
|
|
LOG(error) << "Failed to create table: " << message << std::endl;
|
|
sqlite3_free(message);
|
|
}
|
|
}
|
|
|
|
Database::~Database() {
|
|
if (m_sqlite3 != nullptr) {
|
|
sqlite3_close(m_sqlite3);
|
|
m_sqlite3 = nullptr;
|
|
}
|
|
}
|