1585346868/module-mysql
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'main' of https://github.com/Liuccysdgg/module-mysql

Browse Source
This commit is contained in:
xx
2024-06-26 02:58:19 +08:00
parent cfeef05fbd 750b0a5ee1
commit 84cf147868
10 changed files with 1060 additions and 8 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
CMakeLists.txt
View File

@@ -31,19 +31,31 @@ set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
# 安装复制
set(CMAKE_INSTALL_ALWAYS_COPY TRUE)
if(MSVC)
set(YLIB ${CMAKE_INSTALL_PREFIX}/../ylib)
set(FASTWEB ${CMAKE_INSTALL_PREFIX}/../fastweb)
else()
set(YLIB /usr/local/include/ylib)
set(FASTWEB /usr/local/include/fastweb)
endif()
# 包含路径
include_directories(
${YLIB}/include
${FASTWEB}/include
${FASTWEB}/include/lua
)
if(MSVC)
include_directories(
${YLIB}/include
${FASTWEB}/include
${FASTWEB}/include/lua
)
add_definitions(/bigobj)
set(MYSQL_CPP_LIB_DIR "$ENV{USERPROFILE}/MySQL/MySQL Connector C++ 8.2.0/lib64")
else()
include_directories(
/usr/local/include/ylib
/usr/local/include/fastweb
/opt/lua54/include
/usr/local/include)
add_definitions(-DfPIC)
endif()
# 添加共享库
@@ -76,7 +88,7 @@ else()
hpsocket
ylib
crypto
lua5.3
/opt/lua54/lib/liblua.a
mysqlcppconn
pthread
)
@@ -84,4 +96,4 @@ else()
endif()
install(TARGETS ${MODULE_NAME} DESTINATION $<IF:$<CONFIG:Debug>,${FASTWEB}/bin/debug/module/${MODULE_NAME},${FASTWEB}/bin/release/module/${MODULE_NAME}>)
install(TARGETS ${MODULE_NAME} DESTINATION $<IF:$<CONFIG:Debug>,${FASTWEB}/bin/debug/module/${MODULE_NAME},${FASTWEB}/bin/release/module/${MODULE_NAME}>)

10
build.sh Executable file
View File

@@ -0,0 +1,10 @@
#!/bin/bash
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
cd "$SCRIPT_DIR"
mkdir target -p
mkdir build -p
cd build
cmake ..
make
cp -f libmysql.so ../target

131
target/mysql/builder_delete.lua Normal file
View File

@@ -0,0 +1,131 @@
-- mysql_builder_delete.lua
local mysql_builder_delete = {}
mysql_builder_delete.__index = mysql_builder_delete
--[[
创建一个新的 fw_mysql_builder_delete 对象
@return 返回一个新的 fw_mysql_builder_delete 对象
]]
function mysql_builder_delete.new(__module)
local instance = setmetatable({}, mysql_builder_delete)
instance.module =__module
return instance
end
--[[
设置要删除的表名
@param table_name 表名
@return 返回 mysql_builder_delete 对象自身，以便链式调用
]]
function mysql_builder_delete:table(table_name)
self.module:table(table_name)
return self
end
--[[
添加 int32 类型的条件
@param name 字段名称
@param expression 条件表达式
@param value 值
@return 返回 mysql_builder_delete 对象自身，以便链式调用
]]
function mysql_builder_delete:where_i32(name, expression, value)
self.module:where_i32(name, expression, value)
return self
end
--[[
添加 int64 类型的条件
@param name 字段名称
@param expression 条件表达式
@param value 值
@return 返回 mysql_builder_delete 对象自身，以便链式调用
]]
function mysql_builder_delete:where_i64(name, expression, value)
self.module:where_i64(name, expression, value)
return self
end
--[[
添加 double 类型的条件
@param name 字段名称
@param expression 条件表达式
@param value 值
@return 返回 mysql_builder_delete 对象自身，以便链式调用
]]
function mysql_builder_delete:where_dob(name, expression, value)
self.module:where_dob(name, expression, value)
return self
end
--[[
添加字符串类型的条件
@param name 字段名称
@param expression 条件表达式
@param value 值
@return 返回 mysql_builder_delete 对象自身，以便链式调用
]]
function mysql_builder_delete:where_str(name, expression, value)
self.module:where_str(name, expression, value)
return self
end
--[[
添加自定义表达式的条件
@param expression 条件表达式
@return 返回 mysql_builder_delete 对象自身，以便链式调用
]]
function mysql_builder_delete:where_expression(expression)
self.module:where_expression(expression)
return self
end
--[[
设置分页参数
@param page 页码
@param count 每页记录数
@return 返回 mysql_builder_delete 对象自身，以便链式调用
]]
function mysql_builder_delete:page(page, count)
self.module:page(page, count)
return self
end
--[[
设置查询限制
@param start 起始位置
@param count 记录数
@return 返回 mysql_builder_delete 对象自身，以便链式调用
]]
function mysql_builder_delete:limit(start, count)
self.module:limit(start, count)
return self
end
--[[
设置排序
@param field 字段名称
@param sort 排序方式（升序或降序）
@return 返回 mysql_builder_delete 对象自身，以便链式调用
]]
function mysql_builder_delete:orderby(field, sort)
self.module:orderby(field, sort)
return self
end
--[[
执行删除操作
@return 返回受影响的行数
]]
function mysql_builder_delete:exec()
return self.module:exec()
end
--[[
清空删除条件
]]
function mysql_builder_delete:clear()
self.module:clear()
end
return mysql_builder_delete

