数据库MySql类库系列(一)-DBOperator

最新推荐文章于 2024-04-25 10:10:30 发布
最新推荐文章于 2024-04-25 10:10:30 发布
阅读量3.6k 收藏 4
点赞数
分类专栏： 数据库类库 文章标签： 数据库 mysql c api
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zilaishuichina/article/details/60578783
版权

第二个库：libdb，封装了MySql的c api


第一个工具类：DBOperator，比较纯粹的，就是封装MySql的c api

主要是为了提供一些更友好一些的接口，供上层逻辑使用

封装了出错时的错误信息输出到log（log使用的是之前工具类库中的Logger）


提供两类接口：

1、直接执行sql的方式：

直接执行sql的方式就是，每次都需要进行字符串拼接，

用每一个字段的值，想要进行的操作，拼接一个完整的sql语句。

拼接之后，交给mysql。

mysql收到sql字符串之后，需要先对字符串进行解析，再执行。


2、预处理sql的方式：

预处理sql的方式就是，先将sql语句中字段的值，以变量的形式（用一个问号'?'表示），先占位，组成一个带占位符的sql语句，

然后就交给mysql去解析字符串。

在此之后的每次执行，不需要再次对sql字符串做解析，只需要对变量赋值，就可以执行得出结果。


一般推荐都是采用第二种方式。


提供的主要功能：

功能说明对应封装的c api
1、建立，断开数据库连接mysql_real_connect，mysql_close
2、维持数据库链接心跳mysql_ping
3、直接执行sql(1)、执行sql语句mysql_real_query
(2)、执行sql之后，如果是查询，获取结果集mysql_store_result
(3)、获取结果集之后，获取结果集的列数mysql_num_fields
(4)、获取结果集之后，获取其中一条结果数据（数据以字符串数组的形式表现）mysql_fetch_row
(5)、获取一条结果数据之后，获取每一列的数据长度（字符串形式的长度）mysql_fetch_lengths
(6)、拼接sql语句时，执行sql之前，如有必要，对sql字符串进行安全转换，防止sql注入mysql_real_escape_string
4、预处理sql(1)、预处理sql语句，得到预处理句柄（以下预处理相关的操作，将都在这个句柄上执行）mysql_stmt_init，mysql_stmt_prepare
(2)、绑定sql语句的参数（参数一般就是sql语句中where后面跟的那些字段）mysql_stmt_bind_param
(3)、绑定sql语句的查询结果（查询结果就是select ... from，select的那些字段）mysql_stmt_bind_result
(4)、具体绑定某一类型的值（由于本人的业务需要，目前仅提供支持7种数据类型：int，unsigned int，long long，unsigned long long，float，字符串，Blob）MYSQL_BIND结构赋值
(5)、真实执行预处理sql，得到结果mysql_stmt_execute
(6)、执行sql之后，如果是查询，获取结果集mysql_stmt_result_metadata，mysql_stmt_store_result
(7)、获取结果集之后，获取其中一条结果数据（数据将直接返回到（4）中绑定的对应内存中）mysql_stmt_fetch
(8)、关闭，释放预处理句柄mysql_stmt_close
(9)、预处理方式的获取错误信息mysql_stmt_errno，mysql_stmt_error
5、获取结果集之后，释放结果集（以上两种方式通用）mysql_free_result
6、在数据库连接上获取错误信息mysql_errno，mysql_error

上代码：

DBOperator.h

#ifndef __DBOperator_h__
#define	__DBOperator_h__

struct st_mysql;
typedef struct st_mysql MYSQL;
struct st_mysql_stmt;
typedef struct st_mysql_stmt MYSQL_STMT;
struct st_mysql_bind;
typedef struct st_mysql_bind MYSQL_BIND;
struct st_mysql_res;
typedef struct st_mysql_res MYSQL_RES;
typedef char** MYSQL_ROW;

namespace common{
	namespace db{

		class DBOperator
		{
		public:
			DBOperator();
			~DBOperator();

