devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

数据库-ODBC操作_odbc数据源配置

作者：知新_RL | 2024-05-03 22:27:56

赞

踩

odbc数据源配置

承接Qt/C++软件开发项目，高质量交付，灵活沟通，长期维护支持。需求所寻，技术正适，共创完美，欢迎私信联系！

一、ODBC 数据源配置

打开ODBC数据源管理器：

  • 在Windows搜索栏中键入“ODBC数据源”并选择“ODBC数据源(64位)”（如果你的系统是64位的）。
  • 如果你的系统是32位的，你可以选择“ODBC数据源(32位)”。
  • 或者，你可以在控制面板中找到ODBC数据源管理器。

添加数据源：

  • 在ODBC数据源管理器中，选择“用户DSN/系统DSN”选项卡。
  • 点击“添加”按钮，在弹出的对话框中选择要配置的数据库类型（如SQLite、MySQL等）。
  • 根据数据库类型和具体的配置要求填写相应的信息，例如数据库文件路径、服务器名称、用户名、密码等。
  • 完成配置后，点击“确定”按钮。

二、使用ODBC的优点和缺点

优点：

        平台独立性：ODBC提供了一种标准的API，使得应用程序可以在不同的操作系统上连接和操作数据库，从而实现了一定程度的平台独立性。

        数据库透明性：通过ODBC，应用程序可以通过相同的API连接到不同类型的数据库，无论是关系型数据库还是非关系型数据库，这增加了灵活性和可扩展性。

        易于维护：ODBC提供了一种标准的接口，使得数据库连接和操作可以在不修改应用程序代码的情况下进行配置和更改。这使得维护和管理数据库连接变得更加简单。

        大量的驱动支持：由于ODBC已经成为了一种行业标准，几乎所有的主流数据库供应商都提供了ODBC驱动程序，因此你可以很容易地连接到各种不同类型的数据库。

缺点：

        性能损失：与直接使用特定数据库的本地API相比，通过ODBC连接数据库可能会带来一定的性能损失，因为它涉及到额外的数据转换和通信开销。

        功能限制：由于ODBC只提供了一种标准的API，因此某些特定于数据库引擎的功能可能无法直接通过ODBC访问，你可能需要使用特定数据库的本地API来实现这些功能。

        连接和配置复杂性：配置和管理ODBC数据源可能需要一些额外的工作，特别是对于一些复杂的数据库配置，可能需要更多的时间和精力。

        平台依赖性：虽然ODBC提供了一定程度的平台独立性，但在不同的操作系统上可能会有一些细微的差异，这可能需要在跨平台应用程序中进行一些额外的处理。

三、实现操作代码