106
target/mysql/builder_insert.lua Normal file
View File

@@ -0,0 +1,106 @@
-- mysql_builder_insert.lua
local mysql_builder_insert = {}
mysql_builder_insert.__index = mysql_builder_insert
--[[
创建一个新的 fw_mysql_builder_insert 对象
@return 返回一个新的 fw_mysql_builder_insert 对象
]]
function mysql_builder_insert.new(__module)
local instance = setmetatable({}, mysql_builder_insert)
instance.module = __module
return instance
end
--[[
设置要插入的表名
@param table_name 表名
@return 返回 mysql_builder_insert 对象自身，以便链式调用
]]
function mysql_builder_insert:table(table_name)
self.module:table(table_name)
return self
end
--[[
设置 int32 类型的字段
@param name 字段名称
@param value 值
@return 返回 mysql_builder_insert 对象自身，以便链式调用
]]
function mysql_builder_insert:set_i32(name, value)
self.module:set_i32(name, value)
return self
end
--[[
设置 int64 类型的字段
@param name 字段名称
@param value 值
@return 返回 mysql_builder_insert 对象自身，以便链式调用
]]
function mysql_builder_insert:set_i64(name, value)
self.module:set_i64(name, value)
return self
end
--[[
设置 double 类型的字段
@param name 字段名称
@param value 值
@return 返回 mysql_builder_insert 对象自身，以便链式调用
]]
function mysql_builder_insert:set_dob(name, value)
self.module:set_dob(name, value)
return self
end
--[[
设置字符串类型的字段
@param name 字段名称
@param value 值
@return 返回 mysql_builder_insert 对象自身，以便链式调用
]]
function mysql_builder_insert:set_str(name, value)
self.module:set_str(name, value)
return self
end
--[[
设置 blob 类型的字段
@param name 字段名称
@param value 值
@return 返回 mysql_builder_insert 对象自身，以便链式调用
]]
function mysql_builder_insert:set_blob(name, value)
self.module:set_blob(name, value)
return self
end
--[[
设置不作为预处理语句的字段
@param name 字段名称
@param value 值
@return 返回 mysql_builder_insert 对象自身，以便链式调用
]]
function mysql_builder_insert:set_not_ppst(name, value)
self.module:set_not_ppst(name, value)
return self
end
--[[
执行插入操作
@return 返回受影响的行数
]]
function mysql_builder_insert:exec()
return self.module:exec()
end
--[[
清空插入语句
]]
function mysql_builder_insert:clear()
self.module:clear()
end
return mysql_builder_insert

161
target/mysql/builder_select.lua Normal file
View File