			//获取错误信息
			static void GetErrorInfo(MYSQL* mysql);
			static void GetStmtErrorInfo(MYSQL_STMT* stmt);

			//连接数据库
			static MYSQL* Connect(const char *host,
				unsigned int port,
				const char *user,
				const char *passwd,
				const char *db,
				const char *charset = "utf8");

			//断开连接
			static void DisConnect(MYSQL* mysql);

			//ping
			static bool Ping(MYSQL* mysql);

			/直接执行SQL的方式/
			//转换sql字符
			static bool MakeSafeStr(MYSQL* mysql, char *to, int toLen, const char *from, int fromLen);

			//执行sql
			static bool ExecQuery(MYSQL* mysql, const char *sql);

			//查询/获取查询结果集
			static MYSQL_RES* SelectResult(MYSQL* mysql);
			static MYSQL_ROW GetNextResult(MYSQL_RES* res);
			
			//获取结果集的列数
			static unsigned int GetResultFields(MYSQL_RES* res);

			//获取结果集的每个字段的（字符串形式的）长度
			static unsigned long* GetResultLens(MYSQL_RES* res);

			//释放结果集（预处理方式下通用）
			static void FreeResult(MYSQL_RES* pRes);

			/预处理执行SQL的方式/
			//预处理句柄
			static MYSQL_STMT* ExecPrepare(MYSQL* mysql, const char *sql);

			//绑定字段
			static bool BindInt(MYSQL_STMT* stmt, MYSQL_BIND* bind, int *value);
			static bool BindUInt(MYSQL_STMT* stmt, MYSQL_BIND* bind, unsigned int *value);
			static bool BindInt64(MYSQL_STMT* stmt, MYSQL_BIND* bind, long long *value);
			static bool BindUInt64(MYSQL_STMT* stmt, MYSQL_BIND* bind, unsigned long long *value);
			static bool BindFloat(MYSQL_STMT* stmt, MYSQL_BIND* bind, float *value);
			static bool BindString(MYSQL_STMT* stmt, MYSQL_BIND* bind, char *value, unsigned long *len);
			static bool BindBlob(MYSQL_STMT* stmt, MYSQL_BIND* bind, void *value, unsigned long *len);

			//绑定参数/结果
			static bool BindResultStmt(MYSQL_STMT* stmt, MYSQL_BIND* bind);
			static bool BindParameterStmt(MYSQL_STMT* stmt, MYSQL_BIND* bind);

			//执行预处理sql
			static bool ExecStmt(MYSQL_STMT* stmt);

			//查询/获取查询结果
			static MYSQL_RES* SelectResult(MYSQL_STMT* stmt);
			static bool GetNextResult(MYSQL_STMT* stmt);

			//关闭预处理句柄
			static bool FreeStmt(MYSQL_STMT* stmt);
		};

	}
}

#endif

DBOperator.cpp 

#include "DBOperator.h"

#ifdef WIN32
#include <winsock2.h>
#endif
#include <stdio.h>
#include <mysql.h>
#include <string.h>

#include "Logger.h"

using namespace common::tool;

#include "DBDefine.h"

namespace common{
	namespace db{

		DBOperator::DBOperator()
		{

		}

		DBOperator::~DBOperator()
		{

		}

		void DBOperator::GetErrorInfo(MYSQL* mysql)
		{
			LOG_INFO(g_LibDBLog) << "error : " << mysql_errno(mysql) << ", " << mysql_error(mysql);
		}

		void DBOperator::GetStmtErrorInfo(MYSQL_STMT* stmt)
		{
			LOG_INFO(g_LibDBLog) << "error : " << mysql_stmt_errno(stmt) << ", " << mysql_stmt_error(stmt);
		}

