一个简陋的mysql封装类(Windows下)

最新推荐文章于 2024-08-07 23:56:32 发布
最新推荐文章于 2024-08-07 23:56:32 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： database 文章标签： mysql windows semaphore string null sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kusey/article/details/6988954
版权

         mysql的一个在windows下的封装类，做成了dll，用着可能不是很顺手，以后有时间再修改。

mysql_cpp.h

#ifndef __mysql_cpp_h__
#define __mysql_cpp_h__

typedef unsigned char	uchar;
typedef	unsigned short	ushort;
typedef unsigned int	uint;
typedef	unsigned long	ulong;

#define DEFAULT_HOST		"127.0.0.1"
#define DEFAULT_ENCODING	"utf8"
#define DEFAULT_PORT		3306
#define DEFAULT_CONN_NUM	5
#define DEFAULT_TIMEOUT		3000

#include <string>
#include <vector>

#include <Windows.h>

#include <mysql.h>
#pragma comment( lib, "libmysql.lib" )

#endif // __mysql_cpp_h__


mysql_connection_pool.h

#ifndef __mysql_connection_pool_h__
#define __mysql_connection_pool_h__

#ifndef	DLLEXPORT
#define	DLLAPI		__declspec(dllimport)
#else
#define	DLLAPI		__declspec(dllexport)
#endif

#define DLLCLS		DLLAPI

#include "mysql_cpp.h"

class CMysqlConnection;

class DLLCLS CMysqlConnectionPool
{
public:
	CMysqlConnectionPool( const std::string& username, const std::string& password, const std::string& dbname,
		const std::string& host = DEFAULT_HOST, ushort port = DEFAULT_PORT,
		const std::string& encoding = DEFAULT_ENCODING );
	~CMysqlConnectionPool();

	bool				initConnections	( ushort num = DEFAULT_CONN_NUM );
	CMysqlConnection*	getConnection	();
	void				putConnection	( CMysqlConnection* connection );

protected:
	bool				addConnection	();
	void				clearConnections();

private:
	std::string						_username;
	std::string						_password;
	std::string						_dbname;
	std::string						_host;
	std::string						_encoding;
	ushort							_port;
	ushort							_connection_num;
	std::vector<CMysqlConnection*>	_connections;
	CRITICAL_SECTION				_cs;
	HANDLE							_semaphore;
};

#endif // __mysql_connection_pool_h__


mysql_connection.h

#ifndef __mysql_connection_h__
#define __mysql_connection_h__

#ifndef	DLLEXPORT
#define	DLLAPI		__declspec(dllimport)
#else
#define	DLLAPI		__declspec(dllexport)
#endif

#define DLLCLS		DLLAPI

#include "mysql_cpp.h"

class CMysqlRecordSet;

class DLLCLS CMysqlConnection
{
	friend class CMysqlConnectionPool;

public:
	virtual ~CMysqlConnection();

	CMysqlRecordSet*	executeQuery	( const std::string& sql);
	bool				executeNonQuery	( const std::string& sql );

	int					errorNum		() const;
	const char*			errorString		() const;

protected:
	CMysqlConnection( MYSQL *mysql );

private:
	CMysqlConnection( const CMysqlConnection& );
	CMysqlConnection& operator = ( const CMysqlConnection& );

	MYSQL	*_mysql;
};

#endif // __mysql_connection_h__


mysql_record_set.h

#ifndef __mysql_record_set_h__
#define __mysql_record_set_h__

#ifndef	DLLEXPORT
#define	DLLAPI		__declspec(dllimport)
#else
#define	DLLAPI		__declspec(dllexport)
#endif

#define DLLCLS		DLLAPI

#include "mysql_cpp.h"

class CMysqlRecord;

class DLLCLS CMysqlRecordSet
{
	friend class CMysqlConnection;

public:
	~CMysqlRecordSet();

