windows数据库mysql安装及C++连接

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/kunyXu/article/details/78864073

windows数据库mysql安装及C++连接

安装mysql

在mysql官网下载smi安装包
双击mysql安装包，全程按照默认配置进行即可，注意最后需要设置mysql的root用户的密码

安装好后，如果需要在终端操作数据库，则需要将mysql的bin目录添加到系统路径下：找到mysqlserver的bin，将其添加到path下即可

安装boost

要用mysql的C++连接，需要用到boost，所以windows下编译安装boost是必须的，但是编译安装boost还必须要有g++和gcc，又需要安装MinGW

安装MinGW

• 直接打开MinGW官网，点击右上方DownLoad Install即可下载。
• 下载后双击，按照默认进行，然后会出现一个界面，列出一些mingw32…… 选择其中的mingw32-gcc-g++ 右键点击 Mark for Installation，然后点击左上角的Installation菜单中的Apply changes，然后就开始安装了，最后安装好后关闭即可
• 配置环境变量，此时MinGW应该安装在C盘中，将C:\MinGW\bin添加到系统路径下，即环境变量–>path中

编译boost

• 解压boost安装包，进入到boost目录下
• 终端运行bootstrap.bat gcc，会生成b2.exe和bjam.exe两个文件
• 然后执行bjam "toolset=gcc" install
• 等待很长一段时间，C盘根目录下会生成一个boost文件夹，其中有include和lib文件夹

C++连接mysql数据库

配置环境

• 找到mysql的安装路径，一般如下图所示

• 因为我们是要连接上C++，因此我们只需要Connector.C++11和MySQL Server 5.7两个文件夹下的内容，分别将这两个文件夹下的include和lib文件夹添加到程序的include路径和lib路径，注意还得把刚才编译的libboost库的include 和lib路径添加进来

• 再将libmysql.dll和mysqlcppconn.dll两个文件放到程序运行路径下，环境就配置好了。

用代码操作数据库

可以查看mysqlcppconnect官网的demo代码，里面有比较详细简单的使用方法。
这里是我的代码
头文件

#include <mysql_connection.h>
#include <cppconn/driver.h>
#include <cppconn/exception.h>
#include <cppconn/statement.h>
#include <cppconn/resultset.h>
#include <cppconn/prepared_statement.h>
#include <sstream>
#include <vector>

class DataManager {
private:
    DataManager(std::string user_name, std::string pass_word, std::string ip);

public:
    static DataManager *getInstance(std::string user_name = "...", std::string pass_word = "...", std::string ip = "tcp://127.0.0.1:3306"); // tcp://127.0.0.1:3306 表示本机数据库
    ~DataManager();

    /*
     * insert a new data to database
     */
    bool insertNewData(const DataBaseStruct &measure_data);

    /*
     * query database
     */
    bool queryData(std::string operator_id, std::string start_time, std::string end_time, std::vector<DataBaseStruct> &query_result);


    /*
     * delete a data by id
     */
    bool deleteById(std::string id);

    /*
     * delete datas by date
     */
    bool deleteByDate(std::string date);


private:
    std::string convertResultToString(ErrorResult error_result);
    ErrorResult convertStringToResult(std::string result_str);

private:
    sql::Driver *driver_;
    sql::Connection *con_;
    sql::Statement *stmt_;
    sql::ResultSet *res_;
    sql::PreparedStatement *pre_stmt_;
    sql::PreparedStatement *insert_pre_stmt_;
    std::stringstream ss_;
    static DataManager *instance;
};

.cpp文件

#include "DataManager.h"
#include "iostream"

using namespace std;

DataManager::DataManager(std::string user_name, std::string pass_word, std::string ip)
{
    driver_ = get_driver_instance();
    con_ = driver_->connect(ip, user_name, pass_word);

    stmt_ = con_->createStatement();
    //自动创建数据库
    string create_database_str = "create database if not exists measureSysDatabase DEFAULT CHARACTER SET utf8";
    stmt_->executeUpdate(create_database_str);
    con_->setSchema("measuresysdatabase");
    // 自动创建表格
    string create_table_str = "create table if not exists measure_data("
            "component_index INT, component_id VARCHAR(20), measure_time VARCHAR(25), operator_id VARCHAR(20), measure_result VARCHAR(300),"
            "measure_graphic_path VARCHAR(150), measure_result_graphic_path VARCHAR(150), limit_deviation DOUBLE, measure_times INT, measure_place INT)  DEFAULT CHARACTER SET utf8";
    stmt_->executeUpdate(create_table_str);
    delete stmt_;
    stmt_ = NULL;

    // 预先设定好插入语句，以便后续调用
    string insert_str = "insert into measure_data(component_index, component_id, measure_time, operator_id, measure_result,"
            "measure_graphic_path, measure_result_graphic_path, limit_deviation, measure_times, measure_place) "
            "values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
    insert_pre_stmt_ = con_->prepareStatement(insert_str);
}

