MySQL数据库从win导出成_db.sql复制到linux

MySQL数据库下载后基本使用+增删改查语句模板_mysql增语句大全-CSDN博客

1.启动服务后，导出到指定文件

格式：mysqldump -u 用户名 -p 数据库名 > 输出路径\文件名.sql

mysqldump -u root -p log_db > D:\MySQL\mysql-8.0.34-winx64\dboutput\log_db.sql

验证：

2.修改mysqlutil.cpp mysqlutil.h

mysqlutil.cpp

#include "mysqlutil.h"
#include "QDebug"
#include <QSqlRecord>
#include <QSqlError>
#include <QMessageBox>
#include <QFileInfo>  // 新增：处理文件路径

// 静态成员初始化
QSqlDatabase MySqlUtil::mDb = QSqlDatabase();  // 初始化为空，避免提前创建驱动
QMap<QString,QString> MySqlUtil::mMap;
QString MySqlUtil::mCurrentDriver = "";  // 新增：记录当前驱动类型

MySqlUtil *MySqlUtil::instance()
{
    static MySqlUtil instance;
    return &instance;
}

MySqlUtil::MySqlUtil(QObject *parent): QObject(parent)
{
    // 构造函数仅初始化，不提前创建驱动
}

MySqlUtil::~MySqlUtil()
{
    closeDb();
}

// 原有远程MySQL连接接口（完全保留，仅微调驱动创建逻辑）
bool MySqlUtil::connectDb(const QString &host, const QString &user, const QString &password, const QString &dbName, int port)
{
    if(mDb.isOpen()){
        mDb.close();
    }

    qDebug() << "=== 可用的数据库驱动列表 ===";
    QStringList drivers = QSqlDatabase::drivers();
    foreach (QString driver, drivers) {
        qDebug() << "驱动名称：" << driver;
    }

    // 重新创建MySQL驱动（避免复用SQLite驱动）
    if (mCurrentDriver != "QMYSQL") {
        mDb = QSqlDatabase::addDatabase("QMYSQL", "MySqlUtil");
        mCurrentDriver = "QMYSQL";
    }

    if(!mDb.isValid()){
        qDebug()<<"core_mysql mysqlutil.cpp 获取MySQL驱动失败";
        return false;
    }

    if (!drivers.contains("QMYSQL")) {
        QMessageBox::critical(nullptr, "错误", "Qt未找到MySQL驱动！");
        return false;
    } else {
        qDebug()<<"MySQL驱动加载成功";
    }

    mDb.setHostName(host);
    mDb.setUserName(user);
    mDb.setPassword(password);
    mDb.setDatabaseName(dbName);
    mDb.setPort(port);

    bool ret = mDb.open();
    if(!ret){
        qWarning() << "远程MySQL连接失败：" << mDb.lastError().text();
        return false;
    }

    qDebug() << "远程MySQL连接成功！";
    return true;
}

// 新增：本地数据库文件连接接口（支持绝对/相对路径）
bool MySqlUtil::connectLocalDb(const QString &dbFilePath)
{
    if(mDb.isOpen()){
        mDb.close();
    }

    // 解析路径：相对路径转绝对路径（确保兼容性）
    QFileInfo fileInfo(dbFilePath);
    QString absDbPath = fileInfo.absoluteFilePath();
    qDebug() << "本地数据库文件路径（绝对）：" << absDbPath;

    // 重新创建SQLite驱动（避免复用MySQL驱动）
    if (mCurrentDriver != "QSQLITE") {
        mDb = QSqlDatabase::addDatabase("QSQLITE", "MySqlUtil");
        mCurrentDriver = "QSQLITE";
    }

    if(!mDb.isValid()){
        qDebug()<<"获取SQLite驱动失败，请检查Qt是否编译SQLite插件";
        return false;
    }

    // 设置本地数据库文件路径（不存在则自动创建）
    mDb.setDatabaseName(absDbPath);

    bool ret = mDb.open();
    if(!ret){
        qWarning() << "本地数据库连接失败：" << mDb.lastError().text();
        return false;
    }

    qDebug() << "本地数据库文件连接成功！";
    return true;
}

