首次更新

.gitignore

@@ -30,3 +30,4 @@
 *.exe
 *.out
 *.app
+/build

CMakeLists.txt

@@ -0,0 +1,78 @@
+cmake_minimum_required(VERSION 3.5)
+
+set(MODULE_NAME "mysql")
+# 设置项目名为当前目录名
+project(${MODULE_NAME})
+
+# 搜索源文件和头文件
+file(GLOB_RECURSE SOURCE_FILES "${PROJECT_SOURCE_DIR}/src/*.cpp")
+file(GLOB_RECURSE HEADER_FILES 
+    "${PROJECT_SOURCE_DIR}/src/*.h"
+)
+
+# 将源文件分配到 Source Files 文件夹
+foreach(source IN LISTS SOURCE_FILES)
+    get_filename_component(source_path "${source}" PATH)
+    file(RELATIVE_PATH source_path_rel "${PROJECT_SOURCE_DIR}" "${source_path}")
+    string(REPLACE "/" "\\" source_path_rel_win "${source_path_rel}")
+    source_group("Source Files\\${source_path_rel_win}" FILES "${source}")
+endforeach()
+
+# 将头文件分配到 Header Files 文件夹
+foreach(header IN LISTS HEADER_FILES)
+    get_filename_component(header_path "${header}" PATH)
+    file(RELATIVE_PATH header_path_rel "${PROJECT_SOURCE_DIR}" "${header_path}")
+    string(REPLACE "/" "\\" header_path_rel_win "${header_path_rel}")
+    source_group("Header Files\\${header_path_rel_win}" FILES "${header}")
+endforeach()
+
+set(CMAKE_CXX_STANDARD 20) 
+set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
+# 安装复制
+set(CMAKE_INSTALL_ALWAYS_COPY TRUE)
+
+set(YLIB ${CMAKE_INSTALL_PREFIX}/../ylib)
+set(FASTWEB ${CMAKE_INSTALL_PREFIX}/../fastweb)
+
+# 包含路径
+include_directories(
+	${YLIB}/include
+	${FASTWEB}/include
+	${FASTWEB}/include/lua
+)
+
+# 添加共享库
+add_library(${MODULE_NAME} SHARED ${HEADER_FILES} ${SOURCE_FILES})
+
+if(MSVC)
+	target_link_libraries(${MODULE_NAME} PRIVATE
+			odbc32.lib
+			User32.lib
+			Advapi32.lib
+			IPHLPAPI.lib
+			WS2_32.lib
+			Shell32.lib
+			
+			${YLIB}/lib/libcrypto_static_win64.lib
+			$<$<CONFIG:Debug>:${FASTWEB}/bin/debug/3rdparty/lib/lua.lib>
+			$<$<CONFIG:Debug>:D:/3rdparty/mysql-connector-c++-8.2.0-winx64/lib64/vs14/debug/mysqlcppconn.lib>
+			$<$<CONFIG:Debug>:${YLIB}/lib/ylib_d.lib>
+
+			$<$<CONFIG:Release>:${FASTWEB}/bin/release/3rdparty/lib/lua.lib>
+			$<$<CONFIG:Release>:D:/3rdparty/mysql-connector-c++-8.2.0-winx64-release/lib64/vs14/mysqlcppconn.lib>
+			$<$<CONFIG:Release>:${YLIB}/lib/ylib.lib>
+	)
+else()
+	target_link_libraries(${MODULE_NAME} 
+			hpsocket
+			ylib
+			crypto
+			lua5.3
+			mysqlcppconn
+			pthread
+	)
+
+endif()
+
+
+install(TARGETS ${MODULE_NAME} DESTINATION $<IF:$<CONFIG:Debug>,${FASTWEB}/bin/debug/module/${MODULE_NAME},${FASTWEB}/bin/release/module/${MODULE_NAME}>)

README.md

@@ -1,2 +1,5 @@
 # module-mysql
+
 FastWeb - MYSQL模块
+
+文档：<a href="http://fw.newobj.org/doc/module/database/">点击访问</a>