@@ -0,0 +1,161 @@
local result = require("mysql.result")
local mysql_builder_select = {}
mysql_builder_select.__index = mysql_builder_select
--[[
创建一个新的 fw_mysql_builder_select 对象
@return 返回一个新的 fw_mysql_builder_select 对象
]]
function mysql_builder_select.new(__module)
local instance = setmetatable({}, mysql_builder_select)
instance.module = __module
return instance
end
--[[
添加 int32 类型的条件
@param name 字段名称
@param expression 条件表达式
@param value 值
@return 返回 mysql_builder_select 对象自身，以便链式调用
]]
function mysql_builder_select:where_i32(name, expression, value)
self.module:where_i32(name, expression, value)
return self
end
--[[
添加 int64 类型的条件
@param name 字段名称
@param expression 条件表达式
@param value 值
@return 返回 mysql_builder_select 对象自身，以便链式调用
]]
function mysql_builder_select:where_i64(name, expression, value)
self.module:where_i64(name, expression, value)
return self
end
--[[
添加 double 类型的条件
@param name 字段名称
@param expression 条件表达式
@param value 值
@return 返回 mysql_builder_select 对象自身，以便链式调用
]]
function mysql_builder_select:where_dob(name, expression, value)
self.module:where_dob(name, expression, value)
return self
end
--[[
添加字符串类型的条件
@param name 字段名称
@param expression 条件表达式
@param value 值
@return 返回 mysql_builder_select 对象自身，以便链式调用
]]
function mysql_builder_select:where_str(name, expression, value)
self.module:where_str(name, expression, value)
return self
end
--[[
添加自定义表达式的条件
@param expression 条件表达式
@return 返回 mysql_builder_select 对象自身，以便链式调用
]]
function mysql_builder_select:where_expression(expression)
self.module:where_expression(expression)
return self
end
--[[
添加 LIKE 条件
@param name 字段名称
@param value 值
@return 返回 mysql_builder_select 对象自身，以便链式调用
]]
function mysql_builder_select:where_like(name, value)
self.module:where_like(name, value)
return self
end
--[[
设置查询的表名
@param table_name 表名
@return 返回 mysql_builder_select 对象自身，以便链式调用
]]
function mysql_builder_select:table(table_name)
self.module:table(table_name)
return self
end
--[[
设置查询的字段
@param table 字段表
@return 返回 mysql_builder_select 对象自身，以便链式调用
]]
function mysql_builder_select:field(table)
self.module:field(table)
return self
end
--[[
设置分页参数
@param page 页码
@param count 每页记录数
@return 返回 mysql_builder_select 对象自身，以便链式调用
]]
function mysql_builder_select:page(page, count)
self.module:page(page, count)
return self
end
--[[
设置查询限制
@param start 起始位置
@param count 记录数
@return 返回 mysql_builder_select 对象自身，以便链式调用
]]
function mysql_builder_select:limit(start, count)
self.module:limit(start, count)
return self
end
--[[
设置排序
@param field 字段名称
@param sort 排序方式（升序或降序）
@return 返回 mysql_builder_select 对象自身，以便链式调用
]]
function mysql_builder_select:orderby(field, sort)
self.module:orderby(field, sort)
return self
end
--[[
清空查询条件
]]
function mysql_builder_select:clear()
self.module:clear()
end
--[[
执行查询
@return 返回 mysql_result 对象
]]
function mysql_builder_select:query()
return result.new(self.module:query())
end
--[[
获取查询结果的记录数
@return 返回记录数
]]
function mysql_builder_select:count()
return self.module:count()
end
return mysql_builder_select

196
target/mysql/builder_update.lua Normal file
View File