	ulong			getRecordsNum	() const { return _row_num; }
	ulong			getFieldsNum	() const { return _field_num; }
	const char*		getFieldName	( ulong idx ) const {
		if( idx < _field_num )
			 return _fields[idx].c_str(); 
		else
			return NULL;
	}
	CMysqlRecord*	getRecord		( ulong idx ) const {
		if( idx < _row_num )
			return _records[idx];
		else
			return NULL;
	}

protected:
	CMysqlRecordSet();

	bool initRecordSet	( MYSQL_RES *res );

private:
	ulong						_field_num;
	ulong						_row_num;
	std::vector<std::string>	_fields;
	std::vector<CMysqlRecord*>	_records;
};

#endif // __mysql_record_set_h__


mysql_record.h

#ifndef __mysql_record_h__
#define __mysql_record_h__

#ifndef	DLLEXPORT
#define	DLLAPI		__declspec(dllimport)
#else
#define	DLLAPI		__declspec(dllexport)
#endif

#define DLLCLS		DLLAPI

#include "mysql_cpp.h"

class DLLCLS CMysqlRecord
{
	friend class CMysqlRecordSet;

public:
	~CMysqlRecord();

	const char*	getFieldValue	( uint index ) const {
		if( index < _values.size() )
			return _values[index].c_str();
		else
			return NULL;
	}

protected:
	CMysqlRecord();

	bool initRecord	( MYSQL_ROW row, ulong fieldnum );

private:
	std::vector<std::string>	_values;
};

#endif // __mysql_record_h__


mysql_connection_pool.cpp

#define DLLEXPORT
#include "../include/mysql_connection_pool.h"
#include "../include/mysql_connection.h"

CMysqlConnectionPool::CMysqlConnectionPool( const std::string& username, const std::string& password, 
	const std::string& dbname, const std::string& host /* = DEFAULT_HOST */, ushort port /* = DEFAULT_PORT */,
	const std::string& encoding /* = DEFAULT_ENCODING */ )
	: _username( username )
	, _password( password )
	, _dbname( dbname )
	, _host( host )
	, _port( port )
	, _encoding( encoding )
	, _connection_num( 0 )
	, _semaphore( NULL )
{
	InitializeCriticalSection( &_cs );
}

CMysqlConnectionPool::~CMysqlConnectionPool()
{
	clearConnections();

	DeleteCriticalSection( &_cs );

	if( NULL != _semaphore ) {
		CloseHandle( _semaphore );
		_semaphore = NULL;
	}
}

bool CMysqlConnectionPool::initConnections( ushort num /* = DEFAULT_CONN_NUM */ )
{
	if( 0 == num )
		return false;
	
	_semaphore = CreateSemaphore( NULL, num, num, NULL );
	if( NULL == _semaphore )
		return false;

	for( int i = 0; i < num; i++ ) {
		if( !addConnection() ) {
			clearConnections();
			return false;
		}
	}

	_connection_num = num;
	return true;
}

CMysqlConnection* CMysqlConnectionPool::getConnection()
{
	if( _connections.empty() )
		return NULL;

	CMysqlConnection *ret = NULL;

	if( WAIT_OBJECT_0 == WaitForSingleObject(_semaphore, DEFAULT_TIMEOUT) ) {
		EnterCriticalSection( &_cs );
		ret = _connections.front();
		_connections.erase( _connections.begin() );
		LeaveCriticalSection( &_cs );
	}
	
	return ret;
}

void CMysqlConnectionPool::putConnection( CMysqlConnection* connection )
{
	if( NULL == connection )
		return;

	EnterCriticalSection( &_cs );
	_connections.push_back( connection );
	LeaveCriticalSection( &_cs );

	ReleaseSemaphore( _semaphore, 1, NULL );
}