创建了一个名为DatabaseManager的类，其中分为通过ODBC数据源模式和直接ODBC访问数据库模式，注意代码注释内容。

  1. #ifndef DATABASEMANAGER_H
  2. #define DATABASEMANAGER_H
  3.  
  4. #include <QObject>
  5.  
  6. #include <QSqlDatabase>
  7. #include <QSqlQuery>
  8.  
  9. typedef struct{
  10.     QString username;
  11.     QString password;
  12.     QString databaseName;
  13.     QString serverName;
  14.     QString driverName;
  15. }T_Database;
  16.  
  17. /*
  18.  * 数据库操作管理类
  19.  */
  20. class  DatabaseManager : public QObject
  21. {
  22.     Q_OBJECT
  23.  
  24. public:
  25.     DatabaseManager(QObject *parent = nullptr);
  26.     ~DatabaseManager();
  27.  
  28.     // 打开数据库
  29.     bool openDB(const T_Database &data);
  30.     // 关闭数据库
  31.     void closeDB();
  32.     // 数据库是否有效
  33.     bool isDatabaseValid();
  34.     // 判断字段值是否存在
  35.     bool isExistsValue(const QString& tableName, const QString& condition);
  36.     // 创建表
  37.     bool createTable(const QString& createSql);
  38.     // 插入数据
  39.     bool insertData(const QString& tableName, const QMap<QString, QVariant>& data);
  40.     // 删除数据
  41.     bool deleteData(const QString& tableName, const QString& condition);
  42.     // 更新数据
  43.     bool updateData(const QString& tableName, const QString& condition, const QMap<QString, QVariant>& data);
  44.     // 查询数据
  45.     bool queryData(const QString& tableName, const QString& condition, QList<QMap<QString, QVariant>>& data);
  46.  
  47. private:
  48.     QSqlDatabase m_db;
  49. };
  50.  
  51.  
  52. #endif // DATABASEMANAGER_H
  1. #include "databasemanager.h"
  2.  
  3. #include <QSqlRecord>
  4. #include <QSqlQuery>
  5. #include <QSqlError>
  6. #include <QDebug>
  7.  
  8. #pragma execution_character_set("utf-8")
  9.  
  10.  
  11. DatabaseManager::DatabaseManager(QObject* parent)
  12.     : QObject(parent)
  13. {
  14. }
  15.  
  16. DatabaseManager::~DatabaseManager()
  17. {
  18. }
  19.  
  20. bool DatabaseManager::openDB(const T_Database &data)
  21. {
  22.     if (isDatabaseValid())
  23.     {
  24.         return true;
  25.     }
  26.  
  27.     m_db = QSqlDatabase::addDatabase("QODBC");
  28.     if (!m_db.isValid())
  29.     {
  30.         QStringList drivers = QSqlDatabase::drivers();
  31.         qDebug() << "drivers: " << drivers;
  32.         qCritical() << "Failed to load QODBC driver. " << m_db.lastError().text();
  33.         return false;
  34.     }
  35.     
  36.     // 方法一、连接到ODBC数据源 
  37.     // m_db.setDatabaseName(dataSourceName);
  38.     
  39.     // 方法二、直接通过ODBC连接数据库
  40.     QString connectionString = QString("DRIVER={%1};SERVER=%2;DATABASE=%3;UID=%4;PWD=%5;PORT=%6;")
  41.             .arg(data.driverName)
  42.             .arg(data.serverName)
  43.             .arg(data.databaseName)
  44.             .arg(data.username)
  45.             .arg(data.password)
  46.             .arg(data.serverPort);
  47.     m_db.setDatabaseName(connectionString);
  48.  
  49.     if (!m_db.open())
  50.     {
  51.         qCritical() << "Error: Failed to connect to database." << m_db.lastError().text();
  52.         return false;
  53.     }
  54.  
  55.     return true;
  56. }
  57.  
  58. void DatabaseManager::closeDB()
  59. {
  60.     if (m_db.isOpen())
  61.     {
  62.         m_db.close();
  63.     }
  64. }
  65.  
  66. bool DatabaseManager::isDatabaseValid()
  67. {
  68.     return (m_db.isOpen() || m_db.isValid());
  69. }
  70.  
  71. bool DatabaseManager::isExistsValue(const QString& tableName, const QString& condition)
  72. {
  73.     QString sql = QString("SELECT * FROM %2").arg(tableName);
  74.     if(!condition.isEmpty())
  75.     {
  76.         sql += " " + condition;
  77.     }
  78.     QSqlQuery selectQuery;
  79.     selectQuery.prepare(sql);
  80.     // 绑定参数或拼接查询条件
  81.     // selectQuery.bindValue(...);
  82.     if (!selectQuery.exec())
  83.     {
  84.         qCritical() << "Error: Failed to select data from the database. " << selectQuery.lastError().text();
  85.         return false;
  86.     }
  87.  
  88.     if (selectQuery.next())
  89.     {
  90.         // 字段的值存在
  91.         // 执行相应的逻辑
  92.         // ...
  93.         return true;
  94.     }
  95.  
  96.  
  97.     // 字段的值不存在
  98.     // 执行相应的逻辑
  99.     // ...
  100.     //
  101.     return false;
  102. }
  103.  
  104. bool DatabaseManager::createTable(const QString& createSql)
  105. {
  106.     if (!isDatabaseValid())
  107.     {
  108.         qCritical() << "Error: Database connection is not valid.";
  109.         return false;
  110.     }
  111.     qDebug() << "createTable: " << createSql;
  112.  
  113.     QSqlQuery query;
  114.     if (!query.exec(createSql))
  115.     {
  116.         qCritical() << "Error: Failed to create table.";
  117.         return false;
  118.     }
  119.  
  120.     query.finish();
  121.  
  122.     return true;
  123. }
  124.  
  125.  
  126. bool DatabaseManager::insertData(const QString& tableName, const QMap<QString, QVariant>& data)
  127. {
  128.     if (!isDatabaseValid())
  129.     {
  130.         qCritical() << "Error: Database is not valid.";
  131.         return false;
  132.     }
  133.  
  134.     QString sql = "INSERT INTO " + tableName + " (";
  135.     QString values = "VALUES (";
  136.  
  137.     // 构建字段列表和值列表
  138.     QStringList fields;
  139.     QStringList placeholders;
  140.     for (const auto& key : data.keys())
  141.     {
  142.         fields << key;
  143.         placeholders << ":" + key;
  144.     }
  145.  
  146.     sql += fields.join(", ") + ") ";
  147.     values += placeholders.join(", ") + ")";
  148.  
  149.     QSqlQuery query;
  150.     query.prepare(sql + values);
  151.  
  152.     // 绑定参数
  153.     for (const auto& key : data.keys())
  154.     {
  155.         query.bindValue(":" + key, data.value(key));
  156.     }
  157.  
  158.     qDebug() << "insertData: " << sql + values;
  159.     if (!query.exec())
  160.     {
  161.         qCritical() << "Error: Failed to insert data into database. " << query.lastError().text();
  162.         return false;
  163.     }
  164.  
  165.     query.finish();
  166.  
  167.     return true;
  168. }
  169.  
  170. bool DatabaseManager::deleteData(const QString& tableName, const QString& condition)
  171. {
  172.     if (!isDatabaseValid())
  173.     {
  174.         qCritical() << "Error: Database is not valid.";
  175.         return false;
  176.     }
  177.  
  178.     QString sql = "DELETE FROM " + tableName + " " + condition;
  179.     qDebug() << "deleteData: " << sql;
  180.  
  181.     QSqlQuery query;
  182.     query.prepare(sql);
  183.     if (!query.exec())
  184.     {
  185.         qCritical() << "Error: Failed to delete data from database. " << query.lastError().text();
  186.         return false;
  187.     }
  188.     return true;
  189. }
  190.  
  191. bool DatabaseManager::updateData(const QString& tableName, const QString& condition,
  192.                                  const QMap<QString, QVariant>& data)
  193. {
  194.     if (!isDatabaseValid())
  195.     {
  196.         qCritical() << "Error: Database is not valid.";
  197.         return false;
  198.     }
  199.  
  200.     QString sql = "UPDATE " + tableName + " SET ";
  201.  
  202.     // 构建更新字段列表
  203.     QStringList updates;
  204.     for (const auto& key : data.keys())
  205.     {
  206.         updates << key + " = :" + key;
  207.     }
  208.  
  209.     sql += updates.join(", ") + " " + condition;
  210.     qDebug() << "updateData: " << sql;
  211.  
  212.  
  213.     QSqlQuery query;
  214.     query.prepare(sql);
  215.  
  216.     // 绑定参数
  217.     for (const auto& key : data.keys())
  218.     {
  219.         query.bindValue(":" + key, data.value(key));
  220.     }
  221.  
  222.     if (!query.exec())
  223.     {
  224.         qCritical() << "Error: Failed to update data in database. " << query.lastError().text();
  225.         return false;
  226.     }
  227.  
  228.     query.finish();
  229.  
  230.     return true;
  231. }
  232.  
  233. bool DatabaseManager::queryData(const QString& tableName, const QString& condition,
  234.                                 QList<QMap<QString, QVariant>>& data)
  235. {
  236.     if (!isDatabaseValid())
  237.     {
  238.         qCritical() << "Error: Database is not valid.";
  239.         return false;
  240.     }
  241.  
  242.     QString sql = "SELECT * FROM " + tableName;
  243.     if (!condition.isEmpty())
  244.     {
  245.         sql += " " + condition;
  246.     }
  247.     qDebug() << "queryData: " << sql;
  248.  
  249.     QSqlQuery query(sql);
  250.     while (query.next())
  251.     {
  252.         QMap<QString, QVariant> row;
  253.         QSqlRecord record = query.record();
  254.  
  255.         for (int i = 0; i < record.count(); i++)
  256.         {
  257.             QString fieldName = record.fieldName(i);
  258.             QVariant value = query.value(i);
  259.             row.insert(fieldName, value);
  260.         }
  261.  
  262.         data.append(row);
  263.     }
  264.  
  265.     query.finish();
  266.  
  267.     return true;
  268. }
  269.
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/531853
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号