src/mysql.cpp

@@ -0,0 +1,617 @@
+#include "mysql.h"
+#include "util/time.h"
+#include "dll_interface.h"
+
+extern "C" {
+#ifdef _WIN32
+    DLL_EXPORT
+#endif
+        int fastweb_module_regist(void* sol2, void* lua)
+    {
+        sol::state* state = static_cast<sol::state*>(sol2);
+        module::mysql_regist(state);
+        return 0;
+    }
+}
+module::select::select(ylib::mysql::conn *conn)
+{
+    m_select = std::make_shared<ylib::select>(conn);
+}
+
+module::select::~select()
+{
+}
+
+module::select& module::select::where_i32(const std::string& name, const std::string& expression, int32 value)
+{
+    m_select->where(name,expression,value);
+    return *this;
+}
+
+module::select& module::select::where_i64(const std::string& name, const std::string& expression, int64 value)
+{
+    m_select->where(name, expression, value);
+    return *this;
+}
+
+module::select& module::select::where_dob(const std::string& name, const std::string& expression, double value)
+{
+    m_select->where(name, expression, value);
+    return *this;
+}
+
+module::select& module::select::where_str(const std::string& name, const std::string& expression, const std::string& value)
+{
+    m_select->where(name, expression, value);
+    return *this;
+}
+
+module::select& module::select::where_expression(const std::string& expression)
+{
+    m_select->where(expression);
+    return *this;
+}
+
+module::select& module::select::where_like(const std::string& name, const std::string& value)
+{
+    m_select->where_like(name, value);
+    return *this;
+}
+
+module::select& module::select::table(const std::string& table_name)
+{
+    m_select->table(table_name);
+    return *this;
+}
+
+module::select& module::select::field(sol::table table)
+{
+    std::vector<std::string> strings;
+    for (auto& pair : table) {
+        if (pair.second.get_type() != sol::type::string)
+        {
+            throw ylib::exception("module::select::field:  attempting to obtain field name that is not a string");
+        }
+        strings.push_back(pair.second.as<std::string>());
+    }
+    m_select->field(strings);
+    return *this;
+}
+
+module::select& module::select::page(uint32 page, uint32 count)
+{
+    m_select->page(page,count);
+    return *this;
+}
+
+module::select& module::select::limit(uint32 start, uint32 count)
+{
+    m_select->limit(start,count);
+    return *this;
+}
+
+module::select& module::select::orderby(const std::string& field, int sort)
+{
+    m_select->orderby(field,(ylib::sort)sort);
+    return *this;
+}
+
+void module::select::clear()
+{
+    m_select->clear();
+}
+
+std::shared_ptr<module::mysql_result> module::select::query()
+{
+    return std::make_shared<module::mysql_result>(m_select->query());
+}
+
+uint64 module::select::count()
+{
+    return m_select->count();
+}
+
+void module::select::regist(sol::state* lua)
+{
+    lua->new_usertype<module::select>("mysql_builder_select",
+        "new", sol::constructors<module::select(ylib::mysql::conn*)>(),
+        "count", &module::select::count,
+        "field", &module::select::field,
+        "limit", &module::select::limit,
+        "orderby", &module::select::orderby,
+        "page", &module::select::page,
+        "table", &module::select::table,
+        "where_dob", &module::select::where_dob,
+        "where_expression", &module::select::where_expression,
+        "where_i32", &module::select::where_i32,
+        "where_i64", &module::select::where_i64,
+        "where_str", &module::select::where_str,
+        "query", &module::select::query,
+        "clear", &module::select::clear,
+        "where_like", &module::select::where_like,
+        "clear", &module::select::clear
+    );
+}
+
+module::update::update(ylib::mysql::conn* conn)
+{
+    m_update = std::make_shared<ylib::update>(conn);
+}
+
+module::update::~update()
+{
+}
+
+module::update& module::update::table(const std::string& table_name)
+{
+    m_update->table(table_name);
+    return *this;
+}
+
+module::update& module::update::set_i32(const std::string& name, int32 value)
+{
+    m_update->set(name, value);
+    return *this;
+}
+
+module::update& module::update::set_i64(const std::string& name, int64 value)
+{
+    m_update->set(name, value);
+    return *this;
+}
+
+module::update& module::update::set_dob(const std::string& name, double value)
+{
+    m_update->set(name, value);
+    return *this;
+}
+
+module::update& module::update::set_str(const std::string& name, const std::string& value)
+{
+    m_update->set(name, value);
+    return *this;
+}
+
+module::update& module::update::set(const std::string& expression)
+{
+    m_update->set(expression);
+    return *this;
+}
+
+module::update& module::update::where_i32(const std::string& name, const std::string& expression, int32 value)
+{
+    m_update->where(name,expression,value);
+    return *this;
+}
+
+module::update& module::update::where_i64(const std::string& name, const std::string& expression, int64 value)
+{
+    m_update->where(name, expression, value);
+    return *this;
+}
+
+module::update& module::update::where_dob(const std::string& name, const std::string& expression, double value)
+{
+    m_update->where(name, expression, value);
+    return *this;
+}
+
+module::update& module::update::where_str(const std::string& name, const std::string& expression, const std::string& value)
+{
+    m_update->where(name, expression, value);
+    return *this;
+}
+
+module::update& module::update::where_expression(const std::string& expression)
+{
+    m_update->where(expression);
+    return *this;
+}
+
+module::update& module::update::page(uint32 page, uint32 count)
+{
+    m_update->page(page,count);
+    return *this;
+}
+
+module::update& module::update::limit(uint32 start, uint32 count)
+{
+    m_update->limit(start, count);
+    return *this;
+}
+
+module::update& module::update::orderby(const std::string& field, int sort)
+{
+    m_update->orderby(field,(ylib::sort)sort);
+    return *this;
+}
+
+uint64 module::update::exec()
+{
+    return m_update->exec();
+}
+
+void module::update::clear()
+{
+    m_update->clear();
+}
+
+void module::update::regist(sol::state* lua)
+{
+    lua->new_usertype<module::update>("mysql_builder_update",
+        "new", sol::constructors<module::update(ylib::mysql::conn*)>(),
+        "exec", &module::update::exec,
+        "limit", &module::update::limit,
+        "orderby", &module::update::orderby,
+        "page", &module::update::page,
+        "table", &module::update::table,
+        "where_dob", &module::update::where_dob,
+        "where_expression", &module::update::where_expression,
+        "where_i32", &module::update::where_i32,
+        "where_i64", &module::update::where_i64,
+        "where_str", &module::update::where_str,
+        "set", &module::update::set,
+        "set_dob", &module::update::set_dob,
+        "set_i32", &module::update::set_i32,
+        "set_i64", &module::update::set_i64,
+        "set_str", &module::update::set_str,
+        "clear", &module::update::clear
+    );
+}
+
+module::insert::insert(ylib::mysql::conn* conn)
+{
+    m_insert = std::make_shared<ylib::insert>(conn);
+}
+
+module::insert::~insert()
+{
+}
+
+module::insert& module::insert::table(const std::string& table_name)
+{
+    m_insert->table(table_name);
+    return *this;
+}
+
+module::insert& module::insert::set_i32(const std::string& name, int32 value)
+{
+    m_insert->set(name, value);
+    return *this;
+}
+
+module::insert& module::insert::set_i64(const std::string& name, int64 value)
+{
+    m_insert->set(name, value);
+    return *this;
+}
+
+module::insert& module::insert::set_dob(const std::string& name, double value)
+{
+    m_insert->set(name, value);
+    return *this;
+}
+
+module::insert& module::insert::set_str(const std::string& name, const std::string& value)
+{
+    m_insert->set(name, value);
+    return *this;
+}
+
+module::insert& module::insert::set_not_ppst(const std::string& name, const std::string& value)
+{
+    m_insert->set_not_pret(name, value);
+    return *this;
+}
+
+uint64 module::insert::exec()
+{
+    return m_insert->exec();
+}
+
+void module::insert::clear()
+{
+    m_insert->clear();
+}
+
+void module::insert::regist(sol::state* lua)
+{
+    lua->new_usertype<module::insert>("mysql_builder_insert",
+        "new", sol::constructors<module::insert(ylib::mysql::conn*)>(),
+        "exec", &module::insert::exec,
+        "table", &module::insert::table,
+        "set_not_ppst", &module::insert::set_not_ppst,
+        "set_dob", &module::insert::set_dob,
+        "set_i32", &module::insert::set_i32,
+        "set_i64", &module::insert::set_i64,
+        "set_str", &module::insert::set_str,
+        "clear", &module::insert::clear
+    );
+}
+
+
+
+module::delete_::delete_(ylib::mysql::conn* conn)
+{
+    m_delete = std::make_shared<ylib::delete_>(conn);
+}
+
+module::delete_::~delete_()
+{
+}
+
+module::delete_& module::delete_::table(const std::string& table_name)
+{
+    m_delete->table(table_name);
+    return *this;
+}
+module::delete_& module::delete_::where_i32(const std::string& name, const std::string& expression, int32 value)
+{
+    m_delete->where(name, expression, value);
+    return *this;
+}
+
+module::delete_& module::delete_::where_i64(const std::string& name, const std::string& expression, int64 value)
+{
+    m_delete->where(name, expression, value);
+    return *this;
+}
+
+module::delete_& module::delete_::where_dob(const std::string& name, const std::string& expression, double value)
+{
+    m_delete->where(name, expression, value);
+    return *this;
+}
+
+module::delete_& module::delete_::where_str(const std::string& name, const std::string& expression, const std::string& value)
+{
+    m_delete->where(name, expression, value);
+    return *this;
+}
+
+module::delete_& module::delete_::where_expression(const std::string& expression)
+{
+    m_delete->where(expression);
+    return *this;
+}
+
+module::delete_& module::delete_::page(uint32 page, uint32 count)
+{
+    m_delete->page(page, count);
+    return *this;
+}
+
+module::delete_& module::delete_::limit(uint32 start, uint32 count)
+{
+    m_delete->limit(start, count);
+    return *this;
+}
+
+module::delete_& module::delete_::orderby(const std::string& field, int sort)
+{
+    m_delete->orderby(field, (ylib::sort)sort);
+    return *this;
+}
+
+uint64 module::delete_::exec()
+{
+    return m_delete->exec();
+}
+
+void module::delete_::clear()
+{
+    m_delete->clear();
+}
+
+void module::delete_::regist(sol::state* lua)
+{
+    lua->new_usertype<module::delete_>("mysql_builder_delete",
+        "new", sol::constructors<module::delete_(ylib::mysql::conn*)>(),
+        "exec", &module::delete_::exec,
+        "limit", &module::delete_::limit,
+        "orderby", &module::delete_::orderby,
+        "page", &module::delete_::page,
+        "table", &module::delete_::table,
+        "where_dob", &module::delete_::where_dob,
+        "where_expression", &module::delete_::where_expression,
+        "where_i32", &module::delete_::where_i32,
+        "where_i64", &module::delete_::where_i64,
+        "where_str", &module::delete_::where_str,
+        "clear", &module::delete_::clear
+    );
+}
+
+void module::mysql_regist(sol::state* lua)
+{
+    (*lua)["DESC"] = ylib::sort::DESC;
+    (*lua)["ASC"] = ylib::sort::ASC;
+    
+    lua->new_usertype<ylib::mysql::conn>("mysql_conn",
+        "clear", &ylib::mysql::conn::clear,
+        "close", &ylib::mysql::conn::close,
+        "commit", &ylib::mysql::conn::commit,
+        "insert_id", &ylib::mysql::conn::insert_id,
+        "last_error", &ylib::mysql::conn::last_error,
+        "recover", &ylib::mysql::conn::recover,
+        "rollback", &ylib::mysql::conn::rollback,
+        "setsql", &ylib::mysql::conn::setsql
+    );
+    lua->new_usertype<module::mysql>("mysql_pool",
+        "new", sol::constructors<module::mysql()>(),
+        "start", &module::mysql::start,
+        "close", &module::mysql::close,
+        "self", &module::mysql::self,
+        "select", &module::mysql::select,
+        "update", &module::mysql::update,
+        "insert", &module::mysql::insert,
+        "delete", &module::mysql::delete_
+    );
+    module::mysql_result::regist(lua);
+
+    module::select::regist(lua);
+    module::update::regist(lua);
+    module::delete_::regist(lua);
+    module::insert::regist(lua);
+
+}
+
+module::mysql::mysql()
+{
+}
+
+module::mysql::~mysql()
+{
+    close();
+}
+
+bool module::mysql::start(const std::string& ipaddress, const std::string& username, const std::string& password, const std::string& database, const std::string& charset, ushort port, int32 size)
+{
+    close();
+    m_pool = std::make_shared<ylib::mysql::pool>();
+    ylib::mysql::mysql_conn_info info;
+    info.ipaddress = ipaddress;
+    info.username = username;
+    info.password = password;
+    info.charset = charset;
+    info.port = port;
+    info.database = database;
+    return m_pool->start(info, size);
+}
+
+void module::mysql::close()
+{
+
+}
+
+std::shared_ptr<module::select> module::mysql::select()
+{
+    return std::make_shared<module::select>(m_pool->get());
+}
+
+std::shared_ptr<module::insert> module::mysql::insert()
+{
+    return std::make_shared<module::insert>(m_pool->get());
+}
+
+std::shared_ptr<module::update> module::mysql::update()
+{
+    return std::make_shared<module::update>(m_pool->get());
+}
+
+std::shared_ptr<module::delete_> module::mysql::delete_()
+{
+    return std::make_shared<module::delete_>(m_pool->get());
+}
+
+void module::mysql::regist_global(const std::string& name, sol::state* lua)
+{
+    lua->registry()[name] = this;
+    (*lua)[name] = this;
+}
+module::mysql_result::mysql_result(ylib::mysql::result* result):m_result(result)
+{
+
+}
+
+module::mysql_result::~mysql_result()
+{
+
+}
+uint32 module::mysql_result::field_count()
+{
+    return m_result->field_count();
+}
+
+std::string module::mysql_result::field_type(sol::object obj)
+{
+    if (obj.is<int>() || obj.is<double>()) {
+        m_result->field_type((uint32)obj.as<int>());
+    }
+    else if (obj.is<std::string>()) {
+        m_result->field_type((std::string)obj.as<std::string>());
+    }
+    return "";
+}
+std::string module::mysql_result::field_name(uint32 index)
+{
+    return m_result->field_name(index);
+}
+
+size_t module::mysql_result::row_count()
+{
+    return m_result->row_count();
+}
+
+bool module::mysql_result::next()
+{
+    return m_result->next();
+}
+
+sol::object module::mysql_result::get(sol::object obj, sol::this_state s)
+{
+    std::string type;
+    if (obj.get_type() == sol::type::string)
+        type = m_result->field_type(obj.as<std::string>());
+    else if (obj.get_type() == sol::type::number)
+        type = m_result->field_type(obj.as<int>());
+
+#define GET_VALUE(FUNCTION)                                                                                             \
+    if (obj.get_type() == sol::type::string)                                                                                    \
+        return sol::make_object(s, m_result->FUNCTION(obj.as<std::string>()));                          \
+    else if (obj.get_type() == sol::type::number)                                                                           \
+        return sol::make_object(s, m_result->FUNCTION(obj.as<uint32>()))
+
+    if (type == "int" || type == "tinyint")
+    {
+        GET_VALUE(get_int32);
+    }
+      
+    else if (type == "varchar" || type == "char" || type == "text" || type == "datetime")
+    {
+        GET_VALUE(get_string);
+    }
+    else if (type == "int unsigned")
+    {
+        GET_VALUE(get_uint32);
+    }
+    else if (type == "bigint")
+    {
+        GET_VALUE(get_int64);
+    }
+    else if (type == "decimal")
+    {
+        GET_VALUE(get_double);
+    }
+    return sol::make_object(s, sol::nil); 
+    
+}
+
+sol::table module::mysql_result::table(sol::this_state s)
+{
+    sol::state_view lua(s);
+    sol::table result_table = lua.create_table();
+    int row_num = 1;
+
+    while (next()) {
+        sol::table row = lua.create_table();
+        for (uint32_t i = 0; i < field_count(); ++i) {
+            row[field_name(i+1)] = get(sol::make_object(s, i+1), s);
+        }
+        result_table[row_num++] = row;
+    }
+    return result_table;
+}
+
+void module::mysql_result::regist(sol::state* lua)
+{
+    lua->new_usertype<module::mysql_result>("mysql_result",
+        "field_name", &module::mysql_result::field_name,
+        "get", &module::mysql_result::get,
+        "next", &module::mysql_result::next,
+        "row_count", &module::mysql_result::row_count,
+        "table", &module::mysql_result::table,
+        "field_count", &module::mysql_result::field_count,
+        "field_type", &module::mysql_result::field_type
+    );
+}
+