bool CMysqlConnectionPool::addConnection()
{
	MYSQL *mysql = mysql_init( NULL );
	if( NULL == mysql )
		return false;

	my_bool reconn = 1;
	if( mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconn) ) {
		mysql_close( mysql );
		return false;
	}

	if( !mysql_real_connect(mysql, _host.c_str(), _username.c_str(), _password.c_str(), _dbname.c_str(), _port,
		NULL, 0) ) {
			mysql_close( mysql );
			return false;
	}

	if( mysql_set_character_set(mysql, _encoding.c_str()) ) {
		mysql_close( mysql );
		return false;
	}

	CMysqlConnection *connection = new CMysqlConnection( mysql );
	if( NULL == connection )
		return false;

	EnterCriticalSection( &_cs );
	_connections.push_back( connection );
	LeaveCriticalSection( &_cs );

	return true;
}

void CMysqlConnectionPool::clearConnections()
{
	EnterCriticalSection( &_cs );
	std::vector<CMysqlConnection*>::iterator iter = _connections.begin();
	while( iter != _connections.end() ) {
		delete (*iter);
		iter++;
	}
	_connections.clear();
	LeaveCriticalSection( &_cs );
}


mysql_connection.cpp

#define DLLEXPORT
#include "../include/mysql_connection.h"
#include "../include/mysql_record_set.h"

CMysqlConnection::CMysqlConnection( MYSQL *mysql )
	: _mysql( mysql )
{
}

CMysqlConnection::~CMysqlConnection()
{
	if( NULL != _mysql ) {
		mysql_close( _mysql );
		_mysql = NULL;
	}
}

CMysqlRecordSet* CMysqlConnection::executeQuery( const std::string& sql )
{
	if( NULL == _mysql || sql.empty() )
		return NULL;

	if( 0 != mysql_real_query(_mysql, sql.c_str(), sql.size()) )
		return NULL;

	MYSQL_RES* res = mysql_store_result( _mysql );
	if( NULL == res )
		return NULL;
	
	CMysqlRecordSet *p = new CMysqlRecordSet;
	if( p->initRecordSet(res) )
		return p;
	else {
		delete p;
		return NULL;
	}
}

bool CMysqlConnection::executeNonQuery( const std::string& sql )
{
	if( NULL == _mysql || sql.empty() )
		return false;

	if( 0 == mysql_real_query(_mysql, sql.c_str(), sql.size()) )
		return true;
	else
		return false;
}

int CMysqlConnection::errorNum() const
{
	if( NULL == _mysql )
		return -1;
	else
		return mysql_errno( _mysql );
}

const char* CMysqlConnection::errorString() const
{
	if( NULL == _mysql )
		return NULL;
	else
		return mysql_error( _mysql );
}


mysql_record_set.cpp

#define DLLEXPORT
#include "../include/mysql_record_set.h"
#include "../include/mysql_record.h"

CMysqlRecordSet::CMysqlRecordSet()
	: _field_num( 0 )
	, _row_num( 0 )
{
}

CMysqlRecordSet::~CMysqlRecordSet()
{
	_field_num	= 0;
	_row_num	= 0;

	_fields.clear();

	std::vector<CMysqlRecord*>::iterator iter = _records.begin();
	while( iter != _records.end() ) {
		delete (*iter);
		iter++;
	}
	_records.clear();
}

bool CMysqlRecordSet::initRecordSet( MYSQL_RES *res )
{
	if( NULL == res )
		return false;

	MYSQL_FIELD	*field = NULL;
	while( NULL != (field = mysql_fetch_field(res)) ) {
		_fields.push_back( field->name );
		_field_num++;
	}

	MYSQL_ROW row = NULL;
	while( NULL != (row = mysql_fetch_row(res)) ) {
		CMysqlRecord *record = new CMysqlRecord;
		if( record->initRecord(row, _field_num) ) {
			_records.push_back( record );
			_row_num++;
		}
		else
			delete record;
	}

	mysql_free_result( res );
	return true;
}


mysql_record.cpp

#define DLLEXPORT
#include "../include/mysql_record.h"

CMysqlRecord::CMysqlRecord()
{
}

CMysqlRecord::~CMysqlRecord()
{
	_values.clear();
}

bool CMysqlRecord::initRecord( MYSQL_ROW row, ulong fieldnum )
{
	if( NULL == row )
		return false;

	ulong i = 0;
	while( i < fieldnum ) {
		_values.push_back( row[i] );
		i++;
	}

	return true;
}