		//申请数据源的连接
		MYSQL* DBOperator::Connect(const char *host,
			unsigned int port,
			const char *user,
			const char *passwd,
			const char *db,
			const char *charset)
		{
			MYSQL* mysql = mysql_init(NULL);
			if (NULL != mysql)
			{
				mysql_options(mysql, MYSQL_SET_CHARSET_NAME, charset);

				mysql = mysql_real_connect(mysql, host, user, passwd, db, port, NULL, 0);
				if (NULL != mysql)
				{
					return mysql;
				}
				else
				{
					GetErrorInfo(mysql);
					return NULL;
				}
			}
			else
			{
				GetErrorInfo(mysql);
				return NULL;
			}
		}

		void DBOperator::DisConnect(MYSQL* mysql)
		{
			if (NULL != mysql)
			{
				mysql_close(mysql);
			}
		}

		bool DBOperator::Ping(MYSQL* mysql)
		{
			if (NULL != mysql)
			{
				if (0 == mysql_ping(mysql))
				{
					return true;
				}
				else
				{
					GetErrorInfo(mysql);
					return false;
				}
			}
			else
			{
				return false;
			}
		}

		bool DBOperator::MakeSafeStr(MYSQL* mysql, char *to, int toLen, const char *from, int fromLen)
		{
			if (NULL != mysql)
			{
				memset(to, 0x00, sizeof(char)* toLen);
				if (0 != mysql_real_escape_string(mysql, to, from, fromLen))
				{
					return true;
				}
				else
				{
					GetErrorInfo(mysql);
					return false;
				}
			}
			else
			{
				return false;
			}
		}

		bool DBOperator::ExecQuery(MYSQL* mysql, const char *sql)
		{
			if (NULL != mysql && NULL != sql)
			{
				if (0 == mysql_real_query(mysql, sql, strlen(sql)))
				{
					return true;
				}
				else
				{
					GetErrorInfo(mysql);
					return false;
				}
			}
			else
			{
				return false;
			}
		}

		MYSQL_RES* DBOperator::SelectResult(MYSQL* mysql)
		{
			if (NULL != mysql)
			{
				return mysql_store_result(mysql);
			}
			else
			{
				return NULL;
			}
		}

		MYSQL_ROW DBOperator::GetNextResult(MYSQL_RES* res)
		{
			if (NULL != res)
			{
				return mysql_fetch_row(res);
			}
			else
			{
				return NULL;
			}
		}

		unsigned int DBOperator::GetResultFields(MYSQL_RES* res)
		{
			if (NULL != res)
			{
				return mysql_num_fields(res);
			}
			else
			{
				return 0;
			}
		}

		unsigned long* DBOperator::GetResultLens(MYSQL_RES* res)
		{
			if (NULL != res)
			{
				return mysql_fetch_lengths(res);
			}
			else
			{
				return NULL;
			}
		}

		void DBOperator::FreeResult(MYSQL_RES* res)
		{
			if (NULL != res)
			{
				mysql_free_result(res);
			}
		}

		MYSQL_STMT* DBOperator::ExecPrepare(MYSQL* mysql, const char *sql)
		{
			if (NULL != mysql)
			{
				MYSQL_STMT* stmt = mysql_stmt_init(mysql);
				if (NULL != stmt)
				{
					if (0 == mysql_stmt_prepare(stmt, sql, strlen(sql)))
					{
						return stmt;
					}
					else
					{
						GetStmtErrorInfo(stmt);
						return NULL;
					}
				}
				else
				{
					GetErrorInfo(mysql);
					return NULL;
				}
			}
			else
			{
				return NULL;
			}
		}

		bool DBOperator::BindInt(MYSQL_STMT* stmt, MYSQL_BIND* bind, int *value)
		{
			if (NULL != stmt && NULL != bind && NULL != value)
			{
				memset(bind, 0, sizeof(MYSQL_BIND));
				bind->buffer_type = MYSQL_TYPE_LONG;
				bind->buffer = (char *)value;
				bind->is_unsigned = false;

				return true;
			}
			else
			{
				return false;
			}
		}

