C++封装MySQL操作

MySQL是一个比较好用并且免费的数据库，实际开发中可能会用到。如果想用C++调用MySQL，需要调用MySQL提供的一系列API。但是，这些API是基于C语言编写的，没有面向对象的特征，特别是查询获取结果集，用起来可能不太方便。而在Java中访问数据库，无论是查询还是其他操作，都被高度封装，非常方便。为了弥补这一缺陷，我最近利用课余时间封装了一下MySQL常用的API，下面就来介绍一下。

程序主要分为Database，QueryResult，QueryRow，QueryFields和一些异常类，主要封装了查询的功能，因为查询获取结果集是最麻烦的，而其它操作直接执行就可以。其中Database的功能是连接数据库并执行操作，QueryResult是查询的结果集，QueryRow是结果集的某一行，QueryFields是结果集的列名。

#include
#include"MySQLLibrary.h"
using namespace std;
using namespace MyStd::MySQL;
void ShowQueryResult(const QueryResult& result)
{
	for (const string& name : result.GetFields().GetFields())
	{
		cout.width(20);
		cout << name;
	}
	cout << endl;
	for (const QueryRow& row : result.GetRows())
	{
		for (const string& name : row.GetData())
		{
			cout.width(20);
			cout << name;
		}
		cout << endl;
	}
}
int main()
{
	try
	{
		Database db("root", 我的密码, "mirai");
		cout << db.GetDatabaseName() << endl;
		ShowQueryResult(db.Query("select*from group473405258"));
		db.Execute("use  information_schema");
		cout << db.GetDatabaseName() << endl;
		ShowQueryResult(db.Query("show tables"));
		db.Query("use mirai");//没有返回数据
	}
	catch (const MySQLException& e)
	{
		cout << e.what();
	}
	return 0;
}

运行结果（程序中出现的数据库和表均存在）：


命令行调用MySQL的运行结果：

可以看出，程序满足需求。
怎么样，是不是有点Java的味了？

注意：如果使用过程中中文出现乱码，需要查看数据库的编码格式，在Database类构造函数注释处做出相应修改即可。查看数据库编码格式方法如下：

show variables like 'character%';

character_set_client，character_set_connection， character_set_results这三个变量的值就是数据库编码格式，在代码中改成与这里格式相同的格式即可。
MySQLLibrary.h:

#pragma once
#include
#include
#include
#include
#include
#include
namespace MyStd
{
	namespace MySQL
	{
		class MySQLException :public std::ios_base::failure
		{
		public:
			MySQLException(const std::string& message);
		};
		class MySQLConnectException :public MySQLException
		{
		public:
			MySQLConnectException(const std::string& message);
		};
		class MySQLExecuteException :public MySQLException
		{
		public:
			MySQLExecuteException(const std::string& message);
		};
		class MySQLFieldNotFoundException :public MySQLException
		{
		public:
			MySQLFieldNotFoundException(const std::string& message);
		};
		class QueryFields
		{
			friend class QueryRow;
			friend class QueryResult;
		private:
			QueryFields(MYSQL_RES& result);
		public:
			QueryFields(const QueryFields& fieds) = delete;
			QueryFields(QueryFields&& fieds) = delete;
			const std::vector& GetFields()const noexcept;
		private:
			std::vectorfields;
			size_t row_count;
		};
		class QueryRow
		{
		public:
			QueryRow(QueryFields* fields, MYSQL_ROW row);
			QueryRow(const QueryRow& row);
			QueryRow(QueryRow&& row);
			const std::vector& GetData()const noexcept;
			std::string operator[](std::string index)const;
			~QueryRow();
		private:
			std::vector data;
			QueryFields* fs;
		};
		class QueryResult
		{
			friend class QueryRow;
		public:
			QueryResult(MYSQL_RES& result);
			const std::vector& GetRows()const noexcept;
			const QueryFields& GetFields()const noexcept;
		private:
			std::vector rows;
			QueryFields* fields;
		};
		class Database
		{
		public:
			Database(const std::string& user_name, const std::string& password, const std::string& database, const std::string& host = "localhost", const unsigned int port = 3306, const char* unix_socket = nullptr, const unsigned long client_flag = 0);
			void Execute(const std::string& str);
			QueryResult Query(const std::string& str);
			std::string GetDatabaseName()const;
			~Database();
		private:
			MYSQL db;
		};
	}
}