void MySqlUtil::closeDb()
{
    if(mDb.isOpen() && mDb.isValid()){
        mDb.close();
        QSqlDatabase::removeDatabase("MySqlUtil");
        mCurrentDriver = "";  // 重置驱动标记
        qInfo() << "[MySqlUtil] 数据库连接已关闭，连接名MySqlUtil已移除";
    } else if(mDb.isValid()){
        qInfo() << "[MySqlUtil] 数据库未打开，无需关闭";
    } else {
        qWarning() << "[MySqlUtil] 数据库驱动无效，无连接可关闭";
    }
}

QSqlQuery MySqlUtil::executeQuery(const QString &sql)
{
    if(!isConnected()){
        qDebug()<<"数据库未连接";
        return QSqlQuery();
    }

    QSqlQuery query(mDb);
    if(!query.exec(sql)){
        qDebug()<<"查询失败：" << query.lastError().text();
        return QSqlQuery();
    }
    return query;
}

bool MySqlUtil::isConnected()
{
    return mDb.isOpen() && mDb.isValid();
}

QVariantList MySqlUtil::getQueryResult(const QString &sql)
{
    QVariantList resultList;

    if(!isConnected()){
        qDebug()<<"数据库没有连接";
        return resultList;
    }

    QSqlQuery query = executeQuery(sql);
    // 修复原代码的逻辑错误：query.isValid() 是判断当前行是否有效，不是查询是否失败
    if (query.lastError().isValid()) {
        qDebug() << "getQueryResult: 查询失败，错误信息：" << query.lastError().text();
        return resultList;
    }

    QSqlRecord record = query.record();
    int columnCount = record.count();
    if (columnCount <= 0) {
        qDebug() << "getQueryResult: 查询结果无有效列";
        return resultList;
    }

    while (query.next()) {
        QVariantMap rowMap;
        for (int i = 0; i < columnCount; ++i) {
            QString columnName = record.fieldName(i);
            QString chineseKey = mMap.value(columnName, columnName);
            QVariant value = query.value(i);
            rowMap[chineseKey] = value;
        }
        resultList.append(rowMap);
    }

    return resultList;
}

bool MySqlUtil::insertData(const QString &sql)
{
    QSqlQuery query = executeQuery(sql);
    bool success = !query.lastError().isValid();
    if (success) {
        qDebug() << "成功插入数据【MySQLUtil】，受影响行数：" << query.numRowsAffected();
    } else {
        qDebug() << "插入失败【MySQLUtil】，错误：" << query.lastError().text();
    }
    return success;
}

bool MySqlUtil::updateData(const QString &sql)
{
    QSqlQuery query = executeQuery(sql);
    bool success = !query.lastError().isValid();
    if (success) {
        qDebug() << "成功更新数据【MySQLUtil】，受影响行数：" << query.numRowsAffected();
    } else {
        qDebug() << "更新数据失败【MySQLUtil】，错误：" << query.lastError().text();
    }
    return success;
}

bool MySqlUtil::deleteData(const QString &sql)
{
    QSqlQuery query = executeQuery(sql);
    bool success = !query.lastError().isValid();
    if (success) {
        qDebug() << "成功删除数据【MySQLUtil】，受影响行数：" << query.numRowsAffected();
    } else {
        qDebug() << "删除数据失败【MySQLUtil】，错误：" << query.lastError().text();
    }
    return success;
}