		bool DBOperator::BindUInt(MYSQL_STMT* stmt, MYSQL_BIND* bind, unsigned int *value)
		{
			if (NULL != stmt && NULL != bind && NULL != value)
			{
				memset(bind, 0, sizeof(MYSQL_BIND));
				bind->buffer_type = MYSQL_TYPE_LONG;
				bind->buffer = (char *)value;
				bind->is_unsigned = true;

				return true;
			}
			else
			{
				return false;
			}
		}

		bool DBOperator::BindInt64(MYSQL_STMT* stmt, MYSQL_BIND* bind, long long *value)
		{
			if (NULL != stmt && NULL != bind && NULL != value)
			{
				memset(bind, 0, sizeof(MYSQL_BIND));
				bind->buffer_type = MYSQL_TYPE_LONGLONG;
				bind->buffer = (char *)value;
				bind->is_unsigned = false;

				return true;
			}
			else
			{
				return false;
			}
		}

		bool DBOperator::BindUInt64(MYSQL_STMT* stmt, MYSQL_BIND* bind, unsigned long long *value)
		{
			if (NULL != stmt && NULL != bind && NULL != value)
			{
				memset(bind, 0, sizeof(MYSQL_BIND));
				bind->buffer_type = MYSQL_TYPE_LONGLONG;
				bind->buffer = (char *)value;
				bind->is_unsigned = true;

				return true;
			}
			else
			{
				return false;
			}
		}

		bool DBOperator::BindFloat(MYSQL_STMT* stmt, MYSQL_BIND* bind, float *value)
		{
			if (NULL != stmt && NULL != bind && NULL != value)
			{
				memset(bind, 0, sizeof(MYSQL_BIND));
				bind->buffer_type = MYSQL_TYPE_FLOAT;
				bind->buffer = (char *)value;

				return true;
			}
			else
			{
				return false;
			}
		}
		
		bool DBOperator::BindString(MYSQL_STMT* stmt, MYSQL_BIND* bind, char *value, unsigned long *len)
		{
			if (NULL != stmt && NULL != bind && NULL != value && NULL != len)
			{
				memset(bind, 0, sizeof(MYSQL_BIND));
				bind->buffer_type = MYSQL_TYPE_STRING;
				bind->buffer = (char *)value;
				bind->buffer_length = *len;
				bind->length = len;

				return true;
			}
			else
			{
				return false;
			}
		}

		bool DBOperator::BindBlob(MYSQL_STMT* stmt, MYSQL_BIND* bind, void *value, unsigned long *len)
		{
			if (NULL != stmt && NULL != bind && NULL != value && NULL != len)
			{
				memset(bind, 0, sizeof(MYSQL_BIND));
				bind->buffer_type = MYSQL_TYPE_BLOB;
				bind->buffer = (char *)value;
				bind->buffer_length = *len;
				bind->length = len;

				return true;
			}
			else
			{
				return false;
			}
		}

		bool DBOperator::BindParameterStmt(MYSQL_STMT* stmt, MYSQL_BIND* bind)
		{
			if (NULL != stmt && NULL != bind)
			{
				if (0 == mysql_stmt_bind_param(stmt, bind))
				{
					return true;
				}
				else
				{
					GetStmtErrorInfo(stmt);
					return false;
				}
			}
			else
			{
				return false;
			}
		}

		bool DBOperator::BindResultStmt(MYSQL_STMT* stmt, MYSQL_BIND* bind)
		{
			if (NULL != stmt && NULL != bind)
			{
				if (0 == mysql_stmt_bind_result(stmt, bind))
				{
					return true;
				}
				else
				{
					GetStmtErrorInfo(stmt);
					return false;
				}
			}
			else
			{
				return false;
			}
		}

		bool DBOperator::ExecStmt(MYSQL_STMT* stmt)
		{
			if (NULL != stmt)
			{
				if (0 == mysql_stmt_execute(stmt))
				{
					return true;
				}
				else
				{
					GetStmtErrorInfo(stmt);
					return false;
				}
			}
			else
			{
				return false;
			}
		}