MySQLLibrary.cpp:

#include "MySQLLibrary.h"
#include
#include
MyStd::MySQL::Database::Database(const std::string& user_name, const std::string& password, const std::string& database, const std::string& host, const unsigned int port, const char* unix_socket, const unsigned long client_flag)
{
	mysql_init(&db);
	if (!mysql_real_connect(&db, host.data(), user_name.data(), password.data(), database.data(), port, unix_socket, client_flag) 
		|| mysql_query(&db, "set names gbk"))
		throw MySQLConnectException(mysql_error(&db));
}

void MyStd::MySQL::Database::Execute(const std::string& str)
{
	if (mysql_real_query(&db, str.data(), str.size()))
		throw MySQLExecuteException(mysql_error(&db));
}

MyStd::MySQL::QueryResult MyStd::MySQL::Database::Query(const std::string& str)
{
	if (mysql_real_query(&db, str.data(), str.size()))
		throw MySQLExecuteException(mysql_error(&db));
	MYSQL_RES* result = mysql_store_result(&db);
	if (result)
	{
		QueryResult temp(*result);
		mysql_free_result(result);
		return temp;
	}
	if (mysql_field_count(&db))
		throw MySQLExecuteException(mysql_error(&db));
	throw MySQLExecuteException("该语句无返回数据");
}

std::string MyStd::MySQL::Database::GetDatabaseName() const
{
	return db.db;
}

MyStd::MySQL::Database::~Database()
{
	mysql_close(&db);
}

MyStd::MySQL::MySQLException::MySQLException(const std::string& message) : std::ios::failure(message)
{
}

MyStd::MySQL::MySQLConnectException::MySQLConnectException(const std::string& message) : MySQLException(message)
{
}

MyStd::MySQL::MySQLExecuteException::MySQLExecuteException(const std::string& message) : MySQLException(message)
{
}

MyStd::MySQL::QueryResult::QueryResult(MYSQL_RES& result) : fields(new QueryFields(result))
{
	MYSQL_ROW row;
	while (row = mysql_fetch_row(&result))
	{
		rows.emplace_back(fields, row);
	}
}


const std::vector& MyStd::MySQL::QueryResult::GetRows() const noexcept
{
	return rows;
}

const MyStd::MySQL::QueryFields& MyStd::MySQL::QueryResult::GetFields() const noexcept
{
	return *fields;
}

MyStd::MySQL::QueryRow::QueryRow(QueryFields* fields, MYSQL_ROW row) :fs(fields)
{
	++fs->row_count;
	for (size_t i = 0; i < fs->fields.size(); ++i)
	{
		data.push_back(row[i]);
	}
}

MyStd::MySQL::QueryRow::QueryRow(const QueryRow& row) :fs(row.fs), data(row.data)
{
	++fs->row_count;
}

MyStd::MySQL::QueryRow::QueryRow(QueryRow&& row) : fs(row.fs), data(std::move(row.data))
{
	++fs->row_count;
}

const std::vector& MyStd::MySQL::QueryRow::GetData() const noexcept
{
	return data;
}

std::string MyStd::MySQL::QueryRow::operator[](std::string index)const
{
	std::transform(index.begin(), index.end(), index.begin(), tolower);
	for (size_t i = 0; i < fs->fields.size(); ++i)
	{
		if (fs->fields[i] == index)
			return data[i];
	}
	throw MySQLFieldNotFoundException(std::format("未找到名为"{}"的列",index));
}

MyStd::MySQL::QueryRow::~QueryRow()
{
	if ((--fs->row_count) == 0)
		delete fs;
}

MyStd::MySQL::MySQLFieldNotFoundException::MySQLFieldNotFoundException(const std::string& message):MySQLException(message)
{
}

MyStd::MySQL::QueryFields::QueryFields(MYSQL_RES& result):row_count(0)
{
	MYSQL_FIELD* fs = mysql_fetch_fields(&result);
	const unsigned int field_count = mysql_num_fields(&result);
	fields.reserve(field_count);
	for (unsigned int i = 0; i < field_count; ++i)
	{
		fields.push_back(fs[i].name);
	}
}


const std::vector& MyStd::MySQL::QueryFields::GetFields() const noexcept
{
	return fields;
}

博主创作不易，三连支持一下吧！