测试程序：

#include "../include/mysql_connection_pool.h"
#include "../include/mysql_connection.h"
#include "../include/mysql_record_set.h"
#include "../include/mysql_record.h"

#pragma comment( lib, "../bin/mysql_cpp.lib" )

void executeQuery( CMysqlConnection *connection, const char *sql )
{
	int records_num	= 0;
	int fields_num	= 0;

	printf( "%s\n", sql );
	CMysqlRecordSet *recordset = connection->executeQuery( sql );
	if( NULL != recordset ) {
		records_num = recordset->getRecordsNum();
		fields_num	= recordset->getFieldsNum();
		printf( "records num = %d\n", records_num );
		printf( "fields num = %d\n", fields_num );

		for( int i = 0; i < fields_num; i++ )
			printf( "field %d is %s\n", i+1, recordset->getFieldName(i) );

		for( int i = 0; i < records_num; i++ ) {
			printf( "record %d: ", i+1 );
			CMysqlRecord *record = recordset->getRecord( i );
			for( int j = 0; j < fields_num; j++ )
				printf( "(%s)", record->getFieldValue(j) );
			printf( "\n" );
		}

		delete recordset;
	}

	printf( "\n\n" );
}

int main( void )
{
	const char *sql1 = "SELECT * FROM table1";
	const char *sql2 = "SELECT * FROM table2 WHERE id>'5'";
	const char *sql3 = "SELECT name,timestamp FROM table3 WHERE timestamp>'2011-10-19 08:45:47'";
	const char *sql4 = "INSERT INTO table2(name) VALUES('testname1'),('testname2')";
	const char *sql5 = "INSERT INTO table3(name) VALUES('nametest1'),('nametest2')";

	CMysqlConnectionPool *pool = new CMysqlConnectionPool( "root", "123456", "testdb1" );
	if( NULL == pool )
		return 1;

	pool->initConnections();

	CMysqlConnection *connection = pool->getConnection();
	if( NULL == connection )
		return NULL;

	executeQuery( connection, sql1 );
	executeQuery( connection, sql2 );
	executeQuery( connection, sql3 );

	if( connection->executeNonQuery(sql4) )
		printf( "%s\n\n\n", sql4 );
	if( connection->executeNonQuery(sql5) )
		printf( "%s\n\n\n", sql5 );

	executeQuery( connection, sql2 );
	executeQuery( connection, sql3 );

	pool->putConnection( connection );
	delete pool;
	return 0;
}