		MYSQL_RES* DBOperator::SelectResult(MYSQL_STMT* stmt)
		{
			if (NULL != stmt)
			{
				MYSQL_RES* res = mysql_stmt_result_metadata(stmt);
				if (NULL != res)
				{
					if (0 == mysql_stmt_store_result(stmt))
					{
						return res;
					}
					else
					{
						GetStmtErrorInfo(stmt);
						return NULL;
					}
				}
				else
				{
					return NULL;
				}
			}
			else
			{
				return NULL;
			}
		}

		bool DBOperator::GetNextResult(MYSQL_STMT* stmt)
		{
			if (NULL != stmt)
			{
				if (0 == mysql_stmt_fetch(stmt))
				{
					return true;
				}
				else
				{
					return false;
				}
			}
			else
			{
				return false;
			}
		}

		bool DBOperator::FreeStmt(MYSQL_STMT* stmt)
		{
			if (NULL != stmt)
			{
				if (0 == mysql_stmt_close(stmt))
				{
					return true;
				}
				else
				{
					GetStmtErrorInfo(stmt);
					return false;
				}
			}
			else
			{
				return false;
			}
		}

	}
}


DBDefine.h

#ifndef __DBDefine_h__
#define __DBDefine_h__

namespace common{
	namespace tool{
		class Logger;
	}
}
//libdb专用log
extern common::tool::Logger g_LibDBLog;

#endif

DBDefine.cpp 

#include "DBDefine.h"

#include "Logger.h"

using namespace common::tool;

//libdb专用log
Logger g_LibDBLog("LibDB");