src/mysql.h

@@ -0,0 +1,188 @@
+#pragma once
+#include "db/mysql.h"
+#include "db/sqler.h"
+#include "sol/sol.hpp"
+#include "basemodule.h"
+namespace module
+{
+	/// <summary>
+	/// 注册
+	/// </summary>
+	/// <param name="lua"></param>
+	void mysql_regist(sol::state* lua);
+	/// <summary>
+	/// 结果集
+	/// </summary>
+	class mysql_result
+	{
+	public:
+		mysql_result(ylib::mysql::result* result);
+		~mysql_result();
+		/// <summary>
+		/// 字段数
+		/// </summary>
+		/// <returns></returns>
+		uint32 field_count();
+		/// <summary>
+		/// 字段类型
+		/// </summary>
+		/// <param name="obj"></param>
+		/// <returns></returns>
+		std::string field_type(sol::object obj);
+		/// <summary>
+		/// 字段名称
+		/// </summary>
+		/// <param name="index"></param>
+		/// <returns></returns>
+		std::string field_name(uint32 index);
+		/// <summary>
+		/// 结果行
+		/// </summary>
+		/// <returns></returns>
+		size_t row_count();
+		/// <summary>
+		/// 下一行
+		/// </summary>
+		/// <returns></returns>
+		bool next();
+		/// <summary>
+		/// 取数据
+		/// </summary>
+		/// <param name="name"></param>
+		/// <returns></returns>
+		sol::object get(sol::object obj, sol::this_state s);
+		/// <summary>
+		/// 取结果集到table
+		/// </summary>
+		/// <param name="s"></param>
+		/// <returns></returns>
+		sol::table table(sol::this_state s);
+		/// <summary>
+		/// 注册
+		/// </summary>
+		/// <param name="lua"></param>
+		static void regist(sol::state* lua);
+	private:
+		ylib::mysql::result* m_result = nullptr;
+	};
+
+
+	class select {
+	public:
+		select(ylib::mysql::conn* conn);
+		~select();
+		module::select& where_i32(const std::string& name, const std::string& expression, int32 value);
+		module::select& where_i64(const std::string& name, const std::string& expression, int64 value);
+		module::select& where_dob(const std::string& name, const std::string& expression, double value);
+		module::select& where_str(const std::string& name, const std::string& expression, const std::string& value);
+		module::select& where_expression(const std::string& expression);
+		module::select& where_like(const std::string& name,const std::string& value);
+		module::select& table(const std::string& table_name);
+		module::select& field(sol::table table);
+		module::select& page(uint32 page, uint32 count);
+		module::select& limit(uint32 start, uint32 count);
+		module::select& orderby(const std::string& field, int sort);
+		void clear();
+		std::shared_ptr<module::mysql_result> query();
+		uint64 count();
+		static void regist(sol::state* lua);
+	private:
+		std::shared_ptr<ylib::select> m_select;
+	};
+	class update {
+	public:
+		update(ylib::mysql::conn* conn);
+		~update();
+		module::update& table(const std::string& table_name);
+		module::update& set_i32(const std::string& name, int32 value);
+		module::update& set_i64(const std::string& name, int64 value);
+		module::update& set_dob(const std::string& name, double value);
+		module::update& set_str(const std::string& name, const std::string& value);
+		module::update& set(const std::string& expression);
+		module::update& where_i32(const std::string& name, const std::string& expression, int32 value);
+		module::update& where_i64(const std::string& name, const std::string& expression, int64 value);
+		module::update& where_dob(const std::string& name, const std::string& expression, double value);
+		module::update& where_str(const std::string& name, const std::string& expression, const std::string& value);
+		module::update& where_expression(const std::string& expression);
+		module::update& page(uint32 page, uint32 count);
+		module::update& limit(uint32 start, uint32 count);
+		module::update& orderby(const std::string& field, int sort);
+		uint64 exec();
+		void clear();
+		static void regist(sol::state* lua);
+	private:
+		std::shared_ptr<ylib::update> m_update;
+	};
+	class insert {
+	public:
+		insert(ylib::mysql::conn* conn);
+		~insert();
+		module::insert& table(const std::string& table_name);
+		module::insert& set_i32(const std::string& name, int32 value);
+		module::insert& set_i64(const std::string& name, int64 value);
+		module::insert& set_dob(const std::string& name, double value);
+		module::insert& set_str(const std::string& name, const std::string& value);
+		module::insert& set_not_ppst(const std::string& name, const std::string& value);
+		uint64 exec();
+		void clear();
+		static void regist(sol::state* lua);
+	private:
+		std::shared_ptr<ylib::insert> m_insert;
+	};
+	class delete_ {
+	public:
+		delete_(ylib::mysql::conn* conn);
+		~delete_();
+		module::delete_& table(const std::string& table_name);
+		module::delete_& where_i32(const std::string& name, const std::string& expression, int32 value);
+		module::delete_& where_i64(const std::string& name, const std::string& expression, int64 value);
+		module::delete_& where_dob(const std::string& name, const std::string& expression, double value);
+		module::delete_& where_str(const std::string& name, const std::string& expression, const std::string& value);
+		module::delete_& where_expression(const std::string& expression);
+		module::delete_& page(uint32 page, uint32 count);
+		module::delete_& limit(uint32 start, uint32 count);
+		module::delete_& orderby(const std::string& field, int sort);
+		uint64 exec();
+		void clear();
+		static void regist(sol::state* lua);
+	private:
+		std::shared_ptr <ylib::delete_> m_delete;
+	};
+	/// <summary>
+	/// MYSQL连接池
+	/// </summary>
+	class mysql :public module::base {
+	public:
+		mysql();
+		~mysql()  override;
+		/// <summary>
+		/// 启动
+		/// </summary>
+		/// <param name="ipaddress"></param>
+		/// <param name="username"></param>
+		/// <param name="password"></param>
+		/// <param name="database"></param>
+		/// <param name="charset"></param>
+		/// <param name="port"></param>
+		/// <param name="size"></param>
+		/// <returns></returns>
+		bool start(const std::string& ipaddress, const std::string& username, const std::string& password, const std::string& database, const std::string& charset, ushort port, int32 size);
+		/// <summary>
+		/// 关闭
+		/// </summary>
+		void close();
+
+		std::shared_ptr<module::select> select();
+		std::shared_ptr<module::insert> insert();
+		std::shared_ptr<module::update> update();
+		std::shared_ptr<module::delete_> delete_();
+	private:
+		std::shared_ptr<ylib::mysql::pool> m_pool;
+
+		// 通过 imodule 继承
+		virtual void regist_global(const std::string& name, sol::state* lua);
+		virtual void delete_global() { delete this; }
+	};
+
+}
+