@@ -0,0 +1,196 @@
-- mysql_builder_update.lua
local mysql_builder_update = {}
mysql_builder_update.__index = mysql_builder_update
--[[
创建一个新的 fw_mysql_builder_update 对象
@return 返回一个新的 fw_mysql_builder_update 对象
]]
function mysql_builder_update.new(__module)
local instance = setmetatable({}, mysql_builder_update)
instance.module = __module
return instance
end
--[[
设置要更新的表名
@param table_name 表名
@return 返回 mysql_builder_update 对象自身，以便链式调用
]]
function mysql_builder_update:table(table_name)
self.module:table(table_name)
return self
end
--[[
设置 int32 类型的字段
@param name 字段名称
@param value 值
@return 返回 mysql_builder_update 对象自身，以便链式调用
]]
function mysql_builder_update:set_i32(name, value)
self.module:set_i32(name, value)
return self
end
--[[
设置 int64 类型的字段
@param name 字段名称
@param value 值
@return 返回 mysql_builder_update 对象自身，以便链式调用
]]
function mysql_builder_update:set_i64(name, value)
self.module:set_i64(name, value)
return self
end
--[[
设置 double 类型的字段
@param name 字段名称
@param value 值
@return 返回 mysql_builder_update 对象自身，以便链式调用
]]
function mysql_builder_update:set_dob(name, value)
self.module:set_dob(name, value)
return self
end
--[[
设置字符串类型的字段
@param name 字段名称
@param value 值
@return 返回 mysql_builder_update 对象自身，以便链式调用
]]
function mysql_builder_update:set_str(name, value)
self.module:set_str(name, value)
return self
end
--[[
设置 blob 类型的字段
@param name 字段名称
@param value 值
@return 返回 mysql_builder_update 对象自身，以便链式调用
]]
function mysql_builder_update:set_blob(name, value)
self.module:set_blob(name, value)
return self
end
--[[
设置自定义表达式的字段
@param expression 自定义表达式
@return 返回 mysql_builder_update 对象自身，以便链式调用
]]
function mysql_builder_update:set(expression)
self.module:set(expression)
return self
end
--[[
添加 int32 类型的条件
@param name 字段名称
@param expression 条件表达式
@param value 值
@return 返回 mysql_builder_update 对象自身，以便链式调用
]]
function mysql_builder_update:where_i32(name, expression, value)
self.module:where_i32(name, expression, value)
return self
end
--[[
添加 int64 类型的条件
@param name 字段名称
@param expression 条件表达式
@param value 值
@return 返回 mysql_builder_update 对象自身，以便链式调用
]]
function mysql_builder_update:where_i64(name, expression, value)
self.module:where_i64(name, expression, value)
return self
end
--[[
添加 double 类型的条件
@param name 字段名称
@param expression 条件表达式
@param value 值
@return 返回 mysql_builder_update 对象自身，以便链式调用
]]
function mysql_builder_update:where_dob(name, expression, value)
self.module:where_dob(name, expression, value)
return self
end
--[[
添加字符串类型的条件
@param name 字段名称
@param expression 条件表达式
@param value 值
@return 返回 mysql_builder_update 对象自身，以便链式调用
]]
function mysql_builder_update:where_str(name, expression, value)
self.module:where_str(name, expression, value)
return self
end
--[[
添加自定义表达式的条件
@param expression 条件表达式
@return 返回 mysql_builder_update 对象自身，以便链式调用
]]
function mysql_builder_update:where_expression(expression)
self.module:where_expression(expression)
return self
end
--[[
设置分页参数
@param page 页码
@param count 每页记录数
@return 返回 mysql_builder_update 对象自身，以便链式调用
]]
function mysql_builder_update:page(page, count)
self.module:page(page, count)
return self
end
--[[
设置查询限制
@param start 起始位置
@param count 记录数
@return 返回 mysql_builder_update 对象自身，以便链式调用
]]
function mysql_builder_update:limit(start, count)
self.module:limit(start, count)
return self
end
--[[
设置排序
@param field 字段名称
@param sort 排序方式（升序或降序）
@return 返回 mysql_builder_update 对象自身，以便链式调用
]]
function mysql_builder_update:orderby(field, sort)
self.module:orderby(field, sort)
return self
end
--[[
执行更新操作
@return 返回受影响的行数
]]
function mysql_builder_update:exec()
return self.module:exec()
end
--[[
清空查询条件
]]
function mysql_builder_update:clear()
self.module:clear()
end
return mysql_builder_update

133
target/mysql/conn.lua Normal file
View File

