MySQL workbench

利用MySQL workbench 建立一个mysql数据库和表_mysqlworkbench创建数据库和表-CSDN博客

QT项目中使用的数据库连接类

DataBaseManager.h

#pragma once
#include <mysql.h>
#include <vector>
#include <string>
#include <iostream>

// 数据库管理类
class DatabaseManager {
public:
    // 构造函数：接受配置文件名，初始化数据库连接参数
    DatabaseManager(const std::string& configFilename);
    ~DatabaseManager();

    bool connect();         // 连接到数据库
    bool executeQuery(const char* query);       // 执行给定的 SQL 查询
    std::vector<std::string> getResult();       // 获取上一个查询的结果
    void close();       // 关闭数据库连接

private:
    MYSQL* conn; // MySQL 连接指针
    MYSQL_RES* res; // 查询结果指针
    std::vector<std::string> m_database; // 存储查询结果的向量

    // 数据库连接所需的参数
    std::string server; // 数据库服务器地址
    std::string user; // 用户名
    std::string password; // 密码
    std::string database; // 数据库名称

    // 打印错误信息的私有方法
    void printError(const std::string& message);
};

DatabaseManager.cpp

#include "DatabaseManager.h"
#include <fstream>
#include <map>
#include <locale>
#include <codecvt>
#include <QDebug>

// 读取配置文件函数
std::map<std::string, std::string> readConfigFile(const std::string& filename)
{
    std::ifstream file(filename); // 打开配置文件
    std::map<std::string, std::string> config; // 存储配置项的映射
    std::string line;

    // 逐行读取配置文件
    while (std::getline(file, line))
    {
        // 查找键值对的分隔符
        // 如果没找到，值为std::string::npos，这是-1的无符号表示
        size_t pos = line.find('=');
        if (pos != std::string::npos)
        {
            std::string key = line.substr(0, pos);
            std::string value = line.substr(pos + 1);
            config[key] = value;
        }
    }

    return config;
}

// DatabaseManager 类实现
DatabaseManager::DatabaseManager(const std::string& configFilename)
{
    // 读取配置文件
    std::map<std::string, std::string> config = readConfigFile(configFilename);

    server = config["server"];
    user = config["user"];
    password = config["password"];
    database = config["database"];

    conn = nullptr;
    res = nullptr;
}

DatabaseManager::~DatabaseManager()
{
    close();
}

bool DatabaseManager::connect()
{
    // 初始化 MYSQL 连接
    conn = mysql_init(NULL);

    // 检查初始化是否成功
    if (conn == NULL)
    {
        printError("mysql_init() failed");
        return false;
    }

    // 尝试建立与数据库连接
    if (mysql_real_connect(conn, server.c_str(), user.c_str(), password.c_str(), database.c_str(), 0, NULL, 0) == NULL)
    {
        printError("mysql_real_connect() failed");
        mysql_close(conn);      // 关闭连接
        return false;
    }
    else
    {
        qDebug() << "mysql_real_connect() success";
    }

    // 设置连接的字符集为 utf8mb4
    if (mysql_set_character_set(conn, "utf8mb4"))
    {
        qDebug() << "mysql_set_character_set() failed";
        mysql_close(conn);
        return false;
    }
    else
    {
        qDebug() << "mysql_set_character_set() success";
    }
    return true;

}

bool DatabaseManager::executeQuery(const char* query)
{
    // 执行 SQL 查询
    if (mysql_query(conn, query))
    {
        qDebug() << "DatabaseManager::executeQuery failed:" << mysql_error(conn);
        return false;
    }
    else
    {
        qDebug() << "DatabaseManager::executeQuery success";
        res = mysql_store_result(conn);     // 存储查询结果
        if (res == NULL)
        {
            //printError("mysql_store_result() failed");
            qDebug() << "mysql_store_result() failed:" << mysql_error(conn);
            return false;
        }
        return true;
    }
}

std::vector<std::string> DatabaseManager::getResult()
{
    m_database.clear();     // 清空存储结果的向量

    // 行指针
    MYSQL_ROW row;
    int num_fields = mysql_num_fields(res);     // 获取字段数

    // 逐行提取结果
    while ((row = mysql_fetch_row(res)))
    {
        std::string m_data;                     // 存储当前行的数据
        for (int i = 0; i < num_fields; i++)
        {
            if (row[i] == NULL)
            {
                m_data += "NULL";               // 处理NULL值
            }
            else
            {
                // 使用 QString 来处理中文字符
                QString qstr = QString::fromUtf8(row[i]);
                m_data += qstr.toStdString();  // 转回 std::string
            }

            if (i < num_fields - 1)
            {
                m_data += ", ";     // 添加字段分割符
            }
        }
        m_database.push_back(m_data);       // 将结果行添加到结果向量中
    }

    return m_database;  // 返回结果
}

void DatabaseManager::close()
{
    // 释放查询结果
    if (res != NULL)
    {
        mysql_free_result(res);
        res = NULL;         // 防止悬空指针
    }

    // 关闭数据库连接
    if (conn != NULL) 
    {
        mysql_close(conn);
        conn = NULL;    // 防止悬空指针
    }
}

void DatabaseManager::printError(const std::string& message)
{
    // 打印错误信息
    std::cerr << message << ": " << mysql_error(conn) << std::endl;
}

使用例子

// db_config.dat
server=localhost
user=root
password=1111password..
database=lkj

void MidWidget::getDefaultLimitSpeed()
{
    // 创建 DatabaseManager 实例，传入配置文件名
    DatabaseManager dbManager("db_config.dat");

    // 连接到数据库
    if (dbManager.connect()) 
    {
        // 执行查询
        std::stringstream ss;
        ss << "SELECT StartMileage, EndMileage, SpeedLimit, IsDecel FROM speedlimitsections WHERE LineID = 0";
        const std::string& queryStr = ss.str();
        const char* query = queryStr.c_str();
        if (dbManager.executeQuery(query))
        {
            // 获取查询结果，传递数据到 MidWidget 进行解析
            std::vector<std::string> results = dbManager.getResult();
            processDefaultDatabaseData(results);
        }
    }
}

查询之后的结果存放在results中，对其进行解析

void processDefaultDatabaseData(const std::vector<std::string>& data)
{
    for (const auto& row : data)
    {
        SpeedLimitSection section;
        std::stringstream ss(row);
        std::string token;

        std::getline(ss, token, ',');
        section.startMileage = std::stod(token);    // stod 字符串转换为double

        std::getline(ss, token, ',');
        section.endMileage = std::stod(token);

        std::getline(ss, token, ',');
        section.speedLimit = std::stod(token);

        std::getline(ss, token, ',');
        section.isDecel = std::stoi(token);

        m_speedLimitSections.push_back(section);
    }
}