/*
SELECT * FROM table1
records num = 8
fields num = 2
field 1 is id
field 2 is name
record 1: (1)(haha)
record 2: (2)(hehe)
record 3: (3)(haha)
record 4: (4)(hehe)
record 5: (5)(haha)
record 6: (6)(hehe)
record 7: (7)(haha)
record 8: (8)(hehe)


SELECT * FROM table2 WHERE id>'5'
records num = 8
fields num = 3
field 1 is id
field 2 is name
field 3 is timestamp
record 1: (6)(hehe)(2011-10-18 13:32:12)
record 2: (7)(haha)(2011-10-18 13:32:13)
record 3: (8)(hehe)(2011-10-18 13:32:13)
record 4: (9)(haha)(2011-10-27 09:41:37)
record 5: (10)(testname1)(2011-11-18 15:21:18)
record 6: (11)(testname2)(2011-11-18 15:21:18)
record 7: (12)(testname1)(2011-11-18 15:21:57)
record 8: (13)(testname2)(2011-11-18 15:21:57)


SELECT name,timestamp FROM table3 WHERE timestamp>'2011-10-19 08:45:47'
records num = 4
fields num = 2
field 1 is name
field 2 is timestamp
record 1: (nametest1)(2011-11-18 15:21:18)
record 2: (nametest2)(2011-11-18 15:21:18)
record 3: (nametest1)(2011-11-18 15:21:57)
record 4: (nametest2)(2011-11-18 15:21:57)


INSERT INTO table2(name) VALUES('testname1'),('testname2')


INSERT INTO table3(name) VALUES('nametest1'),('nametest2')


SELECT * FROM table2 WHERE id>'5'
records num = 10
fields num = 3
field 1 is id
field 2 is name
field 3 is timestamp
record 1: (6)(hehe)(2011-10-18 13:32:12)
record 2: (7)(haha)(2011-10-18 13:32:13)
record 3: (8)(hehe)(2011-10-18 13:32:13)
record 4: (9)(haha)(2011-10-27 09:41:37)
record 5: (10)(testname1)(2011-11-18 15:21:18)
record 6: (11)(testname2)(2011-11-18 15:21:18)
record 7: (12)(testname1)(2011-11-18 15:21:57)
record 8: (13)(testname2)(2011-11-18 15:21:57)
record 9: (14)(testname1)(2011-11-18 15:22:45)
record 10: (15)(testname2)(2011-11-18 15:22:45)


SELECT name,timestamp FROM table3 WHERE timestamp>'2011-10-19 08:45:47'
records num = 6
fields num = 2
field 1 is name
field 2 is timestamp
record 1: (nametest1)(2011-11-18 15:21:18)
record 2: (nametest2)(2011-11-18 15:21:18)
record 3: (nametest1)(2011-11-18 15:21:57)
record 4: (nametest2)(2011-11-18 15:21:57)
record 5: (nametest1)(2011-11-18 15:22:45)
record 6: (nametest2)(2011-11-18 15:22:45)


请按任意键继续. . .
*/


 