DataManager::~DataManager()
{
    delete insert_pre_stmt_;
    insert_pre_stmt_ = NULL;
    delete con_;
    con_ = NULL;
    if(instance != NULL)
        delete instance;
}

DataManager *DataManager::instance = NULL;
DataManager *DataManager::getInstance(std::string user_name, std::string pass_word, std::string ip)
{
    if(instance == NULL)
        instance = new DataManager(user_name, pass_word, ip);
    return instance;
}

bool DataManager::insertNewData(const DataBaseStruct &measure_data)
{
    insert_pre_stmt_->setInt(1, measure_data.component_index);
    insert_pre_stmt_->setString(2, measure_data.component_id);
    insert_pre_stmt_->setString(3, measure_data.measure_time);
    insert_pre_stmt_->setString(4, measure_data.operator_id);
    insert_pre_stmt_->setString(5, convertResultToString(measure_data.measure_result));
    insert_pre_stmt_->setString(6, measure_data.measure_graphic_path);
    insert_pre_stmt_->setString(7, measure_data.measure_result_graphic_path);
    insert_pre_stmt_->setDouble(8, measure_data.limit_deviation);
    insert_pre_stmt_->setInt(9, measure_data.measure_times);
    insert_pre_stmt_->setInt(10, measure_data.measure_place);

    if(insert_pre_stmt_->executeUpdate())
    {
        cout << "The data with id: " << measure_data.component_id << " insert succeed." << endl;
        return true;
    }
    else
    {
        cout << "The data with id: " << measure_data.component_id << " insert failed." << endl;
        return false;
    }
}

bool DataManager::queryData(string operator_id, string start_time, string end_time, std::vector<DataBaseStruct> &query_result)
{
//    cout << "I come in query part." << endl;
    bool query_state;
    stmt_ = con_->createStatement();
    string query_str = "";
    if(operator_id == "")
    {
        if(start_time == "")
        {
            if(end_time == "")
            {
                query_state = false;
            }
            else
            {
                query_str = "select * from measure_data where str_to_date(measure_time, '%Y-%m-%d %H:%i:%s') < \"" + end_time + "\";";
            }
        }
        else
        {
            if(end_time == "")
            {
                query_str = "select * from measure_data where str_to_date(measure_time, '%Y-%m-%d %H:%i:%s') > \"" + start_time + "\";";
            }
            else
            {
                query_str = "select * from measure_data where str_to_date(measure_time, '%Y-%m-%d %H:%i:%s') > \"" + start_time +
                        "\" and str_to_date(measure_time, '%Y-%m-%d %H:%i:%s') < \"" + end_time + "\";";
            }
        }
    }
    else
    {
        if(start_time == "")
        {
            if(end_time == "")
            {
                query_str = "select * from measure_data where operator_id = \"" + operator_id + "\";";
            }
            else
            {
                query_str = "select * from measure_data where operator_id = \"" + operator_id + "\"" +
                        " and str_to_date(measure_time, '%Y-%m-%d %H:%i:%s') < \"" + end_time + "\";";
            }
        }
        else
        {
            if(end_time == "")
            {
                query_str = "select * from measure_data where operator_id = \"" + operator_id + "\"" +
                        " and str_to_date(measure_time, '%Y-%m-%d %H:%i:%s') > \"" + start_time + "\";";
            }
            else
            {
                query_str = "select * from measure_data where operator_id = \"" + operator_id + "\"" +
                        "and str_to_date(measure_time, '%Y-%m-%d %H:%i:%s') > \"" + start_time +
                        "\" and str_to_date(measure_time, '%Y-%m-%d %H:%i:%s') < \"" + end_time + "\";";
            }
        }
    }
//    cout << "I finish create query str." << endl;
    res_ = stmt_->executeQuery(query_str);
//    cout << "I executed query str." << endl;
    query_result.clear();
//    cout << "I cleared the query res." << endl;
    DataBaseStruct single_data;
//    cout << "I begin into while." << endl;
    while(res_->next())
    {
//        cout << "I get into while." << endl;
        query_state = true;
        single_data.component_index = res_->getInt(1);
        single_data.component_id = res_->getString(2);
        single_data.measure_time = res_->getString(3);
        single_data.operator_id = res_->getString(4);
        single_data.measure_result = convertStringToResult(res_->getString(5));
        single_data.measure_graphic_path = res_->getString(6);
        single_data.measure_result_graphic_path = res_->getString(7);
        single_data.limit_deviation = res_->getDouble(8);
        single_data.measure_times = res_->getInt(9);
        single_data.measure_place = res_->getInt(10);
        query_result.push_back(single_data);
    }
//    cout << "I processd all queried data." << endl;
    delete res_;
    res_ = NULL;
    delete stmt_;
    stmt_ = NULL;

    return query_state;
}