@@ -0,0 +1,133 @@
local select = require("mysql.builder_select")
local update = require("mysql.builder_update")
local insert = require("mysql.builder_insert")
local delete = require("mysql.builder_delete")
local ppst = require("mysql.prepare_statement")
local mysql_conn = {}
mysql_conn.__index = mysql_conn
--[[
创建一个新的 fw_mysql_conn 对象
@return 返回一个新的 fw_mysql_conn 对象
]]
function mysql_conn.new(__module)
local instance = setmetatable({}, mysql_conn)
if __module == nil then
instance.module = fw_mysql_conn.new()
else
instance.module = __module
end
return instance
end
--[[
连接到 MySQL 数据库
@param ipaddress IP 地址
@param username 用户名
@param password 密码
@param database 数据库名称
@param charset 字符集
@param port 端口号
@return 返回连接状态码
]]
function mysql_conn:connect(ipaddress, username, password, database, charset, port)
return self.module:connect(ipaddress, username, password, database, charset, port)
end
--[[
清空连接
]]
function mysql_conn:clear()
self.module:clear()
end
--[[
设置 SQL 语句
@param sql SQL 语句
@return 返回 mysql_prepare_statement 对象
]]
function mysql_conn:setsql(sql)
return ppst.new(self.module:setsql(sql))
end
--[[
获取上一次插入操作的 ID
@return 返回上一次插入操作的 ID
]]
function mysql_conn:insert_id()
return self.module:insert_id()
end
--[[
开始事务
@param autocommit 是否自动提交
]]
function mysql_conn:begin(autocommit)
self.module:begin(autocommit or false)
end
--[[
提交事务
]]
function mysql_conn:commit()
self.module:commit()
end
--[[
回滚事务
]]
function mysql_conn:rollback()
self.module:rollback()
end
--[[
设置数据库名称
@param name 数据库名称
]]
function mysql_conn:setDatabase(name)
self.module:setDatabase(name)
end
--[[
获取最后的错误信息
@return 返回错误信息字符串
]]
function mysql_conn:last_error()
return self.module:last_error()
end
--[[
获取一个 select 对象
@return 返回一个 select 对象
]]
function mysql_conn:select()
return select.new(self.module:select())
end
--[[
获取一个 insert 对象
@return 返回一个 insert 对象
]]
function mysql_conn:insert()
return insert.new(self.module:insert())
end
--[[
获取一个 update 对象
@return 返回一个 update 对象
]]
function mysql_conn:update()
return update.new(self.module:update())
end
--[[
获取一个 delete 对象
@return 返回一个 delete 对象
]]
function mysql_conn:delete()
return delete.new(self.module:delete())
end
return mysql_conn

110
target/mysql/pool.lua Normal file
View File

@@ -0,0 +1,110 @@
local select = require("mysql.builder_select")
local update = require("mysql.builder_update")
local insert = require("mysql.builder_insert")
local delete = require("mysql.builder_delete")
local conn = require("mysql.conn")
local mysql_pool = {}
mysql_pool.__index = mysql_pool
--[[
创建一个新的 fw_mysql_pool 对象
@return 返回一个新的 fw_mysql_pool 对象
]]
function mysql_pool.new(pool)
local instance = setmetatable({}, mysql_pool)
if pool == nil then
instance.module = fw_mysql_pool.new()
else
instance.module = pool
end
return instance
end
--[[
启动 MySQL 连接池
@param ipaddress IP 地址
@param username 用户名
@param password 密码
@param database 数据库名称
@param charset 字符集
@param port 端口号
@param size 连接池大小
@return 是否成功启动
]]
function mysql_pool:start(ipaddress, username, password, database, charset, port, size)
return self.module:start(ipaddress, username, password, database, charset, port, size)
end
--[[
关闭 MySQL 连接池
]]
function mysql_pool:close()
self.module:close()
end
--[[
获取一个 select 对象
@return 返回一个 select 对象
]]
function mysql_pool:select()
print("SELECT_DEBUG_0:")
local s = self.module:select()
print("SELECT_DEBUG_1:",s)
local s2 = select.new(s)
print("SELECT_DEBUG_2:",s2)
return s2
--return self.module:select()
end
--[[
获取一个 insert 对象
@return 返回一个 insert 对象
]]
function mysql_pool:insert()
return insert.new(self.module:insert())
end
--[[
获取一个 update 对象
@return 返回一个 update 对象
]]
function mysql_pool:update()
return update.new(self.module:update())
end
--[[
获取一个 delete 对象
@return 返回一个 delete 对象
]]
function mysql_pool:delete()
return delete.new(self.module:delete())
end
--[[
获取一个 mysql_conn 对象
@return 返回一个 mysql_conn 对象
]]
function mysql_pool:get()
return conn.new(self.module:get())
end
--[[
取自身指针
]]
function mysql_pool:self()
return self.module:self()
end
--[[
强制回收连接
]]
function mysql_pool:recover(conn)
if conn == nil then
return
end
return self.module:recover(conn.module)
end
return mysql_pool