QVariantMap MySqlUtil::getLatestTestData()
{
    QVariantMap resultMap;
    if(!isConnected()){
        qCritical() << "[MySqlUtil] 数据库未连接，无法查询test_table！";
        return resultMap;
    }

    QString sql = "SELECT * FROM test_table ORDER BY create_time DESC, id DESC LIMIT 1;";
    QSqlQuery query = executeQuery(sql);

    if (query.lastError().isValid()) {
        qCritical() << "[MySqlUtil] 查询test_table失败：" << query.lastError().text();
        return resultMap;
    }
    if (!query.next()) {
        qWarning() << "[MySqlUtil] test_table无任何数据，请先插入数据！";
        return resultMap;
    }

    QSqlRecord record = query.record();
    int columnCount = record.count();
    qInfo() << "[MySqlUtil] 查到test_table最新数据，开始解析：";
    for (int i = 0; i < columnCount; ++i) {
        QString columnName = record.fieldName(i);
        QVariant value = query.value(i);
        resultMap[columnName] = value;
        qInfo() << "  " << columnName << " = " << value << " (类型：" << value.typeName() << ")";
    }

    return resultMap;
}

mysqlutil.h

#ifndef MYSQLUTIL_H
#define MYSQLUTIL_H

#include <QQmlEngine>
#include <QObject>
#include <QSqlDatabase>
#include <QSqlQuery>
#include <QMap>
#include <QVariantList>
#include <QVariantMap>

class MySqlUtil : public QObject
{
    Q_OBJECT
public:
    explicit MySqlUtil(QObject *parent = nullptr);
    ~MySqlUtil();

    Q_INVOKABLE QVariantList getQueryResult(const QString &sql);
    Q_INVOKABLE bool insertData(const QString &sql);  
    Q_INVOKABLE bool updateData(const QString &sql);  
    Q_INVOKABLE bool deleteData(const QString &sql);  
    Q_INVOKABLE QVariantMap getLatestTestData();

    // 原有远程MySQL连接接口（完全保留）
    Q_INVOKABLE bool connectDb(const QString& host,
                               const QString& user,
                               const QString& password,
                               const QString& dbName,
                               int port = 3306);

    // 新增：本地数据库文件连接接口（SQLite，兼容绝对/相对路径）
    Q_INVOKABLE bool connectLocalDb(const QString &dbFilePath);

    Q_INVOKABLE void closeDb();
    Q_INVOKABLE bool isConnected();

    static MySqlUtil* instance();

private:
    static QSqlDatabase mDb;
    static QMap<QString, QString> mMap;
    QSqlQuery executeQuery(const QString &sql);
    // 新增：标记当前连接类型（避免驱动冲突）
    static QString mCurrentDriver;
};

#endif // MYSQLUTIL_H

3.使用方法

模式 1：远程 MySQL 连接（原有功能，完全不变）

// C++中调用
MySqlUtil::instance()->connectDb("192.168.1.100", "root", "123456", "log_db", 3306);
// 执行查询（和原来一样）
QVariantList result = MySqlUtil::instance()->getQueryResult("SELECT * FROM test_table");

// QML中调用
MySqlUtil.instance.connectDb("192.168.1.100", "root", "123456", "log_db", 3306)
let result = MySqlUtil.instance.getQueryResult("SELECT * FROM test_table")

模式 2：本地数据库文件连接（新增功能）

1. 绝对路径（比如你的截图路径）

// C++中调用（绝对路径）
MySqlUtil::instance()->connectLocalDb("D:/MySQL/mysql-8.0.34-winx64/dboutput/log_db.db");

// QML中调用（注意路径转义，或用file://协议）
MySqlUtil.instance.connectLocalDb("D:/MySQL/mysql-8.0.34-winx64/dboutput/log_db.db")
// 或
MySqlUtil.instance.connectLocalDb("file:///D:/MySQL/mysql-8.0.34-winx64/dboutput/log_db.db")

2. 相对路径（和可执行文件同目录）

// C++中调用（相对路径，自动转为可执行文件同级目录）
MySqlUtil::instance()->connectLocalDb("./log_db.db");  // 可执行文件同目录
// 或
MySqlUtil::instance()->connectLocalDb("db/log_db.db"); // 可执行文件同级的db子目录

// QML中调用
MySqlUtil.instance.connectLocalDb("./log_db.db")