bool DataManager::deleteById(std::string id)
{
    bool success;
    stmt_ = con_->createStatement();
    string delete_str = "delete from system_data where id = \"" + id + "\"";
    if(stmt_->execute(delete_str))
    {
        cout << "delete a data by it's id successed." << endl;
        success = true;
    }
    else
    {
        cerr << "delete a data by it's id failed." << endl;
        success = false;
    }
    delete stmt_;
    stmt_ = NULL;
    return success;
}

bool DataManager::deleteByDate(std::string date)
{
    bool success;
    stmt_ = con_->createStatement();
    string delete_str = "delete from system_data where str_to_date(left(car_pass_time, 19), '%Y-%m-%d %H:%i:%s') < \"" + date + "\";";
    cout << delete_str << endl;
    if(stmt_->execute(delete_str))
    {
        cout << "delete data before time " << date << " succeed." << endl;
        success = true;
    } else{
        cerr << "delete data before time " << date << " failed." << endl;
        success = false;
    }
    delete stmt_;
    stmt_ = NULL;
    return success;
}

string DataManager::convertResultToString(ErrorResult error_result)
{
    string error_str = "";

    for(int i = 0; i < error_result.size(); i++)
    {
        error_str += std::to_string(error_result[i].first.first) + "," + std::to_string(error_result[i].first.second) + ";" +
                std::to_string(error_result[i].second.first) + "," + std::to_string(error_result[i].second.second) + "|";
    }
//    if(error_str != "")
//        error_str = error_str.substr(0, error_str.length() - 1);
    return error_str;
}

ErrorResult DataManager::convertStringToResult(string result_str)
{
    ErrorResult error_result;
    string tmp_str = result_str;

    size_t pos = tmp_str.find('|');
//    while(pos != tmp_str.npos)
//    {
//        string single_error_str = tmp_str.substr(0, pos);
//        tmp_str = tmp_str.substr(pos + 1);
//        std::pair<std::pair<double, double>, std::pair<double, double> > single_error;
//        size_t sub_pos = single_error_str.find(';');
//        string long_error_str = single_error_str.substr(0, sub_pose);
//        string short_error_str = single_error_str.substr(sub_pos + 1);
//    }
    for(; pos != tmp_str.npos; pos = tmp_str.find('|'))
    {
        string single_error_str = tmp_str.substr(0, pos);

        std::pair<std::pair<double, double>, std::pair<double, double> > single_error;
        size_t sub_pos = single_error_str.find(';');
        string long_error_str = single_error_str.substr(0, sub_pos);
        size_t sub_sub_pos = long_error_str.find(',');
        single_error.first.first = atof(long_error_str.substr(0, sub_sub_pos).c_str());
        single_error.first.second = atof(long_error_str.substr(sub_sub_pos+1).c_str());

        string short_error_str = single_error_str.substr(sub_pos + 1);
        sub_sub_pos = short_error_str.find(',');
        single_error.second.first = atof(short_error_str.substr(0, sub_sub_pos).c_str());
        single_error.second.second = atof(short_error_str.substr(sub_sub_pos+1).c_str());

        error_result.push_back(single_error);
        tmp_str = tmp_str.substr(pos + 1);
    }

    return error_result;
}