kusey
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
crecordset连接mysql_利用支持ODBC的CRecordset类实现对数据库的操作 | 学步园
weixin_42471823的博客
01-19 474
1.MFC中的ODBC类主要有CDatabase、CRecordset、CRecordview、CDBException、CFieldExchange。这些类封装了ODBCSDK函数，可以很方便的操作支持ODBC的数据库。(1)CDatabase类：封装应用程序与需要访问的数据库之间的连接，控制事务的提交和执行SQL语句的方法。(2)CRecordset类：封装大部分操纵数据库的方法，包括浏览、修...
Mysql数据库学习（四）：常用Mysql C API 介绍和使用、封装一个访问Mysql数据库的类MysqlDB
Meditation
02-28 4167
首先，环境是windows +  vs2008，Mysql数据库已经安装好，在使用之前，需要配置工程属性，附加包含目录添加 D:\Program Files\MySQL\MySQL Server 5.6\include （Mysql安装目录），附加库目录添加 D:\Program Files\MySQL\MySQL Server 5.6\lib   ，附加依赖项添加 mysqlib.lib，当然
VC++学习-数据库篇（记录集recordset常用操作代码）
深蓝
04-10 3513
一、ASP连接Access数据库： dim conn,mdbfile mdbfile=server.mappath("数据库名称.mdb") set conn=server.createobject("adodb.connection") conn.open "driver={microsoft access driver(*.mdb)};uid=admin;pwd=数据库密码;dbq="&amp...
MySQL-C++封装类
代码人生
01-24 9295
MySQL-C++封装类
Qt中使用MySQL数据库详解，好用的模块类封装
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
07-02 1299
本文将详细介绍如何在Qt应用程序中集成MySQL数据库，并封装实现好用的模块类。包括环境准备、连接数据库、执行查询及异常处理等关键步骤。Qt提供了QtSql模块来进行独立于平台的数据库操作，这里的“平台”既包括操作系统平台，也包括各个数据库平台。Qt使用一个QDatabase表示一个数据库连接，在底层，Qt使用不同的驱动程序来与不同的数据库API进行交互。通常，Qt只默认搭载了QSqlLite驱动程序，如果需要使用其他数据库，需要下载相应的数据库驱动，如mysql的为 libmysql.dll。
MySQL8.0在windows下的下载安装及详细使用
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
07-07 1691
MySQL8.0默认指定使用需要SSL的身份验证插件caching_sha2_password，而我们在创建账号时候没有指定REQUIRE SSL。为了降低这件事情的复杂性，我们选择了绕过SSL插件的验证，改为mysql_native_password验证来登陆即可。注：如果已配置MySQL环境变量，可以在任意路径下进行，不必转到bin目录下。2、下转到MySQL的bin目录下，跳过MySQL密码验证。通过这些步骤，在MySQL中创建新用户并赋予相应的权限。提示输入密码，不用管，直接回车确认即可。
详细介绍windows环境下搭建MySQL
guye
04-11 2749
主要介绍windows环境下的mysql的下载，安装，配置。mysql的登录和图形化管理工具的下载安装和使用。MySQL的目录结构与源代码，最后一些常见问题和解决方案
C# MySQL封装操作类
热门推荐
Lee的博客
04-18 1万+
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Data; using System.Configuration; using System.Windows.Forms; using MySql.Data.MySqlClient; using Sy
C#操作mysql数据库的封装类（封装函数方法）
美奇软件开发工作室
01-06 4290
前言： C#操作mysql需要添加相应版本的MySql.Data.dll引用（.NET4.0就引入.NET4.0版本的MySql.Data.dll），不会的可以看我的另一篇文章：https://blog.csdn.net/qq15577969/article/details/79518731 .NET4.0版本的MySql.Data.dll下载地址：https://download.csdn...
mysql封装类
04-03
MySQL封装类是面向对象编程中对MySQL数据库操作的一种抽象，旨在简化数据库的连接、查询、事务处理等操作。在C++编程中，这样的封装通常包括一个或多个类，如`Mysql`，它包含了与MySQL数据库交互所需的方法。在本...
MySql封装类
09-13
MySQL封装类是为了方便C++开发者在Linux和Windows操作系统下与MySQL数据库进行交互而设计的。这类封装通常会提供一套简洁的API，使得开发者无需直接处理MySQL的C API，而是通过更高级别的接口来执行SQL查询、操作...
windows关于qt的数据库操作封装类以及用例，c++代码
08-08
windows 关于qt的数据库操作封装类 以及用例： SQLite，是一款轻型的数据库，是遵守ACID的关系型数据库管理系统，它包含在一个相对小的C库中。它的功能特点有： 1. ACID事务 2. 零配置 – 无需安装和管理配置 3....
C++ 封装的MYSQL 类
08-20
一个简单的C++ MYSQL封装类可能会包含以下关键组成部分： 1. **构造函数和析构函数**：构造函数用于初始化类实例，例如设置数据库连接参数（如主机名、用户名、密码、数据库名）。析构函数则负责关闭数据库连接。 ...
MFC封装 MySQL
02-24
在IT领域，MFC（Microsoft Foundation Classes）是微软提供的一套C++库，用于构建Windows应用程序。...总的来说，MFC与MySQL的结合为Windows平台上的数据库应用开发提供了一个强大而便捷的解决方案。
C++一个支持Sqlite3和MySQL的数据库封装，支持跨平台（Window和Linux）
Where there is life, there is hope.
07-16 1327
DatabaseLayer 是一个支持 SQLite3 和 MySQL 的数据库封装工具，同时支持跨平台（Windows 和 Linux）。该工具的设计灵感来源于 CppSQLite 和 POCO 中的数据库实现。
SqlServer触发器
reaL's Blog
03-24 684
SqlServer 数据库的一个简单的触发器例子，做个记录。
SpringBoot依赖之Quartz Scheduler定时调度器使用MySQL存储Job
最新发布
ahauedu的专栏
08-07 565
接上一篇。本篇将在 Spring Boot 项目中，使用 Quartz Scheduler 结合 MySQL 数据库来存储 Job。
ADO封装数据库类详解与应用示例
"本文档是关于使用ADO封装类进行数据库程序开发的实例，作者在第一版的基础上进行了完善，增加了更多功能，如文件和图片的存取、字段智能转换等。虽然对command类的测试不足，但对connection和recordset类进行了充分...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值