119
target/mysql/prepare_statement.lua Normal file
View File

@@ -0,0 +1,119 @@
local result = require("mysql.result")
local mysql_prepare_statement = {}
mysql_prepare_statement.__index = mysql_prepare_statement
--[[
创建一个新的 fw_mysql_prepare_statement 对象
@return 返回一个新的 fw_mysql_prepare_statement 对象
]]
function mysql_prepare_statement.new(__module)
local instance = setmetatable({}, mysql_prepare_statement)
instance.module =__module
return instance
end
--[[
设置 bigint 类型的参数
@param index 参数索引
@param value 参数值
]]
function mysql_prepare_statement:set_bigint(index, value)
self.module:set_bigint(index, value)
end
--[[
设置 boolean 类型的参数
@param index 参数索引
@param value 参数值
]]
function mysql_prepare_statement:set_boolean(index, value)
self.module:set_boolean(index, value)
end
--[[
设置 datetime 类型的参数
@param index 参数索引
@param value 参数值
]]
function mysql_prepare_statement:set_datetime(index, value)
self.module:set_datetime(index, value)
end
--[[
设置 double 类型的参数
@param index 参数索引
@param value 参数值
]]
function mysql_prepare_statement:set_dob(index, value)
self.module:set_dob(index, value)
end
--[[
设置 int32 类型的参数
@param index 参数索引
@param value 参数值
]]
function mysql_prepare_statement:set_i32(index, value)
self.module:set_i32(index, value)
end
--[[
设置 int64 类型的参数
@param index 参数索引
@param value 参数值
]]
function mysql_prepare_statement:set_i64(index, value)
self.module:set_i64(index, value)
end
--[[
设置 null 类型的参数
@param index 参数索引
]]
function mysql_prepare_statement:set_null(index)
self.module:set_null(index)
end
--[[
设置字符串类型的参数
@param index 参数索引
@param value 参数值
]]
function mysql_prepare_statement:set_str(index, value)
self.module:set_str(index, value)
end
--[[
设置 blob 类型的参数
@param index 参数索引
@param value 参数值
]]
function mysql_prepare_statement:set_blob(index, value)
self.module:set_blob(index, value)
end
--[[
清空所有参数
]]
function mysql_prepare_statement:clear()
self.module:clear()
end
--[[
执行 update 操作
@return 返回受影响的行数
]]
function mysql_prepare_statement:update()
return self.module:update()
end
--[[
执行 query 操作
@return 返回 mysql_result 对象
]]
function mysql_prepare_statement:query()
return result.new(self.module:query())
end
return mysql_prepare_statement

74
target/mysql/result.lua Normal file
View File

@@ -0,0 +1,74 @@
-- mysql_result.lua
local mysql_result = {}
mysql_result.__index = mysql_result
--[[
创建一个新的 fw_mysql_result 对象
@return 返回一个新的 fw_mysql_result 对象
]]
function mysql_result.new(__module)
local instance = setmetatable({}, mysql_result)
instance.module = __module
return instance
end
--[[
获取字段数
@return 返回字段数
]]
function mysql_result:field_count()
return self.module:field_count()
end
--[[
获取字段类型
@param obj 字段对象
@return 返回字段类型字符串
]]
function mysql_result:field_type(obj)
return self.module:field_type(obj)
end
--[[
获取字段名称
@param index 字段索引
@return 返回字段名称字符串
]]
function mysql_result:field_name(index)
return self.module:field_name(index)
end
--[[
获取结果行数
@return 返回结果行数
]]
function mysql_result:row_count()
return self.module:row_count()
end
--[[
移动到下一行
@return 是否成功移动到下一行
]]
function mysql_result:next()
return self.module:next()
end
--[[
获取数据
@param obj 数据对象
@return 返回数据对象
]]
function mysql_result:get(obj)
return self.module:get(obj)
end
--[[
获取结果集到表
@return 返回结果集表
]]
function mysql_result:table()
return self.module:table()
end
return mysql_result