zilaishuichina
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
DBOperator数据连接
11-09
DBOperator 数据库连接，很好用。
推荐开源项目：MySQL-Operator - 高效管理MySQL集群的Kubernetes Operator
gitblog_00099的博客
04-10 408
推荐开源项目：MySQL-Operator - 高效管理MySQL集群的Kubernetes Operator 项目地址:https://gitcode.com/presslabs/mysql-operator 项目简介 MySQL-Operator 是由Presslabs开发的一个Kubernetes Operator，它旨在简化在Kubernetes环境中部署和管理MySQL集群的过程。通过声...
探索MySQL Operator：自动化数据库管理的新利器
最新发布
gitblog_00051的博客
04-25 409
探索MySQL Operator：自动化数据库管理的新利器 项目地址:https://gitcode.com/mysql/mysql-operator 项目简介 MySQL Operator 是一个由 MySQL 团队开发的 Kubernetes 插件，旨在简化在 Kubernetes 环境中部署、管理和扩展 MySQL 数据库的过程。通过 Operator 设计模式，它将传统的 MySQL 配置...
mysql c api的函数mysql_stmt_bind_param(stmt, bind)的返回值问题
kmx2020的博客
12-10 1302
https://dev.mysql.com/doc/c-api/5.7/en/mysql-stmt-execute.html 官方示例（链接） 示例里给出的用法是 if (mysql_stmt_bind_param(stmt, bind)) { fprintf(stderr, " mysql_stmt_bind_param() failed\n"); fprintf(stderr, " %s\n", mysql_stmt_error(stmt)); exit(0); } 似乎表明该函数如果正常运行返回值.
MySQL - C语言接口-预处理语句
wu_zhiyuan的博客
04-20 1405
版权声明：本文为CSDN博主「zhouxinfeng」的原创文章，原文链接：https://blog.csdn.net/zhouxinfeng/article/details/77891771。
bind mysql_bind支持mysql
weixin_30296995的博客
01-18 220
最近打算将bind的记录信息存入到数据库中去，网上找了下，原来早有老外写好了mysql-bind的补丁，重新编译bind即可实现bind支持mysql存储。(http://mysql-bind.sourceforge.net/)按照官方的做法是行不通的，有个小地方要修改下，下文中会提到。环境centos5.2yum install mysql*装完mysql。下载mysql-bind补丁，goog...
MYSQL_BIND结构体,Gin 使用示例（三十六）：绑定请求实体到不同结构体
weixin_32216791的博客
03-23 417
Gin 使用示例(三十六)：绑定请求实体到不同结构体由 学院君 创建于7个月前, 最后更新于 7个月前版本号 #1601 views0 likes0 collects通常使用 ShouldBind 绑定请求实体，底层使用的是 c.Request.Body：package mainimport ("github.com/gin-gonic/gin""net/http")type formA stru...
MySQL基础语法使用教程
小宝的博客
12-14 6468
MySQL 使用方法简单教程 目录 MySQL 使用方法简单教程 1 1、启动MySQL服务器 1 2、进入mysql交互操作界面 1 3、退出MySQL操作界面 1 4、第一条命令 1 5、多行语句 2 6、使用SHOW语句找出在服务器上当前存在什么数据库： 2 7、创建一个数据库abccs 2 8、选择你所创建的数据库 3 9、 创建一个数据库表 3 10、显示表的结构： 3 11、查询所有数据： 4 12、修正错误记录： 4 14、 多表操作 5 1、查看第一个表mytable的内容： 5 2、创建第
通用数据库访问工具类(2012-08-01)
08-01
//默认数据库(第一个配置) //idb = DBOperator.GetInstance("da3"); //切换数据库 string sqlAccess = @"SELECT * FROM tuser"; dataGridView1.DataSource =idb.ReturnDataTable(sqlAccess);
VC++ ODBCApiDataManager数据库管理
03-15
摘要:VC/C++源码,数据库应用,数据库管理 VC++ ODBCApiDataManager数据库管理源码，1、数据库的自动创建，并初步实现了用户登录登录模块 　2、左边上下滑动窗口的初步实现。使用有ButtonST、CListCtrlEx、ControlBar...
通用数据访问工具类库
08-03
//默认数据库(第一个配置) idb = DBOperator.GetInstance("da3"); //切换数据库 如果你需要 //idb = DBOperator.GetInstance("da4");//切换数据库 string sqlAccess = @"SELECT * FROM tuser"; dataGridView1....
C#通用数据库访问类 常用6种数据库VS2008
06-27
通用数据库访问类 通过配置 可实现不同数据库的的访问&def目前实现了SQLserver&def Oracle&def DataAccess <!--在配置文件中加如下--> <?xml version="1.0" encoding="utf-8" ?> <!-- 连接字符串 --> ;...
.NET通用数据库访问类(支持存储过程)
11-03
基于.NET的通用数据连接类库，支持SQLServer、Oracle、MySQL、SQLite、ACCESS、DB2。
KGIS.DBOperator.rar
01-16
PGSQL封装源码，对增删改查操作的封装；PGSQL封装源码，对增删改查操作的封装；PGSQL封装源码，对增删改查操作的封装
.Net中的数据库操作封装
05-27
1.文件student.accdb(Access 2007 英文版)放在d盘根目录下。 2.此程序基于Visual studio 2005 英文版，主要是为了示例.net中用oledb方式对... 约束要求：数据库操作必须使用DBOperator类(封装数据库)。
c#DB帮助类（源码）
08-09
封装好的BD帮助类源码，可以直接在项目中使用，易扩展和修改，供c#入门的同学更好的学习如何操作数据库，支持操作sql server和oracel。
MySql数据库（最详细简单易懂）看这部篇就够了
2301_77638787的博客
08-17 2980
MySql数据库（最详细简单易懂）是帮助初学者减少初级的困难，其实一旦掌握了之后，会发现它其实是非常容易。
MySQL 使用方法简单教程
chinacodec的专栏
08-08 13万+
MySQL 使用方法简单教程
mysql详解（持续更新）
Ferao的博客
10-21 2万+
去重语句： select distinct 列名 from 表名 字符类型转数值类型语句： select to_number('000123') from dual; 插入语句： insert into 表名 (字段) values (字段值) 新增表字段： alter table 表名 add (字段名 integer default 0 not null); 删除表字段： alter........................................
数据库MySQL详解
热门推荐
卓越无关环境，保持空杯心态——靡不有初，鲜克有终
07-24 18万+
全网最详细MySQL教程，2023持续更新中

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值