Merge branch 'master' of https://github.com/redkale/FrameworkBenchmarks

frameworks/C++/paozhu/paozhu.dockerfile

@@ -1,11 +1,11 @@
-FROM ubuntu:22.04
+FROM ubuntu:24.04
 RUN apt-get update -yqq && apt-get install -yqq apt-utils software-properties-common wget unzip cmake git
 RUN apt-get install -yqq gcc g++ openssl libssl-dev zlib1g-dev build-essential locales
 
 RUN apt-get -y install brotli libbrotli-dev 
 RUN apt-get -y install libreadline-dev 
-RUN apt-get -y install mysql-client
-RUN apt-get -y install libmysqlclient-dev
+# RUN apt-get -y install mysql-client
+# RUN apt-get -y install libmysqlclient-dev
 
 RUN locale-gen en_US.UTF-8
 ENV LANG en_US.UTF-8
@@ -20,8 +20,30 @@ RUN git clone https://github.com/hggq/paozhu
 # RUN unzip benchmark.zip
 RUN rm -Rf ./paozhu/controller
 RUN rm -Rf ./paozhu/libs
+# RUN rm -Rf ./paozhu/view
+RUN rm -Rf ./paozhu/viewsrc
+RUN rm -Rf ./paozhu/orm
+RUN rm -Rf ./paozhu/models
+RUN rm -Rf ./paozhu/common
+
+
+
+# COPY ./paozhu_benchmark/controller ./paozhu/
+# COPY ./paozhu_benchmark/libs ./paozhu/
+# COPY ./paozhu_benchmark/view ./paozhu/
+# COPY ./paozhu_benchmark/viewsrc ./paozhu/
+
+# COPY ./paozhu_benchmark/orm ./paozhu/
+# COPY ./paozhu_benchmark/models ./paozhu/
+# COPY ./paozhu_benchmark/common ./paozhu/
+
+# RUN ls -l ./paozhu
+# RUN pwd
+RUN mkdir ./paozhu/common
 RUN mkdir ./paozhu/libs
 RUN mkdir ./paozhu/libs/types
+COPY ./paozhu_benchmark/libs/types/techempower_json.h ./paozhu/libs/types/
+COPY ./paozhu_benchmark/libs/types/techempower_json_jsonreflect.cpp ./paozhu/libs/types/
 
 RUN mkdir ./paozhu/controller
 RUN mkdir ./paozhu/controller/include
@@ -30,25 +52,63 @@ RUN mkdir ./paozhu/controller/src
 COPY ./paozhu_benchmark/controller/include/techempower.h ./paozhu/controller/include/
 COPY ./paozhu_benchmark/controller/src/techempower.cpp ./paozhu/controller/src/
 
-COPY ./paozhu_benchmark/libs/types/techempower_json.h ./paozhu/libs/types/
-COPY ./paozhu_benchmark/libs/types/techempower_json_jsonreflect.cpp ./paozhu/libs/types/
 
 COPY ./paozhu_benchmark/common/autocontrolmethod.hpp ./paozhu/common/
 COPY ./paozhu_benchmark/common/reghttpmethod_pre.hpp ./paozhu/common/
 COPY ./paozhu_benchmark/common/reghttpmethod.hpp ./paozhu/common/
 COPY ./paozhu_benchmark/common/json_reflect_headers.h ./paozhu/common/
 
+COPY ./paozhu_benchmark/common/cost_define.h ./paozhu/common/
+COPY ./paozhu_benchmark/common/autorestfulpaths.hpp ./paozhu/common/
+COPY ./paozhu_benchmark/common/websockets_method_reg.hpp ./paozhu/common/
+COPY ./paozhu_benchmark/common/httphook.cpp ./paozhu/common/
+
 COPY ./paozhu_benchmark/conf/server.conf ./paozhu/conf/server.conf
 COPY ./paozhu_benchmark/conf/orm.conf ./paozhu/conf/orm.conf
+
+# must use testbenchmark.cpp to test benchmark
 COPY ./paozhu_benchmark/CMakeLists.txt ./paozhu/CMakeLists.txt
 
+# RUN mkdir ./paozhu/view
+# RUN mkdir ./paozhu/view/techempower
+
+# COPY ./paozhu_benchmark/view/techempower/fortunes.html ./paozhu/view/techempower/
+
+RUN mkdir ./paozhu/viewsrc
+RUN mkdir ./paozhu/viewsrc/include
+RUN mkdir ./paozhu/viewsrc/view
+RUN mkdir ./paozhu/viewsrc/view/techempower
+
+COPY ./paozhu_benchmark/viewsrc/view/techempower/fortunes.cpp ./paozhu/viewsrc/view/techempower/
+COPY ./paozhu_benchmark/viewsrc/include/viewsrc.h ./paozhu/viewsrc/include/
+COPY ./paozhu_benchmark/viewsrc/include/regviewmethod.hpp ./paozhu/viewsrc/include/
+
+
+
+RUN mkdir ./paozhu/orm
+RUN mkdir ./paozhu/orm/include
+
+
+COPY ./paozhu_benchmark/orm/orm.h ./paozhu/orm/
+COPY ./paozhu_benchmark/orm/include/fortunebase.h ./paozhu/orm/include/
+COPY ./paozhu_benchmark/orm/include/worldbase.h ./paozhu/orm/include/
+COPY ./paozhu_benchmark/orm/include/fortune_mysql.h ./paozhu/orm/include/
+COPY ./paozhu_benchmark/orm/include/world_mysql.h ./paozhu/orm/include/
+
+RUN mkdir ./paozhu/models
+RUN mkdir ./paozhu/models/include
+
+COPY ./paozhu_benchmark/models/include/Fortune.h ./paozhu/models/include/
+COPY ./paozhu_benchmark/models/include/World.h ./paozhu/models/include/
+COPY ./paozhu_benchmark/models/World.cpp ./paozhu/models/
+COPY ./paozhu_benchmark/models/Fortune.cpp ./paozhu/models/
+
 WORKDIR /paozhu
 RUN unzip asio.zip
 
 RUN cmake . -B build -DCMAKE_BUILD_TYPE=Release 
 RUN cmake --build build
 
-
 EXPOSE 8888
 
-CMD ./bin/paozhu 
+CMD ./bin/paozhu

frameworks/C++/paozhu/paozhu_benchmark/CMakeLists.txt

@@ -7,21 +7,27 @@ set(ENABLE_BOOST OFF CACHE BOOL "choose ON to enable")
 set(ENABLE_GD OFF CACHE BOOL "choose ON to enable")
 set(ENABLE_WIN_VCPKG OFF CACHE BOOL "choose ON to enable")
 
-if (ENABLE_GD STREQUAL "ON")
-    list(FIND VCPKG_MANIFEST_FEATURES "gd" index)
-    if (index EQUAL -1)
-        message(STATUS "Auto append features: gd")
-        list(APPEND VCPKG_MANIFEST_FEATURES "gd")
-    endif ()
-endif ()
+if(ENABLE_VCPKG)
+    set(vcpkg_root $ENV{VCPKG_ROOT})
+    if(NOT DEFINED CMAKE_TOOLCHAIN_FILE AND vcpkg_root)
+        set(CMAKE_TOOLCHAIN_FILE "${vcpkg_root}/scripts/buildsystems/vcpkg.cmake")
+    endif()
+endif()
 
-if (ENABLE_BOOST STREQUAL "ON")
-    list(FIND VCPKG_MANIFEST_FEATURES "boost" index)
-    if (index EQUAL -1)
-        message(STATUS "Auto append features: boost")
-        list(APPEND VCPKG_MANIFEST_FEATURES "boost")
-    endif ()
-endif ()
+macro(auto_enable_vcpkg_feature opt feature)
+    if(${opt})
+        list(FIND VCPKG_MANIFEST_FEATURES ${feature} index)
+        if(index EQUAL -1)
+            message(STATUS "Auto append features: ${feature}")
+            list(APPEND VCPKG_MANIFEST_FEATURES ${feature})
+        endif()
+    endif()
+endmacro()
+
+if(ENABLE_VCPKG)
+  auto_enable_vcpkg_feature(ENABLE_GD "gd")
+  auto_enable_vcpkg_feature(ENABLE_BOOST "boost")
+endif()
 
 PROJECT(Paozhu_web_framework)
 set(CMAKE_CXX_STANDARD 20)
@@ -59,7 +65,7 @@ endif ()
 if(${mode} AND (CMAKE_BUILD_TYPE STREQUAL "Debug"))
 
     if(CMAKE_SYSTEM_NAME MATCHES "Windows")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DASIO_STANDALONE -DDEBUG ${BOOST_OPEN} ${GD_OPEN}")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DASIO_STANDALONE -DBENCHMARK -DDEBUG ${BOOST_OPEN} ${GD_OPEN}")
         if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
             set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /fsanitize=address")
         elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
@@ -67,20 +73,20 @@ if(${mode} AND (CMAKE_BUILD_TYPE STREQUAL "Debug"))
         endif ()
     else()
         set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall -Wextra")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pthread -g -fsanitize=address -DASIO_STANDALONE -DDEBUG ${BOOST_OPEN} ${GD_OPEN} -I/usr/local/include -I/usr/local/mysql/include   -I/usr/include -I/usr/include/mysql " )
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pthread -g -fsanitize=address -DASIO_STANDALONE -DBENCHMARK -DDEBUG ${BOOST_OPEN} ${GD_OPEN} -I/usr/local/include -I/usr/include " )
     endif ()
     message("Debug mode:${CMAKE_CXX_FLAGS_DEBUG}")
 
 elseif(${mode} AND (CMAKE_BUILD_TYPE STREQUAL "Release"))
 
     if (CMAKE_SYSTEM_NAME MATCHES "Windows")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DASIO_STANDALONE ${BOOST_OPEN} ${GD_OPEN} -O3")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DASIO_STANDALONE ${BOOST_OPEN} ${GD_OPEN} -DBENCHMARK  -O3")
         if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
             set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pthread")
         endif ()
     else ()
         set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -Wall -Wextra -O3")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread  -DASIO_STANDALONE ${BOOST_OPEN} ${GD_OPEN}  -I/usr/local/include -I/usr/local/mysql/include -I/usr/include -I/usr/include/mysql  " )
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread  -DASIO_STANDALONE ${BOOST_OPEN} ${GD_OPEN} -DBENCHMARK -I/usr/local/include -I/usr/include  " )
         file(MAKE_DIRECTORY /usr/local/etc/paozhu)
         file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/conf/ DESTINATION /usr/local/etc/paozhu/)
     endif ()
@@ -89,7 +95,7 @@ elseif(${mode} AND (CMAKE_BUILD_TYPE STREQUAL "Release"))
 else()
     set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall -Wextra")
     message("Debug mode:${CMAKE_CXX_FLAGS_DEBUG}")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pthread  -g -fsanitize=address  -DASIO_STANDALONE -DDEBUG ${BOOST_OPEN} ${GD_OPEN} -I/usr/local/include -I/usr/local/mysql/include   -I/usr/include  -I/usr/include/mysql  " )
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pthread  -g -fsanitize=address  -DASIO_STANDALONE -DBENCHMARK -DDEBUG ${BOOST_OPEN} ${GD_OPEN} -I/usr/local/include -I/usr/include " )
 
     if(NOT CMAKE_SYSTEM_NAME MATCHES "Windows")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address")
@@ -116,14 +122,13 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR}/vendor/httpcli)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/viewsrc/include)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/websockets/include)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/orm)
 
-if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/bin/paozhu_empty)
-  file(REMOVE_RECURSE ${CMAKE_CURRENT_SOURCE_DIR}/bin/paozhu_empty)
-endif ()
-#EXECUTE_PROCESS(COMMAND rm ${CMAKE_CURRENT_SOURCE_DIR}/bin/paozhu_empty)
+if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/bin/paozhu_pre)
+  file(REMOVE_RECURSE ${CMAKE_CURRENT_SOURCE_DIR}/bin/paozhu_pre)
+endif()
 set(PAOZHU_PRE paozhu_pre)
 add_executable(${PAOZHU_PRE} ${CMAKE_CURRENT_SOURCE_DIR}/vendor/httpcli/autopickmethod.cpp ${CMAKE_CURRENT_SOURCE_DIR}/vendor/httpserver/src/md5.cpp)
-add_executable(paozhu_empty ${CMAKE_CURRENT_SOURCE_DIR}/vendor/httpcli/autoemptymethod.cpp)
 
 
 
@@ -138,6 +143,22 @@ file(GLOB_RECURSE src_list ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
 
 foreach(cppfile IN LISTS controller_list)
   string(REGEX REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/controller/src/" "" cppfilename ${cppfile})
+  string(FIND ${cppfilename} "/" strpos)
+  if(${strpos} GREATER_EQUAL "0" )
+      string(REGEX MATCHALL "([A-Za-z0-9._-]+)/" npaths ${cppfilename} )
+      set(fullpaths "")
+      string(APPEND fullpaths "${CMAKE_CURRENT_SOURCE_DIR}/controller/include/")
+      foreach(onepathname ${npaths})
+            string(REPLACE "/" "" toucpath ${onepathname})
+            string(APPEND fullpaths ${toucpath})
+            if (IS_DIRECTORY "${fullpaths}") 
+            else()
+                  message("mkdir ${fullpaths}") 
+                  file(MAKE_DIRECTORY "${fullpaths}")
+            endif()
+            string(APPEND fullpaths "/")
+      endforeach()
+  endif()
   string(REGEX REPLACE ".cpp" "" cppbasename ${cppfilename})
 #  message(${cppbasename})
   if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/controller/include/${cppbasename}.h")
@@ -169,8 +190,9 @@ include_sub_directories_recursively(${CMAKE_CURRENT_SOURCE_DIR}/models)
 include_sub_directories_recursively(${CMAKE_CURRENT_SOURCE_DIR}/controller/include)
 include_sub_directories_recursively(${CMAKE_CURRENT_SOURCE_DIR}/libs)
 include_sub_directories_recursively(${CMAKE_CURRENT_SOURCE_DIR}/include)
+include_sub_directories_recursively(${CMAKE_CURRENT_SOURCE_DIR}/common)
 
-add_executable(paozhu_cli ${CMAKE_CURRENT_SOURCE_DIR}/vendor/httpcli/http_cli.cpp)
+add_executable(paozhu_cli ${CMAKE_CURRENT_SOURCE_DIR}/vendor/httpcli/http_cli.cpp ${CMAKE_CURRENT_SOURCE_DIR}/vendor/httpserver/src/mysql_conn.cpp ${CMAKE_CURRENT_SOURCE_DIR}/vendor/httpserver/src/mysql_conn_pool.cpp ${CMAKE_CURRENT_SOURCE_DIR}/vendor/httpserver/src/clientdatacache.cpp)
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/bin)
 
 
@@ -181,15 +203,12 @@ else()
 endif()
 
 if (ENABLE_WIN_VCPKG STREQUAL "ON")
-else ()
+else()
 add_custom_command(
-    TARGET paozhu_empty paozhu
-    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/bin/paozhu_pre
-    PRE_BUILD
+    TARGET paozhu_pre POST_BUILD
     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/
     COMMAND echo "-- controls method --"
     COMMAND ${PAOZHU_PRE} ${CMAKE_CURRENT_SOURCE_DIR}/
-    COMMAND ${CMAKE_COMMAND} -E remove ${CMAKE_CURRENT_SOURCE_DIR}/bin/paozhu_empty
     )
 endif()
 
@@ -212,14 +231,17 @@ if (ENABLE_VCPKG)
     target_link_libraries(paozhu ZLIB::ZLIB)
 
     # find_package(libmysql REQUIRED)
-    find_package(unofficial-libmariadb CONFIG REQUIRED)
-    find_path(MYSQL_ROOT_DIR mysql)
+    # find_package(unofficial-libmariadb CONFIG REQUIRED)
+    # find_path(MYSQL_ROOT_DIR mysql)
     # target_link_libraries(paozhu ${MYSQL_LIBRARIES})
     # target_link_libraries(paozhu_cli ${MYSQL_LIBRARIES})
-    target_link_libraries(paozhu unofficial::libmariadb)
-    target_link_libraries(paozhu_cli unofficial::libmariadb)
-    target_include_directories(paozhu PUBLIC ${MYSQL_ROOT_DIR}/mysql)
-    target_include_directories(paozhu_cli PUBLIC ${MYSQL_ROOT_DIR}/mysql)
+    # target_link_libraries(paozhu unofficial::libmariadb)
+    # target_link_libraries(paozhu_cli unofficial::libmariadb)
+    # target_include_directories(paozhu PUBLIC ${MYSQL_ROOT_DIR}/mysql)
+    # target_include_directories(paozhu_cli PUBLIC ${MYSQL_ROOT_DIR}/mysql)
+
+    target_link_libraries(paozhu_cli asio::asio)
+    target_link_libraries(paozhu_cli OpenSSL::Crypto OpenSSL::SSL)
 
     if (ENABLE_GD STREQUAL "ON")
         find_package(PkgConfig)
@@ -265,7 +287,7 @@ else ()
 
 if(USE_STANDALONE_ASIO)
 if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
-set(ASIO_PATH "/usr/local/opt/asio/include" "/usr/local/include")
+set(ASIO_PATH "/usr/local/opt/asio/include" "/usr/local/include" "/opt/homebrew/opt/asio" ${CMAKE_CURRENT_SOURCE_DIR}/asio)
 else()
 set(ASIO_PATH ${CMAKE_CURRENT_SOURCE_DIR}/asio "/usr/include")
 endif()
@@ -313,6 +335,9 @@ if(OPENSSL_FOUND)
   INCLUDE_DIRECTORIES("${OPENSSL_INCLUDE_DIR}")
   target_link_libraries (paozhu ${OPENSSL_SSL_LIBRARY})
   target_link_libraries (paozhu ${OPENSSL_CRYPTO_LIBRARY})
+  
+  target_link_libraries (paozhu_cli ${OPENSSL_SSL_LIBRARY})
+  target_link_libraries (paozhu_cli ${OPENSSL_CRYPTO_LIBRARY})
 endif()
 
 
@@ -324,46 +349,81 @@ if(ZLIB_FOUND)
   target_link_libraries(paozhu z)
 endif()
 
-find_path(MYSQL_ROOT_DIR mysql)
-MESSAGE( STATUS "MYSQL_ROOT_DIR = ${MYSQL_ROOT_DIR} ")
-find_package_handle_standard_args(mysql REQUIRED_VARS MYSQL_ROOT_DIR)
 
-FIND_PATH(MYSQL_INCLUDE_DIR mysql.h
-  /usr/local/include/mysql
-  /usr/include/mysql
-  /usr/local/mysql/include
-)
-SET(MYSQL_NAMES mysqlclient)
-FIND_LIBRARY(MYSQL_LIBRARY
-  NAMES ${MYSQL_NAMES}
-  PATHS /usr/lib /usr/local/lib /usr/local/mysql/lib
-  PATH_SUFFIXES mysql
-)
-
-IF (MYSQL_INCLUDE_DIR AND MYSQL_LIBRARY)
-  SET(MYSQL_FOUND TRUE)
-  SET( MYSQL_LIBRARIES ${MYSQL_LIBRARY} )
-ELSE (MYSQL_INCLUDE_DIR AND MYSQL_LIBRARY)
-  SET(MYSQL_FOUND FALSE)
-  SET( MYSQL_LIBRARIES )
-ENDIF (MYSQL_INCLUDE_DIR AND MYSQL_LIBRARY)
-
-IF (MYSQL_FOUND)
-  IF (NOT MYSQL_FIND_QUIETLY)
-    MESSAGE(STATUS "Found MySQL: ${MYSQL_LIBRARY}")
-  ENDIF (NOT MYSQL_FIND_QUIETLY)
-ELSE (MYSQL_FOUND)
-  IF (MYSQL_FIND_REQUIRED)
-    MESSAGE(STATUS "Looked for MySQL libraries named ${MYSQL_NAMES}.")
-    MESSAGE(FATAL_ERROR "Could NOT find MySQL library")
-  ENDIF (MYSQL_FIND_REQUIRED)
-ENDIF (MYSQL_FOUND)
-
-target_include_directories(paozhu PUBLIC ${MYSQL_INCLUDE_DIR})
-target_link_libraries(paozhu ${MYSQL_LIBRARY})
-
-target_include_directories(paozhu_cli PUBLIC ${MYSQL_INCLUDE_DIR})
-target_link_libraries(paozhu_cli ${MYSQL_LIBRARY})
+#if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
+#  if (IS_DIRECTORY "/usr/local/mysql/include")
+# MESSAGE( STATUS "/usr/local/mysql")
+#     set(MYSQL_INCLUDE_DIR "/usr/local/mysql/include")
+#     include_sub_directories_recursively(/usr/local/mysql/include)
+# endif()
+#
+# if (IS_DIRECTORY "/usr/local/opt/mysql-client")
+#       MESSAGE( STATUS "/usr/local/opt/mysql-client")
+#     set(MYSQL_INCLUDE_DIR "/usr/local/opt/mysql-client/include")
+#     include_sub_directories_recursively(/usr/local/opt/mysql-client/include)
+# endif()
+# 
+# if (IS_DIRECTORY "/opt/homebrew/opt/mysql")
+#       MESSAGE( STATUS "/opt/homebrew/opt/mysql")
+#     set(MYSQL_INCLUDE_DIR "/opt/homebrew/opt/mysql/include")
+#     include_sub_directories_recursively(/opt/homebrew/opt/mysql/include)
+# endif()
+#   
+#   
+#   if (IS_DIRECTORY "/opt/homebrew/opt/mysql-client")
+#         MESSAGE( STATUS "/opt/homebrew/opt/mysql-client")
+#       set(MYSQL_INCLUDE_DIR "/opt/homebrew/opt/mysql-client/include")
+#       include_sub_directories_recursively(/opt/homebrew/opt/mysql-client/include)
+#   endif()
+#   MESSAGE( STATUS "MYSQL_ROOT_DIR = ${MYSQL_ROOT_DIR} ")
+#else()  
+#  find_path(MYSQL_ROOT_DIR mysql)
+#endif()
+# 
+# 
+# FIND_PATH(MYSQL_INCLUDE_DIR NAMES mysql.h
+#   PATHS /usr/local/include/mysql /usr/include/mysql /opt/homebrew/opt/mysql/include /usr/local/opt/mysql-client/include /opt/homebrew/opt/mysql-client/include
+# )
+# 
+# MESSAGE( STATUS "MYSQL_ROOT_DIR = ${MYSQL_ROOT_DIR} ")
+# find_package_handle_standard_args(mysql REQUIRED_VARS MYSQL_ROOT_DIR)
+# 
+# 
+# if(NOT MYSQL_INCLUDE_DIR)
+#   message(STATUS "Could not find \"mysql.h\" from searching ")
+# endif()
+# 
+# SET(MYSQL_NAMES mysqlclient)
+# FIND_LIBRARY(MYSQL_LIBRARY
+#   NAMES ${MYSQL_NAMES}
+#   PATHS /usr/lib /usr/local/lib /usr/local/mysql/lib /usr/local/opt/mysql/lib /opt/homebrew/opt/mysql/lib /opt/homebrew/opt/mysql-client/lib
+#   PATH_SUFFIXES mysql
+# )
+# 
+# IF (MYSQL_INCLUDE_DIR AND MYSQL_LIBRARY)
+#   SET(MYSQL_FOUND TRUE)
+#   SET( MYSQL_LIBRARIES ${MYSQL_LIBRARY} )
+# ELSE (MYSQL_INCLUDE_DIR AND MYSQL_LIBRARY)
+#   SET(MYSQL_FOUND FALSE)
+#   SET( MYSQL_LIBRARIES )
+# ENDIF (MYSQL_INCLUDE_DIR AND MYSQL_LIBRARY)
+# 
+# IF (MYSQL_FOUND)
+#   IF (NOT MYSQL_FIND_QUIETLY)
+#     MESSAGE(STATUS "Found MySQL: ${MYSQL_LIBRARY}")
+#   ENDIF (NOT MYSQL_FIND_QUIETLY)
+# ELSE (MYSQL_FOUND)
+#   IF (MYSQL_FIND_REQUIRED)
+#     MESSAGE(STATUS "Looked for MySQL libraries named ${MYSQL_NAMES}.")
+#     MESSAGE(FATAL_ERROR "Could NOT find MySQL library")
+#   ENDIF (MYSQL_FIND_REQUIRED)
+# ENDIF (MYSQL_FOUND)
+# 
+# target_include_directories(paozhu PUBLIC ${MYSQL_INCLUDE_DIR})
+# target_link_libraries(paozhu ${MYSQL_LIBRARY})
+# 
+# target_include_directories(paozhu_cli PUBLIC ${MYSQL_INCLUDE_DIR})
+# target_link_libraries(paozhu_cli ${MYSQL_LIBRARY})
 
 
 
@@ -371,7 +431,17 @@ if(ENABLE_GD STREQUAL "ON")
 message("---ENABLE_GD-----")
 
 if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
-  set(GD_ROOT_DIR "/usr/local/opt/gd/lib")
+  
+  if (IS_DIRECTORY "/usr/local/opt/gd/lib")
+        MESSAGE( STATUS "/usr/local/opt/gd/lib")
+      set(GD_ROOT_DIR "/usr/local/opt/gd/lib")
+      include_sub_directories_recursively(/usr/local/opt/gd/include)
+  endif()
+  if (IS_DIRECTORY "/opt/homebrew/opt/gd/lib")
+        MESSAGE( STATUS "/opt/homebrew/opt/gd/lib")
+      set(GD_ROOT_DIR "/opt/homebrew/opt/gd/lib")
+      include_sub_directories_recursively(/opt/homebrew/opt/gd/include)
+  endif()
 else()
   set(GD_ROOT_DIR "${sys_so_path}")
 endif()
@@ -393,7 +463,18 @@ endif()
 message(STATUS "GD Graphics Library  at: ${GD_LIB_DIR}")
 
 if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
-set(QR_ROOT_DIR "/usr/local/opt/qrencode/lib")
+
+  if (IS_DIRECTORY "/usr/local/opt/qrencode/lib")
+        MESSAGE( STATUS "/usr/local/opt/qrencode/lib")
+      set(QR_ROOT_DIR "/usr/local/opt/qrencode/lib")
+      include_sub_directories_recursively(/usr/local/opt/qrencode/include)
+  endif()
+  if (IS_DIRECTORY "/opt/homebrew/opt/qrencode/lib")
+        MESSAGE( STATUS "/opt/homebrew/opt/qrencode/lib")
+      set(QR_ROOT_DIR "/opt/homebrew/opt/qrencode/lib")
+      include_sub_directories_recursively(/opt/homebrew/opt/qrencode/include)
+  endif()
+  
 else()
 set(QR_ROOT_DIR "${sys_so_path}")
 endif()
@@ -422,7 +503,18 @@ target_link_libraries(paozhu ${GD_LIB_DIR})
 target_link_libraries(paozhu ${QR_LIB_DIR})
 
 if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
-set(PNG_ROOT_DIR "/usr/local/opt/libpng/lib")
+
+  if (IS_DIRECTORY "/usr/local/opt/libpng/lib")
+        MESSAGE( STATUS "/usr/local/opt/libpng/lib")
+      set(PNG_ROOT_DIR "/usr/local/opt/libpng/lib")
+      include_sub_directories_recursively(/usr/local/opt/libpng/include)
+  endif()
+  if (IS_DIRECTORY "/opt/homebrew/opt/libpng/lib")
+        MESSAGE( STATUS "/opt/homebrew/opt/libpng/lib")
+      set(PNG_ROOT_DIR "/opt/homebrew/opt/libpng/lib")
+      include_sub_directories_recursively(/opt/homebrew/opt/libpng/include)
+  endif()
+  
 else()
 set(PNG_ROOT_DIR "${sys_so_path}")
 endif()
@@ -435,7 +527,18 @@ find_library(PNG_LIB_DIR
 target_link_libraries(paozhu ${PNG_LIB_DIR})
 
 if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
-  set(FREETYPE_ROOT_DIR "/usr/local/opt/freetype/lib")
+  
+    if (IS_DIRECTORY "/usr/local/opt/freetype/lib")
+        MESSAGE( STATUS "/usr/local/opt/freetype/lib")
+      set(FREETYPE_ROOT_DIR "/usr/local/opt/freetype/lib")
+      include_sub_directories_recursively(/usr/local/opt/freetype/include)
+  endif()
+  if (IS_DIRECTORY "/opt/homebrew/opt/freetype/lib")
+        MESSAGE( STATUS "/opt/homebrew/opt/freetype/lib")
+      set(FREETYPE_ROOT_DIR "/opt/homebrew/opt/freetype/lib")
+      include_sub_directories_recursively(/opt/homebrew/opt/freetype/include)
+  endif()
+  
 else()
   set(FREETYPE_ROOT_DIR "${sys_so_path}")
 endif()
@@ -450,7 +553,15 @@ target_link_libraries(paozhu ${FREETYPE_LIB_DIR})
 endif()
 
 if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
-  set(BROTLI_ROOT_DIR "/usr/local/opt/brotli/lib")
+  if (IS_DIRECTORY "/usr/local/opt/brotli/lib")
+      set(BROTLI_ROOT_DIR "/usr/local/opt/brotli/lib")
+      INCLUDE_DIRECTORIES("/usr/local/opt/brotli/include")
+  endif()
+#  set(BROTLI_ROOT_DIR "/usr/local/opt/brotli/lib")
+  if (IS_DIRECTORY "/opt/homebrew/opt/brotli/lib")
+      set(BROTLI_ROOT_DIR "/opt/homebrew/opt/brotli/lib")
+      INCLUDE_DIRECTORIES("/opt/homebrew/opt/brotli/include")
+  endif()
 else()
   set(BROTLI_ROOT_DIR "${sys_so_path}")
 endif()
@@ -505,4 +616,4 @@ endif ()
 if (CMAKE_SYSTEM_NAME MATCHES "Windows")
    target_link_libraries(paozhu ws2_32)
    target_link_libraries(paozhu_cli ws2_32)
-endif ()
+endif ()

frameworks/C++/paozhu/paozhu_benchmark/common/autocontrolmethod.hpp

@@ -9,14 +9,21 @@
 #include "httppeer.h" 
 
 #include "techempower.h"
+ 
+namespace http
+{ 
+     
+    void _initauto_control_httpmethodregto(std::map<std::string, regmethold_t> &methodcallback)
+    {
+        struct regmethold_t temp;
 
 
-namespace http
-{
-  void _initauto_control_httpmethodregto(std::map<std::string, regmethold_t> &methodcallback)
-  {
-    struct regmethold_t temp;
 
+    }
+    
+    void _initauto_co_control_httpmethodregto(std::map<std::string, regmethold_co_t> &methodcallback)
+    {
+        struct regmethold_co_t temp;
 		temp.pre = nullptr;
 		temp.regfun = techempowerplaintext;
 		methodcallback.emplace("plaintext",temp);
@@ -44,8 +51,26 @@ namespace http
 
 
     }
-}
+    
+    void _initauto_domain_httpmethodregto(std::map<std::string, std::map<std::string, regmethold_t>> &domain_methodcallback)
+    {
+        struct regmethold_t temp;
+        std::map<std::string, regmethold_t> methodcallback;
+        std::map<std::string, std::map<std::string, regmethold_t>>::iterator domain_iterator;
+    
 
+    }
+    
+    void _initauto_co_domain_httpmethodregto(std::map<std::string, std::map<std::string, regmethold_co_t>> &domain_methodcallback)
+    {
+        struct regmethold_co_t temp;
+        std::map<std::string, regmethold_co_t> methodcallback;
+        std::map<std::string, std::map<std::string, regmethold_co_t>>::iterator domain_iterator;
+    
+
+    }
+        
+}    
 #endif
 
     

frameworks/C++/paozhu/paozhu_benchmark/common/autorestfulpaths.hpp

@@ -0,0 +1,40 @@
+
+#ifndef __HTTP_AUTO_REG_CONTROL_HTTPRESTFUL_HPP
+#define __HTTP_AUTO_REG_CONTROL_HTTPRESTFUL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "httppeer.h" 
+
+
+
+namespace http
+{
+  void _initauto_control_httprestful_paths(std::map<std::string, std::vector<std::string>>  &restfulmethod)
+  {
+    
+
+        if(restfulmethod.size())
+        {}
+        
+
+  }
+    
+    void _initauto_domain_httprestful_paths(std::map<std::string,std::map<std::string, std::vector<std::string>>>  &restfulmethod)
+    {
+        std::map<std::string, std::vector<std::string>> temp_path;
+        std::map<std::string,std::map<std::string, std::vector<std::string>>>::iterator domain_iterator;  
+
+        domain_iterator=restfulmethod.begin();
+        temp_path.clear();
+        
+
+    }
+    
+}
+
+#endif
+
+    

frameworks/C++/paozhu/paozhu_benchmark/common/cost_define.h

@@ -0,0 +1,12 @@
+#pragma once
+#ifndef _CONST_DEFINE_FUNC_H
+#define _CONST_DEFINE_FUNC_H
+
+#define CONST_MONEY_PART 1000000
+#define CONST_HTTP_HEADER_BODY_SIZE 16384
+#define CONST_PHP_BODY_POST_SIZE 16777216
+
+#define CONST_HTTP_BODY_POST_SIZE 33554432
+#define CONST_HTTP_JSON_POST_SIZE 2097152
+
+#endif

frameworks/C++/paozhu/paozhu_benchmark/common/httphook.cpp

@@ -0,0 +1,50 @@
+#include <iostream>
+#include <list>
+#include <map>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <memory>
+#include <string_view>
+#include "httppeer.h"
+#include "client_session.h"
+namespace http
+{
+std::map<std::string, bool> _block_ip_tables;
+std::map<std::string, bool> _block_host_tables;
+std::map<std::string, bool> _passport_ip_tables;
+std::map<std::string, bool> _passport_host_tables;
+bool check_blockip(std::shared_ptr<client_session> peer_session)
+{
+    if (peer_session->isssl)
+    {
+        return false;
+    }
+    return false;
+}
+bool check_pressl_blockip(std::shared_ptr<client_session> peer_session)
+{
+    if (peer_session->isssl)
+    {
+        return false;
+    }
+    return false;
+}
+bool hook_host_http1(std::shared_ptr<httppeer> peer)
+{
+    if (peer->host.size() > 0)
+    {
+        return false;
+    }
+    return false;
+}
+bool hook_host_http2(std::shared_ptr<httppeer> peer)
+{
+    if (peer->host.size() > 0)
+    {
+        return false;
+    }
+    return false;
+}
+}// namespace http

frameworks/C++/paozhu/paozhu_benchmark/common/json_reflect_headers.h

@@ -0,0 +1,19 @@
+#pragma once
+#include <map>
+#include "httppeer.h"
+#include "websockets.h"
+#include "mywebsockets.hpp"
+#include "websockets_callback.h"
+namespace http
+{
+void _initwebsocketmethodregto(WEBSOCKET_REG &methodcallback)
+{
+
+    methodcallback.emplace("wstest", [](std::weak_ptr<httppeer> p) -> std::shared_ptr<websockets_api>
+                           { return http::mywebsockets::create(p); });
+    //    methodcallback.emplace("looptest",[](std::weak_ptr<clientpeer> p)->std::shared_ptr<websockets_api>{
+    //      return http::loopwebsockets::create(p);
+    //   });
+}
+
+}// namespace http

frameworks/C++/paozhu/paozhu_benchmark/conf/orm.conf

@@ -6,7 +6,8 @@ dbname=hello_world
 user=benchmarkdbuser
 password=benchmarkdbpass
 pretable=
-maxpool=5
+maxpool=120
+minpool=30
 dbtype=mysql
 
 type=second
@@ -16,5 +17,6 @@ dbname=hello_world
 user=benchmarkdbuser
 password=benchmarkdbpass
 pretable=
-maxpool=20
+maxpool=120
+minpool=30
 dbtype=mysql

frameworks/C++/paozhu/paozhu_benchmark/conf/server.conf

@@ -3,7 +3,7 @@ threadmax=1024
 threadmin=5
 httpport=8888
 httpsport=4430
-cothreadnum=8 ;Coroutines run on thread num
+cothreadnum=16 ;Coroutines run on thread num
 
 http2_enable=0
 debug_enable=1
@@ -13,21 +13,24 @@ certificate_chain_file=localhost.pem
 private_key_file=localhost.key
 tmp_dh_file=dh4096.pem
 reboot_password=e10adc3949ba59abbe56e057f20f883e ;md5(md5("123456")+"rand_char"+md5("123456"))
+reboot_cron =w1h5 ;MDSW+Hhours reboot process M month D day S season (1 4 7 10) W week  
+clean_cron  =m5t600 ;5-minute interval clean 600 seconds ago inactive connection
+links_restart_process =n9998877ts1te5 ;More than 15000 connections, restart the process from 1:00 am to 5:00 am
 session_type=1 ;session save type 0.file 1.memory 2.redis 3.memcache 4.reserve
 static_file_compress_cache=1 ;1 enable, Cache static file compress(gzip,br) content to cache directory 
-modelspath=/root/benchmark/models
-serverpath=/root/benchmark
-viewpath=/root/benchmark/view
-viewsopath=/root/benchmark/module/view
+modelspath=/paozhu/models
+serverpath=/paozhu
+viewpath=/paozhu/view
+viewsopath=/paozhu/module/view
 
-controlpath=/root/benchmark/controller
-controlsopath=/root/benchmark/module/controller
+controlpath=/paozhu/controller
+controlsopath=/paozhu/module/controller
 
-temppath=/root/benchmark/temp
-logpath=/root/benchmark/log
-wwwpath=/root/benchmark/www/default
-pluginspath=/root/benchmark/plugins
-libspath=/root/benchmark/libs
+temppath=/paozhu/temp
+logpath=/paozhu/log
+wwwpath=/paozhu/www/default
+pluginspath=/paozhu/plugins
+libspath=/paozhu/libs
 directorylist=0
 index=index.html
 ;usehtmlcache=1
@@ -39,4 +42,7 @@ method_after=
 show_visitinfo=0
 upload_max_size=16777216
 
-
+siteid=0
+groupid=0
+alias_domain=
+init_func=

frameworks/C++/paozhu/paozhu_benchmark/controller/include/techempower.h

@@ -5,15 +5,13 @@
 #include "httppeer.h"
 
 namespace http
-{
-
-            
-	std::string techempowerplaintext(std::shared_ptr<httppeer> peer);
-	std::string techempowerjson(std::shared_ptr<httppeer> peer);
-	std::string techempowerdb(std::shared_ptr<httppeer> peer);
-	std::string techempowerqueries(std::shared_ptr<httppeer> peer);
-	std::string techempowerfortunes(std::shared_ptr<httppeer> peer);
-	std::string techempowerupdates(std::shared_ptr<httppeer> peer);
-	std::string techempowercached_queries(std::shared_ptr<httppeer> peer);
-	std::string techempowercached_db(std::shared_ptr<httppeer> peer);
+{        
+	asio::awaitable<std::string> techempowerplaintext(std::shared_ptr<httppeer> peer);
+	asio::awaitable<std::string> techempowerjson(std::shared_ptr<httppeer> peer);
+	asio::awaitable<std::string> techempowerdb(std::shared_ptr<httppeer> peer);
+	asio::awaitable<std::string> techempowerqueries(std::shared_ptr<httppeer> peer);
+	asio::awaitable<std::string> techempowerfortunes(std::shared_ptr<httppeer> peer);
+	asio::awaitable<std::string> techempowerupdates(std::shared_ptr<httppeer> peer);
+	asio::awaitable<std::string> techempowercached_queries(std::shared_ptr<httppeer> peer);
+	asio::awaitable<std::string> techempowercached_db(std::shared_ptr<httppeer> peer);
 }

frameworks/C++/paozhu/paozhu_benchmark/controller/src/techempower.cpp

@@ -6,236 +6,245 @@
 #include <chrono>
 #include "httppeer.h"
 #include "techempower.h"
+#include "techempower_json.h"
 #include "datetime.h"
 #include "func.h"
 #include "pzcache.h"
 #include "json_reflect_headers.h"
-#include "techempower_json.h"
 namespace http
 {
-    //@urlpath(null,plaintext)
-    std::string techempowerplaintext(std::shared_ptr<httppeer> peer)
+//@urlpath(null,plaintext)
+asio::awaitable<std::string> techempowerplaintext(std::shared_ptr<httppeer> peer)
+{
+    peer->type("text/plain; charset=UTF-8");
+    peer->set_header("Date", get_gmttime());
+    peer->output = "Hello, World!";
+    co_return "";
+}
+
+//@urlpath(null,json)
+asio::awaitable<std::string> techempowerjson(std::shared_ptr<httppeer> peer)
+{
+    peer->type("application/json; charset=UTF-8");
+    peer->set_header("Date", get_gmttime());
+    struct techempower_outjson_t a;
+    a.message    = "Hello, World!";
+    peer->output = json_encode(a);
+    co_return "";
+}
+
+//@urlpath(null,db)
+asio::awaitable<std::string> techempowerdb(std::shared_ptr<httppeer> peer)
+{
+    peer->type("application/json; charset=UTF-8");
+    peer->set_header("Date", get_gmttime());
+    auto myworld        = orm::World();
+    unsigned int rd_num = rand_range(1, 10000);
+    myworld.where("id", rd_num);
+    myworld.limit(1);
+    co_await myworld.async_fetch_one();
+    peer->output = myworld.data_tojson();
+    co_return "";
+}
+
+//@urlpath(null,queries)
+asio::awaitable<std::string> techempowerqueries(std::shared_ptr<httppeer> peer)
+{
+    peer->type("application/json; charset=UTF-8");
+    peer->set_header("Date", get_gmttime());
+
+    unsigned int get_num = peer->get["queries"].to_int();
+    if (get_num == 0)
     {
-        peer->type("text/plain; charset=UTF-8");
-        peer->set_header("Date", get_gmttime());
-        peer->output = "Hello, World!";
-        return "";
+        get_num = 1;
     }
-
-    //@urlpath(null,json)
-    std::string techempowerjson(std::shared_ptr<httppeer> peer)
+    else if (get_num > 500)
     {
-        peer->type("application/json; charset=UTF-8");
-        peer->set_header("Date", get_gmttime());
-        struct techempower_outjson_t a;
-        a.message = "Hello, World!";
-        peer->output = json_encode(a);
-        return "";
+        get_num = 500;
     }
-
-    //@urlpath(null,db)
-    std::string techempowerdb(std::shared_ptr<httppeer> peer)
+    auto myworld = orm::World();
+    myworld.record.reserve(get_num);
+    for (unsigned int i = 0; i < get_num; i++)
     {
-        peer->type("application/json; charset=UTF-8");
-        peer->set_header("Date", get_gmttime());
-        auto myworld = orm::World();
+        myworld.wheresql.clear();
         unsigned int rd_num = rand_range(1, 10000);
-        myworld.get_one(rd_num);
-
-        peer->output = myworld.data_tojson();
-        return "";
+        myworld.where("id", rd_num);
+        co_await myworld.async_fetch_append();
     }
 
-    //@urlpath(null,queries)
-    std::string techempowerqueries(std::shared_ptr<httppeer> peer)
-    {
-        peer->type("application/json; charset=UTF-8");
-        peer->set_header("Date", get_gmttime());
+    peer->output = myworld.to_json();
+    co_return "";
+}
 
-        unsigned int get_num = peer->get["queries"].to_int();
-        if (get_num == 0)
-        {
-            get_num = 1;
-        }
-        else if (get_num > 500)
-        {
-            get_num = 500;
-        }
-        auto myworld = orm::World();
-        myworld.record.reserve(get_num);
-        for (unsigned int i = 0; i < get_num; i++)
-        {
-            myworld.wheresql.clear();
-            unsigned int rd_num = rand_range(1, 10000);
-            myworld.where("id", rd_num).fetch_append();
-        }
-
-        peer->output = myworld.to_json();
-        return "";
+//@urlpath(null,fortunes)
+asio::awaitable<std::string> techempowerfortunes(std::shared_ptr<httppeer> peer)
+{
+    peer->type("text/html; charset=UTF-8");
+    peer->set_header("Date", get_gmttime());
+
+    auto myfortune = orm::Fortune();
+    co_await myfortune.async_fetch();
+    myfortune.data.id      = 0;
+    myfortune.data.message = "Additional fortune added at request time.";
+    myfortune.record.push_back(myfortune.data);
+
+    std::sort(myfortune.record.begin(), myfortune.record.end(), [](const auto &lhs, const auto &rhs)
+              { return lhs.message < rhs.message; });
+    peer->val["list"].set_array();
+    OBJ_ARRAY item;
+    for (unsigned int i = 0; i < myfortune.record.size(); i++)
+    {
+        item["id"]      = myfortune.record[i].id;
+        item["message"] = html_encode(myfortune.record[i].message);
+        peer->val["list"].push(item);
     }
+    peer->view("techempower/fortunes");
+    // peer->output = "<!DOCTYPE html><html><head><title>Fortunes</title></head><body><table><tr><th>id</th><th>message</th></tr>";
+    // for (unsigned int i = 0; i < myfortune.record.size(); i++)
+    // {
+    //     peer->output += "<tr><td>" + std::to_string(myfortune.record[i].id) + "</td><td>" + html_encode(myfortune.record[i].message) + "</td></tr>";
+    // }
+    // peer->output += "</table></body></html>";
+    co_return "";
+}
+
+//@urlpath(null,updates)
+asio::awaitable<std::string> techempowerupdates(std::shared_ptr<httppeer> peer)
+{
+    peer->type("application/json; charset=UTF-8");
+    peer->set_header("Date", get_gmttime());
+    unsigned int get_num = peer->get["queries"].to_int();
 
-    //@urlpath(null,fortunes)
-    std::string techempowerfortunes(std::shared_ptr<httppeer> peer)
+    if (get_num == 0)
     {
-        peer->type("text/html; charset=UTF-8");
-        peer->set_header("Date", get_gmttime());
-
-        auto myfortune = orm::Fortune();
-        myfortune.fetch();
-        myfortune.data.id = 0;
-        myfortune.data.message = "Additional fortune added at request time.";
-        myfortune.record.push_back(myfortune.data);
-
-        std::sort(myfortune.record.begin(), myfortune.record.end(), [](const auto &lhs, const auto &rhs)
-                  { return lhs.message < rhs.message; });
-        peer->val["list"].set_array();
-        OBJ_ARRAY item;
-        for (unsigned int i = 0; i < myfortune.record.size(); i++)
-        {
-            item["id"] = myfortune.record[i].id;
-            item["message"] = html_encode(myfortune.record[i].message);
-            peer->val["list"].push(item);
-        }
-
-        peer->view("techempower/fortunes");
-        return "";
+        get_num = 1;
     }
-
-    //@urlpath(null,updates)
-    std::string techempowerupdates(std::shared_ptr<httppeer> peer)
+    else if (get_num > 500)
     {
-        peer->type("application/json; charset=UTF-8");
-        peer->set_header("Date", get_gmttime());
-        unsigned int get_num = peer->get["queries"].to_int();
-
-        if (get_num == 0)
-        {
-            get_num = 1;
-        }
-        else if (get_num > 500)
-        {
-            get_num = 500;
-        }
-        auto myworld = orm::World();
-        myworld.record.clear();
-        myworld.record.reserve(get_num);
-        for (unsigned int i = 0; i < get_num; i++)
+        get_num = 500;
+    }
+    auto myworld = orm::World();
+    myworld.record.clear();
+    myworld.record.reserve(get_num);
+    for (unsigned int i = 0; i < get_num; i++)
+    {
+        myworld.wheresql.clear();
+        myworld.where("id", rand_range(1, 10000));
+        co_await myworld.async_fetch_append();
+        if (myworld.effect() > 0)
         {
-            myworld.wheresql.clear();
-            myworld.where("id", rand_range(1, 10000)).fetch_append();
-            if (myworld.effect() > 0)
-            {
-                unsigned int j = myworld.record.size() - 1;
-                myworld.data.randomnumber = rand_range(1, 10000);
-                myworld.record[j].randomnumber = myworld.data.randomnumber;
-                myworld.update("randomnumber");
-            }
+            unsigned int j                 = myworld.record.size() - 1;
+            myworld.data.randomnumber      = rand_range(1, 10000);
+            myworld.record[j].randomnumber = myworld.data.randomnumber;
+            co_await myworld.async_update("randomnumber");
         }
-        peer->output = myworld.to_json();
-        return "";
     }
+    peer->output = myworld.to_json();
+    co_return "";
+}
 
-    //@urlpath(null,cached-queries)
-    std::string techempowercached_queries(std::shared_ptr<httppeer> peer)
-    {
-        peer->type("application/json; charset=UTF-8");
-        peer->set_header("Date", get_gmttime());
+//@urlpath(null,cached-queries)
+asio::awaitable<std::string> techempowercached_queries(std::shared_ptr<httppeer> peer)
+{
+    peer->type("application/json; charset=UTF-8");
+    peer->set_header("Date", get_gmttime());
 
-        unsigned int get_num = peer->get["count"].to_int();
-        if (get_num == 0)
-        {
-            get_num = 1;
-        }
-        else if (get_num > 500)
-        {
-            get_num = 500;
-        }
-        auto myworld = orm::World();
-        std::string mycacheid = "alldatacache";
+    unsigned int get_num = peer->get["count"].to_int();
+    if (get_num == 0)
+    {
+        get_num = 1;
+    }
+    else if (get_num > 500)
+    {
+        get_num = 500;
+    }
+    auto myworld          = orm::World();
+    std::string mycacheid = "alldatacache";
 
-        pzcache<std::vector<orm::worldbase::meta>> &temp_cache = pzcache<std::vector<orm::worldbase::meta>>::conn();
+    pzcache<std::vector<orm::worldbase::meta>> &temp_cache = pzcache<std::vector<orm::worldbase::meta>>::conn();
 
-        std::vector<orm::worldbase::meta> allcachedata_array;
-        allcachedata_array.reserve(10000);
-        // create rand data to cache
-        if (temp_cache.check(mycacheid) > -1)
-        {
-            allcachedata_array = temp_cache.get(mycacheid);
-        }
-        else
-        {
-            allcachedata_array.resize(10000);
-            for (unsigned int i = 0; i < 10000; i++)
-            {
-                allcachedata_array[i].id = i + 1;
-                allcachedata_array[i].randomnumber = rand_range(1, 10000);
-            }
-            temp_cache.save(mycacheid, allcachedata_array, 120);
-        }
-        // get rand data from cache
-        mycacheid = "my" + std::to_string(get_num);
-        myworld.record.reserve(get_num);
-        if (temp_cache.check(mycacheid) > -1)
+    std::vector<orm::worldbase::meta> allcachedata_array;
+    allcachedata_array.reserve(10000);
+    //create rand data to cache
+    if (temp_cache.check(mycacheid) > -1)
+    {
+        allcachedata_array = temp_cache.get(mycacheid);
+    }
+    else
+    {
+        allcachedata_array.resize(10000);
+        for (unsigned int i = 0; i < 10000; i++)
         {
-            myworld.record = temp_cache.get(mycacheid);
+            allcachedata_array[i].id           = i + 1;
+            allcachedata_array[i].randomnumber = rand_range(1, 10000);
         }
-        else
+        temp_cache.save(mycacheid, allcachedata_array, 360);
+    }
+    //get rand data from cache
+    mycacheid = "my" + std::to_string(get_num);
+    myworld.record.reserve(get_num);
+    if (temp_cache.check(mycacheid) > -1)
+    {
+        myworld.record = temp_cache.get(mycacheid);
+    }
+    else
+    {
+        if (allcachedata_array.size() == 10000)
         {
-            if (allcachedata_array.size() == 10000)
+            for (unsigned int i = 0; i < get_num; i++)
             {
-                for (unsigned int i = 0; i < get_num; i++)
-                {
-                    unsigned int temp_rid = rand_range(0, 9999);
-                    myworld.record.push_back(allcachedata_array[temp_rid]);
-                }
+                unsigned int temp_rid = rand_range(0, 9999);
+                myworld.record.push_back(allcachedata_array[temp_rid]);
             }
-            temp_cache.save(mycacheid, myworld.record, 120);
         }
-
-        peer->output = myworld.to_json();
-        return "";
+        temp_cache.save(mycacheid, myworld.record, 360);
     }
 
-    //@urlpath(null,cached-db)
-    std::string techempowercached_db(std::shared_ptr<httppeer> peer)
+    peer->output = myworld.to_json();
+    co_return "";
+}
+
+//@urlpath(null,cached-db)
+asio::awaitable<std::string> techempowercached_db(std::shared_ptr<httppeer> peer)
+{
+    peer->type("application/json; charset=UTF-8");
+    peer->set_header("Date", get_gmttime());
+    //this test from database to cache
+    unsigned int get_num = peer->get["count"].to_int();
+    if (get_num == 0)
     {
-        peer->type("application/json; charset=UTF-8");
-        peer->set_header("Date", get_gmttime());
-        // this test from database to cache
-        unsigned int get_num = peer->get["count"].to_int();
-        if (get_num == 0)
-        {
-            get_num = 1;
-        }
-        else if (get_num > 500)
-        {
-            get_num = 500;
-        }
-        auto myworld = orm::World();
-        std::string mycacheid = "my" + std::to_string(get_num);
+        get_num = 1;
+    }
+    else if (get_num > 500)
+    {
+        get_num = 500;
+    }
+    auto myworld          = orm::World();
+    std::string mycacheid = "my" + std::to_string(get_num);
 
-        pzcache<std::vector<orm::worldbase::meta>> &temp_cache = pzcache<std::vector<orm::worldbase::meta>>::conn();
+    pzcache<std::vector<orm::worldbase::meta>> &temp_cache = pzcache<std::vector<orm::worldbase::meta>>::conn();
 
-        myworld.record.reserve(get_num);
-        if (temp_cache.check(mycacheid) > -1)
-        {
-            myworld.record = temp_cache.get(mycacheid);
-        }
-        else
+    myworld.record.reserve(get_num);
+    if (temp_cache.check(mycacheid) > -1)
+    {
+        myworld.record = temp_cache.get(mycacheid);
+    }
+    else
+    {
+        std::vector<unsigned int> cacheid;
+        for (unsigned int i = 0; i < get_num; i++)
         {
-            std::vector<unsigned int> cacheid;
-            for (unsigned int i = 0; i < get_num; i++)
-            {
-                cacheid.push_back(rand_range(1, 10000));
-            }
-
-            std::string sqlstr = array_to_sql(cacheid);
-            myworld.whereIn("id", sqlstr).fetch();
-            temp_cache.save(mycacheid, myworld.record, 120);
+            cacheid.push_back(rand_range(1, 10000));
         }
 
-        peer->output = myworld.to_json();
-        return "";
+        std::string sqlstr = array_to_sql(cacheid);
+        myworld.whereIn("id", sqlstr);
+        co_await myworld.async_fetch();
+        temp_cache.save(mycacheid, myworld.record, 360);
     }
 
-} // namespace http
+    peer->output = myworld.to_json();
+    co_return "";
+}
+
+}// namespace http

frameworks/C++/paozhu/paozhu_benchmark/models/Fortune.cpp

@@ -0,0 +1,16 @@
+
+#include "fortune_mysql.h"
+#include "fortunebase.h"
+#include "Fortune.h"
+
+/* 如果此文件存在不会自动覆盖，没有则会自动生成。
+*If this file exists, it will not be overwritten automatically. If not, it will be generated automatically. */
+
+	 
+ namespace orm{
+ 
+			 Fortune::Fortune(std::string dbtag):fortune_mysql(dbtag){ mod=this; }
+			 Fortune::Fortune():fortune_mysql(){ mod=this; }
+
+
+	  }

frameworks/C++/paozhu/paozhu_benchmark/models/World.cpp

@@ -0,0 +1,16 @@
+
+#include "world_mysql.h"
+#include "worldbase.h"
+#include "World.h"
+
+/* 如果此文件存在不会自动覆盖，没有则会自动生成。
+*If this file exists, it will not be overwritten automatically. If not, it will be generated automatically. */
+
+	 
+ namespace orm{
+ 
+			 World::World(std::string dbtag):world_mysql(dbtag){ mod=this; }
+			 World::World():world_mysql(){ mod=this; }
+
+
+	  }

frameworks/C++/paozhu/paozhu_benchmark/models/include/Fortune.h

@@ -0,0 +1,16 @@
+#ifndef ORM_DEFAULT_FORTUNE_H
+#define ORM_DEFAULT_FORTUNE_H
+#include "fortune_mysql.h" 
+#include "fortunebase.h"
+
+/* 如果此文件存在不会自动覆盖，没有则会自动生成。
+*If this file exists, it will not be overwritten automatically. If not, it will be generated automatically. */
+
+ namespace orm {
+		class Fortune : public fortune_mysql<Fortune,fortunebase>{
+		 public:
+		 Fortune(std::string dbtag);
+		 Fortune();
+		};
+}
+#endif

frameworks/C++/paozhu/paozhu_benchmark/models/include/World.h

@@ -0,0 +1,16 @@
+#ifndef ORM_DEFAULT_WORLD_H
+#define ORM_DEFAULT_WORLD_H
+#include "world_mysql.h" 
+#include "worldbase.h"
+
+/* 如果此文件存在不会自动覆盖，没有则会自动生成。
+*If this file exists, it will not be overwritten automatically. If not, it will be generated automatically. */
+
+ namespace orm {
+		class World : public world_mysql<World,worldbase>{
+		 public:
+		 World(std::string dbtag);
+		 World();
+		};
+}
+#endif

frameworks/C++/paozhu/paozhu_benchmark/orm/include/fortune_mysql.h

@@ -0,0 +1,9788 @@
+#ifndef _ORM_DEFAULT_FORTUNE_OPERATE_H
+#define _ORM_DEFAULT_FORTUNE_OPERATE_H
+
+#include <iostream>
+#include <mutex>
+#include <string>
+#include <map>
+#include <set>
+#include <string_view>
+#include <thread>
+#include "request.h"
+#include "unicode.h"
+#include "datetime.h"
+#include <stdexcept>
+#include <iostream>
+#include <functional>
+#include <tuple>
+#include <typeinfo>
+#include <memory>
+#include <list>
+#include <queue>
+#include <cmath>
+#include <condition_variable>
+#include <sstream>
+#include <algorithm>
+#include <vector>
+
+#include "mysql_conn.h"
+#include "mysql_conn_pool.h"
+#include "orm_cache.hpp"
+/*baseincludefile*/
+namespace orm
+{
+// mysql Operational SQL middleware
+/*tagnamespace*/
+//{ /*tagnamespace_replace*/
+    template <typename M_MODEL, typename B_BASE>
+    class fortune_mysql : public B_BASE
+    {
+      public:
+        fortune_mysql(const std::string &tag) : dbtag(tag)
+        {
+            std::map<std::string, std::shared_ptr<orm_conn_pool>> &conn_pool_obj = get_orm_conn_pool_obj();
+            auto iter                                                            = conn_pool_obj.find(dbtag);
+            if (iter != conn_pool_obj.end())
+            {
+                conn_obj = iter->second;
+            }
+            else
+            {
+                conn_obj  = nullptr;
+                iserror   = true;
+                error_msg = "conn_pool not found " + dbtag;
+            }
+        }
+        fortune_mysql() : dbtag(B_BASE::_rmstag)
+        {
+            std::map<std::string, std::shared_ptr<orm_conn_pool>> &conn_pool_obj = get_orm_conn_pool_obj();
+            auto iter                                                            = conn_pool_obj.find(dbtag);
+            if (iter != conn_pool_obj.end())
+            {
+                conn_obj = iter->second;
+            }
+            else
+            {
+                conn_obj  = nullptr;
+                iserror   = true;
+                error_msg = "conn_pool not found " + dbtag;
+            }
+        }
+        M_MODEL &switchDB(const std::string &temptag)
+        {
+            std::map<std::string, std::shared_ptr<orm_conn_pool>> &conn_pool_obj = get_orm_conn_pool_obj();
+            auto iter                                                            = conn_pool_obj.find(temptag);
+            if (iter != conn_pool_obj.end())
+            {
+                conn_obj = iter->second;
+            }
+            else
+            {
+                conn_obj  = nullptr;
+                iserror   = true;
+                error_msg = "conn_pool not found " + temptag;
+            }
+        }
+        M_MODEL &set_table(const std::string &table_name)
+        {
+            if (original_tablename.empty())
+            {
+                original_tablename = B_BASE::tablename;
+            }
+            if (table_name.size() > 0)
+            {
+                B_BASE::tablename = table_name;
+            }
+            return *mod;
+        }
+        M_MODEL &reset_table()
+        {
+            if (original_tablename.empty())
+            {
+                return *mod;
+            }
+            B_BASE::tablename = original_tablename;
+            return *mod;
+        }
+        unsigned int count()
+        {
+            std::string countsql;
+            countsql = "SELECT count(*) as total_countnum  FROM ";
+            countsql.append(B_BASE::tablename);
+            countsql.append(" WHERE ");
+            if (wheresql.empty())
+            {
+                countsql.append(" 1 ");
+            }
+            else
+            {
+                countsql.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                countsql.append(groupsql);
+            }
+            if (!limitsql.empty())
+            {
+                countsql.append(limitsql);
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+
+            try
+            {
+                effect_num = 0;
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_select_conn();
+
+                unsigned int querysql_len = countsql.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(countsql);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                //std::vector<field_info_t> field_array;
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+                unsigned int offset        = 0;
+
+                querysql_len = 0;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = conn->read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int tempnum = 0;
+
+                                unsigned int name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                querysql_len = 0;
+                                for (unsigned int ik = 0; ik < name_length; ik++)
+                                {
+                                    if (temp_pack_data.data[tempnum] >= '0' && temp_pack_data.data[tempnum] <= '9')
+                                    {
+                                        querysql_len = querysql_len * 10 + (temp_pack_data.data[tempnum] - '0');
+                                    }
+                                    tempnum++;
+                                }
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+
+                conn_obj->back_select_conn(conn);
+
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        save_cache(exptime);
+                        exptime = 0;
+                        iscache = false;
+                    }
+                }
+                return querysql_len;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                return 0;
+            }
+
+            return 0;
+        }
+        std::tuple<unsigned int, unsigned int, unsigned int, unsigned int>
+        page(unsigned int page, unsigned int per_page = 10, unsigned int list_num = 5)
+        {
+            unsigned int total_page = count();
+            if (per_page == 0)
+            {
+                per_page = 10;
+            }
+            if (list_num < 1)
+            {
+                list_num = 1;
+            }
+            total_page = std::ceil((float)total_page / per_page);
+
+            if (total_page < 1)
+            {
+                total_page = 1;
+            }
+            if (page > total_page)
+            {
+                page = total_page;
+            }
+            if (page < 1)
+            {
+                page = 1;
+            }
+            unsigned int mid_num  = std::floor(list_num / 2);
+            unsigned int last_num = list_num - 1;
+
+            int temp_num = page - mid_num;
+
+            unsigned int minpage = temp_num < 1 ? 1 : temp_num;
+            unsigned int maxpage = minpage + last_num;
+
+            if (maxpage > total_page)
+            {
+                maxpage  = total_page;
+                temp_num = (maxpage - last_num);
+                if (temp_num < 1)
+                {
+                    minpage = 1;
+                }
+                else
+                {
+                    minpage = temp_num;
+                }
+            }
+            limit((page - 1) * per_page, per_page);
+            return std::make_tuple(minpage, maxpage, page, total_page);
+        }
+        asio::awaitable<unsigned int> async_count()
+        {
+            std::string countsql;
+            countsql = "SELECT count(*) as total_countnum  FROM ";
+            countsql.append(B_BASE::tablename);
+            countsql.append(" WHERE ");
+            if (wheresql.empty())
+            {
+                countsql.append(" 1 ");
+            }
+            else
+            {
+                countsql.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                countsql.append(groupsql);
+            }
+            if (!limitsql.empty())
+            {
+                countsql.append(limitsql);
+            }
+
+            if (iserror)
+            {
+                co_return 0;
+            }
+
+            try
+            {
+                effect_num = 0;
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_select_conn();
+
+                unsigned int querysql_len = countsql.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(countsql);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                //std::vector<field_info_t> field_array;
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+                unsigned int offset        = 0;
+
+                querysql_len = 0;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = co_await conn->async_read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int tempnum = 0;
+
+                                unsigned int name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                querysql_len = 0;
+                                for (unsigned int ik = 0; ik < name_length; ik++)
+                                {
+                                    if (temp_pack_data.data[tempnum] >= '0' && temp_pack_data.data[tempnum] <= '9')
+                                    {
+                                        querysql_len = querysql_len * 10 + (temp_pack_data.data[tempnum] - '0');
+                                    }
+                                    tempnum++;
+                                }
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+
+                conn_obj->back_select_conn(conn);
+
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        save_cache(exptime);
+                        exptime = 0;
+                        iscache = false;
+                    }
+                }
+                co_return querysql_len;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                co_return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                co_return 0;
+            }
+            co_return 0;
+        }
+
+        asio::awaitable<std::tuple<unsigned int, unsigned int, unsigned int, unsigned int>>
+        async_page(unsigned int page, unsigned int per_page = 10, unsigned int list_num = 5)
+        {
+            unsigned int total_page = async_count();
+            if (per_page == 0)
+            {
+                per_page = 10;
+            }
+            if (list_num < 1)
+            {
+                list_num = 1;
+            }
+            total_page = std::ceil((float)total_page / per_page);
+
+            if (total_page < 1)
+            {
+                total_page = 1;
+            }
+            if (page > total_page)
+            {
+                page = total_page;
+            }
+            if (page < 1)
+            {
+                page = 1;
+            }
+            unsigned int mid_num  = std::floor(list_num / 2);
+            unsigned int last_num = list_num - 1;
+
+            int temp_num = page - mid_num;
+
+            unsigned int minpage = temp_num < 1 ? 1 : temp_num;
+            unsigned int maxpage = minpage + last_num;
+
+            if (maxpage > total_page)
+            {
+                maxpage  = total_page;
+                temp_num = (maxpage - last_num);
+                if (temp_num < 1)
+                {
+                    minpage = 1;
+                }
+                else
+                {
+                    minpage = temp_num;
+                }
+            }
+            limit((page - 1) * per_page, per_page);
+            co_return std::make_tuple(minpage, maxpage, page, total_page);
+        }
+
+        unsigned int update_col(std::string colname, int num, char symbol = '+')
+        {
+            effect_num = 0;
+            std::string countsql;
+            countsql = "UPDATE ";
+            countsql.append(B_BASE::tablename);
+            countsql.append(" SET ");
+            countsql.append(colname);
+            if (num > 0)
+            {
+                countsql.append(" = ");
+                countsql.append(colname);
+                countsql.push_back(' ');
+                countsql.push_back(symbol);
+                countsql.append(std::to_string(num));
+            }
+            else
+            {
+                countsql.append(" = ");
+                countsql.append(colname);
+                countsql.push_back(' ');
+                countsql.push_back(symbol);
+                countsql.push_back('(');
+                countsql.push_back('-');
+                countsql.append(std::to_string(std::abs(num)));
+                countsql.push_back(')');
+            }
+            countsql.append(" where ");
+            if (wheresql.empty())
+            {
+                if (B_BASE::getPK() > 0)
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    countsql.append(tempsql.str());
+                }
+                else
+                {
+                    return 0;
+                }
+            }
+            else
+            {
+                countsql.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                countsql.append(groupsql);
+            }
+            if (!limitsql.empty())
+            {
+                countsql.append(limitsql);
+            }
+            if (iscommit)
+            {
+                iscommit = false;
+                return 0;
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = countsql.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(countsql);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    //insertid      = pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    return effect_num;
+                }
+
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+
+            }
+            return 0;
+        }
+
+        asio::awaitable<unsigned int> async_update_col(std::string colname, int num, char symbol = '+')
+        {
+            effect_num = 0;
+            std::string countsql;
+            countsql = "UPDATE ";
+            countsql.append(B_BASE::tablename);
+            countsql.append(" SET ");
+            countsql.append(colname);
+            if (num > 0)
+            {
+                countsql.append(" = ");
+                countsql.append(colname);
+                countsql.push_back(' ');
+                countsql.push_back(symbol);
+                countsql.append(std::to_string(num));
+            }
+            else
+            {
+                countsql.append(" = ");
+                countsql.append(colname);
+                countsql.push_back(' ');
+                countsql.push_back(symbol);
+                countsql.push_back('(');
+                countsql.push_back('-');
+                countsql.append(std::to_string(std::abs(num)));
+                countsql.push_back(')');
+            }
+            countsql.append(" where ");
+            if (wheresql.empty())
+            {
+                if (B_BASE::getPK() > 0)
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    countsql.append(tempsql.str());
+                }
+                else
+                {
+                    co_return 0;
+                }
+            }
+            else
+            {
+                countsql.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                countsql.append(groupsql);
+            }
+            if (!limitsql.empty())
+            {
+                countsql.append(limitsql);
+            }
+            if (iscommit)
+            {
+                iscommit = false;
+                co_return 0;
+            }
+
+            if (iserror)
+            {
+                co_return 0;
+            }
+
+            try
+            {
+
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_edit_conn();
+
+                unsigned int querysql_len = countsql.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(countsql);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+
+                unsigned int offset = 0;
+                n                   = co_await conn->async_read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    //insertid      = pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    co_return effect_num;
+                }
+
+                co_return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                co_return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                
+            }
+            co_return 0;
+        }
+
+        int replace_col(std::string colname, const std::string &old_string, const std::string &new_string)
+        {
+            effect_num = 0;
+            std::string countsql;
+            countsql = "UPDATE ";
+            countsql.append(B_BASE::tablename);
+            countsql.append(" SET ");
+            countsql.append(colname);
+
+            countsql.append(" = REPLACE(");
+            countsql.append(colname);
+            countsql.append(",'");
+            countsql.append(old_string);
+            countsql.append("','");
+            countsql.append(new_string);
+            countsql.append("') ");
+
+            countsql.append(" where ");
+            if (wheresql.empty())
+            {
+                if (B_BASE::getPK() > 0)
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    countsql.append(tempsql.str());
+                }
+                else
+                {
+                    return 0;
+                }
+            }
+            else
+            {
+                countsql.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                countsql.append(groupsql);
+            }
+            if (!limitsql.empty())
+            {
+                countsql.append(limitsql);
+            }
+            if (iscommit)
+            {
+                iscommit = false;
+                return 0;
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = countsql.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(countsql);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    //insertid      = pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    return effect_num;
+                }
+
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                
+            }
+            return 0;
+        }
+
+        void assign_field_value(unsigned char index_pos, unsigned char *result_temp_data, unsigned int value_size, typename B_BASE::meta &data_temp)
+    {
+        switch(index_pos)
+        {
+            case 0:
+            data_temp.id=0;
+            
+            for(unsigned int i=0; i< value_size; i++)
+            {
+                if(result_temp_data[i]>='0'&&result_temp_data[i]<='9')
+                {
+
+                data_temp.id= data_temp.id * 10 + (result_temp_data[i]-'0');
+                }   
+                if(i>32)
+                {
+                    break;
+                }
+            }
+            break;
+                case 1:
+            data_temp.message.clear();
+            data_temp.message.resize(value_size);
+            
+            std::memcpy(data_temp.message.data(), result_temp_data, value_size);
+            break;
+                
+        }
+    }
+    
+
+M_MODEL& eqId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id = ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& nqId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id != ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& inId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id IN(");
+
+        wheresql.append(val);
+        wheresql.push_back(')');
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& inId(const std::vector<T>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+            wheresql.append(std::to_string(val[i]));
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& inId(const std::vector<std::string>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+
+            try
+            {
+                wheresql.append(std::to_string(std::stoll(val[i])));
+            }
+            catch (std::invalid_argument const& ex)
+            {
+                wheresql.push_back('0');
+            }
+            catch (std::out_of_range const& ex)
+            {
+                wheresql.push_back('0');
+            }
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& ninId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id NOT IN(");
+
+        wheresql.append(val);
+        wheresql.push_back(')');
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& ninId(const std::vector<T>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id NOT IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+            wheresql.append(std::to_string(val[i]));
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& ninId(const std::vector<std::string>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id NOT IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+
+            try
+            {
+                wheresql.append(std::to_string(std::stoll(val[i])));
+            }
+            catch (std::invalid_argument const& ex)
+            {
+                wheresql.push_back('0');
+            }
+            catch (std::out_of_range const& ex)
+            {
+                wheresql.push_back('0');
+            }
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& btId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id > ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& beId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id >= ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& ltId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id < ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& leId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id <= ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_eqId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id = ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_nqId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id != ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_inId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id IN(");
+
+        wheresql.append(val);
+        wheresql.push_back(')');
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_inId(const std::vector<T>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+            wheresql.append(std::to_string(val[i]));
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_inId(const std::vector<std::string>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+
+            try
+            {
+                wheresql.append(std::to_string(std::stoll(val[i])));
+            }
+            catch (std::invalid_argument const& ex)
+            {
+                wheresql.push_back('0');
+            }
+            catch (std::out_of_range const& ex)
+            {
+                wheresql.push_back('0');
+            }
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_ninId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id NOT IN(");
+
+        wheresql.append(val);
+        wheresql.push_back(')');
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_ninId(const std::vector<T>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id NOT IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+            wheresql.append(std::to_string(val[i]));
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_ninId(const std::vector<std::string>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id NOT IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+
+            try
+            {
+                wheresql.append(std::to_string(std::stoll(val[i])));
+            }
+            catch (std::invalid_argument const& ex)
+            {
+                wheresql.push_back('0');
+            }
+            catch (std::out_of_range const& ex)
+            {
+                wheresql.push_back('0');
+            }
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_btId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id > ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_beId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id >= ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_ltId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id < ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_leId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id <= ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& eqId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id = ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& nqId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id != ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& btId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id > ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& beId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id >= ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& ltId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id < ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& leId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id <= ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_eqId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id = ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_nqId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id != ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_btId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id > ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_beId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id >= ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_ltId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id < ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_leId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id <= ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+M_MODEL& nullMessage()
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message = NULL ");
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& nnullMessage()
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message != NULL ");
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& eqMessage(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message = '");
+				wheresql.append(B_BASE::stringaddslash(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& nqMessage(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message != '");
+				wheresql.append(B_BASE::stringaddslash(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& inMessage(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message IN(");
+				wheresql.append(val);
+				wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& inMessage(const std::vector<std::string> &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i>0)
+            {
+                wheresql.push_back(',');  
+            }
+            wheresql.push_back('\'');  
+            wheresql.append(B_BASE::stringaddslash(val[i]));
+            wheresql.push_back('\'');    
+        }
+    
+
+    
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& inMessage(const std::vector<T> &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i>0)
+            {
+                wheresql.push_back(',');  
+            }
+            wheresql.push_back('\'');  
+            wheresql.append(std::to_string(val[i]));
+            wheresql.push_back('\'');    
+        }
+    
+
+    
+        return *mod;   
+    }   
+    
+
+M_MODEL& ninMessage(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message NOT IN(");
+				wheresql.append(val);
+				wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& ninMessage(const std::vector<std::string> &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message NOT IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i>0)
+            {
+                wheresql.push_back(',');  
+            }
+            wheresql.push_back('\'');  
+            wheresql.append(B_BASE::stringaddslash(val[i]));
+            wheresql.push_back('\'');    
+        }
+    
+
+    
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& ninMessage(const std::vector<T> &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message NOT IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i>0)
+            {
+                wheresql.push_back(',');  
+            }
+            wheresql.push_back('\'');  
+            wheresql.append(std::to_string(val[i]));
+            wheresql.push_back('\'');    
+        }
+    
+
+    
+        return *mod;   
+    }   
+    
+
+M_MODEL& likeMessage(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message LIKE '%");
+				wheresql.append(B_BASE::stringaddslash(val));
+				wheresql.append("%'");
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& l_likeMessage(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message LIKE '%");
+				wheresql.append(B_BASE::stringaddslash(val));
+				wheresql.append("'");
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& r_likeMessage(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message LIKE '");
+				wheresql.append(B_BASE::stringaddslash(val));
+				wheresql.append("%'");
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& btMessage(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message > '");
+				wheresql.append(B_BASE::stringaddslash(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& beMessage(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message >= '");
+				wheresql.append(B_BASE::stringaddslash(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& ltMessage(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message < '");
+				wheresql.append(B_BASE::stringaddslash(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& leMessage(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message <= '");
+				wheresql.append(B_BASE::stringaddslash(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_nullMessage()
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message = NULL ");
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_nnullMessage()
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message != NULL ");
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_eqMessage(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message = '");
+				wheresql.append(B_BASE::stringaddslash(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_nqMessage(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message != '");
+				wheresql.append(B_BASE::stringaddslash(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_inMessage(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message IN(");
+				wheresql.append(val);
+				wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_inMessage(const std::vector<std::string> &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i>0)
+            {
+                wheresql.push_back(',');  
+            }
+            wheresql.push_back('\'');  
+            wheresql.append(B_BASE::stringaddslash(val[i]));
+            wheresql.push_back('\'');    
+        }
+    
+
+    
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_inMessage(const std::vector<T> &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i>0)
+            {
+                wheresql.push_back(',');  
+            }
+            wheresql.push_back('\'');  
+            wheresql.append(std::to_string(val[i]));
+            wheresql.push_back('\'');    
+        }
+    
+
+    
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_ninMessage(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message NOT IN(");
+				wheresql.append(val);
+				wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_ninMessage(const std::vector<std::string> &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message NOT IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i>0)
+            {
+                wheresql.push_back(',');  
+            }
+            wheresql.push_back('\'');  
+            wheresql.append(B_BASE::stringaddslash(val[i]));
+            wheresql.push_back('\'');    
+        }
+    
+
+    
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_ninMessage(const std::vector<T> &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message NOT IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i>0)
+            {
+                wheresql.push_back(',');  
+            }
+            wheresql.push_back('\'');  
+            wheresql.append(std::to_string(val[i]));
+            wheresql.push_back('\'');    
+        }
+    
+
+    
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_likeMessage(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message LIKE '%");
+				wheresql.append(B_BASE::stringaddslash(val));
+				wheresql.append("%'");
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& orl_likeMessage(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message LIKE '%");
+				wheresql.append(B_BASE::stringaddslash(val));
+				wheresql.append("'");
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& orr_likeMessage(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message LIKE '");
+				wheresql.append(B_BASE::stringaddslash(val));
+				wheresql.append("%'");
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_btMessage(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message > '");
+				wheresql.append(B_BASE::stringaddslash(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_beMessage(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message >= '");
+				wheresql.append(B_BASE::stringaddslash(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_ltMessage(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message < '");
+				wheresql.append(B_BASE::stringaddslash(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_leMessage(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message <= '");
+				wheresql.append(B_BASE::stringaddslash(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+template <typename T>
+		requires std::is_floating_point_v<T>||std::is_integral_v<T>
+M_MODEL& eqMessage(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message = '");
+				wheresql.append(std::to_string(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+template <typename T>
+		requires std::is_floating_point_v<T>||std::is_integral_v<T>
+M_MODEL& nqMessage(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message != '");
+				wheresql.append(std::to_string(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+template <typename T>
+		requires std::is_floating_point_v<T>||std::is_integral_v<T>
+M_MODEL& btMessage(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message > '");
+				wheresql.append(std::to_string(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+template <typename T>
+		requires std::is_floating_point_v<T>||std::is_integral_v<T>
+M_MODEL& beMessage(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message >= '");
+				wheresql.append(std::to_string(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+template <typename T>
+		requires std::is_floating_point_v<T>||std::is_integral_v<T>
+M_MODEL& ltMessage(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message < '");
+		wheresql.append(std::to_string(val));
+		wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+template <typename T>
+		requires std::is_floating_point_v<T>||std::is_integral_v<T>
+M_MODEL& leMessage(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message <= '");
+				wheresql.append(std::to_string(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+template <typename T>
+		requires std::is_floating_point_v<T>||std::is_integral_v<T>
+M_MODEL& or_eqMessage(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message = '");
+				wheresql.append(std::to_string(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+template <typename T>
+		requires std::is_floating_point_v<T>||std::is_integral_v<T>
+M_MODEL& or_nqMessage(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message != '");
+				wheresql.append(std::to_string(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+template <typename T>
+		requires std::is_floating_point_v<T>||std::is_integral_v<T>
+M_MODEL& or_btMessage(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message > '");
+				wheresql.append(std::to_string(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+template <typename T>
+		requires std::is_floating_point_v<T>||std::is_integral_v<T>
+M_MODEL& or_beMessage(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message >= '");
+				wheresql.append(std::to_string(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+template <typename T>
+		requires std::is_floating_point_v<T>||std::is_integral_v<T>
+M_MODEL& or_ltMessage(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message < '");
+				wheresql.append(std::to_string(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+template <typename T>
+		requires std::is_floating_point_v<T>||std::is_integral_v<T>
+M_MODEL& or_leMessage(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" message <= '");
+				wheresql.append(std::to_string(val));
+				wheresql.push_back('\'');
+
+        return *mod;   
+    }   
+    
+
+        M_MODEL &select(const std::string &fieldname)
+        {
+            if (selectsql.size() > 0)
+            {
+                selectsql.push_back(',');
+            }
+            selectsql.append(fieldname);
+            return *mod;
+        }
+
+        M_MODEL &where(const std::string &wq)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+
+            wheresql.append(wq);
+            return *mod;
+        }
+        template <typename _SQL_Value>
+            requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value>
+        M_MODEL &where(const std::string &wq, _SQL_Value val)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            char bi = wq.back();
+            if (bi == '=' || bi == '>' || bi == '<')
+            {
+            }
+            else
+            {
+                wheresql.push_back('=');
+            }
+
+            std::stringstream _stream;
+            _stream << val;
+            wheresql.append(_stream.str());
+            return *mod;
+        }
+
+        M_MODEL &where(const std::string &wq, char bi, http::OBJ_VALUE &obj)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            wheresql.push_back(bi);
+            if (obj.is_string())
+            {
+                wheresql.push_back('\'');
+                wheresql.append(obj.as_string());
+                wheresql.push_back('\'');
+            }
+            else
+            {
+
+                wheresql.append(obj.to_string());
+            }
+            return *mod;
+        }
+        M_MODEL &where(const std::string &wq, http::OBJ_VALUE &obj)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            char bi = wq.back();
+            if (bi == '=' || bi == '>' || bi == '<')
+            {
+            }
+            else
+            {
+                wheresql.push_back('=');
+            }
+
+            if (obj.is_string())
+            {
+                wheresql.push_back('\'');
+                wheresql.append(obj.as_string());
+                wheresql.push_back('\'');
+            }
+            else
+            {
+
+                wheresql.append(obj.to_string());
+            }
+            return *mod;
+        }
+        template <typename _SQL_Value>
+            requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value>
+        M_MODEL &where(const std::string &wq, char bi, _SQL_Value val)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            wheresql.push_back(bi);
+            std::stringstream _stream;
+            _stream << val;
+            wheresql.append(_stream.str());
+            return *mod;
+        }
+
+        M_MODEL &where(const std::string &wq, char bi, const std::string &val)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            wheresql.push_back(bi);
+            wheresql.push_back('\'');
+
+            wheresql.append(val);
+            wheresql.push_back('\'');
+            return *mod;
+        }
+        M_MODEL &where(const std::string &wq, const std::string &val)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            char bi = wq.back();
+            if (bi == '=' || bi == '>' || bi == '<')
+            {
+            }
+            else
+            {
+                wheresql.push_back('=');
+            }
+
+            wheresql.push_back('\'');
+            wheresql.append(val);
+            wheresql.push_back('\'');
+            return *mod;
+        }
+
+        M_MODEL &between(const std::string &wq, const std::string &a, const std::string &b)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(" (");
+            wheresql.append(wq);
+            wheresql.append(" BETWEEN '");
+            std::stringstream _stream;
+            _stream << a;
+            _stream << "' AND '";
+            _stream << b;
+            _stream << "' ) ";
+            wheresql.append(_stream.str());
+            return *mod;
+        }
+        template <typename _SQL_Value>
+            requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value>
+        M_MODEL &between(const std::string &wq, _SQL_Value a, _SQL_Value b)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(" (");
+            wheresql.append(wq);
+            wheresql.append(" BETWEEN ");
+            std::stringstream _stream;
+            _stream << a;
+            _stream << " AND ";
+            _stream << b;
+            _stream << " ) ";
+            wheresql.append(_stream.str());
+            return *mod;
+        }
+        template <typename _SQL_Value>
+            requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value>
+        M_MODEL &orBetween(const std::string &wq, _SQL_Value a, _SQL_Value b)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" OR ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" OR ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(" (");
+            wheresql.append(wq);
+            wheresql.append(" BETWEEN ");
+            std::stringstream _stream;
+            _stream << a;
+            _stream << " AND ";
+            _stream << b;
+            _stream << " ) ";
+            wheresql.append(_stream.str());
+            return *mod;
+        }
+        M_MODEL &whereLike(const std::string &wq, const std::string &val)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            wheresql.append(" like '");
+            if (val.size() > 0 && (val[0] == '%' || val.back() == '%'))
+            {
+                wheresql.append(val);
+                wheresql.append("' ");
+            }
+            else
+            {
+                wheresql.push_back('%');
+                wheresql.append(val);
+                wheresql.append("%' ");
+            }
+            return *mod;
+        }
+        M_MODEL &whereLikeLeft(const std::string &wq, const std::string &val)
+        {
+
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            wheresql.append(" like '");
+            wheresql.push_back('%');
+            wheresql.append(val);
+            wheresql.append("' ");
+            return *mod;
+        }
+        M_MODEL &whereLikeRight(const std::string &wq, const std::string &val)
+        {
+
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            wheresql.append(" like '");
+            wheresql.append(val);
+            wheresql.append("%' ");
+            return *mod;
+        }
+        M_MODEL &whereOrLike(const std::string &wq, const std::string &val)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" OR ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" OR ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            wheresql.append(" like '");
+            if (val[0] == '%' || val.back() == '%')
+            {
+                wheresql.append(val);
+                wheresql.append("' ");
+            }
+            else
+            {
+                wheresql.push_back('%');
+                wheresql.append(val);
+                wheresql.append("%' ");
+            }
+            return *mod;
+        }
+        M_MODEL &whereAnd(const std::string &wq)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            return *mod;
+        }
+        template <typename _SQL_Value>
+            requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value>
+        M_MODEL &whereAnd(const std::string &wq, _SQL_Value val)
+        {
+
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            char bi = wq.back();
+            if (bi == '=' || bi == '>' || bi == '<')
+            {
+            }
+            else
+            {
+                wheresql.push_back('=');
+            }
+            std::stringstream _stream;
+            _stream << val;
+            wheresql.append(_stream.str());
+            return *mod;
+        }
+        M_MODEL &whereAnd(const std::string &wq, const std::string &val)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            char bi = wq.back();
+            if (bi == '=' || bi == '>' || bi == '<')
+            {
+            }
+            else
+            {
+                wheresql.push_back('=');
+            }
+
+            wheresql.push_back('\'');
+            wheresql.append(val);
+            wheresql.push_back('\'');
+
+            return *mod;
+        }
+        M_MODEL &whereOr(const std::string &wq)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" OR ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" OR ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            return *mod;
+        }
+        template <typename _SQL_Value>
+            requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value>
+        M_MODEL &whereOr(const std::string &wq, _SQL_Value val)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" OR ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" OR ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            char bi = wq.back();
+            if (bi == '=' || bi == '>' || bi == '<')
+            {
+            }
+            else
+            {
+                wheresql.push_back('=');
+            }
+            std::stringstream _stream;
+            _stream << val;
+            wheresql.append(_stream.str());
+            return *mod;
+        }
+        M_MODEL &whereOr(const std::string &wq, const std::string &val)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" OR ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" OR ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            char bi = wq.back();
+            if (bi == '=' || bi == '>' || bi == '<')
+            {
+            }
+            else
+            {
+                wheresql.push_back('=');
+            }
+
+            wheresql.push_back('\'');
+            wheresql.append(val);
+            wheresql.push_back('\'');
+            return *mod;
+        }
+        M_MODEL &whereIn(const std::string &k)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(k);
+            return *mod;
+        }
+        M_MODEL &whereIn(const std::string &k, const std::string &a)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+
+            wheresql.append(k);
+            wheresql.append(" IN(");
+            wheresql.append(a);
+            wheresql.append(") ");
+            return *mod;
+        }
+
+        M_MODEL &whereIn(const std::string &k, const std::vector<std::string> &a)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(k);
+            wheresql.append(" in(");
+            int i = 0;
+            for (auto &key : a)
+            {
+                if (i > 0)
+                {
+                    wheresql.append(",\'");
+                }
+                else
+                {
+                    wheresql.append("\'");
+                }
+                wheresql.append(key);
+                wheresql.append("\'");
+                i++;
+            }
+            wheresql.append(") ");
+            return *mod;
+        }
+        M_MODEL &whereNotIn(const std::string &k, const std::vector<std::string> &a)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+
+            wheresql.append(k);
+            wheresql.append(" NOT IN(");
+            int i = 0;
+            for (auto &key : a)
+            {
+                if (i > 0)
+                {
+                    wheresql.append(",\'");
+                }
+                else
+                {
+                    wheresql.append("\'");
+                }
+                wheresql.append(key);
+                wheresql.append("\'");
+                i++;
+            }
+            wheresql.append(") ");
+            return *mod;
+        }
+        template <typename _SQL_Value>
+            requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value>
+        M_MODEL &whereIn(const std::string &k, const std::list<_SQL_Value> &a)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+
+            wheresql.append(k);
+            wheresql.append(" in(");
+            int i = 0;
+            std::stringstream _stream;
+            for (auto &key : a)
+            {
+                if (i > 0)
+                {
+                    wheresql.append(",");
+                }
+                _stream << key;
+                wheresql.append(_stream.str());
+                i++;
+                _stream.str("");
+            }
+            wheresql.append(") ");
+            return *mod;
+        }
+
+        template <typename _SQL_Value>
+            requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value>
+        M_MODEL &whereIn(const std::string &k, const std::vector<_SQL_Value> &a)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+
+            wheresql.append(k);
+            wheresql.append(" IN(");
+            int i = 0;
+            std::stringstream _stream;
+            for (auto &key : a)
+            {
+                if (i > 0)
+                {
+                    wheresql.append(",");
+                }
+                _stream << key;
+                wheresql.append(_stream.str());
+                i++;
+                _stream.str("");
+            }
+            wheresql.append(") ");
+            return *mod;
+        }
+        template <typename _SQL_Value>
+            requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value>
+        M_MODEL &whereNotIn(const std::string &k, const std::vector<_SQL_Value> &a)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+
+            wheresql.append(k);
+            wheresql.append(" NOT IN(");
+            int i = 0;
+            std::stringstream _stream;
+            for (auto &key : a)
+            {
+                if (i > 0)
+                {
+                    wheresql.append(",");
+                }
+                _stream << key;
+                wheresql.append(_stream.str());
+                i++;
+                _stream.str("");
+            }
+            wheresql.append(") ");
+            return *mod;
+        }
+
+        M_MODEL &order(const std::string &wq)
+        {
+            ordersql.append(" ORDER by ");
+            ordersql.append(wq);
+            return *mod;
+        }
+        M_MODEL &asc(const std::string &wq)
+        {
+
+            ordersql.append(" ORDER by ");
+            ordersql.append(wq);
+            ordersql.append(" ASC ");
+            return *mod;
+        }
+
+        M_MODEL &desc(const std::string &wq)
+        {
+
+            ordersql.append(" ORDER by ");
+            ordersql.append(wq);
+            ordersql.append(" DESC ");
+            return *mod;
+        }
+
+        M_MODEL &having(const std::string &wq)
+        {
+
+            groupsql.append(" HAVING by ");
+            groupsql.append(wq);
+            return *mod;
+        }
+
+        M_MODEL &group(const std::string &wq)
+        {
+
+            groupsql.append(" GROUP BY ");
+            groupsql.append(wq);
+            return *mod;
+        }
+
+        M_MODEL &orsub()
+        {
+
+            if (iskuohao == true)
+            {
+                iskuohao     = false;
+                ishascontent = false;
+                wheresql.append(" )");
+            }
+            else
+            {
+                wheresql.append(" OR (");
+                iskuohao     = true;
+                ishascontent = false;
+            }
+            return *mod;
+        }
+        M_MODEL &andsub()
+        {
+
+            if (iskuohao == true)
+            {
+                iskuohao = false;
+                wheresql.append(" )");
+                ishascontent = false;
+            }
+            else
+            {
+                wheresql.append(" AND (");
+                iskuohao     = true;
+                ishascontent = false;
+            }
+
+            return *mod;
+        }
+
+        M_MODEL &endsub()
+        {
+            if (iskuohao == true)
+            {
+                iskuohao     = false;
+                ishascontent = false;
+                wheresql.append(" )");
+            }
+            return *mod;
+        }
+
+        M_MODEL &or_b()
+        {
+
+            if (iskuohao == true)
+            {
+                iskuohao     = false;
+                ishascontent = false;
+                wheresql.append(" )");
+            }
+            else
+            {
+                wheresql.append(" OR (");
+                iskuohao     = true;
+                ishascontent = false;
+            }
+            return *mod;
+        }
+        M_MODEL &and_b()
+        {
+
+            if (iskuohao == true)
+            {
+                iskuohao = false;
+                wheresql.append(" )");
+                ishascontent = false;
+            }
+            else
+            {
+                wheresql.append(" AND (");
+                iskuohao     = true;
+                ishascontent = false;
+            }
+
+            return *mod;
+        }
+
+        M_MODEL &or_e()
+        {
+            if (iskuohao == true)
+            {
+                iskuohao     = false;
+                ishascontent = false;
+                wheresql.append(" )");
+            }
+            return *mod;
+        }
+
+        M_MODEL &and_e()
+        {
+            if (iskuohao == true)
+            {
+                iskuohao     = false;
+                ishascontent = false;
+                wheresql.append(" )");
+            }
+            return *mod;
+        }
+
+        M_MODEL &limit(unsigned int num)
+        {
+            limitsql.clear();
+            limitsql.append(" limit ");
+            limitsql.append(std::to_string(num));
+            return *mod;
+        }
+        M_MODEL &limit(unsigned int num, unsigned int endnum)
+        {
+            limitsql.clear();
+            limitsql.append(" limit ");
+            limitsql.append(std::to_string(num));
+            limitsql.push_back(',');
+            limitsql.append(std::to_string(endnum));
+            return *mod;
+        }
+
+        std::vector<std::map<std::string, std::string>> fetch_obj()
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                sqlstring.append(" 1 ");
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            std::vector<std::map<std::string, std::string>> temprecord;
+
+            if (iserror)
+            {
+                return temprecord;
+            }
+
+            try
+            {
+                effect_num = 0;
+                if (conn_empty())
+                {
+                    return temprecord;
+                }
+                auto conn = conn_obj->get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return temprecord;
+                }
+
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+                unsigned int offset        = 0;
+
+                std::vector<unsigned char> field_pos;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = conn->read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                std::map<std::string, std::string> data_temp;
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                    std::string temp_str;
+                                    temp_str.resize(name_length);
+                                    std::memcpy(temp_str.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length);
+                                    if (field_array[ij].name.size() > 0)
+                                    {
+                                        data_temp.insert({field_array[ij].name, std::move(temp_str)});
+                                    }
+                                    else if (field_array[ij].org_name.size() > 0)
+                                    {
+                                        data_temp.insert({field_array[ij].org_name, std::move(temp_str)});
+                                    }
+
+                                    tempnum = tempnum + name_length;
+                                }
+                                temprecord.emplace_back(std::move(data_temp));
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+
+                conn_obj->back_select_conn(conn);
+
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        save_cache(exptime);
+                        exptime = 0;
+                        iscache = false;
+                    }
+                }
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            return temprecord;
+        }
+        std::tuple<std::vector<std::string>, std::map<std::string, unsigned int>, std::vector<std::vector<std::string>>>
+        fetch_row()
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                sqlstring.append(" 1 ");
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            std::vector<std::vector<std::string>> temprecord;
+            std::vector<std::string> table_fieldname;
+            std::map<std::string, unsigned int> table_fieldmap;
+
+            if (iscache)
+            {
+                std::size_t sqlhashid = std::hash<std::string>{}(sqlstring);
+
+                model_meta_cache<std::vector<std::string>> &temp_cache =
+                    model_meta_cache<std::vector<std::string>>::getinstance();
+                temprecord = temp_cache.get(sqlhashid);
+                if (temprecord.size() > 0)
+                {
+                    iscache                                    = false;
+                    model_meta_cache<std::string> &table_cache = model_meta_cache<std::string>::getinstance();
+                    table_fieldname                            = table_cache.get(sqlhashid);
+
+                    model_meta_cache<std::map<std::string, unsigned int>> &tablemap_cache =
+                        model_meta_cache<std::map<std::string, unsigned int>>::getinstance();
+                    table_fieldmap = tablemap_cache.get_obj(sqlhashid);
+
+                    return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+                }
+            }
+
+            if (iserror)
+            {
+                return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+                }
+                auto conn = conn_obj->get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+                }
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+                // std::vector<std::vector<std::string>> field_value;
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                std::vector<unsigned char> field_pos;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = conn->read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                        table_fieldmap.insert({field_array[ii].org_name,table_fieldname.size()});
+                                        table_fieldname.push_back(field_array[ii].org_name);
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                std::vector<std::string> temp_v_record; 
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+                                    std::string tempstr;
+                                    tempstr.resize(name_length);
+                                    std::memcpy(tempstr.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length);
+                                    temp_v_record.push_back(std::move(tempstr));
+                                    tempnum = tempnum + name_length;
+                                }
+                                temprecord.push_back(temp_v_record);
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+                conn_obj->back_select_conn(conn);
+
+                
+
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        if (temprecord.size() > 0)
+                        {
+                            std::size_t sqlhashid = std::hash<std::string>{}(sqlstring);
+
+                            model_meta_cache<std::vector<std::string>> &temp_cache =
+                                model_meta_cache<std::vector<std::string>>::getinstance();
+                            temp_cache.save(sqlhashid, temprecord, exptime);
+
+                            exptime += 1;
+                            model_meta_cache<std::string> &table_cache = model_meta_cache<std::string>::getinstance();
+                            table_cache.save(sqlhashid, table_fieldname, exptime);
+
+                            model_meta_cache<std::map<std::string, unsigned int>> &tablemap_cache =
+                                model_meta_cache<std::map<std::string, unsigned int>>::getinstance();
+                            tablemap_cache.save(sqlhashid, table_fieldmap, exptime);
+                            exptime = 0;
+                            iscache = false;
+                        }
+                    }
+                }
+
+                return std::make_tuple(std::move(table_fieldname), std::move(table_fieldmap), std::move(temprecord));
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+        }
+        M_MODEL &fetch()
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                sqlstring.append(" 1 ");
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscache)
+            {
+                std::size_t sqlhashid = std::hash<std::string>{}(sqlstring);
+                if (get_cacherecord(sqlhashid))
+                {
+                    iscache = false;
+                    return *mod;
+                }
+            }
+
+            B_BASE::record_reset();
+            if (iserror)
+            {
+                return *mod;
+            }
+
+            try
+            {
+                if (conn_empty())
+                {
+                    return *mod;
+                }
+                auto conn = conn_obj->get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return *mod;
+                }
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                std::vector<unsigned char> field_pos;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = conn->read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                typename B_BASE::meta data_temp;
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                    assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp);
+                                    tempnum = tempnum + name_length;
+                                }
+                                B_BASE::record.emplace_back(std::move(data_temp));
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+                conn_obj->back_select_conn(conn);
+
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        save_cache(exptime);
+                        exptime = 0;
+                        iscache = false;
+                    }
+                }
+                return *mod;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return *mod;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            return *mod;
+        }
+
+        asio::awaitable<unsigned int> async_fetch()
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                sqlstring.append(" 1 ");
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscache)
+            {
+                std::size_t sqlhashid = std::hash<std::string>{}(sqlstring);
+                if (get_cacherecord(sqlhashid))
+                {
+                    iscache = false;
+                    co_return 0;
+                }
+            }
+
+            B_BASE::record_reset();
+            if (iserror)
+            {
+                co_return 0;
+            }
+
+            try
+            {
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                std::vector<unsigned char> field_pos;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = co_await conn->async_read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                typename B_BASE::meta data_temp;
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                    assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp);
+                                    tempnum = tempnum + name_length;
+                                }
+                                B_BASE::record.emplace_back(std::move(data_temp));
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+                conn_obj->back_select_conn(conn);
+
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        save_cache(exptime);
+                        exptime = 0;
+                        iscache = false;
+                    }
+                }
+                co_return effect_num;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                co_return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            co_return 0;
+        }
+        M_MODEL &fetch_append()
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                sqlstring.append(" 1 ");
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscache)
+            {
+                std::size_t sqlhashid = std::hash<std::string>{}(sqlstring);
+                if (get_cacherecord(sqlhashid))
+                {
+                    iscache = false;
+                    return *mod;
+                }
+            }
+
+            if (iserror)
+            {
+                return *mod;
+            }
+ 
+            try
+            {
+ 
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                std::vector<unsigned char> field_pos;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = conn->read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                typename B_BASE::meta data_temp;
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                    assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp);
+                                    tempnum = tempnum + name_length;
+                                }
+                                B_BASE::record.emplace_back(std::move(data_temp));
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+                conn_obj->back_select_conn(conn);
+                
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        save_cache(exptime);
+                        exptime = 0;
+                        iscache = false;
+                    }
+                }
+                return *mod;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return *mod;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            return *mod;
+        }
+
+        asio::awaitable<unsigned int> async_fetch_append()
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                sqlstring.append(" 1 ");
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscache)
+            {
+                std::size_t sqlhashid = std::hash<std::string>{}(sqlstring);
+                if (get_cacherecord(sqlhashid))
+                {
+                    iscache = false;
+                    co_return 1;
+                }
+            }
+
+            if (iserror)
+            {
+                co_return 0;
+            }
+
+            try
+            {
+                effect_num = 0;
+
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+
+                // asio::error_code ec;
+
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+                // std::vector<std::vector<std::string>> field_value;
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                std::vector<unsigned char> field_pos;
+                // std::map<unsigned char, std::string> other_col;
+
+                for (; is_sql_item == false;)
+                {
+                    // std::memset(result_data, 0x00, 4096);
+                    // n      = co_await conn->socket->async_read_some(asio::buffer(result_data), asio::use_awaitable);
+                    n      = co_await conn->async_read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                typename B_BASE::meta data_temp;
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                    assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp);
+                                    tempnum = tempnum + name_length;
+                                }
+                                effect_num++;
+                                B_BASE::record.emplace_back(std::move(data_temp));
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+                conn_obj->back_select_conn(conn);
+
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        save_cache(exptime);
+                        exptime = 0;
+                        iscache = false;
+                    }
+                }
+                co_return effect_num;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                co_return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            co_return 0;
+        }
+        unsigned int fetch_one(bool isappend = false)
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                sqlstring.append(" 1 ");
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+
+            sqlstring.append(" limit 1");
+
+            if (iscache)
+            {
+                std::size_t sqlhashid = std::hash<std::string>{}(sqlstring);
+                if (get_cacherecord(sqlhashid))
+                {
+                    iscache = false;
+                    return 0;
+                }
+            }
+
+            B_BASE::data_reset();
+            if (iserror)
+            {
+                return 0;
+            }
+
+            try
+            {
+                effect_num = 0;
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+                unsigned int offset        = 0;
+
+                std::vector<unsigned char> field_pos;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = conn->read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                if (isappend)
+                                {
+                                    typename B_BASE::meta data_temp;
+                                    for (unsigned int ij = 0; ij < column_num; ij++)
+                                    {
+                                        unsigned long long name_length = 0;
+                                        name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                        assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp);
+                                        tempnum = tempnum + name_length;
+                                    }
+                                    B_BASE::record.emplace_back(std::move(data_temp));
+                                    effect_num++;
+                                }
+                                else
+                                {
+                                    for (unsigned int ij = 0; ij < column_num; ij++)
+                                    {
+                                        unsigned long long name_length = 0;
+                                        name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                        assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, B_BASE::data);
+                                        tempnum = tempnum + name_length;
+                                    }
+                                    effect_num++;
+                                }
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+
+                conn_obj->back_select_conn(conn);
+
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        save_cache(exptime);
+                        exptime = 0;
+                        iscache = false;
+                    }
+                }
+                return effect_num;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            return 0;
+        }
+
+        asio::awaitable<unsigned int> async_fetch_one(bool isappend = false)
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                sqlstring.append(" 1 ");
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+
+            sqlstring.append(" limit 1");
+
+            if (iscache)
+            {
+                std::size_t sqlhashid = std::hash<std::string>{}(sqlstring);
+                if (get_cacherecord(sqlhashid))
+                {
+                    iscache = false;
+                    co_return 0;
+                }
+            }
+
+            B_BASE::data_reset();
+            if (iserror)
+            {
+                co_return 0;
+            }
+
+            try
+            {
+                effect_num = 0;
+
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+                // std::vector<std::vector<std::string>> field_value;
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                std::vector<unsigned char> field_pos;
+                // std::map<unsigned char, std::string> other_col;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = co_await conn->async_read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                if (isappend)
+                                {
+                                    typename B_BASE::meta data_temp;
+                                    for (unsigned int ij = 0; ij < column_num; ij++)
+                                    {
+                                        unsigned long long name_length = 0;
+                                        name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                        assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp);
+                                        tempnum = tempnum + name_length;
+                                    }
+                                    B_BASE::record.emplace_back(std::move(data_temp));
+                                    effect_num++;
+                                }
+                                else
+                                {
+                                    for (unsigned int ij = 0; ij < column_num; ij++)
+                                    {
+                                        unsigned long long name_length = 0;
+                                        name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                        assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, B_BASE::data);
+                                        tempnum = tempnum + name_length;
+                                    }
+                                    effect_num++;
+                                }
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+
+                conn_obj->back_select_conn(conn);
+
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        save_cache(exptime);
+                        exptime = 0;
+                        iscache = false;
+                    }
+                }
+                co_return effect_num;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                co_return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            co_return 0;
+        }
+
+        M_MODEL &use_cache(int cache_time = 0)
+        {
+            iscache = true;
+            exptime = cache_time;
+            return *mod;
+        }
+        bool isuse_cache(bool iscachedate = false)
+        {
+            if (iscachedate)
+            {
+                return exptime == 0 && iscache == false;
+            }
+            return iscache;
+        }
+        void set_cache_state(bool isrestatus = false) { iscache = isrestatus; }
+        void remove_exptime_cache()
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            temp_cache.remove_exptime();
+        }
+        void clear_cache()
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            temp_cache.clear();
+        }
+        bool remove_cache()
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            std::size_t sqlhashid                               = std::hash<std::string>{}(sqlstring);
+            return temp_cache.remove(sqlhashid);
+        }
+        bool remove_cache(std::size_t cache_key_name)
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            return temp_cache.remove(cache_key_name);
+        }
+        int check_cache(std::size_t cache_key_name)
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            return temp_cache.check(cache_key_name);
+        }
+        std::vector<typename B_BASE::meta> get_cache_data(std::size_t cache_key_name)
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            auto cache_data                                     = temp_cache.get(cache_key_name);
+            return cache_data;
+        }
+        typename B_BASE::meta get_cache_obj(std::size_t cache_key_name)
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            auto cache_data                                     = temp_cache.get_obj(cache_key_name);
+            return cache_data;
+        }
+        M_MODEL &get_cache(std::size_t cache_key_name)
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            B_BASE::record                                      = temp_cache.get(cache_key_name);
+            if (B_BASE::record.size() == 0)
+            {
+                B_BASE::record_reset();
+            }
+            else
+            {
+                B_BASE::data = B_BASE::record[0];
+            }
+            return *mod;
+        }
+        int update_cache(int exp_time = 0)
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            std::size_t sqlhashid                               = std::hash<std::string>{}(sqlstring);
+            return temp_cache.update(sqlhashid, exp_time);
+        }
+        int update_cache(std::size_t cache_key_name, int exp_time)
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            return temp_cache.update(cache_key_name, exp_time);
+        }
+        bool save_cache(int exp_time = 0)
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            std::size_t sqlhashid                               = std::hash<std::string>{}(sqlstring);
+            temp_cache.save(sqlhashid, B_BASE::record, exp_time);
+            return true;
+        }
+
+        bool save_cache(std::size_t cache_key_name, typename B_BASE::meta &cache_data, int exp_time = 0)
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            temp_cache.save(cache_key_name, cache_data, exp_time);
+            return true;
+        }
+
+        bool save_cache(std::size_t cache_key_name, std::vector<typename B_BASE::meta> &cache_data, int exp_time = 0)
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            temp_cache.save(cache_key_name, cache_data, exp_time);
+            return true;
+        }
+        bool get_cacherecord(std::size_t cache_key_name)
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            B_BASE::record                                      = temp_cache.get(cache_key_name);
+            if (B_BASE::record.size() == 0)
+            {
+                return false;
+            }
+            else
+            {
+                B_BASE::data = B_BASE::record[0];
+                return true;
+            }
+        }
+        http::OBJ_VALUE fetch_json()
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                sqlstring.append(" 1 ");
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            http::OBJ_VALUE valuetemp;
+            valuetemp.set_array();
+
+            if (iserror)
+            {
+                return valuetemp;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+ 
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = conn->read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                http::OBJ_VALUE json_temp_v;  
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                    std::string temp_str;    
+                                    temp_str.resize(name_length);
+                                    std::memcpy(temp_str.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length);
+                                    if(field_array[ij].name.size()>0)
+                                    {
+                                        //or alias name
+                                        json_temp_v[field_array[ij].name]=std::move(temp_str);
+                                    }
+                                    else if(field_array[ij].org_name.size()>0)
+                                    {
+                                        json_temp_v[field_array[ij].org_name]=std::move(temp_str);
+                                    }
+                                    tempnum = tempnum + name_length;
+                                }
+                                valuetemp.push(json_temp_v);
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+                conn_obj->back_select_conn(conn);
+
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            return valuetemp;
+        }
+
+        asio::awaitable<http::OBJ_VALUE> async_fetch_json()
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                sqlstring.append(" 1 ");
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            http::OBJ_VALUE valuetemp;
+            valuetemp.set_array();
+
+            if (iserror)
+            {
+                co_return valuetemp;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    co_return valuetemp;
+                }
+                auto conn = co_await conn_obj->async_get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+                conn->send_data.clear();
+
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+                
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+ 
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = co_await conn->async_read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                http::OBJ_VALUE json_temp_v;  
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                    std::string temp_str;    
+                                    temp_str.resize(name_length);
+                                    std::memcpy(temp_str.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length);
+                                    if(field_array[ij].name.size()>0)
+                                    {
+                                        //or alias name
+                                        json_temp_v[field_array[ij].name]=std::move(temp_str);
+                                    }
+                                    else if(field_array[ij].org_name.size()>0)
+                                    {
+                                        json_temp_v[field_array[ij].org_name]=std::move(temp_str);
+                                    }
+                                    tempnum = tempnum + name_length;
+                                }
+                                valuetemp.push(json_temp_v);
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+                conn_obj->back_select_conn(conn);
+
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            co_return valuetemp;
+        }
+
+        long long get_one(long long id)
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            sqlstring.append(B_BASE::getPKname());
+            sqlstring.append("=");
+            sqlstring.append(std::to_string(id));
+            sqlstring.append(" limit 1");
+            if (iscache)
+            {
+                std::size_t sqlhashid = std::hash<std::string>{}(sqlstring);
+                if (get_cacherecord(sqlhashid))
+                {
+                    iscache = false;
+                    return 0;
+                }
+            }
+
+            B_BASE::data_reset();
+
+            if (iserror)
+            {
+                return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                std::vector<unsigned char> field_pos;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = conn->read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                    assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, B_BASE::data);
+                                    tempnum = tempnum + name_length;
+                                }
+                                 
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+                conn_obj->back_select_conn(conn);               
+
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        save_cache(exptime);
+                        exptime = 0;
+                        iscache = false;
+                    }
+                }
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            return 0;
+        }
+
+        asio::awaitable<long long> async_get_one(long long id)
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            sqlstring.append(B_BASE::getPKname());
+            sqlstring.append("=");
+            sqlstring.append(std::to_string(id));
+            sqlstring.append(" limit 1");
+            if (iscache)
+            {
+                std::size_t sqlhashid = std::hash<std::string>{}(sqlstring);
+                if (get_cacherecord(sqlhashid))
+                {
+                    iscache = false;
+                    co_return 0;
+                }
+            }
+
+            B_BASE::data_reset();
+
+            if (iserror)
+            {
+                co_return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+                
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                std::vector<unsigned char> field_pos;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = co_await conn->async_read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                    assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, B_BASE::data);
+                                    tempnum = tempnum + name_length;
+                                }
+                                 
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+                conn_obj->back_select_conn(conn);               
+
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        save_cache(exptime);
+                        exptime = 0;
+                        iscache = false;
+                    }
+                }
+                co_return effect_num;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                co_return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            co_return 0;
+        }
+
+        int update()
+        {
+            effect_num = 0;
+            if (wheresql.empty())
+            {
+                if (B_BASE::getPK() > 0)
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    wheresql = tempsql.str();
+                }
+                else
+                {
+                    return 0;
+                }
+            }
+            sqlstring = B_BASE::_makeupdatesql("");
+            sqlstring.append(" where ");
+            if (wheresql.empty())
+            {
+                return 0;
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscommit)
+            {
+                iscommit = false;
+                return 0;
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    return effect_num;
+                }
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                
+            }
+            return 0;
+        }
+        int update(const std::string &fieldname)
+        {
+            effect_num = 0;
+            if (wheresql.empty())
+            {
+                if (B_BASE::getPK() > 0)
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    wheresql = tempsql.str();
+                }
+                else
+                {
+                    error_msg = "warning empty where sql!";
+                    return 0;
+                }
+            }
+
+            sqlstring = B_BASE::_makeupdatesql(fieldname);
+            sqlstring.append(" where ");
+            if (wheresql.empty())
+            {
+                return 0;
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscommit)
+            {
+                iscommit = false;
+                return 0;
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    return effect_num;
+                }
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                
+            }
+            return 0;
+        }
+
+        asio::awaitable<int> async_update(const std::string &fieldname)
+        {
+            effect_num = 0;
+            if (wheresql.empty())
+            {
+                if (B_BASE::getPK() > 0)
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    wheresql = tempsql.str();
+                }
+                else
+                {
+                    error_msg = "warning empty where sql!";
+                    co_return 0;
+                }
+            }
+
+            sqlstring = B_BASE::_makeupdatesql(fieldname);
+            sqlstring.append(" where ");
+            if (wheresql.empty())
+            {
+                co_return 0;
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscommit)
+            {
+                iscommit = false;
+                co_return 0;
+            }
+
+            if (iserror)
+            {
+                co_return 0;
+            }
+            try
+            {
+
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+
+                unsigned int offset = 0;
+                n                   = co_await conn->async_read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                    iserror = true;
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+
+                    co_return effect_num;
+                }
+                co_return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                co_return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+
+            }
+            co_return 0;
+        }
+        asio::awaitable<int> async_update()
+        {
+            effect_num = 0;
+            if (wheresql.empty())
+            {
+                if (B_BASE::getPK() > 0)
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    wheresql = tempsql.str();
+                }
+                else
+                {
+                    error_msg = "warning empty where sql!";
+                    co_return 0;
+                }
+            }
+
+            sqlstring = B_BASE::_makeupdatesql("");
+            sqlstring.append(" where ");
+            if (wheresql.empty())
+            {
+                co_return 0;
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscommit)
+            {
+                iscommit = false;
+                co_return 0;
+            }
+
+            if (iserror)
+            {
+                co_return 0;
+            }
+            try
+            {
+
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+
+                unsigned int offset = 0;
+                n                   = co_await conn->async_read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                    iserror = true;
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+
+                    co_return effect_num;
+                }
+                co_return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                co_return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+
+            }
+            co_return 0;
+        }
+
+        int update_batch(const std::string &fieldname)
+        {
+            effect_num = 0;
+            if (B_BASE::record.size() == 0)
+            {
+                return 0;
+            }
+            if (fieldname.size() > 0)
+            {
+                sqlstring = B_BASE::_make_insert_into_sql(fieldname);
+            }
+            else
+            {
+                sqlstring = B_BASE::_make_replace_into_sql();
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    return effect_num;
+                }
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                
+            }
+            return 0;
+        }
+        int remove()
+        {
+            effect_num = 0;
+            if (wheresql.empty())
+            {
+                if (B_BASE::getPK() > 0)
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    wheresql = tempsql.str();
+                }
+                else
+                {
+                    return 0;
+                }
+            }
+
+            sqlstring = "DELETE FROM  ";
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                return 0;
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscommit)
+            {
+                iscommit = false;
+                return 0;
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    return effect_num;
+                }
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                
+            }
+            return 0;
+        }
+
+        asio::awaitable<unsigned int> async_remove()
+        {
+            effect_num = 0;
+            if (wheresql.empty())
+            {
+                if (B_BASE::getPK() > 0)
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    wheresql = tempsql.str();
+                }
+                else
+                {
+                    co_return 0;
+                }
+            }
+
+            sqlstring = "DELETE FROM  ";
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                co_return 0;
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscommit)
+            {
+                iscommit = false;
+                co_return 0;
+            }
+
+            if (iserror)
+            {
+                co_return 0;
+            }
+
+            try
+            {
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+                
+                unsigned int offset = 0;
+                n                   = co_await conn->async_read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    co_return effect_num;
+                }
+                co_return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                co_return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                
+            }
+            co_return 0;
+        }
+
+        int remove(long long id)
+        {
+            effect_num = 0;
+            sqlstring  = "DELETE FROM  ";
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            sqlstring.append(B_BASE::getPKname());
+            sqlstring.append("=");
+            sqlstring.append(std::to_string(id));
+
+            if (iscommit)
+            {
+                iscommit = false;
+                return 0;
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    return effect_num;
+                }
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                
+            }
+            return 0;
+        }
+
+        asio::awaitable<unsigned int> async_remove(long long id)
+        {
+            effect_num = 0;
+            sqlstring  = "DELETE FROM  ";
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            sqlstring.append(B_BASE::getPKname());
+            sqlstring.append("=");
+            sqlstring.append(std::to_string(id));
+
+            if (iscommit)
+            {
+                iscommit = false;
+                co_return 0;
+            }
+
+            if (iserror)
+            {
+                co_return 0;
+            }
+
+            try
+            {
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+                
+                unsigned int offset = 0;
+                n                   = co_await conn->async_read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    co_return effect_num;
+                }
+                co_return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                co_return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                
+            }
+            co_return 0;
+        }
+
+        int soft_remove(const std::string &fieldsql)
+        {
+            effect_num = 0;
+            if (wheresql.empty())
+            {
+                if (B_BASE::getPK() > 0)
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    wheresql = tempsql.str();
+                }
+                else
+                {
+                    return 0;
+                }
+            }
+
+            sqlstring = B_BASE::soft_remove_sql(fieldsql);
+            if (sqlstring.empty())
+            {
+                error_msg = "soft delete field empty.";
+                return 0;
+            }
+            sqlstring.append(" where ");
+            if (wheresql.empty())
+            {
+                return 0;
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscommit)
+            {
+                iscommit = false;
+                return 0;
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    return effect_num;
+                }
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                
+            }
+            return 0;
+        }
+        int soft_remove()
+        {
+            effect_num = 0;
+            if (wheresql.empty())
+            {
+                if (B_BASE::getPK() > 0)
+                {
+                    std::ostringstream tempsql;
+                    effect_num = 1;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    wheresql = tempsql.str();
+                }
+                else
+                {
+                    return 0;
+                }
+            }
+            if (effect_num == 1)
+            {
+                sqlstring = B_BASE::soft_remove_sql(" ");
+            }
+            else
+            {
+                sqlstring = B_BASE::soft_remove_sql("");
+            }
+            effect_num = 0;
+            if (sqlstring.empty())
+            {
+                error_msg = "soft delete field empty.";
+                return 0;
+            }
+            sqlstring.append(" where ");
+            if (wheresql.empty())
+            {
+                return 0;
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscommit)
+            {
+                iscommit = false;
+                return 0;
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    return effect_num;
+                }
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                
+            }
+            return 0;
+        }
+        long long insert(typename B_BASE::meta &insert_data)
+        {
+            effect_num = 0;
+            sqlstring  = B_BASE::_makerecordinsertsql(insert_data);
+            if (iscommit)
+            {
+                iscommit = false;
+                return 0;
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num      = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    long long   insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);    
+
+                    return insert_last_id;
+                }
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            return 0;
+        }
+
+        asio::awaitable<long long> async_insert(typename B_BASE::meta &insert_data)
+        {
+            effect_num = 0;
+            sqlstring  = B_BASE::_makerecordinsertsql(insert_data);
+            if (iscommit)
+            {
+                iscommit = false;
+                co_return 0;
+            }
+
+            if (iserror)
+            {
+                co_return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+                
+                unsigned int offset = 0;
+                n                   = co_await conn->async_read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num      = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    long long   insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);    
+
+                    co_return insert_last_id;
+                }
+                co_return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            co_return 0;
+        }
+
+        long long insert(std::vector<typename B_BASE::meta> &insert_data)
+        {
+            effect_num = 0;
+            sqlstring  = B_BASE::_makerecordinsertsql(insert_data);
+            if (iscommit)
+            {
+                iscommit = false;
+                return 0;
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num      = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    long long   insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);    
+
+                    return insert_last_id;
+                }
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            return 0;
+        }
+
+        asio::awaitable<long long> async_insert(std::vector<typename B_BASE::meta> &insert_data)
+        {
+            effect_num = 0;
+            sqlstring  = B_BASE::_makerecordinsertsql(insert_data);
+            if (iscommit)
+            {
+                iscommit = false;
+                co_return 0;
+            }
+
+            if (iserror)
+            {
+                co_return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+                
+                unsigned int offset = 0;
+                n                   = co_await conn->async_read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num      = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    long long   insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);    
+
+                    co_return insert_last_id;
+                }
+                co_return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            co_return 0;
+        }
+
+        long long insert()
+        {
+            effect_num = 0;
+            sqlstring  = B_BASE::_makeinsertsql();
+            if (iscommit)
+            {
+                iscommit = false;
+                return 0;
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+                    unsigned int d_offset = 1;
+                    effect_num      = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    long long   insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);    
+
+                    return insert_last_id;
+                }
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            return 0;
+        }
+
+        asio::awaitable<long long> async_insert()
+        {
+            effect_num = 0;
+            sqlstring  = B_BASE::_makeinsertsql();
+            if (iscommit)
+            {
+                iscommit = false;
+                co_return 0;
+            }
+
+            if (iserror)
+            {
+                co_return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+                
+                unsigned int offset = 0;
+                n                   = co_await conn->async_read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num      = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    long long   insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);    
+
+                    co_return insert_last_id;
+                }
+                co_return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            co_return 0;
+        }
+
+
+        long long save(bool isrealnew = false)
+        {
+            effect_num = 0;
+            if (B_BASE::getPK() > 0 && isrealnew == false)
+            {
+                if (wheresql.empty())
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    wheresql = tempsql.str();
+                }
+                sqlstring = B_BASE::_makeupdatesql("");
+                sqlstring.append(" where ");
+                if (wheresql.empty())
+                {
+                    return 0;
+                }
+                else
+                {
+                    sqlstring.append(wheresql);
+                }
+                if (!groupsql.empty())
+                {
+                    sqlstring.append(groupsql);
+                }
+                if (!ordersql.empty())
+                {
+                    sqlstring.append(ordersql);
+                }
+                if (!limitsql.empty())
+                {
+                    sqlstring.append(limitsql);
+                }
+                if (iscommit)
+                {
+                    iscommit = false;
+                    return 0;
+                }
+
+                if (iserror)
+                {
+                    return 0;
+                }
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num      = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    return effect_num;
+                }
+                return 0;
+            }
+            else
+            {
+                sqlstring  = B_BASE::_makeinsertsql();
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num      = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    long long   insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);    
+
+                    return insert_last_id;
+                }
+                return 0;
+            }
+            return 0;
+        }
+
+        asio::awaitable<long long> async_save(bool isrealnew = false)
+        {
+            effect_num = 0;
+            if (B_BASE::getPK() > 0 && isrealnew == false)
+            {
+                if (wheresql.empty())
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    wheresql = tempsql.str();
+                }
+                sqlstring = B_BASE::_makeupdatesql("");
+                sqlstring.append(" where ");
+                if (wheresql.empty())
+                {
+                    co_return 0;
+                }
+                else
+                {
+                    sqlstring.append(wheresql);
+                }
+                if (!groupsql.empty())
+                {
+                    sqlstring.append(groupsql);
+                }
+                if (!ordersql.empty())
+                {
+                    sqlstring.append(ordersql);
+                }
+                if (!limitsql.empty())
+                {
+                    sqlstring.append(limitsql);
+                }
+                if (iscommit)
+                {
+                    iscommit = false;
+                    co_return 0;
+                }
+
+                if (iserror)
+                {
+                    co_return 0;
+                }
+
+                try
+                {
+                    if (conn_empty())
+                    {
+                        co_return 0;
+                    }
+                    auto conn = co_await conn_obj->async_get_edit_conn();
+
+                    unsigned int querysql_len = sqlstring.length() + 1;
+
+                    conn->send_data.clear();
+                    conn->send_data.push_back((querysql_len & 0xFF));
+                    conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                    conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                    conn->send_data.push_back(0x00);
+                    conn->send_data.push_back(0x03);
+                    conn->send_data.append(sqlstring);
+
+                    std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+
+                    unsigned int offset = 0;
+                    n                   = co_await conn->async_read_loop();
+
+                    pack_info_t temp_pack_data;
+                    temp_pack_data.seq_id = 1;
+                    conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                    conn_obj->back_edit_conn(conn);
+
+                    if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                    {
+                        error_msg = temp_pack_data.data.substr(3);
+                        iserror = true;
+                    }
+                    else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                    {
+
+                        unsigned int d_offset = 1;
+                        effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+
+                        co_return effect_num;
+                    }
+                    co_return 0;
+                }
+                catch (const std::exception &e)
+                {
+                    error_msg = std::string(e.what());
+                    co_return 0;
+                }
+                catch (const std::string &e)
+                {
+                    error_msg = e;
+                }
+                catch (...)
+                {
+                    co_return 0;
+                }
+                co_return 0;
+            }
+            else
+            {
+                sqlstring  = B_BASE::_makeinsertsql();
+                try
+                {
+                    if (conn_empty())
+                    {
+                        co_return 0;
+                    }
+                    auto conn = co_await conn_obj->async_get_edit_conn();
+
+                    unsigned int querysql_len = sqlstring.length() + 1;
+
+                    conn->send_data.clear();
+                    conn->send_data.push_back((querysql_len & 0xFF));
+                    conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                    conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                    conn->send_data.push_back(0x00);
+                    conn->send_data.push_back(0x03);
+                    conn->send_data.append(sqlstring);
+
+                    std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+                    
+                    unsigned int offset = 0;
+                    n                   = co_await conn->async_read_loop();
+
+                    pack_info_t temp_pack_data;
+                    temp_pack_data.seq_id = 1;
+                    conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                    conn_obj->back_edit_conn(conn);
+
+                    if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                    {
+                        error_msg = temp_pack_data.data.substr(3);
+                    }
+                    else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                    {
+
+                        unsigned int d_offset = 1;
+                        effect_num      = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                        long long   insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);    
+
+                        co_return insert_last_id;
+                    }
+                    co_return 0;
+                }
+                catch (const std::exception &e)
+                {
+                    error_msg = std::string(e.what());
+                }
+                catch (const std::string &e)
+                {
+                    error_msg = e;
+                }
+                catch (...)
+                {
+                }
+                co_return 0;
+            }
+            co_return 0;
+        }
+
+        std::tuple<std::vector<std::string>, std::map<std::string, unsigned int>, std::vector<std::vector<std::string>>>
+        query(const std::string &rawsql)
+        {
+
+            std::vector<std::vector<std::string>> temprecord;
+            std::vector<std::string> table_fieldname;
+            std::map<std::string, unsigned int> table_fieldmap;
+
+            if(rawsql.size()>10)
+            {
+                unsigned int i=0;
+                for(;i<rawsql.size();i++)
+                {
+                    if(rawsql[i]!=0x20)
+                    {
+                        break;
+                    }
+                }
+                if(i<5)
+                {
+                    //must be select
+                    if(rawsql[i]!='s' && rawsql[i]!='S')
+                    {
+                        iserror = true;   
+                    }
+                }
+                else
+                {
+                    iserror = true;   
+                }
+            }
+            else
+            {
+                iserror = true;   
+            }
+
+            if (iserror)
+            {
+                return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+            }
+
+            try
+            {
+                if (conn_empty())
+                {
+                    return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+                }
+                auto conn = conn_obj->get_select_conn();
+
+                unsigned int querysql_len = rawsql.length() + 1;
+
+                conn->send_data.clear();
+
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(rawsql);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+                }
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                std::vector<unsigned char> field_pos;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = conn->read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                        table_fieldmap.insert({field_array[ii].org_name,table_fieldname.size()});
+                                        table_fieldname.push_back(field_array[ii].org_name);
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                std::vector<std::string> temp_v_record; 
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+                                    std::string tempstr;
+                                    tempstr.resize(name_length);
+                                    std::memcpy(tempstr.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length);
+                                    temp_v_record.push_back(std::move(tempstr));
+                                    tempnum = tempnum + name_length;
+                                }
+                                temprecord.push_back(temp_v_record);
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+                conn_obj->back_select_conn(conn);
+
+                return std::make_tuple(std::move(table_fieldname), std::move(table_fieldmap), std::move(temprecord));
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+        }
+
+        asio::awaitable<std::tuple<std::vector<std::string>, std::map<std::string, unsigned int>, std::vector<std::vector<std::string>>>>
+        async_query(const std::string &rawsql)
+        {
+
+            std::vector<std::vector<std::string>> temprecord;
+            std::vector<std::string> table_fieldname;
+            std::map<std::string, unsigned int> table_fieldmap;
+
+            if(rawsql.size()>10)
+            {
+                unsigned int i=0;
+                for(;i<rawsql.size();i++)
+                {
+                    if(rawsql[i]!=0x20)
+                    {
+                        break;
+                    }
+                }
+                if(i<5)
+                {
+                    //must be select
+                    if(rawsql[i]!='s' && rawsql[i]!='S')
+                    {
+                        iserror = true;   
+                    }
+                }
+                else
+                {
+                    iserror = true;   
+                }
+            }
+            else
+            {
+                iserror = true;   
+            }
+
+            if (iserror)
+            {
+                co_return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+            }
+
+            try
+            {
+                if (conn_empty())
+                {
+                    co_return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+                }
+                auto conn = co_await conn_obj->async_get_select_conn();
+
+                unsigned int querysql_len = rawsql.length() + 1;
+
+                conn->send_data.clear();
+
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(rawsql);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+                
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                std::vector<unsigned char> field_pos;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = co_await conn->async_read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                        table_fieldmap.insert({field_array[ii].org_name,table_fieldname.size()});
+                                        table_fieldname.push_back(field_array[ii].org_name);
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                std::vector<std::string> temp_v_record; 
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+                                    std::string tempstr;
+                                    tempstr.resize(name_length);
+                                    std::memcpy(tempstr.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length);
+                                    temp_v_record.push_back(std::move(tempstr));
+                                    tempnum = tempnum + name_length;
+                                }
+                                temprecord.push_back(temp_v_record);
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+                conn_obj->back_select_conn(conn);
+
+                co_return std::make_tuple(std::move(table_fieldname), std::move(table_fieldmap), std::move(temprecord));
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            co_return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+        }
+
+        // long long edit_query(const std::string &rawsql, bool isinsert = false)
+        // {
+        //     if (iserror)
+        //     {
+        //         return 0;
+        //     }
+
+        //     return 0;
+        // }
+        M_MODEL &clear(bool both = true)
+        {
+            selectsql.clear();
+            wheresql.clear();
+            ordersql.clear();
+            groupsql.clear();
+            limitsql.clear();
+            sqlstring.clear();
+            error_msg.clear();
+            iskuohao     = false;
+            ishascontent = false;
+            iscommit     = false;
+            iscache      = false;
+            effect_num   = 0;
+            if (both)
+            {
+                B_BASE::record_reset();
+                B_BASE::data_reset();
+            }
+            return *mod;
+        }
+        M_MODEL &clearWhere()
+        {
+            selectsql.clear();
+            wheresql.clear();
+            ordersql.clear();
+            groupsql.clear();
+            limitsql.clear();
+            sqlstring.clear();
+            error_msg.clear();
+            iskuohao     = false;
+            ishascontent = false;
+            iscommit     = false;
+            iscache      = false;
+            effect_num   = 0;
+            return *mod;
+        }
+        M_MODEL &set_data(typename B_BASE::meta indata)
+        {
+            B_BASE::data = indata;
+            return *mod;
+        }
+        M_MODEL &get() { return *mod; }
+        std::string get_query() { return sqlstring; }
+        M_MODEL &start_commit()
+        {
+            iscommit = true;
+            return *mod;
+        }
+        M_MODEL &end_commit()
+        {
+            iscommit = false;
+            return *mod;
+        }
+
+        unsigned int effect()
+        {
+            return effect_num;
+        }
+        bool conn_empty()
+        {
+            if (conn_obj)
+            {
+                return false; 
+            }
+            error_msg = "conn_obj is null";
+            iserror   = true;
+            return true;
+        }
+
+      public:
+        std::string selectsql;
+        std::string wheresql;
+        std::string ordersql;
+        std::string groupsql;
+        std::string limitsql;
+        std::string sqlstring;
+        std::string dbtag;
+        std::string error_msg;
+        std::string original_tablename;
+
+        // std::list<std::string> commit_sqllist;
+        bool iskuohao           = false;
+        bool iscommit           = false;
+        bool ishascontent       = false;
+        bool iscache            = false;
+        bool iserror            = false;
+        int exptime             = 0;
+        unsigned int effect_num = 0;
+
+        M_MODEL *mod;
+
+        std::shared_ptr<orm_conn_pool> conn_obj;
+    };
+//} /*tagnamespace_replace*/
+}// namespace orm
+#endif

frameworks/C++/paozhu/paozhu_benchmark/orm/include/fortunebase.h

@@ -0,0 +1,2626 @@
+#ifndef ORM_DEFAULT_FORTUNEBASEMATA_H
+#define ORM_DEFAULT_FORTUNEBASEMATA_H
+/*
+*This file is auto create from cli
+*本文件为自动生成 Sun, 02 Mar 2025 10:54:30 GMT
+***/
+#include <iostream>
+#include <cstdio>
+#include <sstream>
+#include <array>
+#include <map> 
+#include <string_view> 
+#include <string> 
+#include <vector>
+#include <ctime>
+#include <array>
+#include "unicode.h"
+
+namespace orm { 
+   
+    
+struct fortunebase
+{
+    struct meta{
+     unsigned  int  id = 0; ///**/
+ std::string  message = ""; ///**/
+ } data;
+ std::vector<fortunebase::meta> record;
+std::string _rmstag="default";//this value must be default or tag value, tag in mysqlconnect config file .
+unsigned int _offset=0;
+std::vector<fortunebase::meta>::iterator begin(){     return record.begin(); }
+std::vector<fortunebase::meta>::iterator end(){     return record.end(); }
+std::vector<fortunebase::meta>::const_iterator begin() const{     return record.begin(); }
+std::vector<fortunebase::meta>::const_iterator end() const{     return record.end(); }
+static constexpr std::array<std::string_view,2> col_names={"id","message"};
+static constexpr std::array<unsigned char,2> col_types={3,253};
+static constexpr std::array<unsigned char,2> col_length={0,0};
+static constexpr std::array<unsigned char,2> col_decimals={0,0};
+std::string tablename="fortune";
+static constexpr std::string_view modelname="Fortune";
+
+	  unsigned char findcolpos(const std::string &coln){
+            if(coln.size()==0)
+            {
+                return 255;
+            }
+		    unsigned char  bi=coln[0];
+         
+
+	         if(bi<91&&bi>64){
+				bi+=32;
+			}
+            switch(coln[0]){
+
+
+         case 'i':
+   	 return 0;
+break;
+case 'm':
+   	 return 1;
+break;
+
+             }
+             return 255;
+           }
+         
+    int size(){ return record.size(); }   
+
+    std::string getPKname(){ 
+       return "id";
+}
+
+      void record_reset()
+      {
+            record.clear();     
+      }
+      void data_reset(){
+     fortunebase::meta metatemp;    
+            data = metatemp; 
+      }
+      
+      std::string soft_remove_sql([[maybe_unused]] const std::string &fieldsql){
+          std::string temp;
+     
+         return temp;
+     }
+     
+
+  inline  std::string stringaddslash(const std::string &content){
+        std::string temp;
+        for(unsigned int i=0;i<content.size();i++){
+            if(content[i]=='\''){
+                temp.append("\\'");
+                continue;
+            }else if(content[i]=='"'){
+                temp.append("\\\"");
+                continue;
+            }else if(content[i]=='\\'){
+                temp.append("\\\\");
+                continue;
+            }
+            temp.push_back(content[i]);
+        }
+        return temp;
+   }  
+  inline  std::string jsonaddslash(const std::string &content){
+        std::string temp;
+        for(unsigned int i=0;i<content.size();i++){
+            if(content[i]=='"'){
+                temp.append("\\\"");
+                continue;
+            }
+            else if(content[i]=='\\'){
+                temp.append("\\\\");
+                continue;
+            }
+            temp.push_back(content[i]);
+        }
+        return temp;
+   }  
+
+   std::string _makeinsertsql(){
+        unsigned int j=0;
+        std::ostringstream tempsql;
+        tempsql<<"INSERT INTO ";
+        tempsql<<tablename;
+        tempsql<<" (";
+        for(;j<col_names.size();j++){
+                if(j>0){
+                    tempsql<<"`,`";
+                }else{
+                    tempsql<<"`";
+                }
+                tempsql<<col_names[j];
+        }
+        if(j>0){
+            tempsql<<"`";
+        }
+        tempsql<<") VALUES (";
+
+        if(data.id==0){
+tempsql<<"null";
+ }else{ 
+	tempsql<<std::to_string(data.id);
+}
+tempsql<<",'"<<stringaddslash(data.message)<<"'";
+tempsql<<")";
+
+     
+       return tempsql.str();
+   } 
+      
+      std::string _makerecordinsertsql(const meta &insert_data){
+        unsigned int j=0;
+        std::ostringstream tempsql;
+        tempsql<<"INSERT INTO ";
+        tempsql<<tablename;
+        tempsql<<" (";
+        for(;j<col_names.size();j++){
+                if(j>0){
+                    tempsql<<"`,`";
+                }else{
+                    tempsql<<"`";
+                }
+                tempsql<<col_names[j];
+        }
+        if(j>0){
+            tempsql<<"`";
+        }
+        tempsql<<") VALUES (";
+
+        if(insert_data.id==0){
+tempsql<<"null";
+ }else{ 
+	tempsql<<std::to_string(insert_data.id);
+}
+tempsql<<",'"<<stringaddslash(insert_data.message)<<"'";
+tempsql<<")";
+
+     
+       return tempsql.str();
+   } 
+       
+    std::string _makerecordinsertsql(const std::vector<meta> &insert_data){
+        unsigned int j=0;
+        std::ostringstream tempsql;
+        tempsql<<"INSERT INTO ";
+        tempsql<<tablename;
+        tempsql<<" (";
+        for(;j<col_names.size();j++){
+                if(j>0){
+                    tempsql<<"`,`";
+                }else{
+                    tempsql<<"`";
+                }
+                tempsql<<col_names[j];
+        }
+        if(j>0){
+            tempsql<<"`";
+        }
+        tempsql<<") VALUES ";
+
+        for(unsigned int i=0;i<insert_data.size();i++)
+        {
+            if(i>0)
+            {
+                tempsql<<",";	
+            }
+            tempsql<<"(";
+
+
+            	if(insert_data[i].id==0){
+	tempsql<<"null";
+	 }else{ 
+	tempsql<<std::to_string(insert_data[i].id);
+	}
+		tempsql<<",'"<<stringaddslash(insert_data[i].message)<<"'";
+		tempsql<<")";
+	 } 
+
+     
+       return tempsql.str();
+   } 
+       
+    std::string _makeupdatesql(const std::string &fileld){
+        std::ostringstream tempsql;
+        tempsql<<"UPDATE ";
+        tempsql<<tablename;
+        tempsql<<" SET ";
+
+        bool isall=false;
+        if(fileld.empty()){
+            isall=true;
+        }
+        if(isall){
+
+        if(data.id==0){
+	tempsql<<"`id`=0";
+ }else{ 
+	tempsql<<"`id`="<<std::to_string(data.id);
+}
+tempsql<<",`message`='"<<stringaddslash(data.message)<<"'";
+ }else{ 
+
+     
+  unsigned int jj=0;
+                  std::string keyname;
+                  std::vector<unsigned char> keypos;
+                  for(;jj<fileld.size();jj++){
+                        if(fileld[jj]==','){
+                                unsigned char bpos_i=findcolpos(keyname);
+                               keypos.emplace_back(bpos_i); 
+#ifdef DEBUG
+                    if (bpos_i == 255)
+                    {
+                        std::cout << "\033[1m\033[31m-----------\n"
+                                  << keyname << " not in " << tablename << " table Field.\n-----------\033[0m"
+                                  << std::endl;
+                    }
+#endif                               
+                               keyname.clear();
+                             continue;   
+                        }
+                        if(fileld[jj]==0x20){
+
+                             continue;   
+                        }
+                        keyname.push_back(fileld[jj]);
+
+                  }  
+                 if(keyname.size()>0){
+                                unsigned char bpos_i=findcolpos(keyname);
+ #ifdef DEBUG
+                    if (bpos_i == 255)
+                    {
+                        std::cout << "\033[1m\033[31m-----------\n"
+                                  << keyname << " not in " << tablename << " table Field.\n-----------\033[0m"
+                                  << std::endl;
+                    }
+#endif                                       
+                                keypos.emplace_back(bpos_i); 
+                                keyname.clear();
+                 }
+                 for(jj=0;jj<keypos.size();jj++){
+                       switch(keypos[jj]){
+
+         case 0:
+ if(jj>0){ tempsql<<","; } 
+if(data.id==0){
+	tempsql<<"`id`=0";
+ }else{ 
+	tempsql<<"`id`="<<std::to_string(data.id);
+}
+ break;
+ case 1:
+ if(jj>0){ tempsql<<","; } 
+tempsql<<"`message`='"<<stringaddslash(data.message)<<"'";
+ break;
+
+     
+                  default:
+                                ;
+                     }
+                 }   
+
+            }        
+
+        return tempsql.str();
+   } 
+   
+    std::string _make_replace_into_sql()
+    {
+        unsigned int j = 0;
+        std::ostringstream tempsql;
+        tempsql << "REPLACE INTO ";
+        tempsql << tablename;
+        tempsql << " (";
+        for (; j < col_names.size(); j++)
+        {
+            if (j > 0)
+            {
+                tempsql << "`,`";
+            }
+            else
+            {
+                tempsql << "`";
+            }
+            tempsql << col_names[j];
+        }
+        if (j > 0)
+        {
+            tempsql << "`";
+        }
+        tempsql << ") VALUES ";
+
+        for (unsigned int i = 0; i < record.size(); i++)
+        {
+            if (i > 0)
+            {
+                tempsql << ",\n";
+            }
+            tempsql << "(";
+            	if(record[i].id==0){
+	tempsql<<"null";
+	 }else{ 
+	tempsql<<std::to_string(record[i].id);
+	}
+	tempsql<<",'"<<stringaddslash(record[i].message)<<"'";
+	tempsql<<")";
+
+ }
+ return tempsql.str();
+}
+
+    std::string _make_insert_into_sql(const std::string &fileld)
+    {
+        unsigned int j = 0;
+        std::ostringstream tempsql;
+        tempsql << "INSERT INTO ";
+        tempsql << tablename;
+        tempsql << " (";
+        for (; j < col_names.size(); j++)
+        {
+            if (j > 0)
+            {
+                tempsql << "`,`";
+            }
+            else
+            {
+                tempsql << "`";
+            }
+            tempsql << col_names[j];
+        }
+        if (j > 0)
+        {
+            tempsql << "`";
+        }
+        tempsql << ") VALUES ";
+
+        for (unsigned int i = 0; i < record.size(); i++)
+        {
+            if (i > 0)
+            {
+                tempsql << ",\n";
+            }
+            tempsql << "(";
+            	if(record[i].id==0){
+	tempsql<<"null";
+	 }else{ 
+	tempsql<<std::to_string(record[i].id);
+	}
+	tempsql<<",'"<<stringaddslash(record[i].message)<<"'";
+	tempsql<<")";
+	 }
+	 tempsql<<" as new ON DUPLICATE KEY UPDATE ";
+
+     
+        std::string keyname;
+        unsigned char jj=0;
+        j=0;
+        if(fileld.size()>0){
+        for(;jj<fileld.size();jj++){
+            if(fileld[jj]==','){
+                if(findcolpos(keyname)<255)
+                {
+                    if(j>0)
+                    {
+                        tempsql<<",";
+                    }
+                    tempsql<<keyname;
+                    tempsql<<"=new.";
+                    tempsql<<keyname;
+                }
+                continue;   
+            }
+            if(fileld[jj]==0x20){
+                continue;   
+            }
+            keyname.push_back(fileld[jj]);
+
+        }  
+        if(keyname.size()>0){
+            if(findcolpos(keyname)<255)
+            {
+                if(j>0)
+                {
+                    tempsql<<",";
+                }
+                tempsql<<keyname;
+                tempsql<<"=new.";
+                tempsql<<keyname;
+                
+            }
+        }
+
+    } 
+ 
+ return tempsql.str();
+}
+
+   std::vector<std::string> data_toarray(std::string fileld=""){
+        std::vector<std::string> temparray;
+        std::string keyname;
+        unsigned char jj=0;
+        std::vector<unsigned char> keypos;
+        if(fileld.size()>1){
+            for(;jj<fileld.size();jj++){
+                if(fileld[jj]==','){
+                    keypos.emplace_back(findcolpos(keyname)); 
+                    keyname.clear();
+                    continue;   
+                }
+                if(fileld[jj]==0x20){
+
+                    continue;   
+                }
+                keyname.push_back(fileld[jj]);
+
+            }  
+            if(keyname.size()>0){
+                keypos.emplace_back(findcolpos(keyname)); 
+                keyname.clear();
+            }
+        }else{
+            for(jj=0;jj<col_names.size();jj++){
+                keypos.emplace_back(jj); 
+            }
+        }
+               
+            for(jj=0;jj<keypos.size();jj++){
+                switch(keypos[jj]){
+         case 0:
+if(data.id==0){
+	temparray.push_back("0");
+ }else{ 
+	temparray.push_back(std::to_string(data.id));
+}
+ break;
+ case 1:
+	temparray.push_back(data.message);
+ break;
+
+                             default:
+                                ;
+                     }
+                 }   
+   
+     return temparray;             
+   }   
+   
+   std::map<std::string,std::string> data_tomap(std::string fileld=""){
+       std::map<std::string,std::string> tempsql;
+        std::string keyname;
+        unsigned char jj=0;
+        std::vector<unsigned char> keypos;
+        if(fileld.size()>1){
+        for(;jj<fileld.size();jj++){
+            if(fileld[jj]==','){
+                keypos.emplace_back(findcolpos(keyname)); 
+                keyname.clear();
+                continue;   
+            }
+            if(fileld[jj]==0x20){
+
+                continue;   
+            }
+            keyname.push_back(fileld[jj]);
+
+        }  
+        if(keyname.size()>0){
+            keypos.emplace_back(findcolpos(keyname)); 
+            keyname.clear();
+        }
+        }else{
+            for(jj=0;jj<col_names.size();jj++){
+                keypos.emplace_back(jj); 
+            }
+        }
+    
+        for(jj=0;jj<keypos.size();jj++){
+            switch(keypos[jj]){
+         case 0:
+if(data.id==0){
+	tempsql.insert({"id","0"});
+ }else{ 
+	tempsql.insert({"id",std::to_string(data.id)});
+}
+ break;
+ case 1:
+	tempsql.insert({"message",data.message});
+ break;
+
+                             default:
+                                ;
+                     }
+                 }   
+    
+     return tempsql;             
+   }   
+   
+   std::string data_tojson(){
+       std::ostringstream tempsql;
+
+        tempsql<<"{";
+if(data.id==0){
+	tempsql<<"\"id\":0";
+ }else{ 
+	tempsql<<"\"id\":"<<std::to_string(data.id);
+}
+tempsql<<",\"message\":\""<<http::utf8_to_jsonstring(data.message);
+tempsql<<"\"";
+tempsql<<"}";
+
+     
+     return tempsql.str();             
+   }   
+   
+   std::string data_tojson(std::string fileld){
+        std::ostringstream tempsql;
+        std::string keyname;
+        unsigned char jj=0;
+        std::vector<unsigned char> keypos;
+        if(fileld.size()>0){
+        for(;jj<fileld.size();jj++){
+            if(fileld[jj]==','){
+                keypos.emplace_back(findcolpos(keyname)); 
+                keyname.clear();
+                continue;   
+            }
+            if(fileld[jj]==0x20){
+
+                continue;   
+            }
+            keyname.push_back(fileld[jj]);
+
+        }  
+        if(keyname.size()>0){
+            keypos.emplace_back(findcolpos(keyname)); 
+            keyname.clear();
+        }
+        }else{
+            for(jj=0;jj<col_names.size();jj++){
+                keypos.emplace_back(jj); 
+            }
+        }
+        tempsql<<"{";
+        for(jj=0;jj<keypos.size();jj++){
+            switch(keypos[jj]){
+         case 0:
+ if(jj>0){ tempsql<<","; } 
+if(data.id==0){
+	tempsql<<"\"id\":0";
+ }else{ 
+	tempsql<<"\"id\":"<<std::to_string(data.id);
+}
+ break;
+ case 1:
+ if(jj>0){ tempsql<<","; } 
+tempsql<<"\"message\":\""<<http::utf8_to_jsonstring(data.message)<<"\"";
+ break;
+
+                             default:
+                                ;
+                     }
+                 }   
+      tempsql<<"}";  
+     return tempsql.str();             
+   }   
+   
+    void from_json(const std::string &json_content)
+   {
+        record.clear();
+        fortunebase::meta metatemp; 
+        data=metatemp;
+        unsigned int json_offset=0;
+        bool isarray=false;
+        //std::vector<std::string> list_content;
+        for(;json_offset<json_content.size();json_offset++)
+        {
+            if(json_content[json_offset]=='{')
+            {
+                break;
+            }
+            if(json_content[json_offset]=='[')
+            {
+                isarray=true;
+                break;
+            }
+        }
+        if(isarray)
+        {
+            json_offset+=1; 
+            std::string json_key_name,json_value_name; 
+            for(;json_offset<json_content.size();json_offset++)
+            {
+                for(;json_offset<json_content.size();json_offset++)
+                {
+                    if(json_content[json_offset]=='{')
+                    {
+                        json_offset+=1;
+                        break;
+                    }
+                }
+                if(record.size()>0)
+                {
+                    data=metatemp;
+                }
+                if(json_offset>=json_content.size())
+                {
+                    break;
+                }
+                for(;json_offset<json_content.size();json_offset++)
+                {
+    
+                            if(json_content[json_offset]==0x20||json_content[json_offset]==0x0A||json_content[json_offset]==0x0D||json_content[json_offset]=='\t')
+                            {
+                                continue;
+                            }
+                            else
+                            {
+                                if(json_content[json_offset]==0x22)
+                                {
+                                    unsigned int temp_offset=json_offset;
+                                    json_key_name=http::jsonstring_to_utf8(&json_content[json_offset],json_content.size()-json_offset,temp_offset);
+                                    json_offset=temp_offset;
+                                    if(json_content[json_offset]==0x22)
+                                    {
+                                        json_offset+=1;
+                                    }
+                                    for(;json_offset<json_content.size();json_offset++)
+                                    {
+                                    
+                                        if(json_content[json_offset]==0x20||json_content[json_offset]==0x0A||json_content[json_offset]==0x0D||json_content[json_offset]=='\t')
+                                        {
+                                            continue;
+                                        }
+                                        break;
+                                    }       
+                                    if(json_content[json_offset]!=':')
+                                    {
+                                        break;
+                                    }
+                                    for(;json_offset<json_content.size();json_offset++)
+                                    {
+                                        if(json_content[json_offset]==0x20||json_content[json_offset]==0x0A||json_content[json_offset]==0x0D||json_content[json_offset]=='\t')
+                                        {
+                                            continue;
+                                        }
+                                        break;
+                                    } 
+                                    json_offset+=1;
+                                    if(json_offset>=json_content.size())
+                                    {
+                                        break;
+                                    }
+                                    json_value_name.clear();
+                                    if(json_content[json_offset]==0x22)
+                                    {
+                                        
+                                        temp_offset=json_offset;
+                                        json_value_name=http::jsonstring_to_utf8(&json_content[json_offset],json_content.size()-json_offset,temp_offset);
+                                        json_offset=temp_offset;
+                                        if(json_content[json_offset]==0x22)
+                                        {
+                                            json_offset+=1;
+                                        }
+                                    }
+                                    else
+                                    {
+                                        if(json_content[json_offset]!='{'&&json_content[json_offset]!=']')
+                                        {
+                                            for(;json_offset<json_content.size();json_offset++)
+                                            {
+                                                if(json_content[json_offset]==0x5D||json_content[json_offset]==0x7D||json_content[json_offset]==0x22||json_content[json_offset]==0x2C||json_content[json_offset]==0x20||json_content[json_offset]==0x0A||json_content[json_offset]==0x0D||json_content[json_offset]=='\t')
+                                                {
+                                                    if(json_content[json_offset]==0x7D)
+                                                    {
+                                                        json_offset-=1;
+                                                    } 
+                                                    break;
+                                                }
+                                                json_value_name.push_back(json_content[json_offset]);
+                                            }   
+                                        }
+                                    }
+                                    //////////////////////////
+                                    set_val(json_key_name,json_value_name);
+                                    continue;
+                                }
+                                else
+                                {
+                                    break;
+                                }
+                            }
+    
+                }
+                record.emplace_back(data);
+                
+                json_offset+=1;
+            }
+            if(record.size()>1)
+            {
+                data=record[0];
+            }
+        }
+        else
+        {
+           if(json_content[json_offset]=='{')
+            {
+                json_offset+=1; 
+                std::string json_key_name,json_value_name; 
+                 
+                
+                for(;json_offset<json_content.size();json_offset++)
+                {
+ 
+                        if(json_content[json_offset]==0x20||json_content[json_offset]==0x0A||json_content[json_offset]==0x0D||json_content[json_offset]=='\t')
+                        {
+                            continue;
+                        }
+                        else
+                        {
+                            if(json_content[json_offset]==0x22)
+                            {
+                                 unsigned int temp_offset=json_offset;
+                                 json_key_name=http::jsonstring_to_utf8(&json_content[json_offset],json_content.size()-json_offset,temp_offset);
+                                 json_offset=temp_offset;
+                                 if(json_content[json_offset]==0x22)
+                                 {
+                                    json_offset+=1;
+                                 }
+                                for(;json_offset<json_content.size();json_offset++)
+                                {
+                                
+                                    if(json_content[json_offset]==0x20||json_content[json_offset]==0x0A||json_content[json_offset]==0x0D||json_content[json_offset]=='\t')
+                                    {
+                                        continue;
+                                    }
+                                    break;
+                                }       
+                                if(json_content[json_offset]!=':')
+                                {
+                                    break;
+                                }
+                                for(;json_offset<json_content.size();json_offset++)
+                                {
+                                    if(json_content[json_offset]==0x20||json_content[json_offset]==0x0A||json_content[json_offset]==0x0D||json_content[json_offset]=='\t')
+                                    {
+                                        continue;
+                                    }
+                                    break;
+                                } 
+                                json_offset+=1;
+                                if(json_offset>=json_content.size())
+                                {
+                                    break;
+                                }
+                                json_value_name.clear();
+                                if(json_content[json_offset]==0x22)
+                                {
+                                    
+                                    temp_offset=json_offset;
+                                    json_value_name=http::jsonstring_to_utf8(&json_content[json_offset],json_content.size()-json_offset,temp_offset);
+                                    json_offset=temp_offset;
+                                    if(json_content[json_offset]==0x22)
+                                    {
+                                        json_offset+=1;
+                                    }
+                                }
+                                else
+                                {
+                                    if(json_content[json_offset]!='{'&&json_content[json_offset]!=']')
+                                    {
+                                        for(;json_offset<json_content.size();json_offset++)
+                                        {
+                                            if(json_content[json_offset]==0x5D||json_content[json_offset]==0x7D||json_content[json_offset]==0x22||json_content[json_offset]==0x2C||json_content[json_offset]==0x20||json_content[json_offset]==0x0A||json_content[json_offset]==0x0D||json_content[json_offset]=='\t')
+                                            {
+                                               if(json_content[json_offset]==0x7D)
+                                               {
+                                                   json_offset-=1;
+                                               } 
+                                               break;
+                                            }
+                                            json_value_name.push_back(json_content[json_offset]);
+                                        }   
+                                    }
+                                }
+                                //////////////////////////
+                                set_val(json_key_name,json_value_name);
+                                continue;
+                            }
+                            else
+                            {
+                                break;
+                            }
+                        }
+ 
+                }
+                record.emplace_back(data);
+            } 
+        }
+   }   
+    
+    void set_val(const std::string& set_key_name,const std::string& set_value_name)
+    {
+        switch(findcolpos(set_key_name))
+        {
+    		case 0:
+		 try{
+			data.id=std::stoul(set_value_name);
+		}catch (...) { 
+			data.id=0;
+			 }
+			break;
+		case 1:
+		 try{
+			data.message.append(set_value_name);
+		}catch (...) { 
+			data.message.clear();
+			 }
+			break;
+	default:
+		 { }
+			
+
+
+        }
+   } 
+    
+    void set_val(const std::string& set_key_name,const long long set_value_name)
+    {
+        switch(findcolpos(set_key_name))
+        {
+    		case 0:
+		 try{
+			data.id=set_value_name;
+		}catch (...) { 
+			data.id=0;
+			 }
+			break;
+		case 1:
+		 try{
+			data.message=std::to_string(set_value_name);
+		}catch (...) { 
+			data.message.clear();
+			 }
+			break;
+	default:
+		 { }
+			
+
+
+        }
+   } 
+    
+    void set_val(const std::string& set_key_name,const double set_value_name)
+    {
+        switch(findcolpos(set_key_name))
+        {
+    		case 0:
+		 try{
+			data.id=(unsigned int)set_value_name;
+		}catch (...) { 
+			data.id=0;
+			 }
+			break;
+		case 1:
+		 try{
+			data.message=std::to_string(set_value_name);
+		}catch (...) { 
+			data.message.clear();
+			 }
+			break;
+	default:
+		 { }
+			
+
+
+        }
+   } 
+    
+   std::string to_json(std::string fileld=""){
+    std::ostringstream tempsql;
+    std::string keyname;
+    unsigned char jj=0;
+    std::vector<unsigned char> keypos;
+    if(fileld.size()>0){
+        for(;jj<fileld.size();jj++){
+            if(fileld[jj]==','){
+                keypos.emplace_back(findcolpos(keyname)); 
+                keyname.clear();
+                continue;   
+            }
+            if(fileld[jj]==0x20){
+
+                continue;   
+            }
+            keyname.push_back(fileld[jj]);
+
+        }  
+        if(keyname.size()>0){
+            keypos.emplace_back(findcolpos(keyname)); 
+            keyname.clear();
+        }
+    }else{
+        for(jj=0;jj<col_names.size();jj++){
+            keypos.emplace_back(jj); 
+        }
+    }
+    tempsql<<"[";
+    for(size_t n=0;n<record.size();n++){
+        if(n>0){
+            tempsql<<",{";
+        }else{
+            tempsql<<"{";
+        }  
+    
+        for(jj=0;jj<keypos.size();jj++){
+            switch(keypos[jj]){
+         case 0:
+ if(jj>0){ tempsql<<","; } 
+if(record[n].id==0){
+	tempsql<<"\"id\":0";
+ }else{ 
+	tempsql<<"\"id\":"<<std::to_string(record[n].id);
+}
+ break;
+ case 1:
+ if(jj>0){ tempsql<<","; } 
+tempsql<<"\"message\":\""<<http::utf8_to_jsonstring(record[n].message)<<"\"";
+ break;
+
+                             default:
+                                ;
+                     }
+                 }   
+      tempsql<<"}";  
+            }
+      tempsql<<"]";
+     return tempsql.str();             
+   }   
+   
+   std::string to_json(std::function<bool(std::string&,meta&)> func,std::string fileld=""){
+       std::ostringstream tempsql;
+        std::string keyname;
+        unsigned char jj=0;
+        std::vector<unsigned char> keypos;
+        if(fileld.size()>0){
+            for(;jj<fileld.size();jj++){
+                if(fileld[jj]==','){
+                    keypos.emplace_back(findcolpos(keyname)); 
+                    keyname.clear();
+                    continue;   
+                }
+                if(fileld[jj]==0x20){
+
+                    continue;   
+                }
+                keyname.push_back(fileld[jj]);
+
+            }  
+            if(keyname.size()>0){
+                keypos.emplace_back(findcolpos(keyname)); 
+                keyname.clear();
+            }
+        }else{
+            for(jj=0;jj<col_names.size();jj++){
+                keypos.emplace_back(jj); 
+            }
+        }
+        tempsql<<"[";
+        for(size_t n=0;n<record.size();n++){
+            keyname.clear();
+            if(func(keyname,record[n])){ 
+                if(n>0){
+                    tempsql<<",{";
+                }else{
+                    tempsql<<"{";
+                } 
+                tempsql<<keyname;
+            }else{
+            continue;
+            } 
+        
+        for(jj=0;jj<keypos.size();jj++){
+            
+            switch(keypos[jj]){
+         case 0:
+ if(jj>0){ tempsql<<","; } 
+if(record[n].id==0){
+	tempsql<<"\"id\":0";
+ }else{ 
+	tempsql<<"\"id\":"<<std::to_string(record[n].id);
+}
+ break;
+ case 1:
+ if(jj>0){ tempsql<<","; } 
+tempsql<<"\"message\":\""<<http::utf8_to_jsonstring(record[n].message)<<"\"";
+ break;
+
+                             default:
+                                ;
+                     }
+                 }   
+      tempsql<<"}";  
+            }
+      tempsql<<"]";
+     return tempsql.str();             
+   }   
+   long long getPK(){  return data.id; } 
+ void setPK(long long val){  data.id=val;} 
+ unsigned  int  getId(){  return data.id; } 
+ void setId( unsigned  int  val){  data.id=val;} 
+
+ std::string  getMessage(){  return data.message; } 
+ std::string & getRefMessage(){  return std::ref(data.message); } 
+ void setMessage( std::string  &val){  data.message=val;} 
+ void setMessage(std::string_view val){  data.message=val;} 
+
+fortunebase::meta getnewData(){
+ 	 struct meta newdata;
+	 return newdata; 
+} 
+fortunebase::meta getData(){
+ 	 return data; 
+} 
+std::vector<fortunebase::meta> getRecord(){
+ 	 return record; 
+} 
+
+
+    template<typename T, typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true>
+    T& ref_meta([[maybe_unused]] std::string key_name)
+    {
+   		 if(key_name=="message")
+		{
+			return data.message;
+		}
+		return nullptr; 
+	}
+
+
+    template<typename T, typename std::enable_if<std::is_integral_v<T>,bool>::type = true>
+    T& ref_meta([[maybe_unused]] std::string key_name)
+    {
+   		 if(key_name=="id")
+		{
+			return data.id;
+		}
+		return nullptr; 
+	}
+
+
+    template<typename T, typename std::enable_if<std::is_floating_point_v<T>,bool>::type = true >
+    T& ref_meta([[maybe_unused]] std::string key_name)
+    {
+   		return nullptr; 
+	}
+
+            template<typename T, typename std::enable_if<std::is_integral_v<T>,bool>::type = true >  
+            std::vector<T> getCol([[maybe_unused]] std::string keyname)
+            {
+                std::vector<T> a;
+                
+   
+                unsigned char kpos;
+                kpos=findcolpos(keyname);               
+                for(auto &iter:record)
+                {
+                    switch(kpos)
+                    {
+   			case 0: 
+ 				 a.emplace_back(iter.id);
+				 break;
+
+                    }
+                }
+    
+                return a;
+            }
+    
+            template<typename T, typename std::enable_if<std::is_floating_point_v<T>,bool>::type = true >    
+			std::vector<T> getCol([[maybe_unused]] std::string keyname)
+			{
+				std::vector<T> a;
+				
+
+                return a;
+            }
+    
+            template<typename T, typename std::enable_if<std::is_integral_v<T>,bool>::type = true >   
+            T getVal([[maybe_unused]] std::string keyname)
+            {
+   
+                    unsigned char kpos;
+                    kpos=findcolpos(keyname);                   
+                    switch(kpos)
+                    {
+
+   			case 0: 
+ 				 return data.id;
+				 break;
+			}
+                return 0;
+            }  
+    
+        template<typename T, typename std::enable_if<std::is_integral_v<T>,bool>::type = true > 
+        T getVal([[maybe_unused]] fortunebase::meta & iter,[[maybe_unused]] std::string keyname)
+        {
+
+          
+            unsigned char kpos;
+            kpos=findcolpos(keyname);   
+            switch(kpos)
+            {
+   			case 0: 
+ 				 return iter.id;
+				 break;
+
+			}
+
+            return 0;
+        }  
+    
+            template<typename T, typename std::enable_if<std::is_floating_point_v<T>,bool>::type = true > 
+            T getVal(std::string keyname)
+            {
+                unsigned char kpos;
+                kpos=findcolpos(keyname);
+            
+                switch(kpos)
+                {
+
+    
+                    }
+                   
+    
+                    return 0.0;
+            }  
+    
+            template<typename T, typename std::enable_if<std::is_floating_point_v<T>,bool>::type = true > 
+            T getVal([[maybe_unused]] fortunebase::meta & iter,std::string keyname)
+            {
+                unsigned char kpos;
+                kpos=findcolpos(keyname);
+                switch(kpos)
+                {
+   
+                }
+                 
+    
+            
+                return 0.0;
+            }  
+    
+            template<typename T, typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true > 
+            std::string getVal(std::string keyname)
+            {
+                unsigned char kpos;
+                kpos=findcolpos(keyname);
+        
+                switch(kpos)
+                {
+
+   			case 1: 
+ 				 return data.message;
+				 break;
+
+                }
+                return "";
+            }  
+   
+            template<typename T, typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true > 
+            std::string getVal([[maybe_unused]] fortunebase::meta & iter,std::string keyname)
+            {
+         
+                unsigned char kpos;
+                kpos=findcolpos(keyname);
+       
+                switch(kpos)
+                {
+
+   			case 1: 
+ 				 return iter.message;
+				 break;
+
+                }
+                
+    
+                 
+                return "";
+            }  
+     
+            template<typename T, typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true >   
+            std::vector<std::string> getCol([[maybe_unused]] std::string keyname)
+            {
+                std::vector<std::string> a;
+
+           
+                unsigned char kpos;
+                kpos=findcolpos(keyname);                    
+                for(auto &iter:record)
+                {
+                    switch(kpos)
+                    {
+
+    			case 1: 
+ 				 a.emplace_back(iter.message);
+					 break;
+					}
+				}
+
+        return a;
+    }
+     
+        std::string getstrCol(std::string keyname,[[maybe_unused]] bool isyinhao=false)
+        {
+            std::ostringstream a;
+    
+            unsigned char kpos;
+            kpos=findcolpos(keyname);   
+            int j=0;
+            if(isyinhao&&record.size()>0)
+            {
+                a<<'"';
+            }
+            for(auto &iter:record)
+            {
+                    if(j>0)
+                    {
+                        if(isyinhao)
+                        {
+                            a<<"\",\"";
+                        }else{
+                            a<<',';    
+                        }
+                    }
+                    switch(kpos)
+                    {
+
+   			case 0: 
+ 				 a<<std::to_string(iter.id);
+				 break;
+			case 1: 
+ 				 if(isyinhao){ a<<jsonaddslash(iter.message); 
+				 }else{
+				 a<<iter.message;
+				 }
+				 break;
+
+                    }
+                    j++;
+            } 
+            if(isyinhao&&j>0){
+                a<<'"';
+            }      
+    
+                return a.str();
+        }
+    
+    template<typename T,typename U,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true,typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true>     
+    std::map<std::string,std::string> getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+    {
+        std::map<std::string,std::string> a;
+    
+        unsigned char kpos,vpos;
+        kpos=findcolpos(keyname);
+        vpos=findcolpos(valname);        
+         std::string ktemp,vtemp;
+         for(auto &iter:record)
+         {
+                switch(kpos)
+                {
+
+   			case 1: 
+ 				 ktemp=iter.message;
+				 break;
+				 } 
+			switch(vpos){
+			case 1: 
+ 				 vtemp=iter.message;
+				 break;
+
+                }
+                if(ktemp.size()>0)
+                {
+                    a.emplace(ktemp,vtemp);
+                }
+            }       
+
+        
+            return a;
+        } 
+    
+
+        template<typename T,typename U,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true, typename std::enable_if<std::is_floating_point<U>::value,bool>::type = true>    
+        std::map<std::string,U> getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+                std::map<std::string,U> a;
+      
+                unsigned char kpos,vpos;
+                kpos=findcolpos(keyname);
+                vpos=findcolpos(valname);            
+                std::string ktemp;
+                U vtemp;
+                for(auto &iter:record)
+                {    
+                    switch(kpos)
+                    {
+ 
+       			case 1: 
+ 				 ktemp=iter.message;
+				 break;
+			 } 
+		 switch(vpos){
+
+                    }
+                    if(ktemp.size()>0)
+                    {
+                        a.emplace(ktemp,vtemp);
+                    }
+                }       
+        
+            return a;
+        } 
+    
+        template<typename T,typename U,typename std::enable_if<std::is_integral_v<T>,bool>::type = true, typename std::enable_if<std::is_floating_point<U>::value,bool>::type = true>       
+        std::map<T,U> getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,U> a;
+       
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);        
+            T ktemp;
+            U vtemp;
+            for(auto &iter:record)
+            {
+                switch(kpos)
+                {
+ 
+       case 0: 
+ 	 ktemp=iter.id;
+	 break;
+	 } 
+ 		  switch(vpos){
+
+                }
+                if(ktemp.size()>0)
+                {
+                    a.emplace(ktemp,vtemp);
+                }
+            }       
+     
+        return a;
+    }  
+            template<typename T,typename U,typename std::enable_if<std::is_integral_v<T>,bool>::type = true, typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true>      
+            std::map<T,std::string> getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+            {
+                std::map<T,std::string> a;
+   
+                unsigned char kpos,vpos;
+                kpos=findcolpos(keyname);
+                vpos=findcolpos(valname);         
+                T ktemp;
+                std::string vtemp;
+                for(auto &iter:record)
+                {
+                    switch(kpos)
+                    {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			  }
+ 			switch(vpos){
+			case 1: 
+ 				 vtemp=iter.message;
+				 break;
+
+                    }
+                    if(ktemp.size()>0)
+                    {
+                        a.emplace(ktemp,vtemp);
+                    }
+                } 
+         
+                return a;
+            }     
+        
+        template<typename T,typename U, typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true>       
+        std::map<std::string,U> getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<std::string,U> a;
+   
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);            
+            std::string  ktemp;
+            U  vtemp;
+            for(auto &iter:record)
+            {
+                switch(kpos)
+                {
+
+   			case 1: 
+ 				 ktemp=iter.message;
+				 break;
+			  }
+ 			 switch(vpos){
+			case 0: 
+ 				 vtemp=iter.id;
+				 break;
+
+                }
+                if(ktemp.size()>0)
+                {
+                    a.emplace(ktemp,vtemp);
+                }
+            }       
+      
+        return a;
+    }  
+    
+        template<typename T,typename U, typename std::enable_if<std::is_integral_v<T>,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true>   
+        std::map<T,U> getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,U> a;
+    
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);            
+            T ktemp;
+            U vtemp;
+            for(auto &iter:record)
+            {
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			  }
+ 			switch(vpos){
+			case 0: 
+ 				 vtemp=iter.id;
+				 break;
+
+                }
+                if(ktemp.size()>0)
+                {
+                    a.emplace(ktemp,vtemp);
+                }
+            }       
+    
+            return a;
+        }   
+    
+        template<typename T, typename std::enable_if<std::is_integral_v<T>,bool>::type = true >         
+        std::map<T,meta> getmapRows([[maybe_unused]] std::string keyname)
+        {
+            std::map<T,meta> a;
+    
+            unsigned char kpos;
+            kpos=findcolpos(keyname);                        
+            for(auto &iter:record)
+            {
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 a.emplace(iter.id,iter);
+				 break;
+
+                }
+            }       
+     
+            return a;
+        }     
+    
+        template<typename T, typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true >    
+        std::map<std::string,meta> getmapRows([[maybe_unused]] std::string keyname)
+        {
+            std::map<std::string,meta> a;
+
+    
+            unsigned char kpos;
+            kpos=findcolpos(keyname);            
+            for(auto &iter:record)
+            {
+                switch(kpos)
+                {
+
+   			case 1: 
+ 				 a.emplace(iter.message,iter);
+			 break;
+
+                }
+                //a.emplace(ktemp,iter);
+            }       
+    
+
+        return a;
+    }
+    
+        template<typename T,typename U,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true, typename std::enable_if<std::is_floating_point<U>::value,bool>::type = true>  
+        std::vector<std::pair<std::string,U>> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::vector<std::pair<std::string,U>> a;
+   
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);                   
+            std::string ktemp;
+            U vtemp;
+            for(auto &iter:record)
+            {
+                switch(kpos)
+                {
+
+   			case 1: 
+ 				 ktemp=iter.message;
+				 break;
+	 		 }
+ 			switch(vpos){
+
+                   }
+
+                 a.emplace_back(ktemp,vtemp);
+            }       
+
+     
+
+            return a;
+        }   
+    
+        template<typename T,typename U,typename std::enable_if<std::is_integral_v<T>,bool>::type = true, typename std::enable_if<std::is_floating_point<U>::value,bool>::type = true>    
+        std::vector<std::pair<T,U>> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+                std::vector<std::pair<T,U>> a;
+   
+                unsigned char kpos,vpos;
+                kpos=findcolpos(keyname);
+                vpos=findcolpos(valname);
+                T ktemp;
+                U vtemp;
+                for(auto &iter:record)
+                {
+                    switch(kpos)
+                    {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+			 break;
+			  }
+			 switch(vpos){
+
+                   }
+
+                   a.emplace_back(ktemp,vtemp);
+                }       
+
+    
+
+            return a;
+        }   
+    
+        template<typename T,typename U,typename std::enable_if<std::is_integral_v<T>,bool>::type = true, typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true>    
+        std::vector<std::pair<T,U>> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+                std::vector<std::pair<T,U>> a;
+
+   
+                unsigned char kpos,vpos;
+                kpos=findcolpos(keyname);
+                vpos=findcolpos(valname);
+                T ktemp;
+                U vtemp;
+                for(auto &iter:record)
+                {
+                    switch(kpos)
+                    {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			  }
+ 			switch(vpos){
+			case 1: 
+ 				 vtemp=iter.message;
+				 break;
+
+                   }
+
+                    a.emplace_back(ktemp,vtemp);
+                }       
+    
+            return a;
+        }  
+    
+        template<typename T,typename U, typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true>     
+        std::vector<std::pair<T,U>> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+                std::vector<std::pair<T,U>> a;
+   
+                unsigned char kpos,vpos;
+                kpos=findcolpos(keyname);
+                vpos=findcolpos(valname);                
+                T ktemp;
+                U vtemp;
+                for(auto &iter:record)
+                {
+                    
+                    switch(kpos)
+                    {
+
+   			case 1: 
+ 				 ktemp=iter.message;
+				 break;
+			  }
+ 			 switch(vpos){
+			case 0: 
+ 				 vtemp=iter.id;
+				 break;
+
+                   }
+                    a.emplace_back(ktemp,vtemp);
+                }       
+    
+            return a;
+        }  
+    
+        template<typename T,typename U, typename std::enable_if<std::is_integral_v<T>,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true>    
+        std::vector<std::pair<T,U>> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+                std::vector<std::pair<T,U>> a;
+   
+                unsigned char kpos,vpos;
+                kpos=findcolpos(keyname);
+                vpos=findcolpos(valname);
+                T ktemp;
+                U vtemp;
+                for(auto &iter:record)
+                {
+                    switch(kpos)
+                    {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			  }
+			 switch(vpos){
+			case 0: 
+ 				 vtemp=iter.id;
+				 break;
+
+                   }
+                    a.emplace_back(ktemp,vtemp);
+                }       
+      
+            return a;
+        }   
+    
+        template<typename T,typename U, typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true>     
+        std::vector<std::pair<T,U>> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+                std::vector<std::pair<T,U>> a;
+   
+                unsigned char kpos,vpos;
+                kpos=findcolpos(keyname);
+                vpos=findcolpos(valname);
+                T ktemp;
+                U vtemp;
+                for(auto &iter:record)
+                {
+                    switch(kpos)
+                    {
+
+   case 1: 
+ 	 ktemp=iter.message;
+	 break;
+	  }
+ switch(vpos){
+case 1: 
+ 	 vtemp=iter.message;
+	 break;
+
+                   }
+
+                    a.emplace_back(ktemp,vtemp);
+                }       
+    
+            return a;
+        }  
+    
+        template<typename T, typename std::enable_if<std::is_integral_v<T>,bool>::type = true >   
+        std::vector<std::pair<T,meta>> getvecRows([[maybe_unused]] std::string keyname)
+        {
+            std::vector<std::pair<T,meta>> a;
+     
+            unsigned char kpos;
+            kpos=findcolpos(keyname);                  
+            for(auto &iter:record)
+            { 
+                switch(kpos)
+                {
+
+   case 0: 
+ 	 a.emplace_back(iter.id,iter);
+	 break;
+
+                }
+            }       
+    
+        return a;
+    }
+        template<typename T, typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true >  
+        std::vector<std::pair<std::string,meta>> getvecRows([[maybe_unused]] std::string keyname)
+        {
+            std::vector<std::pair<std::string,meta>> a;
+      
+            unsigned char kpos;
+            kpos=findcolpos(keyname);                     
+            for(auto &iter:record)
+            {
+                switch(kpos)
+                {
+
+   case 1: 
+ 	 a.emplace_back(iter.message,iter);
+	 break;
+
+                }
+            }       
+    
+
+        return a;
+    }
+        template<typename T,typename U,typename D,typename std::enable_if<std::is_integral_v<T>,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true, typename std::enable_if<std::is_floating_point<D>::value,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+        {
+            std::map<T,std::map<U,std::vector<D>>> a;
+    
+            unsigned char kpos,vpos,dpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            dpos=findcolpos(dataname);      
+            T ktemp;
+            U vtemp;
+            for(auto &iter:record)
+            { 
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			  }
+
+			 switch(vpos){
+			case 0: 
+ 				 vtemp=iter.id;
+				 break;
+			  }
+
+			 switch(dpos){
+
+                }
+            }       
+
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename D,typename std::enable_if<std::is_integral_v<T>,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true, typename std::enable_if<std::is_integral_v<D>,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+        {
+            std::map<T,std::map<U,std::vector<D>>> a;
+    
+            unsigned char kpos,vpos,dpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            dpos=findcolpos(dataname);          
+            T ktemp;
+            U vtemp;
+            //D vtemp;
+
+            for(auto &iter:record)
+            {
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			  }
+
+			 switch(vpos){
+			case 0: 
+ 				 vtemp=iter.id;
+				 break;
+			  }
+
+			 switch(dpos){
+			case 0: 
+ 				 a[ktemp][vtemp].emplace_back(iter.id);
+				 break;
+
+                }
+            }       
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename D,typename std::enable_if<std::is_integral_v<T>,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true, typename std::enable_if<std::is_same<D,std::string>::value,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+        {
+            std::map<T,std::map<U,std::vector<D>>> a;
+   
+            unsigned char kpos,vpos,dpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            dpos=findcolpos(dataname);       
+            T ktemp;
+            U vtemp;
+            // D dtemp;
+
+            for(auto &iter:record)
+            {
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+				  }
+
+			 switch(vpos){
+			case 0: 
+ 				 vtemp=iter.id;
+				 break;
+			 }
+
+			 switch(dpos){
+			case 1: 
+ 				 a[ktemp][vtemp].emplace_back(iter.message);
+				 break;
+
+                }
+            }       
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename D,typename std::enable_if<std::is_integral_v<T>,bool>::type = true, typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true, typename std::enable_if<std::is_floating_point<D>::value,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+        {
+                std::map<T,std::map<U,std::vector<D>>> a;
+   
+                unsigned char kpos,vpos,dpos;
+                kpos=findcolpos(keyname);
+                vpos=findcolpos(valname);
+                dpos=findcolpos(dataname);
+                T ktemp;
+                U vtemp;
+            // D dtemp;
+
+                for(auto &iter:record)
+                {
+                    
+                    switch(kpos)
+                    {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			 }
+
+			 switch(vpos){
+			case 1: 
+ 				 vtemp=iter.message;
+				 break;
+			  }
+
+			 switch(dpos){
+
+                   }
+                }       
+    
+            return a;
+        }
+    
+    template<typename T,typename U,typename D,typename std::enable_if<std::is_integral_v<T>,bool>::type = true, typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true, typename std::enable_if<std::is_integral_v<D>,bool>::type = true>    
+    std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+    {
+        std::map<T,std::map<U,std::vector<D>>> a;
+
+   
+        unsigned char kpos,vpos,dpos;
+        kpos=findcolpos(keyname);
+        vpos=findcolpos(valname);
+        dpos=findcolpos(dataname);             
+        T ktemp;
+        U vtemp;
+       // D dtemp;
+
+         for(auto &iter:record)
+         {
+            switch(kpos)
+            {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			 }
+
+			 switch(vpos){
+			case 1: 
+ 				 vtemp=iter.message;
+				 break;
+			 }
+
+			 switch(dpos){
+			case 0: 
+ 				 a[ktemp][vtemp].emplace_back(iter.id);
+				 break;
+
+            }
+         }       
+    
+        return a;
+    }
+        template<typename T,typename U,typename D,typename std::enable_if<std::is_integral_v<T>,bool>::type = true, typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true, typename std::enable_if<std::is_same<D,std::string>::value,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+        {
+            std::map<T,std::map<U,std::vector<D>>> a;
+   
+            unsigned char kpos,vpos,dpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            dpos=findcolpos(dataname);
+            T ktemp;
+            U vtemp;
+            // D dtemp;
+
+            for(auto &iter:record)
+            { 
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			  }
+
+			 switch(vpos){
+			case 1: 
+ 				 vtemp=iter.message;
+				 break;
+			  }
+
+			 switch(dpos){
+			case 1: 
+ 				 a[ktemp][vtemp].emplace_back(iter.message);
+				 break;
+
+                }
+            }       
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename D,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true, typename std::enable_if<std::is_floating_point<D>::value,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+        {
+                std::map<T,std::map<U,std::vector<D>>> a;
+   
+                unsigned char kpos,vpos,dpos;
+                kpos=findcolpos(keyname);
+                vpos=findcolpos(valname);
+                dpos=findcolpos(dataname);               
+                T ktemp;
+                U vtemp;
+                //D vtemp;
+                for(auto &iter:record)
+                {
+                    switch(kpos)
+                    {
+
+   			case 1: 
+ 				 ktemp=iter.message;
+				 break;
+			 }
+
+			 switch(vpos){
+			case 0: 
+ 				 vtemp=iter.id;
+				 break;
+			  }
+
+			 switch(dpos){
+
+                    }
+                }       
+    
+
+            return a;
+        }
+    
+        template<typename T,typename U,typename D,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true, typename std::enable_if<std::is_integral_v<D>,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+        {
+            std::map<T,std::map<U,std::vector<D>>> a;
+   
+            unsigned char kpos,vpos,dpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            dpos=findcolpos(dataname);            
+            T ktemp;
+            U vtemp;
+            //D vtemp;
+
+            for(auto &iter:record)
+            {
+                
+                switch(kpos)
+                {
+
+   			case 1: 
+ 				 ktemp=iter.message;
+				 break;
+			  }
+
+			 switch(vpos){
+			case 0: 
+ 				 vtemp=iter.id;
+				 break;
+			 }
+
+			 switch(dpos){
+			case 0: 
+ 				 a[ktemp][vtemp].emplace_back(iter.id);
+				 break;
+
+                }
+            }       
+    
+            return a;
+        }
+    
+    template<typename T,typename U,typename D,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true, typename std::enable_if<std::is_same<D,std::string>::value,bool>::type = true>    
+    std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+    {
+        std::map<T,std::map<U,std::vector<D>>> a;
+
+   
+        unsigned char kpos,vpos,dpos;
+        kpos=findcolpos(keyname);
+        vpos=findcolpos(valname);
+        dpos=findcolpos(dataname);
+        T ktemp;
+        U vtemp;
+        // D dtemp;
+
+         for(auto &iter:record)
+         {
+             
+            switch(kpos)
+            {
+
+   			case 1: 
+ 				 ktemp=iter.message;
+				 break;
+			 }
+
+			switch(vpos){
+			case 0: 
+ 				 vtemp=iter.id;
+				 break;
+			 }
+
+			switch(dpos){
+			case 1: 
+ 				 a[ktemp][vtemp].emplace_back(iter.message);
+				 break;
+
+            }
+         }       
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename D,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true, typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true, typename std::enable_if<std::is_floating_point<D>::value,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+        {
+            std::map<T,std::map<U,std::vector<D>>> a;
+   
+            unsigned char kpos,vpos,dpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            dpos=findcolpos(dataname);        
+            T ktemp;
+            U vtemp;
+            // D dtemp;
+
+            for(auto &iter:record)
+            {
+                switch(kpos)
+                {
+
+   			case 1: 
+ 				 ktemp=iter.message;
+				 break;
+			 }
+
+			 switch(vpos){
+			case 1: 
+ 				 vtemp=iter.message;
+				 break;
+			  }
+
+			 switch(dpos){
+
+                }
+            }       
+
+    
+            return a;
+        }
+        template<typename T,typename U,typename D,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true, typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true, typename std::enable_if<std::is_integral_v<D>,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+        {
+            std::map<T,std::map<U,std::vector<D>>> a;
+   
+            unsigned char kpos,vpos,dpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            dpos=findcolpos(dataname);
+            T ktemp;
+            U vtemp;
+            // D dtemp;
+
+            for(auto &iter:record)
+            {
+                
+                switch(kpos)
+                {
+
+   			case 1: 
+ 				 ktemp=iter.message;
+				 break;
+			  }
+
+			 switch(vpos){
+			case 1: 
+ 				 vtemp=iter.message;
+				 break;
+			 }
+
+			 switch(dpos){
+			case 0: 
+ 				 a[ktemp][vtemp].emplace_back(iter.id);
+				 break;
+
+                }
+            }       
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename D,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true, typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true, typename std::enable_if<std::is_same<D,std::string>::value,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+        {
+            std::map<T,std::map<U,std::vector<D>>> a;
+   
+            unsigned char kpos,vpos,dpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            dpos=findcolpos(dataname);        
+            T ktemp;
+            U vtemp;
+            // D dtemp;
+
+            for(auto &iter:record)
+            {
+                switch(kpos)
+                {
+
+   			case 1: 
+ 				 ktemp=iter.message;
+				 break;
+			  }
+
+			 switch(vpos){
+			case 1: 
+ 				 vtemp=iter.message;
+				 break;
+			  }
+
+			 switch(dpos){
+			case 1: 
+ 				 a[ktemp][vtemp].emplace_back(iter.message);
+				 break;
+
+                }
+            }       
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true, typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true>    
+        std::map<T,std::vector<U>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,std::vector<U>> a;
+
+   
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            T ktemp;
+            //U vtemp;
+
+            for(auto &iter:record)
+            {
+                switch(kpos)
+                {
+
+   			case 1: 
+ 				 ktemp=iter.message;
+				 break;
+			  }
+
+			 switch(vpos){
+			case 1: 
+ 				 a[ktemp].emplace_back(iter.message);
+				 break;
+
+                }
+            }       
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true,typename std::enable_if<std::is_floating_point<U>::value,bool>::type = true>    
+        std::map<T,std::vector<U>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,std::vector<U>> a;
+   
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            T ktemp;
+            //U vtemp;
+
+            for(auto &iter:record)
+            {
+                switch(kpos)
+                {
+
+   			case 1: 
+ 				 ktemp=iter.message;
+				 break;
+			 }
+
+			 switch(vpos){
+
+                }
+            }       
+
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true>    
+        std::map<T,std::vector<U>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,std::vector<U>> a;
+   
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            T ktemp;
+            //U vtemp;
+
+            for(auto &iter:record)
+            {
+                
+                switch(kpos)
+                {
+
+   			case 1: 
+ 				 ktemp=iter.message;
+				 break;
+			  }
+
+			 switch(vpos){
+			case 0: 
+ 				 a[ktemp].emplace_back(iter.id);
+				 break;
+
+                }
+            }       
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename std::enable_if<std::is_integral_v<T>,bool>::type = true, typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true>    
+        std::map<T,std::vector<U>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,std::vector<U>> a;
+   
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            T ktemp;
+            //U vtemp;
+
+            for(auto &iter:record)
+            {
+                
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			 }
+
+			 switch(vpos){
+			case 1: 
+ 				 a[ktemp].emplace_back(iter.message);
+				 break;
+
+                }
+            }       
+
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename std::enable_if<std::is_integral_v<T>,bool>::type = true,typename std::enable_if<std::is_floating_point<U>::value,bool>::type = true>    
+        std::map<T,std::vector<U>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,std::vector<U>> a;
+               
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            T ktemp;
+            //U vtemp;
+
+            for(auto &iter:record)
+            {
+                
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			  }
+
+			 switch(vpos){
+
+                }
+            }       
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename std::enable_if<std::is_integral_v<T>,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true>    
+        std::map<T,std::vector<U>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,std::vector<U>> a;
+   
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            T ktemp;
+            //U vtemp;
+
+            for(auto &iter:record)
+            {
+                
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			 }
+
+			 switch(vpos){
+			case 0: 
+ 				 a[ktemp].emplace_back(iter.id);
+				 break;
+
+                }
+            }       
+    
+            return a;
+        }
+    
+        template<typename T,typename std::enable_if<std::is_integral_v<T>,bool>::type = true>    
+        std::map<T,std::vector<meta>> getgroupRows([[maybe_unused]] std::string keyname)
+        {
+            std::map<T,std::vector<meta>> a;
+   
+            unsigned char kpos;
+            kpos=findcolpos(keyname);
+
+            for(auto &iter:record)
+            {
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 a[iter.id].emplace_back(iter);
+				 break;
+
+                }
+            }       
+    
+            return a;
+        }
+    
+        template<typename T,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true>    
+        std::map<T,std::vector<meta>> getgroupRows([[maybe_unused]] std::string keyname)
+        {
+            std::map<T,std::vector<meta>> a;
+   
+            unsigned char kpos;
+            kpos=findcolpos(keyname);
+
+            for(auto &iter:record)
+            {
+                
+                switch(kpos)
+                {
+
+   			case 1: 
+ 				 a[iter.message].emplace_back(iter);
+				 break;
+
+                }
+            }       
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename D,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true, typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<meta>>> getgroupRows([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,std::map<U,std::vector<meta>>> a;
+   
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            T ktemp;
+
+            for(auto &iter:record)
+            {
+                
+                switch(kpos)
+                {
+
+   			case 1: 
+ 				 ktemp=iter.message;
+				 break;
+			 }
+
+			 switch(vpos){
+			case 1: 
+ 				 a[ktemp][iter.message].emplace_back(iter);
+				 break;
+
+                }
+            }       
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<meta>>> getgroupRows([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,std::map<U,std::vector<meta>>> a;
+   
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);            
+            T ktemp;
+            
+            for(auto &iter:record)
+            {
+                
+                switch(kpos)
+                {
+
+   			case 1: 
+ 				 ktemp=iter.message;
+				 break;
+	  }
+
+ switch(vpos){
+			case 0: 
+ 				 a[ktemp][iter.id].emplace_back(iter);
+				 break;
+
+                }
+            }       
+
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename std::enable_if<std::is_integral_v<U>,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<meta>>> getgroupRows([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,std::map<U,std::vector<meta>>> a;
+   
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);        
+        T ktemp;
+        
+            for(auto &iter:record)
+            {
+                
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			 }
+
+			 switch(vpos){
+			case 0: 
+ 				 a[ktemp][iter.id].emplace_back(iter);
+				 break;
+
+                }
+            }       
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename std::enable_if<std::is_integral_v<T>,bool>::type = true,typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<meta>>> getgroupRows([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,std::map<U,std::vector<meta>>> a;
+
+   
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);            
+            T ktemp;
+            
+            for(auto &iter:record)
+            {
+                
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			  }
+
+			 switch(vpos){
+			case 1: 
+ 				 a[ktemp][iter.message].emplace_back(iter);
+				 break;
+
+                }
+            }       
+    
+            return a;
+        }
+    
+  };
+    
+
+}
+#endif
+   

frameworks/C++/paozhu/paozhu_benchmark/orm/include/world_mysql.h

@@ -0,0 +1,9628 @@
+#ifndef _ORM_DEFAULT_WORLD_OPERATE_H
+#define _ORM_DEFAULT_WORLD_OPERATE_H
+
+#include <iostream>
+#include <mutex>
+#include <string>
+#include <map>
+#include <set>
+#include <string_view>
+#include <thread>
+#include "request.h"
+#include "unicode.h"
+#include "datetime.h"
+#include <stdexcept>
+#include <iostream>
+#include <functional>
+#include <tuple>
+#include <typeinfo>
+#include <memory>
+#include <list>
+#include <queue>
+#include <cmath>
+#include <condition_variable>
+#include <sstream>
+#include <algorithm>
+#include <vector>
+
+#include "mysql_conn.h"
+#include "mysql_conn_pool.h"
+#include "orm_cache.hpp"
+/*baseincludefile*/
+namespace orm
+{
+// mysql Operational SQL middleware
+/*tagnamespace*/
+//{ /*tagnamespace_replace*/
+    template <typename M_MODEL, typename B_BASE>
+    class world_mysql : public B_BASE
+    {
+      public:
+        world_mysql(const std::string &tag) : dbtag(tag)
+        {
+            std::map<std::string, std::shared_ptr<orm_conn_pool>> &conn_pool_obj = get_orm_conn_pool_obj();
+            auto iter                                                            = conn_pool_obj.find(dbtag);
+            if (iter != conn_pool_obj.end())
+            {
+                conn_obj = iter->second;
+            }
+            else
+            {
+                conn_obj  = nullptr;
+                iserror   = true;
+                error_msg = "conn_pool not found " + dbtag;
+            }
+        }
+        world_mysql() : dbtag(B_BASE::_rmstag)
+        {
+            std::map<std::string, std::shared_ptr<orm_conn_pool>> &conn_pool_obj = get_orm_conn_pool_obj();
+            auto iter                                                            = conn_pool_obj.find(dbtag);
+            if (iter != conn_pool_obj.end())
+            {
+                conn_obj = iter->second;
+            }
+            else
+            {
+                conn_obj  = nullptr;
+                iserror   = true;
+                error_msg = "conn_pool not found " + dbtag;
+            }
+        }
+        M_MODEL &switchDB(const std::string &temptag)
+        {
+            std::map<std::string, std::shared_ptr<orm_conn_pool>> &conn_pool_obj = get_orm_conn_pool_obj();
+            auto iter                                                            = conn_pool_obj.find(temptag);
+            if (iter != conn_pool_obj.end())
+            {
+                conn_obj = iter->second;
+            }
+            else
+            {
+                conn_obj  = nullptr;
+                iserror   = true;
+                error_msg = "conn_pool not found " + temptag;
+            }
+        }
+        M_MODEL &set_table(const std::string &table_name)
+        {
+            if (original_tablename.empty())
+            {
+                original_tablename = B_BASE::tablename;
+            }
+            if (table_name.size() > 0)
+            {
+                B_BASE::tablename = table_name;
+            }
+            return *mod;
+        }
+        M_MODEL &reset_table()
+        {
+            if (original_tablename.empty())
+            {
+                return *mod;
+            }
+            B_BASE::tablename = original_tablename;
+            return *mod;
+        }
+        unsigned int count()
+        {
+            std::string countsql;
+            countsql = "SELECT count(*) as total_countnum  FROM ";
+            countsql.append(B_BASE::tablename);
+            countsql.append(" WHERE ");
+            if (wheresql.empty())
+            {
+                countsql.append(" 1 ");
+            }
+            else
+            {
+                countsql.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                countsql.append(groupsql);
+            }
+            if (!limitsql.empty())
+            {
+                countsql.append(limitsql);
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+
+            try
+            {
+                effect_num = 0;
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_select_conn();
+
+                unsigned int querysql_len = countsql.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(countsql);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                //std::vector<field_info_t> field_array;
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+                unsigned int offset        = 0;
+
+                querysql_len = 0;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = conn->read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int tempnum = 0;
+
+                                unsigned int name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                querysql_len = 0;
+                                for (unsigned int ik = 0; ik < name_length; ik++)
+                                {
+                                    if (temp_pack_data.data[tempnum] >= '0' && temp_pack_data.data[tempnum] <= '9')
+                                    {
+                                        querysql_len = querysql_len * 10 + (temp_pack_data.data[tempnum] - '0');
+                                    }
+                                    tempnum++;
+                                }
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+
+                conn_obj->back_select_conn(conn);
+
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        save_cache(exptime);
+                        exptime = 0;
+                        iscache = false;
+                    }
+                }
+                return querysql_len;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                return 0;
+            }
+
+            return 0;
+        }
+        std::tuple<unsigned int, unsigned int, unsigned int, unsigned int>
+        page(unsigned int page, unsigned int per_page = 10, unsigned int list_num = 5)
+        {
+            unsigned int total_page = count();
+            if (per_page == 0)
+            {
+                per_page = 10;
+            }
+            if (list_num < 1)
+            {
+                list_num = 1;
+            }
+            total_page = std::ceil((float)total_page / per_page);
+
+            if (total_page < 1)
+            {
+                total_page = 1;
+            }
+            if (page > total_page)
+            {
+                page = total_page;
+            }
+            if (page < 1)
+            {
+                page = 1;
+            }
+            unsigned int mid_num  = std::floor(list_num / 2);
+            unsigned int last_num = list_num - 1;
+
+            int temp_num = page - mid_num;
+
+            unsigned int minpage = temp_num < 1 ? 1 : temp_num;
+            unsigned int maxpage = minpage + last_num;
+
+            if (maxpage > total_page)
+            {
+                maxpage  = total_page;
+                temp_num = (maxpage - last_num);
+                if (temp_num < 1)
+                {
+                    minpage = 1;
+                }
+                else
+                {
+                    minpage = temp_num;
+                }
+            }
+            limit((page - 1) * per_page, per_page);
+            return std::make_tuple(minpage, maxpage, page, total_page);
+        }
+        asio::awaitable<unsigned int> async_count()
+        {
+            std::string countsql;
+            countsql = "SELECT count(*) as total_countnum  FROM ";
+            countsql.append(B_BASE::tablename);
+            countsql.append(" WHERE ");
+            if (wheresql.empty())
+            {
+                countsql.append(" 1 ");
+            }
+            else
+            {
+                countsql.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                countsql.append(groupsql);
+            }
+            if (!limitsql.empty())
+            {
+                countsql.append(limitsql);
+            }
+
+            if (iserror)
+            {
+                co_return 0;
+            }
+
+            try
+            {
+                effect_num = 0;
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_select_conn();
+
+                unsigned int querysql_len = countsql.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(countsql);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                //std::vector<field_info_t> field_array;
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+                unsigned int offset        = 0;
+
+                querysql_len = 0;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = co_await conn->async_read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int tempnum = 0;
+
+                                unsigned int name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                querysql_len = 0;
+                                for (unsigned int ik = 0; ik < name_length; ik++)
+                                {
+                                    if (temp_pack_data.data[tempnum] >= '0' && temp_pack_data.data[tempnum] <= '9')
+                                    {
+                                        querysql_len = querysql_len * 10 + (temp_pack_data.data[tempnum] - '0');
+                                    }
+                                    tempnum++;
+                                }
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+
+                conn_obj->back_select_conn(conn);
+
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        save_cache(exptime);
+                        exptime = 0;
+                        iscache = false;
+                    }
+                }
+                co_return querysql_len;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                co_return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                co_return 0;
+            }
+            co_return 0;
+        }
+
+        asio::awaitable<std::tuple<unsigned int, unsigned int, unsigned int, unsigned int>>
+        async_page(unsigned int page, unsigned int per_page = 10, unsigned int list_num = 5)
+        {
+            unsigned int total_page = async_count();
+            if (per_page == 0)
+            {
+                per_page = 10;
+            }
+            if (list_num < 1)
+            {
+                list_num = 1;
+            }
+            total_page = std::ceil((float)total_page / per_page);
+
+            if (total_page < 1)
+            {
+                total_page = 1;
+            }
+            if (page > total_page)
+            {
+                page = total_page;
+            }
+            if (page < 1)
+            {
+                page = 1;
+            }
+            unsigned int mid_num  = std::floor(list_num / 2);
+            unsigned int last_num = list_num - 1;
+
+            int temp_num = page - mid_num;
+
+            unsigned int minpage = temp_num < 1 ? 1 : temp_num;
+            unsigned int maxpage = minpage + last_num;
+
+            if (maxpage > total_page)
+            {
+                maxpage  = total_page;
+                temp_num = (maxpage - last_num);
+                if (temp_num < 1)
+                {
+                    minpage = 1;
+                }
+                else
+                {
+                    minpage = temp_num;
+                }
+            }
+            limit((page - 1) * per_page, per_page);
+            co_return std::make_tuple(minpage, maxpage, page, total_page);
+        }
+
+        unsigned int update_col(std::string colname, int num, char symbol = '+')
+        {
+            effect_num = 0;
+            std::string countsql;
+            countsql = "UPDATE ";
+            countsql.append(B_BASE::tablename);
+            countsql.append(" SET ");
+            countsql.append(colname);
+            if (num > 0)
+            {
+                countsql.append(" = ");
+                countsql.append(colname);
+                countsql.push_back(' ');
+                countsql.push_back(symbol);
+                countsql.append(std::to_string(num));
+            }
+            else
+            {
+                countsql.append(" = ");
+                countsql.append(colname);
+                countsql.push_back(' ');
+                countsql.push_back(symbol);
+                countsql.push_back('(');
+                countsql.push_back('-');
+                countsql.append(std::to_string(std::abs(num)));
+                countsql.push_back(')');
+            }
+            countsql.append(" where ");
+            if (wheresql.empty())
+            {
+                if (B_BASE::getPK() > 0)
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    countsql.append(tempsql.str());
+                }
+                else
+                {
+                    return 0;
+                }
+            }
+            else
+            {
+                countsql.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                countsql.append(groupsql);
+            }
+            if (!limitsql.empty())
+            {
+                countsql.append(limitsql);
+            }
+            if (iscommit)
+            {
+                iscommit = false;
+                return 0;
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = countsql.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(countsql);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    //insertid      = pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    return effect_num;
+                }
+
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+
+            }
+            return 0;
+        }
+
+        asio::awaitable<unsigned int> async_update_col(std::string colname, int num, char symbol = '+')
+        {
+            effect_num = 0;
+            std::string countsql;
+            countsql = "UPDATE ";
+            countsql.append(B_BASE::tablename);
+            countsql.append(" SET ");
+            countsql.append(colname);
+            if (num > 0)
+            {
+                countsql.append(" = ");
+                countsql.append(colname);
+                countsql.push_back(' ');
+                countsql.push_back(symbol);
+                countsql.append(std::to_string(num));
+            }
+            else
+            {
+                countsql.append(" = ");
+                countsql.append(colname);
+                countsql.push_back(' ');
+                countsql.push_back(symbol);
+                countsql.push_back('(');
+                countsql.push_back('-');
+                countsql.append(std::to_string(std::abs(num)));
+                countsql.push_back(')');
+            }
+            countsql.append(" where ");
+            if (wheresql.empty())
+            {
+                if (B_BASE::getPK() > 0)
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    countsql.append(tempsql.str());
+                }
+                else
+                {
+                    co_return 0;
+                }
+            }
+            else
+            {
+                countsql.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                countsql.append(groupsql);
+            }
+            if (!limitsql.empty())
+            {
+                countsql.append(limitsql);
+            }
+            if (iscommit)
+            {
+                iscommit = false;
+                co_return 0;
+            }
+
+            if (iserror)
+            {
+                co_return 0;
+            }
+
+            try
+            {
+
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_edit_conn();
+
+                unsigned int querysql_len = countsql.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(countsql);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+
+                unsigned int offset = 0;
+                n                   = co_await conn->async_read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    //insertid      = pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    co_return effect_num;
+                }
+
+                co_return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                co_return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                
+            }
+            co_return 0;
+        }
+
+        int replace_col(std::string colname, const std::string &old_string, const std::string &new_string)
+        {
+            effect_num = 0;
+            std::string countsql;
+            countsql = "UPDATE ";
+            countsql.append(B_BASE::tablename);
+            countsql.append(" SET ");
+            countsql.append(colname);
+
+            countsql.append(" = REPLACE(");
+            countsql.append(colname);
+            countsql.append(",'");
+            countsql.append(old_string);
+            countsql.append("','");
+            countsql.append(new_string);
+            countsql.append("') ");
+
+            countsql.append(" where ");
+            if (wheresql.empty())
+            {
+                if (B_BASE::getPK() > 0)
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    countsql.append(tempsql.str());
+                }
+                else
+                {
+                    return 0;
+                }
+            }
+            else
+            {
+                countsql.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                countsql.append(groupsql);
+            }
+            if (!limitsql.empty())
+            {
+                countsql.append(limitsql);
+            }
+            if (iscommit)
+            {
+                iscommit = false;
+                return 0;
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = countsql.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(countsql);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    //insertid      = pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    return effect_num;
+                }
+
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                
+            }
+            return 0;
+        }
+
+        void assign_field_value(unsigned char index_pos, unsigned char *result_temp_data, unsigned int value_size, typename B_BASE::meta &data_temp)
+    {
+        switch(index_pos)
+        {
+            case 0:
+            data_temp.id=0;
+            
+            for(unsigned int i=0; i< value_size; i++)
+            {
+                if(result_temp_data[i]>='0'&&result_temp_data[i]<='9')
+                {
+
+                data_temp.id= data_temp.id * 10 + (result_temp_data[i]-'0');
+                }   
+                if(i>32)
+                {
+                    break;
+                }
+            }
+            break;
+                case 1:
+            data_temp.randomnumber=0;
+            
+            for(unsigned int i=0; i< value_size; i++)
+            {
+                if(result_temp_data[i]>='0'&&result_temp_data[i]<='9')
+                {
+
+                data_temp.randomnumber= data_temp.randomnumber * 10 + (result_temp_data[i]-'0');
+                }   
+                if(i>32)
+                {
+                    break;
+                }
+            }
+            break;
+                
+        }
+    }
+    
+
+M_MODEL& eqId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id = ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& nqId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id != ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& inId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id IN(");
+
+        wheresql.append(val);
+        wheresql.push_back(')');
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& inId(const std::vector<T>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+            wheresql.append(std::to_string(val[i]));
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& inId(const std::vector<std::string>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+
+            try
+            {
+                wheresql.append(std::to_string(std::stoll(val[i])));
+            }
+            catch (std::invalid_argument const& ex)
+            {
+                wheresql.push_back('0');
+            }
+            catch (std::out_of_range const& ex)
+            {
+                wheresql.push_back('0');
+            }
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& ninId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id NOT IN(");
+
+        wheresql.append(val);
+        wheresql.push_back(')');
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& ninId(const std::vector<T>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id NOT IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+            wheresql.append(std::to_string(val[i]));
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& ninId(const std::vector<std::string>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id NOT IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+
+            try
+            {
+                wheresql.append(std::to_string(std::stoll(val[i])));
+            }
+            catch (std::invalid_argument const& ex)
+            {
+                wheresql.push_back('0');
+            }
+            catch (std::out_of_range const& ex)
+            {
+                wheresql.push_back('0');
+            }
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& btId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id > ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& beId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id >= ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& ltId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id < ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& leId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id <= ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_eqId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id = ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_nqId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id != ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_inId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id IN(");
+
+        wheresql.append(val);
+        wheresql.push_back(')');
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_inId(const std::vector<T>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+            wheresql.append(std::to_string(val[i]));
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_inId(const std::vector<std::string>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+
+            try
+            {
+                wheresql.append(std::to_string(std::stoll(val[i])));
+            }
+            catch (std::invalid_argument const& ex)
+            {
+                wheresql.push_back('0');
+            }
+            catch (std::out_of_range const& ex)
+            {
+                wheresql.push_back('0');
+            }
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_ninId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id NOT IN(");
+
+        wheresql.append(val);
+        wheresql.push_back(')');
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_ninId(const std::vector<T>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id NOT IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+            wheresql.append(std::to_string(val[i]));
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_ninId(const std::vector<std::string>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id NOT IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+
+            try
+            {
+                wheresql.append(std::to_string(std::stoll(val[i])));
+            }
+            catch (std::invalid_argument const& ex)
+            {
+                wheresql.push_back('0');
+            }
+            catch (std::out_of_range const& ex)
+            {
+                wheresql.push_back('0');
+            }
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_btId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id > ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_beId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id >= ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_ltId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id < ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_leId(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id <= ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& eqId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id = ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& nqId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id != ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& btId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id > ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& beId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id >= ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& ltId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id < ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& leId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id <= ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_eqId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id = ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_nqId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id != ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_btId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id > ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_beId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id >= ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_ltId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id < ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_leId(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" id <= ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+M_MODEL& eqRandomnumber(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber = ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& nqRandomnumber(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber != ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& inRandomnumber(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber IN(");
+
+        wheresql.append(val);
+        wheresql.push_back(')');
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& inRandomnumber(const std::vector<T>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+            wheresql.append(std::to_string(val[i]));
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& inRandomnumber(const std::vector<std::string>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+
+            try
+            {
+                wheresql.append(std::to_string(std::stoll(val[i])));
+            }
+            catch (std::invalid_argument const& ex)
+            {
+                wheresql.push_back('0');
+            }
+            catch (std::out_of_range const& ex)
+            {
+                wheresql.push_back('0');
+            }
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& ninRandomnumber(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber NOT IN(");
+
+        wheresql.append(val);
+        wheresql.push_back(')');
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& ninRandomnumber(const std::vector<T>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber NOT IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+            wheresql.append(std::to_string(val[i]));
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& ninRandomnumber(const std::vector<std::string>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber NOT IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+
+            try
+            {
+                wheresql.append(std::to_string(std::stoll(val[i])));
+            }
+            catch (std::invalid_argument const& ex)
+            {
+                wheresql.push_back('0');
+            }
+            catch (std::out_of_range const& ex)
+            {
+                wheresql.push_back('0');
+            }
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& btRandomnumber(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber > ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& beRandomnumber(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber >= ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& ltRandomnumber(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber < ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& leRandomnumber(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber <= ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_eqRandomnumber(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber = ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_nqRandomnumber(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber != ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_inRandomnumber(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber IN(");
+
+        wheresql.append(val);
+        wheresql.push_back(')');
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_inRandomnumber(const std::vector<T>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+            wheresql.append(std::to_string(val[i]));
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_inRandomnumber(const std::vector<std::string>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+
+            try
+            {
+                wheresql.append(std::to_string(std::stoll(val[i])));
+            }
+            catch (std::invalid_argument const& ex)
+            {
+                wheresql.push_back('0');
+            }
+            catch (std::out_of_range const& ex)
+            {
+                wheresql.push_back('0');
+            }
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_ninRandomnumber(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber NOT IN(");
+
+        wheresql.append(val);
+        wheresql.push_back(')');
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_ninRandomnumber(const std::vector<T>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber NOT IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+            wheresql.append(std::to_string(val[i]));
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_ninRandomnumber(const std::vector<std::string>& val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber NOT IN(");
+
+        for(unsigned int i=0;i<val.size(); i++)
+        {
+            if(i > 0)
+            {
+                wheresql.push_back(',');
+            }
+
+            try
+            {
+                wheresql.append(std::to_string(std::stoll(val[i])));
+            }
+            catch (std::invalid_argument const& ex)
+            {
+                wheresql.push_back('0');
+            }
+            catch (std::out_of_range const& ex)
+            {
+                wheresql.push_back('0');
+            }
+        }
+        wheresql.push_back(')');
+
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_btRandomnumber(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber > ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_beRandomnumber(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber >= ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_ltRandomnumber(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber < ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+M_MODEL& or_leRandomnumber(const std::string &val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber <= ");
+
+        try
+        {
+            wheresql.append(std::to_string(std::stoll(val)));
+        }
+        catch (std::invalid_argument const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        catch (std::out_of_range const& ex)
+        {
+           wheresql.push_back('0');
+        }
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& eqRandomnumber(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber = ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& nqRandomnumber(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber != ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& btRandomnumber(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber > ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& beRandomnumber(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber >= ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& ltRandomnumber(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber < ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& leRandomnumber(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" AND ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" AND ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber <= ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_eqRandomnumber(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber = ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_nqRandomnumber(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber != ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_btRandomnumber(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber > ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_beRandomnumber(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber >= ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_ltRandomnumber(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber < ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+template <typename T>
+	requires std::is_integral_v<T>
+M_MODEL& or_leRandomnumber(T val)
+	{
+        if (wheresql.empty())
+        {
+        }
+        else
+        {
+            if (ishascontent)
+            {
+                wheresql.append(" OR ");
+            }
+            else
+            {
+                if (!iskuohao)
+                {
+                    wheresql.append(" OR ");
+                }
+            }
+        }
+        if (iskuohao)
+        {
+            ishascontent = true;
+        }
+        wheresql.append(" randomnumber <= ");
+
+        wheresql.append(std::to_string(val));
+        return *mod;   
+    }   
+    
+
+        M_MODEL &select(const std::string &fieldname)
+        {
+            if (selectsql.size() > 0)
+            {
+                selectsql.push_back(',');
+            }
+            selectsql.append(fieldname);
+            return *mod;
+        }
+
+        M_MODEL &where(const std::string &wq)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+
+            wheresql.append(wq);
+            return *mod;
+        }
+        template <typename _SQL_Value>
+            requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value>
+        M_MODEL &where(const std::string &wq, _SQL_Value val)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            char bi = wq.back();
+            if (bi == '=' || bi == '>' || bi == '<')
+            {
+            }
+            else
+            {
+                wheresql.push_back('=');
+            }
+
+            std::stringstream _stream;
+            _stream << val;
+            wheresql.append(_stream.str());
+            return *mod;
+        }
+
+        M_MODEL &where(const std::string &wq, char bi, http::OBJ_VALUE &obj)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            wheresql.push_back(bi);
+            if (obj.is_string())
+            {
+                wheresql.push_back('\'');
+                wheresql.append(obj.as_string());
+                wheresql.push_back('\'');
+            }
+            else
+            {
+
+                wheresql.append(obj.to_string());
+            }
+            return *mod;
+        }
+        M_MODEL &where(const std::string &wq, http::OBJ_VALUE &obj)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            char bi = wq.back();
+            if (bi == '=' || bi == '>' || bi == '<')
+            {
+            }
+            else
+            {
+                wheresql.push_back('=');
+            }
+
+            if (obj.is_string())
+            {
+                wheresql.push_back('\'');
+                wheresql.append(obj.as_string());
+                wheresql.push_back('\'');
+            }
+            else
+            {
+
+                wheresql.append(obj.to_string());
+            }
+            return *mod;
+        }
+        template <typename _SQL_Value>
+            requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value>
+        M_MODEL &where(const std::string &wq, char bi, _SQL_Value val)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            wheresql.push_back(bi);
+            std::stringstream _stream;
+            _stream << val;
+            wheresql.append(_stream.str());
+            return *mod;
+        }
+
+        M_MODEL &where(const std::string &wq, char bi, const std::string &val)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            wheresql.push_back(bi);
+            wheresql.push_back('\'');
+
+            wheresql.append(val);
+            wheresql.push_back('\'');
+            return *mod;
+        }
+        M_MODEL &where(const std::string &wq, const std::string &val)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            char bi = wq.back();
+            if (bi == '=' || bi == '>' || bi == '<')
+            {
+            }
+            else
+            {
+                wheresql.push_back('=');
+            }
+
+            wheresql.push_back('\'');
+            wheresql.append(val);
+            wheresql.push_back('\'');
+            return *mod;
+        }
+
+        M_MODEL &between(const std::string &wq, const std::string &a, const std::string &b)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(" (");
+            wheresql.append(wq);
+            wheresql.append(" BETWEEN '");
+            std::stringstream _stream;
+            _stream << a;
+            _stream << "' AND '";
+            _stream << b;
+            _stream << "' ) ";
+            wheresql.append(_stream.str());
+            return *mod;
+        }
+        template <typename _SQL_Value>
+            requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value>
+        M_MODEL &between(const std::string &wq, _SQL_Value a, _SQL_Value b)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(" (");
+            wheresql.append(wq);
+            wheresql.append(" BETWEEN ");
+            std::stringstream _stream;
+            _stream << a;
+            _stream << " AND ";
+            _stream << b;
+            _stream << " ) ";
+            wheresql.append(_stream.str());
+            return *mod;
+        }
+        template <typename _SQL_Value>
+            requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value>
+        M_MODEL &orBetween(const std::string &wq, _SQL_Value a, _SQL_Value b)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" OR ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" OR ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(" (");
+            wheresql.append(wq);
+            wheresql.append(" BETWEEN ");
+            std::stringstream _stream;
+            _stream << a;
+            _stream << " AND ";
+            _stream << b;
+            _stream << " ) ";
+            wheresql.append(_stream.str());
+            return *mod;
+        }
+        M_MODEL &whereLike(const std::string &wq, const std::string &val)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            wheresql.append(" like '");
+            if (val.size() > 0 && (val[0] == '%' || val.back() == '%'))
+            {
+                wheresql.append(val);
+                wheresql.append("' ");
+            }
+            else
+            {
+                wheresql.push_back('%');
+                wheresql.append(val);
+                wheresql.append("%' ");
+            }
+            return *mod;
+        }
+        M_MODEL &whereLikeLeft(const std::string &wq, const std::string &val)
+        {
+
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            wheresql.append(" like '");
+            wheresql.push_back('%');
+            wheresql.append(val);
+            wheresql.append("' ");
+            return *mod;
+        }
+        M_MODEL &whereLikeRight(const std::string &wq, const std::string &val)
+        {
+
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            wheresql.append(" like '");
+            wheresql.append(val);
+            wheresql.append("%' ");
+            return *mod;
+        }
+        M_MODEL &whereOrLike(const std::string &wq, const std::string &val)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" OR ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" OR ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            wheresql.append(" like '");
+            if (val[0] == '%' || val.back() == '%')
+            {
+                wheresql.append(val);
+                wheresql.append("' ");
+            }
+            else
+            {
+                wheresql.push_back('%');
+                wheresql.append(val);
+                wheresql.append("%' ");
+            }
+            return *mod;
+        }
+        M_MODEL &whereAnd(const std::string &wq)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            return *mod;
+        }
+        template <typename _SQL_Value>
+            requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value>
+        M_MODEL &whereAnd(const std::string &wq, _SQL_Value val)
+        {
+
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            char bi = wq.back();
+            if (bi == '=' || bi == '>' || bi == '<')
+            {
+            }
+            else
+            {
+                wheresql.push_back('=');
+            }
+            std::stringstream _stream;
+            _stream << val;
+            wheresql.append(_stream.str());
+            return *mod;
+        }
+        M_MODEL &whereAnd(const std::string &wq, const std::string &val)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            char bi = wq.back();
+            if (bi == '=' || bi == '>' || bi == '<')
+            {
+            }
+            else
+            {
+                wheresql.push_back('=');
+            }
+
+            wheresql.push_back('\'');
+            wheresql.append(val);
+            wheresql.push_back('\'');
+
+            return *mod;
+        }
+        M_MODEL &whereOr(const std::string &wq)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" OR ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" OR ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            return *mod;
+        }
+        template <typename _SQL_Value>
+            requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value>
+        M_MODEL &whereOr(const std::string &wq, _SQL_Value val)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" OR ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" OR ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            char bi = wq.back();
+            if (bi == '=' || bi == '>' || bi == '<')
+            {
+            }
+            else
+            {
+                wheresql.push_back('=');
+            }
+            std::stringstream _stream;
+            _stream << val;
+            wheresql.append(_stream.str());
+            return *mod;
+        }
+        M_MODEL &whereOr(const std::string &wq, const std::string &val)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" OR ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" OR ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(wq);
+            char bi = wq.back();
+            if (bi == '=' || bi == '>' || bi == '<')
+            {
+            }
+            else
+            {
+                wheresql.push_back('=');
+            }
+
+            wheresql.push_back('\'');
+            wheresql.append(val);
+            wheresql.push_back('\'');
+            return *mod;
+        }
+        M_MODEL &whereIn(const std::string &k)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(k);
+            return *mod;
+        }
+        M_MODEL &whereIn(const std::string &k, const std::string &a)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+
+            wheresql.append(k);
+            wheresql.append(" IN(");
+            wheresql.append(a);
+            wheresql.append(") ");
+            return *mod;
+        }
+
+        M_MODEL &whereIn(const std::string &k, const std::vector<std::string> &a)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+            wheresql.append(k);
+            wheresql.append(" in(");
+            int i = 0;
+            for (auto &key : a)
+            {
+                if (i > 0)
+                {
+                    wheresql.append(",\'");
+                }
+                else
+                {
+                    wheresql.append("\'");
+                }
+                wheresql.append(key);
+                wheresql.append("\'");
+                i++;
+            }
+            wheresql.append(") ");
+            return *mod;
+        }
+        M_MODEL &whereNotIn(const std::string &k, const std::vector<std::string> &a)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+
+            wheresql.append(k);
+            wheresql.append(" NOT IN(");
+            int i = 0;
+            for (auto &key : a)
+            {
+                if (i > 0)
+                {
+                    wheresql.append(",\'");
+                }
+                else
+                {
+                    wheresql.append("\'");
+                }
+                wheresql.append(key);
+                wheresql.append("\'");
+                i++;
+            }
+            wheresql.append(") ");
+            return *mod;
+        }
+        template <typename _SQL_Value>
+            requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value>
+        M_MODEL &whereIn(const std::string &k, const std::list<_SQL_Value> &a)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+
+            wheresql.append(k);
+            wheresql.append(" in(");
+            int i = 0;
+            std::stringstream _stream;
+            for (auto &key : a)
+            {
+                if (i > 0)
+                {
+                    wheresql.append(",");
+                }
+                _stream << key;
+                wheresql.append(_stream.str());
+                i++;
+                _stream.str("");
+            }
+            wheresql.append(") ");
+            return *mod;
+        }
+
+        template <typename _SQL_Value>
+            requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value>
+        M_MODEL &whereIn(const std::string &k, const std::vector<_SQL_Value> &a)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+
+            wheresql.append(k);
+            wheresql.append(" IN(");
+            int i = 0;
+            std::stringstream _stream;
+            for (auto &key : a)
+            {
+                if (i > 0)
+                {
+                    wheresql.append(",");
+                }
+                _stream << key;
+                wheresql.append(_stream.str());
+                i++;
+                _stream.str("");
+            }
+            wheresql.append(") ");
+            return *mod;
+        }
+        template <typename _SQL_Value>
+            requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value>
+        M_MODEL &whereNotIn(const std::string &k, const std::vector<_SQL_Value> &a)
+        {
+            if (wheresql.empty())
+            {
+            }
+            else
+            {
+                if (ishascontent)
+                {
+                    wheresql.append(" AND ");
+                }
+                else
+                {
+                    if (!iskuohao)
+                    {
+                        wheresql.append(" AND ");
+                    }
+                }
+            }
+            if (iskuohao)
+            {
+                ishascontent = true;
+            }
+
+            wheresql.append(k);
+            wheresql.append(" NOT IN(");
+            int i = 0;
+            std::stringstream _stream;
+            for (auto &key : a)
+            {
+                if (i > 0)
+                {
+                    wheresql.append(",");
+                }
+                _stream << key;
+                wheresql.append(_stream.str());
+                i++;
+                _stream.str("");
+            }
+            wheresql.append(") ");
+            return *mod;
+        }
+
+        M_MODEL &order(const std::string &wq)
+        {
+            ordersql.append(" ORDER by ");
+            ordersql.append(wq);
+            return *mod;
+        }
+        M_MODEL &asc(const std::string &wq)
+        {
+
+            ordersql.append(" ORDER by ");
+            ordersql.append(wq);
+            ordersql.append(" ASC ");
+            return *mod;
+        }
+
+        M_MODEL &desc(const std::string &wq)
+        {
+
+            ordersql.append(" ORDER by ");
+            ordersql.append(wq);
+            ordersql.append(" DESC ");
+            return *mod;
+        }
+
+        M_MODEL &having(const std::string &wq)
+        {
+
+            groupsql.append(" HAVING by ");
+            groupsql.append(wq);
+            return *mod;
+        }
+
+        M_MODEL &group(const std::string &wq)
+        {
+
+            groupsql.append(" GROUP BY ");
+            groupsql.append(wq);
+            return *mod;
+        }
+
+        M_MODEL &orsub()
+        {
+
+            if (iskuohao == true)
+            {
+                iskuohao     = false;
+                ishascontent = false;
+                wheresql.append(" )");
+            }
+            else
+            {
+                wheresql.append(" OR (");
+                iskuohao     = true;
+                ishascontent = false;
+            }
+            return *mod;
+        }
+        M_MODEL &andsub()
+        {
+
+            if (iskuohao == true)
+            {
+                iskuohao = false;
+                wheresql.append(" )");
+                ishascontent = false;
+            }
+            else
+            {
+                wheresql.append(" AND (");
+                iskuohao     = true;
+                ishascontent = false;
+            }
+
+            return *mod;
+        }
+
+        M_MODEL &endsub()
+        {
+            if (iskuohao == true)
+            {
+                iskuohao     = false;
+                ishascontent = false;
+                wheresql.append(" )");
+            }
+            return *mod;
+        }
+
+        M_MODEL &or_b()
+        {
+
+            if (iskuohao == true)
+            {
+                iskuohao     = false;
+                ishascontent = false;
+                wheresql.append(" )");
+            }
+            else
+            {
+                wheresql.append(" OR (");
+                iskuohao     = true;
+                ishascontent = false;
+            }
+            return *mod;
+        }
+        M_MODEL &and_b()
+        {
+
+            if (iskuohao == true)
+            {
+                iskuohao = false;
+                wheresql.append(" )");
+                ishascontent = false;
+            }
+            else
+            {
+                wheresql.append(" AND (");
+                iskuohao     = true;
+                ishascontent = false;
+            }
+
+            return *mod;
+        }
+
+        M_MODEL &or_e()
+        {
+            if (iskuohao == true)
+            {
+                iskuohao     = false;
+                ishascontent = false;
+                wheresql.append(" )");
+            }
+            return *mod;
+        }
+
+        M_MODEL &and_e()
+        {
+            if (iskuohao == true)
+            {
+                iskuohao     = false;
+                ishascontent = false;
+                wheresql.append(" )");
+            }
+            return *mod;
+        }
+
+        M_MODEL &limit(unsigned int num)
+        {
+            limitsql.clear();
+            limitsql.append(" limit ");
+            limitsql.append(std::to_string(num));
+            return *mod;
+        }
+        M_MODEL &limit(unsigned int num, unsigned int endnum)
+        {
+            limitsql.clear();
+            limitsql.append(" limit ");
+            limitsql.append(std::to_string(num));
+            limitsql.push_back(',');
+            limitsql.append(std::to_string(endnum));
+            return *mod;
+        }
+
+        std::vector<std::map<std::string, std::string>> fetch_obj()
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                sqlstring.append(" 1 ");
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            std::vector<std::map<std::string, std::string>> temprecord;
+
+            if (iserror)
+            {
+                return temprecord;
+            }
+
+            try
+            {
+                effect_num = 0;
+                if (conn_empty())
+                {
+                    return temprecord;
+                }
+                auto conn = conn_obj->get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return temprecord;
+                }
+
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+                unsigned int offset        = 0;
+
+                std::vector<unsigned char> field_pos;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = conn->read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                std::map<std::string, std::string> data_temp;
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                    std::string temp_str;
+                                    temp_str.resize(name_length);
+                                    std::memcpy(temp_str.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length);
+                                    if (field_array[ij].name.size() > 0)
+                                    {
+                                        data_temp.insert({field_array[ij].name, std::move(temp_str)});
+                                    }
+                                    else if (field_array[ij].org_name.size() > 0)
+                                    {
+                                        data_temp.insert({field_array[ij].org_name, std::move(temp_str)});
+                                    }
+
+                                    tempnum = tempnum + name_length;
+                                }
+                                temprecord.emplace_back(std::move(data_temp));
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+
+                conn_obj->back_select_conn(conn);
+
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        save_cache(exptime);
+                        exptime = 0;
+                        iscache = false;
+                    }
+                }
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            return temprecord;
+        }
+        std::tuple<std::vector<std::string>, std::map<std::string, unsigned int>, std::vector<std::vector<std::string>>>
+        fetch_row()
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                sqlstring.append(" 1 ");
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            std::vector<std::vector<std::string>> temprecord;
+            std::vector<std::string> table_fieldname;
+            std::map<std::string, unsigned int> table_fieldmap;
+
+            if (iscache)
+            {
+                std::size_t sqlhashid = std::hash<std::string>{}(sqlstring);
+
+                model_meta_cache<std::vector<std::string>> &temp_cache =
+                    model_meta_cache<std::vector<std::string>>::getinstance();
+                temprecord = temp_cache.get(sqlhashid);
+                if (temprecord.size() > 0)
+                {
+                    iscache                                    = false;
+                    model_meta_cache<std::string> &table_cache = model_meta_cache<std::string>::getinstance();
+                    table_fieldname                            = table_cache.get(sqlhashid);
+
+                    model_meta_cache<std::map<std::string, unsigned int>> &tablemap_cache =
+                        model_meta_cache<std::map<std::string, unsigned int>>::getinstance();
+                    table_fieldmap = tablemap_cache.get_obj(sqlhashid);
+
+                    return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+                }
+            }
+
+            if (iserror)
+            {
+                return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+                }
+                auto conn = conn_obj->get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+                }
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+                // std::vector<std::vector<std::string>> field_value;
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                std::vector<unsigned char> field_pos;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = conn->read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                        table_fieldmap.insert({field_array[ii].org_name,table_fieldname.size()});
+                                        table_fieldname.push_back(field_array[ii].org_name);
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                std::vector<std::string> temp_v_record; 
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+                                    std::string tempstr;
+                                    tempstr.resize(name_length);
+                                    std::memcpy(tempstr.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length);
+                                    temp_v_record.push_back(std::move(tempstr));
+                                    tempnum = tempnum + name_length;
+                                }
+                                temprecord.push_back(temp_v_record);
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+                conn_obj->back_select_conn(conn);
+
+                
+
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        if (temprecord.size() > 0)
+                        {
+                            std::size_t sqlhashid = std::hash<std::string>{}(sqlstring);
+
+                            model_meta_cache<std::vector<std::string>> &temp_cache =
+                                model_meta_cache<std::vector<std::string>>::getinstance();
+                            temp_cache.save(sqlhashid, temprecord, exptime);
+
+                            exptime += 1;
+                            model_meta_cache<std::string> &table_cache = model_meta_cache<std::string>::getinstance();
+                            table_cache.save(sqlhashid, table_fieldname, exptime);
+
+                            model_meta_cache<std::map<std::string, unsigned int>> &tablemap_cache =
+                                model_meta_cache<std::map<std::string, unsigned int>>::getinstance();
+                            tablemap_cache.save(sqlhashid, table_fieldmap, exptime);
+                            exptime = 0;
+                            iscache = false;
+                        }
+                    }
+                }
+
+                return std::make_tuple(std::move(table_fieldname), std::move(table_fieldmap), std::move(temprecord));
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+        }
+        M_MODEL &fetch()
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                sqlstring.append(" 1 ");
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscache)
+            {
+                std::size_t sqlhashid = std::hash<std::string>{}(sqlstring);
+                if (get_cacherecord(sqlhashid))
+                {
+                    iscache = false;
+                    return *mod;
+                }
+            }
+
+            B_BASE::record_reset();
+            if (iserror)
+            {
+                return *mod;
+            }
+
+            try
+            {
+                if (conn_empty())
+                {
+                    return *mod;
+                }
+                auto conn = conn_obj->get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return *mod;
+                }
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                std::vector<unsigned char> field_pos;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = conn->read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                typename B_BASE::meta data_temp;
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                    assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp);
+                                    tempnum = tempnum + name_length;
+                                }
+                                B_BASE::record.emplace_back(std::move(data_temp));
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+                conn_obj->back_select_conn(conn);
+
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        save_cache(exptime);
+                        exptime = 0;
+                        iscache = false;
+                    }
+                }
+                return *mod;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return *mod;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            return *mod;
+        }
+
+        asio::awaitable<unsigned int> async_fetch()
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                sqlstring.append(" 1 ");
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscache)
+            {
+                std::size_t sqlhashid = std::hash<std::string>{}(sqlstring);
+                if (get_cacherecord(sqlhashid))
+                {
+                    iscache = false;
+                    co_return 0;
+                }
+            }
+
+            B_BASE::record_reset();
+            if (iserror)
+            {
+                co_return 0;
+            }
+
+            try
+            {
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                std::vector<unsigned char> field_pos;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = co_await conn->async_read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                typename B_BASE::meta data_temp;
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                    assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp);
+                                    tempnum = tempnum + name_length;
+                                }
+                                B_BASE::record.emplace_back(std::move(data_temp));
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+                conn_obj->back_select_conn(conn);
+
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        save_cache(exptime);
+                        exptime = 0;
+                        iscache = false;
+                    }
+                }
+                co_return effect_num;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                co_return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            co_return 0;
+        }
+        M_MODEL &fetch_append()
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                sqlstring.append(" 1 ");
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscache)
+            {
+                std::size_t sqlhashid = std::hash<std::string>{}(sqlstring);
+                if (get_cacherecord(sqlhashid))
+                {
+                    iscache = false;
+                    return *mod;
+                }
+            }
+
+            if (iserror)
+            {
+                return *mod;
+            }
+ 
+            try
+            {
+ 
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                std::vector<unsigned char> field_pos;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = conn->read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                typename B_BASE::meta data_temp;
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                    assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp);
+                                    tempnum = tempnum + name_length;
+                                }
+                                B_BASE::record.emplace_back(std::move(data_temp));
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+                conn_obj->back_select_conn(conn);
+                
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        save_cache(exptime);
+                        exptime = 0;
+                        iscache = false;
+                    }
+                }
+                return *mod;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return *mod;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            return *mod;
+        }
+
+        asio::awaitable<unsigned int> async_fetch_append()
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                sqlstring.append(" 1 ");
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscache)
+            {
+                std::size_t sqlhashid = std::hash<std::string>{}(sqlstring);
+                if (get_cacherecord(sqlhashid))
+                {
+                    iscache = false;
+                    co_return 1;
+                }
+            }
+
+            if (iserror)
+            {
+                co_return 0;
+            }
+
+            try
+            {
+                effect_num = 0;
+
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+
+                // asio::error_code ec;
+
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+                // std::vector<std::vector<std::string>> field_value;
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                std::vector<unsigned char> field_pos;
+                // std::map<unsigned char, std::string> other_col;
+
+                for (; is_sql_item == false;)
+                {
+                    // std::memset(result_data, 0x00, 4096);
+                    // n      = co_await conn->socket->async_read_some(asio::buffer(result_data), asio::use_awaitable);
+                    n      = co_await conn->async_read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                typename B_BASE::meta data_temp;
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                    assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp);
+                                    tempnum = tempnum + name_length;
+                                }
+                                effect_num++;
+                                B_BASE::record.emplace_back(std::move(data_temp));
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+                conn_obj->back_select_conn(conn);
+
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        save_cache(exptime);
+                        exptime = 0;
+                        iscache = false;
+                    }
+                }
+                co_return effect_num;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                co_return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            co_return 0;
+        }
+        unsigned int fetch_one(bool isappend = false)
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                sqlstring.append(" 1 ");
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+
+            sqlstring.append(" limit 1");
+
+            if (iscache)
+            {
+                std::size_t sqlhashid = std::hash<std::string>{}(sqlstring);
+                if (get_cacherecord(sqlhashid))
+                {
+                    iscache = false;
+                    return 0;
+                }
+            }
+
+            B_BASE::data_reset();
+            if (iserror)
+            {
+                return 0;
+            }
+
+            try
+            {
+                effect_num = 0;
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+                unsigned int offset        = 0;
+
+                std::vector<unsigned char> field_pos;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = conn->read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                if (isappend)
+                                {
+                                    typename B_BASE::meta data_temp;
+                                    for (unsigned int ij = 0; ij < column_num; ij++)
+                                    {
+                                        unsigned long long name_length = 0;
+                                        name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                        assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp);
+                                        tempnum = tempnum + name_length;
+                                    }
+                                    B_BASE::record.emplace_back(std::move(data_temp));
+                                    effect_num++;
+                                }
+                                else
+                                {
+                                    for (unsigned int ij = 0; ij < column_num; ij++)
+                                    {
+                                        unsigned long long name_length = 0;
+                                        name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                        assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, B_BASE::data);
+                                        tempnum = tempnum + name_length;
+                                    }
+                                    effect_num++;
+                                }
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+
+                conn_obj->back_select_conn(conn);
+
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        save_cache(exptime);
+                        exptime = 0;
+                        iscache = false;
+                    }
+                }
+                return effect_num;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            return 0;
+        }
+
+        asio::awaitable<unsigned int> async_fetch_one(bool isappend = false)
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                sqlstring.append(" 1 ");
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+
+            sqlstring.append(" limit 1");
+
+            if (iscache)
+            {
+                std::size_t sqlhashid = std::hash<std::string>{}(sqlstring);
+                if (get_cacherecord(sqlhashid))
+                {
+                    iscache = false;
+                    co_return 0;
+                }
+            }
+
+            B_BASE::data_reset();
+            if (iserror)
+            {
+                co_return 0;
+            }
+
+            try
+            {
+                effect_num = 0;
+
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+                // std::vector<std::vector<std::string>> field_value;
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                std::vector<unsigned char> field_pos;
+                // std::map<unsigned char, std::string> other_col;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = co_await conn->async_read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                if (isappend)
+                                {
+                                    typename B_BASE::meta data_temp;
+                                    for (unsigned int ij = 0; ij < column_num; ij++)
+                                    {
+                                        unsigned long long name_length = 0;
+                                        name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                        assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp);
+                                        tempnum = tempnum + name_length;
+                                    }
+                                    B_BASE::record.emplace_back(std::move(data_temp));
+                                    effect_num++;
+                                }
+                                else
+                                {
+                                    for (unsigned int ij = 0; ij < column_num; ij++)
+                                    {
+                                        unsigned long long name_length = 0;
+                                        name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                        assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, B_BASE::data);
+                                        tempnum = tempnum + name_length;
+                                    }
+                                    effect_num++;
+                                }
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+
+                conn_obj->back_select_conn(conn);
+
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        save_cache(exptime);
+                        exptime = 0;
+                        iscache = false;
+                    }
+                }
+                co_return effect_num;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                co_return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            co_return 0;
+        }
+
+        M_MODEL &use_cache(int cache_time = 0)
+        {
+            iscache = true;
+            exptime = cache_time;
+            return *mod;
+        }
+        bool isuse_cache(bool iscachedate = false)
+        {
+            if (iscachedate)
+            {
+                return exptime == 0 && iscache == false;
+            }
+            return iscache;
+        }
+        void set_cache_state(bool isrestatus = false) { iscache = isrestatus; }
+        void remove_exptime_cache()
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            temp_cache.remove_exptime();
+        }
+        void clear_cache()
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            temp_cache.clear();
+        }
+        bool remove_cache()
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            std::size_t sqlhashid                               = std::hash<std::string>{}(sqlstring);
+            return temp_cache.remove(sqlhashid);
+        }
+        bool remove_cache(std::size_t cache_key_name)
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            return temp_cache.remove(cache_key_name);
+        }
+        int check_cache(std::size_t cache_key_name)
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            return temp_cache.check(cache_key_name);
+        }
+        std::vector<typename B_BASE::meta> get_cache_data(std::size_t cache_key_name)
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            auto cache_data                                     = temp_cache.get(cache_key_name);
+            return cache_data;
+        }
+        typename B_BASE::meta get_cache_obj(std::size_t cache_key_name)
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            auto cache_data                                     = temp_cache.get_obj(cache_key_name);
+            return cache_data;
+        }
+        M_MODEL &get_cache(std::size_t cache_key_name)
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            B_BASE::record                                      = temp_cache.get(cache_key_name);
+            if (B_BASE::record.size() == 0)
+            {
+                B_BASE::record_reset();
+            }
+            else
+            {
+                B_BASE::data = B_BASE::record[0];
+            }
+            return *mod;
+        }
+        int update_cache(int exp_time = 0)
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            std::size_t sqlhashid                               = std::hash<std::string>{}(sqlstring);
+            return temp_cache.update(sqlhashid, exp_time);
+        }
+        int update_cache(std::size_t cache_key_name, int exp_time)
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            return temp_cache.update(cache_key_name, exp_time);
+        }
+        bool save_cache(int exp_time = 0)
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            std::size_t sqlhashid                               = std::hash<std::string>{}(sqlstring);
+            temp_cache.save(sqlhashid, B_BASE::record, exp_time);
+            return true;
+        }
+
+        bool save_cache(std::size_t cache_key_name, typename B_BASE::meta &cache_data, int exp_time = 0)
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            temp_cache.save(cache_key_name, cache_data, exp_time);
+            return true;
+        }
+
+        bool save_cache(std::size_t cache_key_name, std::vector<typename B_BASE::meta> &cache_data, int exp_time = 0)
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            temp_cache.save(cache_key_name, cache_data, exp_time);
+            return true;
+        }
+        bool get_cacherecord(std::size_t cache_key_name)
+        {
+            model_meta_cache<typename B_BASE::meta> &temp_cache = model_meta_cache<typename B_BASE::meta>::getinstance();
+            B_BASE::record                                      = temp_cache.get(cache_key_name);
+            if (B_BASE::record.size() == 0)
+            {
+                return false;
+            }
+            else
+            {
+                B_BASE::data = B_BASE::record[0];
+                return true;
+            }
+        }
+        http::OBJ_VALUE fetch_json()
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                sqlstring.append(" 1 ");
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            http::OBJ_VALUE valuetemp;
+            valuetemp.set_array();
+
+            if (iserror)
+            {
+                return valuetemp;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+ 
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = conn->read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                http::OBJ_VALUE json_temp_v;  
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                    std::string temp_str;    
+                                    temp_str.resize(name_length);
+                                    std::memcpy(temp_str.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length);
+                                    if(field_array[ij].name.size()>0)
+                                    {
+                                        //or alias name
+                                        json_temp_v[field_array[ij].name]=std::move(temp_str);
+                                    }
+                                    else if(field_array[ij].org_name.size()>0)
+                                    {
+                                        json_temp_v[field_array[ij].org_name]=std::move(temp_str);
+                                    }
+                                    tempnum = tempnum + name_length;
+                                }
+                                valuetemp.push(json_temp_v);
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+                conn_obj->back_select_conn(conn);
+
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            return valuetemp;
+        }
+
+        asio::awaitable<http::OBJ_VALUE> async_fetch_json()
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                sqlstring.append(" 1 ");
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            http::OBJ_VALUE valuetemp;
+            valuetemp.set_array();
+
+            if (iserror)
+            {
+                co_return valuetemp;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    co_return valuetemp;
+                }
+                auto conn = co_await conn_obj->async_get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+                conn->send_data.clear();
+
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+                
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+ 
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = co_await conn->async_read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                http::OBJ_VALUE json_temp_v;  
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                    std::string temp_str;    
+                                    temp_str.resize(name_length);
+                                    std::memcpy(temp_str.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length);
+                                    if(field_array[ij].name.size()>0)
+                                    {
+                                        //or alias name
+                                        json_temp_v[field_array[ij].name]=std::move(temp_str);
+                                    }
+                                    else if(field_array[ij].org_name.size()>0)
+                                    {
+                                        json_temp_v[field_array[ij].org_name]=std::move(temp_str);
+                                    }
+                                    tempnum = tempnum + name_length;
+                                }
+                                valuetemp.push(json_temp_v);
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+                conn_obj->back_select_conn(conn);
+
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            co_return valuetemp;
+        }
+
+        long long get_one(long long id)
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            sqlstring.append(B_BASE::getPKname());
+            sqlstring.append("=");
+            sqlstring.append(std::to_string(id));
+            sqlstring.append(" limit 1");
+            if (iscache)
+            {
+                std::size_t sqlhashid = std::hash<std::string>{}(sqlstring);
+                if (get_cacherecord(sqlhashid))
+                {
+                    iscache = false;
+                    return 0;
+                }
+            }
+
+            B_BASE::data_reset();
+
+            if (iserror)
+            {
+                return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                std::vector<unsigned char> field_pos;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = conn->read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                    assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, B_BASE::data);
+                                    tempnum = tempnum + name_length;
+                                }
+                                 
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+                conn_obj->back_select_conn(conn);               
+
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        save_cache(exptime);
+                        exptime = 0;
+                        iscache = false;
+                    }
+                }
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            return 0;
+        }
+
+        asio::awaitable<long long> async_get_one(long long id)
+        {
+            effect_num = 0;
+            if (selectsql.empty())
+            {
+                sqlstring = "SELECT *  FROM ";
+            }
+            else
+            {
+                sqlstring = "SELECT ";
+                sqlstring.append(selectsql);
+                sqlstring.append(" FROM ");
+            }
+
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            sqlstring.append(B_BASE::getPKname());
+            sqlstring.append("=");
+            sqlstring.append(std::to_string(id));
+            sqlstring.append(" limit 1");
+            if (iscache)
+            {
+                std::size_t sqlhashid = std::hash<std::string>{}(sqlstring);
+                if (get_cacherecord(sqlhashid))
+                {
+                    iscache = false;
+                    co_return 0;
+                }
+            }
+
+            B_BASE::data_reset();
+
+            if (iserror)
+            {
+                co_return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_select_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+                
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                std::vector<unsigned char> field_pos;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = co_await conn->async_read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+
+                                    assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, B_BASE::data);
+                                    tempnum = tempnum + name_length;
+                                }
+                                 
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+                conn_obj->back_select_conn(conn);               
+
+                if (iscache)
+                {
+                    if (exptime > 0)
+                    {
+                        save_cache(exptime);
+                        exptime = 0;
+                        iscache = false;
+                    }
+                }
+                co_return effect_num;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                co_return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            co_return 0;
+        }
+
+        int update()
+        {
+            effect_num = 0;
+            if (wheresql.empty())
+            {
+                if (B_BASE::getPK() > 0)
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    wheresql = tempsql.str();
+                }
+                else
+                {
+                    return 0;
+                }
+            }
+            sqlstring = B_BASE::_makeupdatesql("");
+            sqlstring.append(" where ");
+            if (wheresql.empty())
+            {
+                return 0;
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscommit)
+            {
+                iscommit = false;
+                return 0;
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    return effect_num;
+                }
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                
+            }
+            return 0;
+        }
+        int update(const std::string &fieldname)
+        {
+            effect_num = 0;
+            if (wheresql.empty())
+            {
+                if (B_BASE::getPK() > 0)
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    wheresql = tempsql.str();
+                }
+                else
+                {
+                    error_msg = "warning empty where sql!";
+                    return 0;
+                }
+            }
+
+            sqlstring = B_BASE::_makeupdatesql(fieldname);
+            sqlstring.append(" where ");
+            if (wheresql.empty())
+            {
+                return 0;
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscommit)
+            {
+                iscommit = false;
+                return 0;
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    return effect_num;
+                }
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                
+            }
+            return 0;
+        }
+
+        asio::awaitable<int> async_update(const std::string &fieldname)
+        {
+            effect_num = 0;
+            if (wheresql.empty())
+            {
+                if (B_BASE::getPK() > 0)
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    wheresql = tempsql.str();
+                }
+                else
+                {
+                    error_msg = "warning empty where sql!";
+                    co_return 0;
+                }
+            }
+
+            sqlstring = B_BASE::_makeupdatesql(fieldname);
+            sqlstring.append(" where ");
+            if (wheresql.empty())
+            {
+                co_return 0;
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscommit)
+            {
+                iscommit = false;
+                co_return 0;
+            }
+
+            if (iserror)
+            {
+                co_return 0;
+            }
+            try
+            {
+
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+
+                unsigned int offset = 0;
+                n                   = co_await conn->async_read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                    iserror = true;
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+
+                    co_return effect_num;
+                }
+                co_return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                co_return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+
+            }
+            co_return 0;
+        }
+        asio::awaitable<int> async_update()
+        {
+            effect_num = 0;
+            if (wheresql.empty())
+            {
+                if (B_BASE::getPK() > 0)
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    wheresql = tempsql.str();
+                }
+                else
+                {
+                    error_msg = "warning empty where sql!";
+                    co_return 0;
+                }
+            }
+
+            sqlstring = B_BASE::_makeupdatesql("");
+            sqlstring.append(" where ");
+            if (wheresql.empty())
+            {
+                co_return 0;
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscommit)
+            {
+                iscommit = false;
+                co_return 0;
+            }
+
+            if (iserror)
+            {
+                co_return 0;
+            }
+            try
+            {
+
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+
+                unsigned int offset = 0;
+                n                   = co_await conn->async_read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                    iserror = true;
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+
+                    co_return effect_num;
+                }
+                co_return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                co_return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+
+            }
+            co_return 0;
+        }
+
+        int update_batch(const std::string &fieldname)
+        {
+            effect_num = 0;
+            if (B_BASE::record.size() == 0)
+            {
+                return 0;
+            }
+            if (fieldname.size() > 0)
+            {
+                sqlstring = B_BASE::_make_insert_into_sql(fieldname);
+            }
+            else
+            {
+                sqlstring = B_BASE::_make_replace_into_sql();
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    return effect_num;
+                }
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                
+            }
+            return 0;
+        }
+        int remove()
+        {
+            effect_num = 0;
+            if (wheresql.empty())
+            {
+                if (B_BASE::getPK() > 0)
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    wheresql = tempsql.str();
+                }
+                else
+                {
+                    return 0;
+                }
+            }
+
+            sqlstring = "DELETE FROM  ";
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                return 0;
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscommit)
+            {
+                iscommit = false;
+                return 0;
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    return effect_num;
+                }
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                
+            }
+            return 0;
+        }
+
+        asio::awaitable<unsigned int> async_remove()
+        {
+            effect_num = 0;
+            if (wheresql.empty())
+            {
+                if (B_BASE::getPK() > 0)
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    wheresql = tempsql.str();
+                }
+                else
+                {
+                    co_return 0;
+                }
+            }
+
+            sqlstring = "DELETE FROM  ";
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            if (wheresql.empty())
+            {
+                co_return 0;
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscommit)
+            {
+                iscommit = false;
+                co_return 0;
+            }
+
+            if (iserror)
+            {
+                co_return 0;
+            }
+
+            try
+            {
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+                
+                unsigned int offset = 0;
+                n                   = co_await conn->async_read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    co_return effect_num;
+                }
+                co_return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                co_return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                
+            }
+            co_return 0;
+        }
+
+        int remove(long long id)
+        {
+            effect_num = 0;
+            sqlstring  = "DELETE FROM  ";
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            sqlstring.append(B_BASE::getPKname());
+            sqlstring.append("=");
+            sqlstring.append(std::to_string(id));
+
+            if (iscommit)
+            {
+                iscommit = false;
+                return 0;
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    return effect_num;
+                }
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                
+            }
+            return 0;
+        }
+
+        asio::awaitable<unsigned int> async_remove(long long id)
+        {
+            effect_num = 0;
+            sqlstring  = "DELETE FROM  ";
+            sqlstring.append(B_BASE::tablename);
+            sqlstring.append(" WHERE ");
+
+            sqlstring.append(B_BASE::getPKname());
+            sqlstring.append("=");
+            sqlstring.append(std::to_string(id));
+
+            if (iscommit)
+            {
+                iscommit = false;
+                co_return 0;
+            }
+
+            if (iserror)
+            {
+                co_return 0;
+            }
+
+            try
+            {
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+                
+                unsigned int offset = 0;
+                n                   = co_await conn->async_read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    co_return effect_num;
+                }
+                co_return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                co_return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                
+            }
+            co_return 0;
+        }
+
+        int soft_remove(const std::string &fieldsql)
+        {
+            effect_num = 0;
+            if (wheresql.empty())
+            {
+                if (B_BASE::getPK() > 0)
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    wheresql = tempsql.str();
+                }
+                else
+                {
+                    return 0;
+                }
+            }
+
+            sqlstring = B_BASE::soft_remove_sql(fieldsql);
+            if (sqlstring.empty())
+            {
+                error_msg = "soft delete field empty.";
+                return 0;
+            }
+            sqlstring.append(" where ");
+            if (wheresql.empty())
+            {
+                return 0;
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscommit)
+            {
+                iscommit = false;
+                return 0;
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    return effect_num;
+                }
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                
+            }
+            return 0;
+        }
+        int soft_remove()
+        {
+            effect_num = 0;
+            if (wheresql.empty())
+            {
+                if (B_BASE::getPK() > 0)
+                {
+                    std::ostringstream tempsql;
+                    effect_num = 1;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    wheresql = tempsql.str();
+                }
+                else
+                {
+                    return 0;
+                }
+            }
+            if (effect_num == 1)
+            {
+                sqlstring = B_BASE::soft_remove_sql(" ");
+            }
+            else
+            {
+                sqlstring = B_BASE::soft_remove_sql("");
+            }
+            effect_num = 0;
+            if (sqlstring.empty())
+            {
+                error_msg = "soft delete field empty.";
+                return 0;
+            }
+            sqlstring.append(" where ");
+            if (wheresql.empty())
+            {
+                return 0;
+            }
+            else
+            {
+                sqlstring.append(wheresql);
+            }
+            if (!groupsql.empty())
+            {
+                sqlstring.append(groupsql);
+            }
+            if (!ordersql.empty())
+            {
+                sqlstring.append(ordersql);
+            }
+            if (!limitsql.empty())
+            {
+                sqlstring.append(limitsql);
+            }
+
+            if (iscommit)
+            {
+                iscommit = false;
+                return 0;
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    return effect_num;
+                }
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+                return 0;
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+                
+            }
+            return 0;
+        }
+        long long insert(typename B_BASE::meta &insert_data)
+        {
+            effect_num = 0;
+            sqlstring  = B_BASE::_makerecordinsertsql(insert_data);
+            if (iscommit)
+            {
+                iscommit = false;
+                return 0;
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num      = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    long long   insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);    
+
+                    return insert_last_id;
+                }
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            return 0;
+        }
+
+        asio::awaitable<long long> async_insert(typename B_BASE::meta &insert_data)
+        {
+            effect_num = 0;
+            sqlstring  = B_BASE::_makerecordinsertsql(insert_data);
+            if (iscommit)
+            {
+                iscommit = false;
+                co_return 0;
+            }
+
+            if (iserror)
+            {
+                co_return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+                
+                unsigned int offset = 0;
+                n                   = co_await conn->async_read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num      = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    long long   insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);    
+
+                    co_return insert_last_id;
+                }
+                co_return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            co_return 0;
+        }
+
+        long long insert(std::vector<typename B_BASE::meta> &insert_data)
+        {
+            effect_num = 0;
+            sqlstring  = B_BASE::_makerecordinsertsql(insert_data);
+            if (iscommit)
+            {
+                iscommit = false;
+                return 0;
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num      = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    long long   insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);    
+
+                    return insert_last_id;
+                }
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            return 0;
+        }
+
+        asio::awaitable<long long> async_insert(std::vector<typename B_BASE::meta> &insert_data)
+        {
+            effect_num = 0;
+            sqlstring  = B_BASE::_makerecordinsertsql(insert_data);
+            if (iscommit)
+            {
+                iscommit = false;
+                co_return 0;
+            }
+
+            if (iserror)
+            {
+                co_return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+                
+                unsigned int offset = 0;
+                n                   = co_await conn->async_read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num      = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    long long   insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);    
+
+                    co_return insert_last_id;
+                }
+                co_return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            co_return 0;
+        }
+
+        long long insert()
+        {
+            effect_num = 0;
+            sqlstring  = B_BASE::_makeinsertsql();
+            if (iscommit)
+            {
+                iscommit = false;
+                return 0;
+            }
+
+            if (iserror)
+            {
+                return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+                    unsigned int d_offset = 1;
+                    effect_num      = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    long long   insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);    
+
+                    return insert_last_id;
+                }
+                return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            return 0;
+        }
+
+        asio::awaitable<long long> async_insert()
+        {
+            effect_num = 0;
+            sqlstring  = B_BASE::_makeinsertsql();
+            if (iscommit)
+            {
+                iscommit = false;
+                co_return 0;
+            }
+
+            if (iserror)
+            {
+                co_return 0;
+            }
+ 
+            try
+            {
+                if (conn_empty())
+                {
+                    co_return 0;
+                }
+                auto conn = co_await conn_obj->async_get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+                
+                unsigned int offset = 0;
+                n                   = co_await conn->async_read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num      = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    long long   insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);    
+
+                    co_return insert_last_id;
+                }
+                co_return 0;
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            co_return 0;
+        }
+
+
+        long long save(bool isrealnew = false)
+        {
+            effect_num = 0;
+            if (B_BASE::getPK() > 0 && isrealnew == false)
+            {
+                if (wheresql.empty())
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    wheresql = tempsql.str();
+                }
+                sqlstring = B_BASE::_makeupdatesql("");
+                sqlstring.append(" where ");
+                if (wheresql.empty())
+                {
+                    return 0;
+                }
+                else
+                {
+                    sqlstring.append(wheresql);
+                }
+                if (!groupsql.empty())
+                {
+                    sqlstring.append(groupsql);
+                }
+                if (!ordersql.empty())
+                {
+                    sqlstring.append(ordersql);
+                }
+                if (!limitsql.empty())
+                {
+                    sqlstring.append(limitsql);
+                }
+                if (iscommit)
+                {
+                    iscommit = false;
+                    return 0;
+                }
+
+                if (iserror)
+                {
+                    return 0;
+                }
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num      = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    return effect_num;
+                }
+                return 0;
+            }
+            else
+            {
+                sqlstring  = B_BASE::_makeinsertsql();
+                if (conn_empty())
+                {
+                    return 0;
+                }
+                auto conn = conn_obj->get_edit_conn();
+
+                unsigned int querysql_len = sqlstring.length() + 1;
+
+                conn->send_data.clear();
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(sqlstring);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return 0;
+                }
+
+                unsigned int offset = 0;
+                n                   = conn->read_loop();
+
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                conn_obj->back_edit_conn(conn);
+
+                if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                {
+                    error_msg = temp_pack_data.data.substr(3);
+                }
+                else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                {
+
+                    unsigned int d_offset = 1;
+                    effect_num      = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                    long long   insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);    
+
+                    return insert_last_id;
+                }
+                return 0;
+            }
+            return 0;
+        }
+
+        asio::awaitable<long long> async_save(bool isrealnew = false)
+        {
+            effect_num = 0;
+            if (B_BASE::getPK() > 0 && isrealnew == false)
+            {
+                if (wheresql.empty())
+                {
+                    std::ostringstream tempsql;
+                    tempsql << " ";
+                    tempsql << B_BASE::getPKname();
+                    tempsql << " = '";
+                    tempsql << B_BASE::getPK();
+                    tempsql << "' ";
+                    wheresql = tempsql.str();
+                }
+                sqlstring = B_BASE::_makeupdatesql("");
+                sqlstring.append(" where ");
+                if (wheresql.empty())
+                {
+                    co_return 0;
+                }
+                else
+                {
+                    sqlstring.append(wheresql);
+                }
+                if (!groupsql.empty())
+                {
+                    sqlstring.append(groupsql);
+                }
+                if (!ordersql.empty())
+                {
+                    sqlstring.append(ordersql);
+                }
+                if (!limitsql.empty())
+                {
+                    sqlstring.append(limitsql);
+                }
+                if (iscommit)
+                {
+                    iscommit = false;
+                    co_return 0;
+                }
+
+                if (iserror)
+                {
+                    co_return 0;
+                }
+
+                try
+                {
+                    if (conn_empty())
+                    {
+                        co_return 0;
+                    }
+                    auto conn = co_await conn_obj->async_get_edit_conn();
+
+                    unsigned int querysql_len = sqlstring.length() + 1;
+
+                    conn->send_data.clear();
+                    conn->send_data.push_back((querysql_len & 0xFF));
+                    conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                    conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                    conn->send_data.push_back(0x00);
+                    conn->send_data.push_back(0x03);
+                    conn->send_data.append(sqlstring);
+
+                    std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+
+                    unsigned int offset = 0;
+                    n                   = co_await conn->async_read_loop();
+
+                    pack_info_t temp_pack_data;
+                    temp_pack_data.seq_id = 1;
+                    conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                    conn_obj->back_edit_conn(conn);
+
+                    if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                    {
+                        error_msg = temp_pack_data.data.substr(3);
+                        iserror = true;
+                    }
+                    else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                    {
+
+                        unsigned int d_offset = 1;
+                        effect_num            = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+
+                        co_return effect_num;
+                    }
+                    co_return 0;
+                }
+                catch (const std::exception &e)
+                {
+                    error_msg = std::string(e.what());
+                    co_return 0;
+                }
+                catch (const std::string &e)
+                {
+                    error_msg = e;
+                }
+                catch (...)
+                {
+                    co_return 0;
+                }
+                co_return 0;
+            }
+            else
+            {
+                sqlstring  = B_BASE::_makeinsertsql();
+                try
+                {
+                    if (conn_empty())
+                    {
+                        co_return 0;
+                    }
+                    auto conn = co_await conn_obj->async_get_edit_conn();
+
+                    unsigned int querysql_len = sqlstring.length() + 1;
+
+                    conn->send_data.clear();
+                    conn->send_data.push_back((querysql_len & 0xFF));
+                    conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                    conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                    conn->send_data.push_back(0x00);
+                    conn->send_data.push_back(0x03);
+                    conn->send_data.append(sqlstring);
+
+                    std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+                    
+                    unsigned int offset = 0;
+                    n                   = co_await conn->async_read_loop();
+
+                    pack_info_t temp_pack_data;
+                    temp_pack_data.seq_id = 1;
+                    conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+
+                    conn_obj->back_edit_conn(conn);
+
+                    if ((unsigned char)temp_pack_data.data[0] == 0xFF)
+                    {
+                        error_msg = temp_pack_data.data.substr(3);
+                    }
+                    else if ((unsigned char)temp_pack_data.data[0] == 0x00)
+                    {
+
+                        unsigned int d_offset = 1;
+                        effect_num      = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);
+                        long long   insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset);    
+
+                        co_return insert_last_id;
+                    }
+                    co_return 0;
+                }
+                catch (const std::exception &e)
+                {
+                    error_msg = std::string(e.what());
+                }
+                catch (const std::string &e)
+                {
+                    error_msg = e;
+                }
+                catch (...)
+                {
+                }
+                co_return 0;
+            }
+            co_return 0;
+        }
+
+        std::tuple<std::vector<std::string>, std::map<std::string, unsigned int>, std::vector<std::vector<std::string>>>
+        query(const std::string &rawsql)
+        {
+
+            std::vector<std::vector<std::string>> temprecord;
+            std::vector<std::string> table_fieldname;
+            std::map<std::string, unsigned int> table_fieldmap;
+
+            if(rawsql.size()>10)
+            {
+                unsigned int i=0;
+                for(;i<rawsql.size();i++)
+                {
+                    if(rawsql[i]!=0x20)
+                    {
+                        break;
+                    }
+                }
+                if(i<5)
+                {
+                    //must be select
+                    if(rawsql[i]!='s' && rawsql[i]!='S')
+                    {
+                        iserror = true;   
+                    }
+                }
+                else
+                {
+                    iserror = true;   
+                }
+            }
+            else
+            {
+                iserror = true;   
+            }
+
+            if (iserror)
+            {
+                return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+            }
+
+            try
+            {
+                if (conn_empty())
+                {
+                    return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+                }
+                auto conn = conn_obj->get_select_conn();
+
+                unsigned int querysql_len = rawsql.length() + 1;
+
+                conn->send_data.clear();
+
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(rawsql);
+
+                std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec);
+                
+                if(conn->ec)
+                {
+                    error_msg = conn->ec.message();
+                    iserror   = true;
+                    return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+                }
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                std::vector<unsigned char> field_pos;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = conn->read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                        table_fieldmap.insert({field_array[ii].org_name,table_fieldname.size()});
+                                        table_fieldname.push_back(field_array[ii].org_name);
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                std::vector<std::string> temp_v_record; 
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+                                    std::string tempstr;
+                                    tempstr.resize(name_length);
+                                    std::memcpy(tempstr.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length);
+                                    temp_v_record.push_back(std::move(tempstr));
+                                    tempnum = tempnum + name_length;
+                                }
+                                temprecord.push_back(temp_v_record);
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+                conn_obj->back_select_conn(conn);
+
+                return std::make_tuple(std::move(table_fieldname), std::move(table_fieldmap), std::move(temprecord));
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+        }
+
+        asio::awaitable<std::tuple<std::vector<std::string>, std::map<std::string, unsigned int>, std::vector<std::vector<std::string>>>>
+        async_query(const std::string &rawsql)
+        {
+
+            std::vector<std::vector<std::string>> temprecord;
+            std::vector<std::string> table_fieldname;
+            std::map<std::string, unsigned int> table_fieldmap;
+
+            if(rawsql.size()>10)
+            {
+                unsigned int i=0;
+                for(;i<rawsql.size();i++)
+                {
+                    if(rawsql[i]!=0x20)
+                    {
+                        break;
+                    }
+                }
+                if(i<5)
+                {
+                    //must be select
+                    if(rawsql[i]!='s' && rawsql[i]!='S')
+                    {
+                        iserror = true;   
+                    }
+                }
+                else
+                {
+                    iserror = true;   
+                }
+            }
+            else
+            {
+                iserror = true;   
+            }
+
+            if (iserror)
+            {
+                co_return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+            }
+
+            try
+            {
+                if (conn_empty())
+                {
+                    co_return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+                }
+                auto conn = co_await conn_obj->async_get_select_conn();
+
+                unsigned int querysql_len = rawsql.length() + 1;
+
+                conn->send_data.clear();
+
+                conn->send_data.push_back((querysql_len & 0xFF));
+                conn->send_data.push_back((querysql_len >> 8 & 0xFF));
+                conn->send_data.push_back((querysql_len >> 16 & 0xFF));
+                conn->send_data.push_back(0x00);
+                conn->send_data.push_back(0x03);
+                conn->send_data.append(rawsql);
+
+                std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable);
+                
+                
+                pack_info_t temp_pack_data;
+                temp_pack_data.seq_id = 1;
+                bool is_sql_item      = false;
+                std::vector<field_info_t> field_array;
+
+                unsigned char action_setup = 0;
+                unsigned int column_num    = 0;
+
+                unsigned int offset = 0;
+
+                std::vector<unsigned char> field_pos;
+
+                for (; is_sql_item == false;)
+                {
+                    n      = co_await conn->async_read_loop();
+                    offset = 0;
+                    for (; offset < n;)
+                    {
+                        conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data);
+                        if (temp_pack_data.length == temp_pack_data.current_length)
+                        {
+                            if (conn->pack_eof_check(temp_pack_data))
+                            {
+                                is_sql_item = true;
+                                break;
+                            }
+
+                            if (action_setup == 0)
+                            {
+                                if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0)
+                                {
+                                    action_setup = 1;
+                                    column_num   = (unsigned char)temp_pack_data.data[0];
+                                }
+                            }
+                            else if (action_setup == 1)
+                            {
+                                field_info_t temp_filed_col;
+                                conn->read_col_info(temp_pack_data.data, temp_filed_col);
+
+                                field_array.emplace_back(std::move(temp_filed_col));
+                                column_num--;
+                                if (column_num == 0)
+                                {
+                                    action_setup = 2;
+                                    for (unsigned int ii = 0; ii < field_array.size(); ii++)
+                                    {
+                                        field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name));
+                                        table_fieldmap.insert({field_array[ii].org_name,table_fieldname.size()});
+                                        table_fieldname.push_back(field_array[ii].org_name);
+                                    }
+                                }
+                            }
+                            else if (action_setup == 2)
+                            {
+                                unsigned int column_num = field_array.size();
+                                unsigned int tempnum    = 0;
+
+                                std::vector<std::string> temp_v_record; 
+                                for (unsigned int ij = 0; ij < column_num; ij++)
+                                {
+                                    unsigned long long name_length = 0;
+                                    name_length                    = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum);
+                                    std::string tempstr;
+                                    tempstr.resize(name_length);
+                                    std::memcpy(tempstr.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length);
+                                    temp_v_record.push_back(std::move(tempstr));
+                                    tempnum = tempnum + name_length;
+                                }
+                                temprecord.push_back(temp_v_record);
+                                effect_num++;
+                            }
+                        }
+                        else
+                        {
+                            if (offset >= n)
+                            {
+                                break;
+                            }
+                            is_sql_item = true;
+                            break;
+                        }
+                    }
+                }
+                conn_obj->back_select_conn(conn);
+
+                co_return std::make_tuple(std::move(table_fieldname), std::move(table_fieldmap), std::move(temprecord));
+            }
+            catch (const std::exception &e)
+            {
+                error_msg = std::string(e.what());
+            }
+            catch (const std::string &e)
+            {
+                error_msg = e;
+            }
+            catch (...)
+            {
+            }
+            co_return std::make_tuple(table_fieldname, table_fieldmap, temprecord);
+        }
+
+        // long long edit_query(const std::string &rawsql, bool isinsert = false)
+        // {
+        //     if (iserror)
+        //     {
+        //         return 0;
+        //     }
+
+        //     return 0;
+        // }
+        M_MODEL &clear(bool both = true)
+        {
+            selectsql.clear();
+            wheresql.clear();
+            ordersql.clear();
+            groupsql.clear();
+            limitsql.clear();
+            sqlstring.clear();
+            error_msg.clear();
+            iskuohao     = false;
+            ishascontent = false;
+            iscommit     = false;
+            iscache      = false;
+            effect_num   = 0;
+            if (both)
+            {
+                B_BASE::record_reset();
+                B_BASE::data_reset();
+            }
+            return *mod;
+        }
+        M_MODEL &clearWhere()
+        {
+            selectsql.clear();
+            wheresql.clear();
+            ordersql.clear();
+            groupsql.clear();
+            limitsql.clear();
+            sqlstring.clear();
+            error_msg.clear();
+            iskuohao     = false;
+            ishascontent = false;
+            iscommit     = false;
+            iscache      = false;
+            effect_num   = 0;
+            return *mod;
+        }
+        M_MODEL &set_data(typename B_BASE::meta indata)
+        {
+            B_BASE::data = indata;
+            return *mod;
+        }
+        M_MODEL &get() { return *mod; }
+        std::string get_query() { return sqlstring; }
+        M_MODEL &start_commit()
+        {
+            iscommit = true;
+            return *mod;
+        }
+        M_MODEL &end_commit()
+        {
+            iscommit = false;
+            return *mod;
+        }
+
+        unsigned int effect()
+        {
+            return effect_num;
+        }
+        bool conn_empty()
+        {
+            if (conn_obj)
+            {
+                return false; 
+            }
+            error_msg = "conn_obj is null";
+            iserror   = true;
+            return true;
+        }
+
+      public:
+        std::string selectsql;
+        std::string wheresql;
+        std::string ordersql;
+        std::string groupsql;
+        std::string limitsql;
+        std::string sqlstring;
+        std::string dbtag;
+        std::string error_msg;
+        std::string original_tablename;
+
+        // std::list<std::string> commit_sqllist;
+        bool iskuohao           = false;
+        bool iscommit           = false;
+        bool ishascontent       = false;
+        bool iscache            = false;
+        bool iserror            = false;
+        int exptime             = 0;
+        unsigned int effect_num = 0;
+
+        M_MODEL *mod;
+
+        std::shared_ptr<orm_conn_pool> conn_obj;
+    };
+//} /*tagnamespace_replace*/
+}// namespace orm
+#endif

frameworks/C++/paozhu/paozhu_benchmark/orm/include/worldbase.h

@@ -0,0 +1,2448 @@
+#ifndef ORM_DEFAULT_WORLDBASEMATA_H
+#define ORM_DEFAULT_WORLDBASEMATA_H
+/*
+*This file is auto create from cli
+*本文件为自动生成 Sun, 02 Mar 2025 10:54:30 GMT
+***/
+#include <iostream>
+#include <cstdio>
+#include <sstream>
+#include <array>
+#include <map> 
+#include <string_view> 
+#include <string> 
+#include <vector>
+#include <ctime>
+#include <array>
+#include "unicode.h"
+
+namespace orm { 
+   
+    
+struct worldbase
+{
+    struct meta{
+     unsigned  int  id = 0; ///**/
+ int  randomnumber = 0; ///**/
+ } data;
+ std::vector<worldbase::meta> record;
+std::string _rmstag="default";//this value must be default or tag value, tag in mysqlconnect config file .
+unsigned int _offset=0;
+std::vector<worldbase::meta>::iterator begin(){     return record.begin(); }
+std::vector<worldbase::meta>::iterator end(){     return record.end(); }
+std::vector<worldbase::meta>::const_iterator begin() const{     return record.begin(); }
+std::vector<worldbase::meta>::const_iterator end() const{     return record.end(); }
+static constexpr std::array<std::string_view,2> col_names={"id","randomnumber"};
+static constexpr std::array<unsigned char,2> col_types={3,3};
+static constexpr std::array<unsigned char,2> col_length={0,0};
+static constexpr std::array<unsigned char,2> col_decimals={0,0};
+std::string tablename="world";
+static constexpr std::string_view modelname="World";
+
+	  unsigned char findcolpos(const std::string &coln){
+            if(coln.size()==0)
+            {
+                return 255;
+            }
+		    unsigned char  bi=coln[0];
+         
+
+	         if(bi<91&&bi>64){
+				bi+=32;
+			}
+            switch(coln[0]){
+
+
+         case 'i':
+   	 return 0;
+break;
+case 'r':
+   	 return 1;
+break;
+
+             }
+             return 255;
+           }
+         
+    int size(){ return record.size(); }   
+
+    std::string getPKname(){ 
+       return "id";
+}
+
+      void record_reset()
+      {
+            record.clear();     
+      }
+      void data_reset(){
+     worldbase::meta metatemp;    
+            data = metatemp; 
+      }
+      
+      std::string soft_remove_sql([[maybe_unused]] const std::string &fieldsql){
+          std::string temp;
+     
+         return temp;
+     }
+     
+
+  inline  std::string stringaddslash(const std::string &content){
+        std::string temp;
+        for(unsigned int i=0;i<content.size();i++){
+            if(content[i]=='\''){
+                temp.append("\\'");
+                continue;
+            }else if(content[i]=='"'){
+                temp.append("\\\"");
+                continue;
+            }else if(content[i]=='\\'){
+                temp.append("\\\\");
+                continue;
+            }
+            temp.push_back(content[i]);
+        }
+        return temp;
+   }  
+  inline  std::string jsonaddslash(const std::string &content){
+        std::string temp;
+        for(unsigned int i=0;i<content.size();i++){
+            if(content[i]=='"'){
+                temp.append("\\\"");
+                continue;
+            }
+            else if(content[i]=='\\'){
+                temp.append("\\\\");
+                continue;
+            }
+            temp.push_back(content[i]);
+        }
+        return temp;
+   }  
+
+   std::string _makeinsertsql(){
+        unsigned int j=0;
+        std::ostringstream tempsql;
+        tempsql<<"INSERT INTO ";
+        tempsql<<tablename;
+        tempsql<<" (";
+        for(;j<col_names.size();j++){
+                if(j>0){
+                    tempsql<<"`,`";
+                }else{
+                    tempsql<<"`";
+                }
+                tempsql<<col_names[j];
+        }
+        if(j>0){
+            tempsql<<"`";
+        }
+        tempsql<<") VALUES (";
+
+        if(data.id==0){
+tempsql<<"null";
+ }else{ 
+	tempsql<<std::to_string(data.id);
+}
+if(data.randomnumber==0){
+	tempsql<<",0";
+ }else{ 
+	tempsql<<","<<std::to_string(data.randomnumber);
+}
+tempsql<<")";
+
+     
+       return tempsql.str();
+   } 
+      
+      std::string _makerecordinsertsql(const meta &insert_data){
+        unsigned int j=0;
+        std::ostringstream tempsql;
+        tempsql<<"INSERT INTO ";
+        tempsql<<tablename;
+        tempsql<<" (";
+        for(;j<col_names.size();j++){
+                if(j>0){
+                    tempsql<<"`,`";
+                }else{
+                    tempsql<<"`";
+                }
+                tempsql<<col_names[j];
+        }
+        if(j>0){
+            tempsql<<"`";
+        }
+        tempsql<<") VALUES (";
+
+        if(insert_data.id==0){
+tempsql<<"null";
+ }else{ 
+	tempsql<<std::to_string(insert_data.id);
+}
+if(insert_data.randomnumber==0){
+	tempsql<<",0";
+ }else{ 
+	tempsql<<","<<std::to_string(insert_data.randomnumber);
+}
+tempsql<<")";
+
+     
+       return tempsql.str();
+   } 
+       
+    std::string _makerecordinsertsql(const std::vector<meta> &insert_data){
+        unsigned int j=0;
+        std::ostringstream tempsql;
+        tempsql<<"INSERT INTO ";
+        tempsql<<tablename;
+        tempsql<<" (";
+        for(;j<col_names.size();j++){
+                if(j>0){
+                    tempsql<<"`,`";
+                }else{
+                    tempsql<<"`";
+                }
+                tempsql<<col_names[j];
+        }
+        if(j>0){
+            tempsql<<"`";
+        }
+        tempsql<<") VALUES ";
+
+        for(unsigned int i=0;i<insert_data.size();i++)
+        {
+            if(i>0)
+            {
+                tempsql<<",";	
+            }
+            tempsql<<"(";
+
+
+            	if(insert_data[i].id==0){
+	tempsql<<"null";
+	 }else{ 
+	tempsql<<std::to_string(insert_data[i].id);
+	}
+	if(insert_data[i].randomnumber==0){
+	tempsql<<",0";
+	 }else{ 
+	tempsql<<","<<std::to_string(insert_data[i].randomnumber);
+	}
+		tempsql<<")";
+	 } 
+
+     
+       return tempsql.str();
+   } 
+       
+    std::string _makeupdatesql(const std::string &fileld){
+        std::ostringstream tempsql;
+        tempsql<<"UPDATE ";
+        tempsql<<tablename;
+        tempsql<<" SET ";
+
+        bool isall=false;
+        if(fileld.empty()){
+            isall=true;
+        }
+        if(isall){
+
+        if(data.id==0){
+	tempsql<<"`id`=0";
+ }else{ 
+	tempsql<<"`id`="<<std::to_string(data.id);
+}
+if(data.randomnumber==0){
+	tempsql<<",`randomnumber`=0";
+ }else{ 
+	tempsql<<",`randomnumber`="<<std::to_string(data.randomnumber);
+}
+ }else{ 
+
+     
+  unsigned int jj=0;
+                  std::string keyname;
+                  std::vector<unsigned char> keypos;
+                  for(;jj<fileld.size();jj++){
+                        if(fileld[jj]==','){
+                                unsigned char bpos_i=findcolpos(keyname);
+                               keypos.emplace_back(bpos_i); 
+#ifdef DEBUG
+                    if (bpos_i == 255)
+                    {
+                        std::cout << "\033[1m\033[31m-----------\n"
+                                  << keyname << " not in " << tablename << " table Field.\n-----------\033[0m"
+                                  << std::endl;
+                    }
+#endif                               
+                               keyname.clear();
+                             continue;   
+                        }
+                        if(fileld[jj]==0x20){
+
+                             continue;   
+                        }
+                        keyname.push_back(fileld[jj]);
+
+                  }  
+                 if(keyname.size()>0){
+                                unsigned char bpos_i=findcolpos(keyname);
+ #ifdef DEBUG
+                    if (bpos_i == 255)
+                    {
+                        std::cout << "\033[1m\033[31m-----------\n"
+                                  << keyname << " not in " << tablename << " table Field.\n-----------\033[0m"
+                                  << std::endl;
+                    }
+#endif                                       
+                                keypos.emplace_back(bpos_i); 
+                                keyname.clear();
+                 }
+                 for(jj=0;jj<keypos.size();jj++){
+                       switch(keypos[jj]){
+
+         case 0:
+ if(jj>0){ tempsql<<","; } 
+if(data.id==0){
+	tempsql<<"`id`=0";
+ }else{ 
+	tempsql<<"`id`="<<std::to_string(data.id);
+}
+ break;
+ case 1:
+ if(jj>0){ tempsql<<","; } 
+if(data.randomnumber==0){
+	tempsql<<"`randomnumber`=0";
+ }else{ 
+	tempsql<<"`randomnumber`="<<std::to_string(data.randomnumber);
+}
+ break;
+
+     
+                  default:
+                                ;
+                     }
+                 }   
+
+            }        
+
+        return tempsql.str();
+   } 
+   
+    std::string _make_replace_into_sql()
+    {
+        unsigned int j = 0;
+        std::ostringstream tempsql;
+        tempsql << "REPLACE INTO ";
+        tempsql << tablename;
+        tempsql << " (";
+        for (; j < col_names.size(); j++)
+        {
+            if (j > 0)
+            {
+                tempsql << "`,`";
+            }
+            else
+            {
+                tempsql << "`";
+            }
+            tempsql << col_names[j];
+        }
+        if (j > 0)
+        {
+            tempsql << "`";
+        }
+        tempsql << ") VALUES ";
+
+        for (unsigned int i = 0; i < record.size(); i++)
+        {
+            if (i > 0)
+            {
+                tempsql << ",\n";
+            }
+            tempsql << "(";
+            	if(record[i].id==0){
+	tempsql<<"null";
+	 }else{ 
+	tempsql<<std::to_string(record[i].id);
+	}
+	if(record[i].randomnumber==0){
+	tempsql<<",0";
+	 }else{ 
+	tempsql<<","<<std::to_string(record[i].randomnumber);
+	}
+	tempsql<<")";
+
+ }
+ return tempsql.str();
+}
+
+    std::string _make_insert_into_sql(const std::string &fileld)
+    {
+        unsigned int j = 0;
+        std::ostringstream tempsql;
+        tempsql << "INSERT INTO ";
+        tempsql << tablename;
+        tempsql << " (";
+        for (; j < col_names.size(); j++)
+        {
+            if (j > 0)
+            {
+                tempsql << "`,`";
+            }
+            else
+            {
+                tempsql << "`";
+            }
+            tempsql << col_names[j];
+        }
+        if (j > 0)
+        {
+            tempsql << "`";
+        }
+        tempsql << ") VALUES ";
+
+        for (unsigned int i = 0; i < record.size(); i++)
+        {
+            if (i > 0)
+            {
+                tempsql << ",\n";
+            }
+            tempsql << "(";
+            	if(record[i].id==0){
+	tempsql<<"null";
+	 }else{ 
+	tempsql<<std::to_string(record[i].id);
+	}
+	if(record[i].randomnumber==0){
+	tempsql<<",0";
+	 }else{ 
+	tempsql<<","<<std::to_string(record[i].randomnumber);
+	}
+	tempsql<<")";
+	 }
+	 tempsql<<" as new ON DUPLICATE KEY UPDATE ";
+
+     
+        std::string keyname;
+        unsigned char jj=0;
+        j=0;
+        if(fileld.size()>0){
+        for(;jj<fileld.size();jj++){
+            if(fileld[jj]==','){
+                if(findcolpos(keyname)<255)
+                {
+                    if(j>0)
+                    {
+                        tempsql<<",";
+                    }
+                    tempsql<<keyname;
+                    tempsql<<"=new.";
+                    tempsql<<keyname;
+                }
+                continue;   
+            }
+            if(fileld[jj]==0x20){
+                continue;   
+            }
+            keyname.push_back(fileld[jj]);
+
+        }  
+        if(keyname.size()>0){
+            if(findcolpos(keyname)<255)
+            {
+                if(j>0)
+                {
+                    tempsql<<",";
+                }
+                tempsql<<keyname;
+                tempsql<<"=new.";
+                tempsql<<keyname;
+                
+            }
+        }
+
+    } 
+ 
+ return tempsql.str();
+}
+
+   std::vector<std::string> data_toarray(std::string fileld=""){
+        std::vector<std::string> temparray;
+        std::string keyname;
+        unsigned char jj=0;
+        std::vector<unsigned char> keypos;
+        if(fileld.size()>1){
+            for(;jj<fileld.size();jj++){
+                if(fileld[jj]==','){
+                    keypos.emplace_back(findcolpos(keyname)); 
+                    keyname.clear();
+                    continue;   
+                }
+                if(fileld[jj]==0x20){
+
+                    continue;   
+                }
+                keyname.push_back(fileld[jj]);
+
+            }  
+            if(keyname.size()>0){
+                keypos.emplace_back(findcolpos(keyname)); 
+                keyname.clear();
+            }
+        }else{
+            for(jj=0;jj<col_names.size();jj++){
+                keypos.emplace_back(jj); 
+            }
+        }
+               
+            for(jj=0;jj<keypos.size();jj++){
+                switch(keypos[jj]){
+         case 0:
+if(data.id==0){
+	temparray.push_back("0");
+ }else{ 
+	temparray.push_back(std::to_string(data.id));
+}
+ break;
+ case 1:
+if(data.randomnumber==0){
+	temparray.push_back("0");
+ }else{ 
+	temparray.push_back(std::to_string(data.randomnumber));
+}
+ break;
+
+                             default:
+                                ;
+                     }
+                 }   
+   
+     return temparray;             
+   }   
+   
+   std::map<std::string,std::string> data_tomap(std::string fileld=""){
+       std::map<std::string,std::string> tempsql;
+        std::string keyname;
+        unsigned char jj=0;
+        std::vector<unsigned char> keypos;
+        if(fileld.size()>1){
+        for(;jj<fileld.size();jj++){
+            if(fileld[jj]==','){
+                keypos.emplace_back(findcolpos(keyname)); 
+                keyname.clear();
+                continue;   
+            }
+            if(fileld[jj]==0x20){
+
+                continue;   
+            }
+            keyname.push_back(fileld[jj]);
+
+        }  
+        if(keyname.size()>0){
+            keypos.emplace_back(findcolpos(keyname)); 
+            keyname.clear();
+        }
+        }else{
+            for(jj=0;jj<col_names.size();jj++){
+                keypos.emplace_back(jj); 
+            }
+        }
+    
+        for(jj=0;jj<keypos.size();jj++){
+            switch(keypos[jj]){
+         case 0:
+if(data.id==0){
+	tempsql.insert({"id","0"});
+ }else{ 
+	tempsql.insert({"id",std::to_string(data.id)});
+}
+ break;
+ case 1:
+if(data.randomnumber==0){
+	tempsql.insert({"randomnumber","0"});
+ }else{ 
+	tempsql.insert({"randomnumber",std::to_string(data.randomnumber)});
+}
+ break;
+
+                             default:
+                                ;
+                     }
+                 }   
+    
+     return tempsql;             
+   }   
+   
+   std::string data_tojson(){
+       std::ostringstream tempsql;
+
+        tempsql<<"{";
+if(data.id==0){
+	tempsql<<"\"id\":0";
+ }else{ 
+	tempsql<<"\"id\":"<<std::to_string(data.id);
+}
+if(data.randomnumber==0){
+	tempsql<<",\"randomnumber\":0";
+ }else{ 
+	tempsql<<",\"randomnumber\":"<<std::to_string(data.randomnumber);
+}
+tempsql<<"}";
+
+     
+     return tempsql.str();             
+   }   
+   
+   std::string data_tojson(std::string fileld){
+        std::ostringstream tempsql;
+        std::string keyname;
+        unsigned char jj=0;
+        std::vector<unsigned char> keypos;
+        if(fileld.size()>0){
+        for(;jj<fileld.size();jj++){
+            if(fileld[jj]==','){
+                keypos.emplace_back(findcolpos(keyname)); 
+                keyname.clear();
+                continue;   
+            }
+            if(fileld[jj]==0x20){
+
+                continue;   
+            }
+            keyname.push_back(fileld[jj]);
+
+        }  
+        if(keyname.size()>0){
+            keypos.emplace_back(findcolpos(keyname)); 
+            keyname.clear();
+        }
+        }else{
+            for(jj=0;jj<col_names.size();jj++){
+                keypos.emplace_back(jj); 
+            }
+        }
+        tempsql<<"{";
+        for(jj=0;jj<keypos.size();jj++){
+            switch(keypos[jj]){
+         case 0:
+ if(jj>0){ tempsql<<","; } 
+if(data.id==0){
+	tempsql<<"\"id\":0";
+ }else{ 
+	tempsql<<"\"id\":"<<std::to_string(data.id);
+}
+ break;
+ case 1:
+ if(jj>0){ tempsql<<","; } 
+if(data.randomnumber==0){
+	tempsql<<"\"randomnumber\":0";
+ }else{ 
+	tempsql<<"\"randomnumber\":"<<std::to_string(data.randomnumber);
+}
+ break;
+
+                             default:
+                                ;
+                     }
+                 }   
+      tempsql<<"}";  
+     return tempsql.str();             
+   }   
+   
+    void from_json(const std::string &json_content)
+   {
+        record.clear();
+        worldbase::meta metatemp; 
+        data=metatemp;
+        unsigned int json_offset=0;
+        bool isarray=false;
+        //std::vector<std::string> list_content;
+        for(;json_offset<json_content.size();json_offset++)
+        {
+            if(json_content[json_offset]=='{')
+            {
+                break;
+            }
+            if(json_content[json_offset]=='[')
+            {
+                isarray=true;
+                break;
+            }
+        }
+        if(isarray)
+        {
+            json_offset+=1; 
+            std::string json_key_name,json_value_name; 
+            for(;json_offset<json_content.size();json_offset++)
+            {
+                for(;json_offset<json_content.size();json_offset++)
+                {
+                    if(json_content[json_offset]=='{')
+                    {
+                        json_offset+=1;
+                        break;
+                    }
+                }
+                if(record.size()>0)
+                {
+                    data=metatemp;
+                }
+                if(json_offset>=json_content.size())
+                {
+                    break;
+                }
+                for(;json_offset<json_content.size();json_offset++)
+                {
+    
+                            if(json_content[json_offset]==0x20||json_content[json_offset]==0x0A||json_content[json_offset]==0x0D||json_content[json_offset]=='\t')
+                            {
+                                continue;
+                            }
+                            else
+                            {
+                                if(json_content[json_offset]==0x22)
+                                {
+                                    unsigned int temp_offset=json_offset;
+                                    json_key_name=http::jsonstring_to_utf8(&json_content[json_offset],json_content.size()-json_offset,temp_offset);
+                                    json_offset=temp_offset;
+                                    if(json_content[json_offset]==0x22)
+                                    {
+                                        json_offset+=1;
+                                    }
+                                    for(;json_offset<json_content.size();json_offset++)
+                                    {
+                                    
+                                        if(json_content[json_offset]==0x20||json_content[json_offset]==0x0A||json_content[json_offset]==0x0D||json_content[json_offset]=='\t')
+                                        {
+                                            continue;
+                                        }
+                                        break;
+                                    }       
+                                    if(json_content[json_offset]!=':')
+                                    {
+                                        break;
+                                    }
+                                    for(;json_offset<json_content.size();json_offset++)
+                                    {
+                                        if(json_content[json_offset]==0x20||json_content[json_offset]==0x0A||json_content[json_offset]==0x0D||json_content[json_offset]=='\t')
+                                        {
+                                            continue;
+                                        }
+                                        break;
+                                    } 
+                                    json_offset+=1;
+                                    if(json_offset>=json_content.size())
+                                    {
+                                        break;
+                                    }
+                                    json_value_name.clear();
+                                    if(json_content[json_offset]==0x22)
+                                    {
+                                        
+                                        temp_offset=json_offset;
+                                        json_value_name=http::jsonstring_to_utf8(&json_content[json_offset],json_content.size()-json_offset,temp_offset);
+                                        json_offset=temp_offset;
+                                        if(json_content[json_offset]==0x22)
+                                        {
+                                            json_offset+=1;
+                                        }
+                                    }
+                                    else
+                                    {
+                                        if(json_content[json_offset]!='{'&&json_content[json_offset]!=']')
+                                        {
+                                            for(;json_offset<json_content.size();json_offset++)
+                                            {
+                                                if(json_content[json_offset]==0x5D||json_content[json_offset]==0x7D||json_content[json_offset]==0x22||json_content[json_offset]==0x2C||json_content[json_offset]==0x20||json_content[json_offset]==0x0A||json_content[json_offset]==0x0D||json_content[json_offset]=='\t')
+                                                {
+                                                    if(json_content[json_offset]==0x7D)
+                                                    {
+                                                        json_offset-=1;
+                                                    } 
+                                                    break;
+                                                }
+                                                json_value_name.push_back(json_content[json_offset]);
+                                            }   
+                                        }
+                                    }
+                                    //////////////////////////
+                                    set_val(json_key_name,json_value_name);
+                                    continue;
+                                }
+                                else
+                                {
+                                    break;
+                                }
+                            }
+    
+                }
+                record.emplace_back(data);
+                
+                json_offset+=1;
+            }
+            if(record.size()>1)
+            {
+                data=record[0];
+            }
+        }
+        else
+        {
+           if(json_content[json_offset]=='{')
+            {
+                json_offset+=1; 
+                std::string json_key_name,json_value_name; 
+                 
+                
+                for(;json_offset<json_content.size();json_offset++)
+                {
+ 
+                        if(json_content[json_offset]==0x20||json_content[json_offset]==0x0A||json_content[json_offset]==0x0D||json_content[json_offset]=='\t')
+                        {
+                            continue;
+                        }
+                        else
+                        {
+                            if(json_content[json_offset]==0x22)
+                            {
+                                 unsigned int temp_offset=json_offset;
+                                 json_key_name=http::jsonstring_to_utf8(&json_content[json_offset],json_content.size()-json_offset,temp_offset);
+                                 json_offset=temp_offset;
+                                 if(json_content[json_offset]==0x22)
+                                 {
+                                    json_offset+=1;
+                                 }
+                                for(;json_offset<json_content.size();json_offset++)
+                                {
+                                
+                                    if(json_content[json_offset]==0x20||json_content[json_offset]==0x0A||json_content[json_offset]==0x0D||json_content[json_offset]=='\t')
+                                    {
+                                        continue;
+                                    }
+                                    break;
+                                }       
+                                if(json_content[json_offset]!=':')
+                                {
+                                    break;
+                                }
+                                for(;json_offset<json_content.size();json_offset++)
+                                {
+                                    if(json_content[json_offset]==0x20||json_content[json_offset]==0x0A||json_content[json_offset]==0x0D||json_content[json_offset]=='\t')
+                                    {
+                                        continue;
+                                    }
+                                    break;
+                                } 
+                                json_offset+=1;
+                                if(json_offset>=json_content.size())
+                                {
+                                    break;
+                                }
+                                json_value_name.clear();
+                                if(json_content[json_offset]==0x22)
+                                {
+                                    
+                                    temp_offset=json_offset;
+                                    json_value_name=http::jsonstring_to_utf8(&json_content[json_offset],json_content.size()-json_offset,temp_offset);
+                                    json_offset=temp_offset;
+                                    if(json_content[json_offset]==0x22)
+                                    {
+                                        json_offset+=1;
+                                    }
+                                }
+                                else
+                                {
+                                    if(json_content[json_offset]!='{'&&json_content[json_offset]!=']')
+                                    {
+                                        for(;json_offset<json_content.size();json_offset++)
+                                        {
+                                            if(json_content[json_offset]==0x5D||json_content[json_offset]==0x7D||json_content[json_offset]==0x22||json_content[json_offset]==0x2C||json_content[json_offset]==0x20||json_content[json_offset]==0x0A||json_content[json_offset]==0x0D||json_content[json_offset]=='\t')
+                                            {
+                                               if(json_content[json_offset]==0x7D)
+                                               {
+                                                   json_offset-=1;
+                                               } 
+                                               break;
+                                            }
+                                            json_value_name.push_back(json_content[json_offset]);
+                                        }   
+                                    }
+                                }
+                                //////////////////////////
+                                set_val(json_key_name,json_value_name);
+                                continue;
+                            }
+                            else
+                            {
+                                break;
+                            }
+                        }
+ 
+                }
+                record.emplace_back(data);
+            } 
+        }
+   }   
+    
+    void set_val(const std::string& set_key_name,const std::string& set_value_name)
+    {
+        switch(findcolpos(set_key_name))
+        {
+    		case 0:
+		 try{
+			data.id=std::stoul(set_value_name);
+		}catch (...) { 
+			data.id=0;
+			 }
+			break;
+		case 1:
+		 try{
+			data.randomnumber=std::stoi(set_value_name);
+		}catch (...) { 
+			data.randomnumber=0;
+			 }
+			break;
+	default:
+		 { }
+			
+
+
+        }
+   } 
+    
+    void set_val(const std::string& set_key_name,const long long set_value_name)
+    {
+        switch(findcolpos(set_key_name))
+        {
+    		case 0:
+		 try{
+			data.id=set_value_name;
+		}catch (...) { 
+			data.id=0;
+			 }
+			break;
+		case 1:
+		 try{
+			data.randomnumber=set_value_name;
+		}catch (...) { 
+			data.randomnumber=0;
+			 }
+			break;
+	default:
+		 { }
+			
+
+
+        }
+   } 
+    
+    void set_val(const std::string& set_key_name,const double set_value_name)
+    {
+        switch(findcolpos(set_key_name))
+        {
+    		case 0:
+		 try{
+			data.id=(unsigned int)set_value_name;
+		}catch (...) { 
+			data.id=0;
+			 }
+			break;
+		case 1:
+		 try{
+			data.randomnumber=(int)set_value_name;
+		}catch (...) { 
+			data.randomnumber=0;
+			 }
+			break;
+	default:
+		 { }
+			
+
+
+        }
+   } 
+    
+   std::string to_json(std::string fileld=""){
+    std::ostringstream tempsql;
+    std::string keyname;
+    unsigned char jj=0;
+    std::vector<unsigned char> keypos;
+    if(fileld.size()>0){
+        for(;jj<fileld.size();jj++){
+            if(fileld[jj]==','){
+                keypos.emplace_back(findcolpos(keyname)); 
+                keyname.clear();
+                continue;   
+            }
+            if(fileld[jj]==0x20){
+
+                continue;   
+            }
+            keyname.push_back(fileld[jj]);
+
+        }  
+        if(keyname.size()>0){
+            keypos.emplace_back(findcolpos(keyname)); 
+            keyname.clear();
+        }
+    }else{
+        for(jj=0;jj<col_names.size();jj++){
+            keypos.emplace_back(jj); 
+        }
+    }
+    tempsql<<"[";
+    for(size_t n=0;n<record.size();n++){
+        if(n>0){
+            tempsql<<",{";
+        }else{
+            tempsql<<"{";
+        }  
+    
+        for(jj=0;jj<keypos.size();jj++){
+            switch(keypos[jj]){
+         case 0:
+ if(jj>0){ tempsql<<","; } 
+if(record[n].id==0){
+	tempsql<<"\"id\":0";
+ }else{ 
+	tempsql<<"\"id\":"<<std::to_string(record[n].id);
+}
+ break;
+ case 1:
+ if(jj>0){ tempsql<<","; } 
+if(record[n].randomnumber==0){
+	tempsql<<"\"randomnumber\":0";
+ }else{ 
+	tempsql<<"\"randomnumber\":"<<std::to_string(record[n].randomnumber);
+}
+ break;
+
+                             default:
+                                ;
+                     }
+                 }   
+      tempsql<<"}";  
+            }
+      tempsql<<"]";
+     return tempsql.str();             
+   }   
+   
+   std::string to_json(std::function<bool(std::string&,meta&)> func,std::string fileld=""){
+       std::ostringstream tempsql;
+        std::string keyname;
+        unsigned char jj=0;
+        std::vector<unsigned char> keypos;
+        if(fileld.size()>0){
+            for(;jj<fileld.size();jj++){
+                if(fileld[jj]==','){
+                    keypos.emplace_back(findcolpos(keyname)); 
+                    keyname.clear();
+                    continue;   
+                }
+                if(fileld[jj]==0x20){
+
+                    continue;   
+                }
+                keyname.push_back(fileld[jj]);
+
+            }  
+            if(keyname.size()>0){
+                keypos.emplace_back(findcolpos(keyname)); 
+                keyname.clear();
+            }
+        }else{
+            for(jj=0;jj<col_names.size();jj++){
+                keypos.emplace_back(jj); 
+            }
+        }
+        tempsql<<"[";
+        for(size_t n=0;n<record.size();n++){
+            keyname.clear();
+            if(func(keyname,record[n])){ 
+                if(n>0){
+                    tempsql<<",{";
+                }else{
+                    tempsql<<"{";
+                } 
+                tempsql<<keyname;
+            }else{
+            continue;
+            } 
+        
+        for(jj=0;jj<keypos.size();jj++){
+            
+            switch(keypos[jj]){
+         case 0:
+ if(jj>0){ tempsql<<","; } 
+if(record[n].id==0){
+	tempsql<<"\"id\":0";
+ }else{ 
+	tempsql<<"\"id\":"<<std::to_string(record[n].id);
+}
+ break;
+ case 1:
+ if(jj>0){ tempsql<<","; } 
+if(record[n].randomnumber==0){
+	tempsql<<"\"randomnumber\":0";
+ }else{ 
+	tempsql<<"\"randomnumber\":"<<std::to_string(record[n].randomnumber);
+}
+ break;
+
+                             default:
+                                ;
+                     }
+                 }   
+      tempsql<<"}";  
+            }
+      tempsql<<"]";
+     return tempsql.str();             
+   }   
+   long long getPK(){  return data.id; } 
+ void setPK(long long val){  data.id=val;} 
+ unsigned  int  getId(){  return data.id; } 
+ void setId( unsigned  int  val){  data.id=val;} 
+
+ int  getRandomnumber(){  return data.randomnumber; } 
+ void setRandomnumber( int  val){  data.randomnumber=val;} 
+
+worldbase::meta getnewData(){
+ 	 struct meta newdata;
+	 return newdata; 
+} 
+worldbase::meta getData(){
+ 	 return data; 
+} 
+std::vector<worldbase::meta> getRecord(){
+ 	 return record; 
+} 
+
+
+    template<typename T, typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true>
+    T& ref_meta([[maybe_unused]] std::string key_name)
+    {
+   		return nullptr; 
+	}
+
+
+    template<typename T, typename std::enable_if<std::is_integral_v<T>,bool>::type = true>
+    T& ref_meta([[maybe_unused]] std::string key_name)
+    {
+   		 if(key_name=="id")
+		{
+			return data.id;
+		}
+		 if(key_name=="randomnumber")
+		{
+			return data.randomnumber;
+		}
+		return nullptr; 
+	}
+
+
+    template<typename T, typename std::enable_if<std::is_floating_point_v<T>,bool>::type = true >
+    T& ref_meta([[maybe_unused]] std::string key_name)
+    {
+   		return nullptr; 
+	}
+
+            template<typename T, typename std::enable_if<std::is_integral_v<T>,bool>::type = true >  
+            std::vector<T> getCol([[maybe_unused]] std::string keyname)
+            {
+                std::vector<T> a;
+                
+   
+                unsigned char kpos;
+                kpos=findcolpos(keyname);               
+                for(auto &iter:record)
+                {
+                    switch(kpos)
+                    {
+   			case 0: 
+ 				 a.emplace_back(iter.id);
+				 break;
+			case 1: 
+ 				 a.emplace_back(iter.randomnumber);
+				 break;
+
+                    }
+                }
+    
+                return a;
+            }
+    
+            template<typename T, typename std::enable_if<std::is_floating_point_v<T>,bool>::type = true >    
+			std::vector<T> getCol([[maybe_unused]] std::string keyname)
+			{
+				std::vector<T> a;
+				
+
+                return a;
+            }
+    
+            template<typename T, typename std::enable_if<std::is_integral_v<T>,bool>::type = true >   
+            T getVal([[maybe_unused]] std::string keyname)
+            {
+   
+                    unsigned char kpos;
+                    kpos=findcolpos(keyname);                   
+                    switch(kpos)
+                    {
+
+   			case 0: 
+ 				 return data.id;
+				 break;
+			case 1: 
+ 				 return data.randomnumber;
+				 break;
+			}
+                return 0;
+            }  
+    
+        template<typename T, typename std::enable_if<std::is_integral_v<T>,bool>::type = true > 
+        T getVal([[maybe_unused]] worldbase::meta & iter,[[maybe_unused]] std::string keyname)
+        {
+
+          
+            unsigned char kpos;
+            kpos=findcolpos(keyname);   
+            switch(kpos)
+            {
+   			case 0: 
+ 				 return iter.id;
+				 break;
+			case 1: 
+ 				 return iter.randomnumber;
+				 break;
+
+			}
+
+            return 0;
+        }  
+    
+            template<typename T, typename std::enable_if<std::is_floating_point_v<T>,bool>::type = true > 
+            T getVal(std::string keyname)
+            {
+                unsigned char kpos;
+                kpos=findcolpos(keyname);
+            
+                switch(kpos)
+                {
+
+    
+                    }
+                   
+    
+                    return 0.0;
+            }  
+    
+            template<typename T, typename std::enable_if<std::is_floating_point_v<T>,bool>::type = true > 
+            T getVal([[maybe_unused]] worldbase::meta & iter,std::string keyname)
+            {
+                unsigned char kpos;
+                kpos=findcolpos(keyname);
+                switch(kpos)
+                {
+   
+                }
+                 
+    
+            
+                return 0.0;
+            }  
+    
+            template<typename T, typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true > 
+            std::string getVal(std::string keyname)
+            {
+                unsigned char kpos;
+                kpos=findcolpos(keyname);
+        
+                switch(kpos)
+                {
+
+   
+                }
+                return "";
+            }  
+   
+            template<typename T, typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true > 
+            std::string getVal([[maybe_unused]] worldbase::meta & iter,std::string keyname)
+            {
+         
+                unsigned char kpos;
+                kpos=findcolpos(keyname);
+       
+                switch(kpos)
+                {
+
+   
+                }
+                
+    
+                 
+                return "";
+            }  
+     
+            template<typename T, typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true >   
+            std::vector<std::string> getCol([[maybe_unused]] std::string keyname)
+            {
+                std::vector<std::string> a;
+
+           
+
+        return a;
+    }
+     
+        std::string getstrCol(std::string keyname,[[maybe_unused]] bool isyinhao=false)
+        {
+            std::ostringstream a;
+    
+            unsigned char kpos;
+            kpos=findcolpos(keyname);   
+            int j=0;
+            if(isyinhao&&record.size()>0)
+            {
+                a<<'"';
+            }
+            for(auto &iter:record)
+            {
+                    if(j>0)
+                    {
+                        if(isyinhao)
+                        {
+                            a<<"\",\"";
+                        }else{
+                            a<<',';    
+                        }
+                    }
+                    switch(kpos)
+                    {
+
+   			case 0: 
+ 				 a<<std::to_string(iter.id);
+				 break;
+			case 1: 
+ 				 a<<std::to_string(iter.randomnumber);
+				 break;
+
+                    }
+                    j++;
+            } 
+            if(isyinhao&&j>0){
+                a<<'"';
+            }      
+    
+                return a.str();
+        }
+    
+    template<typename T,typename U,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true,typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true>     
+    std::map<std::string,std::string> getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+    {
+        std::map<std::string,std::string> a;
+         
+            return a;
+        } 
+    
+
+        template<typename T,typename U,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true, typename std::enable_if<std::is_floating_point<U>::value,bool>::type = true>    
+        std::map<std::string,U> getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+                std::map<std::string,U> a;
+         
+            return a;
+        } 
+    
+        template<typename T,typename U,typename std::enable_if<std::is_integral_v<T>,bool>::type = true, typename std::enable_if<std::is_floating_point<U>::value,bool>::type = true>       
+        std::map<T,U> getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,U> a;
+       
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);        
+            T ktemp;
+            U vtemp;
+            for(auto &iter:record)
+            {
+                switch(kpos)
+                {
+ 
+       case 0: 
+ 	 ktemp=iter.id;
+	 break;
+case 1: 
+ 	 ktemp=iter.randomnumber;
+	 break;
+	 } 
+ 		  switch(vpos){
+
+                }
+                if(ktemp.size()>0)
+                {
+                    a.emplace(ktemp,vtemp);
+                }
+            }       
+     
+        return a;
+    }  
+            template<typename T,typename U,typename std::enable_if<std::is_integral_v<T>,bool>::type = true, typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true>      
+            std::map<T,std::string> getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+            {
+                std::map<T,std::string> a;
+   
+                unsigned char kpos,vpos;
+                kpos=findcolpos(keyname);
+                vpos=findcolpos(valname);         
+                T ktemp;
+                std::string vtemp;
+                for(auto &iter:record)
+                {
+                    switch(kpos)
+                    {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			case 1: 
+ 				 ktemp=iter.randomnumber;
+				 break;
+			  }
+ 			switch(vpos){
+
+                    }
+                    if(ktemp.size()>0)
+                    {
+                        a.emplace(ktemp,vtemp);
+                    }
+                } 
+         
+                return a;
+            }     
+        
+        template<typename T,typename U, typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true>       
+        std::map<std::string,U> getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<std::string,U> a;
+   
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);            
+            std::string  ktemp;
+            U  vtemp;
+            for(auto &iter:record)
+            {
+                switch(kpos)
+                {
+
+   			  }
+ 			 switch(vpos){
+			case 0: 
+ 				 vtemp=iter.id;
+				 break;
+			case 1: 
+ 				 vtemp=iter.randomnumber;
+				 break;
+
+                }
+                if(ktemp.size()>0)
+                {
+                    a.emplace(ktemp,vtemp);
+                }
+            }       
+      
+        return a;
+    }  
+    
+        template<typename T,typename U, typename std::enable_if<std::is_integral_v<T>,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true>   
+        std::map<T,U> getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,U> a;
+    
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);            
+            T ktemp;
+            U vtemp;
+            for(auto &iter:record)
+            {
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			case 1: 
+ 				 ktemp=iter.randomnumber;
+				 break;
+			  }
+ 			switch(vpos){
+			case 0: 
+ 				 vtemp=iter.id;
+				 break;
+			case 1: 
+ 				 vtemp=iter.randomnumber;
+				 break;
+
+                }
+                if(ktemp.size()>0)
+                {
+                    a.emplace(ktemp,vtemp);
+                }
+            }       
+    
+            return a;
+        }   
+    
+        template<typename T, typename std::enable_if<std::is_integral_v<T>,bool>::type = true >         
+        std::map<T,meta> getmapRows([[maybe_unused]] std::string keyname)
+        {
+            std::map<T,meta> a;
+    
+            unsigned char kpos;
+            kpos=findcolpos(keyname);                        
+            for(auto &iter:record)
+            {
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 a.emplace(iter.id,iter);
+				 break;
+			case 1: 
+ 				 a.emplace(iter.randomnumber,iter);
+				 break;
+
+                }
+            }       
+     
+            return a;
+        }     
+    
+        template<typename T, typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true >    
+        std::map<std::string,meta> getmapRows([[maybe_unused]] std::string keyname)
+        {
+            std::map<std::string,meta> a;
+
+    
+
+        return a;
+    }
+    
+        template<typename T,typename U,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true, typename std::enable_if<std::is_floating_point<U>::value,bool>::type = true>  
+        std::vector<std::pair<std::string,U>> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::vector<std::pair<std::string,U>> a;
+   
+
+            return a;
+        }   
+    
+        template<typename T,typename U,typename std::enable_if<std::is_integral_v<T>,bool>::type = true, typename std::enable_if<std::is_floating_point<U>::value,bool>::type = true>    
+        std::vector<std::pair<T,U>> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+                std::vector<std::pair<T,U>> a;
+   
+                unsigned char kpos,vpos;
+                kpos=findcolpos(keyname);
+                vpos=findcolpos(valname);
+                T ktemp;
+                U vtemp;
+                for(auto &iter:record)
+                {
+                    switch(kpos)
+                    {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+			 break;
+			case 1: 
+ 				 ktemp=iter.randomnumber;
+			 break;
+			  }
+			 switch(vpos){
+
+                   }
+
+                   a.emplace_back(ktemp,vtemp);
+                }       
+
+    
+
+            return a;
+        }   
+    
+        template<typename T,typename U,typename std::enable_if<std::is_integral_v<T>,bool>::type = true, typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true>    
+        std::vector<std::pair<T,U>> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+                std::vector<std::pair<T,U>> a;
+
+   
+                unsigned char kpos,vpos;
+                kpos=findcolpos(keyname);
+                vpos=findcolpos(valname);
+                T ktemp;
+                U vtemp;
+                for(auto &iter:record)
+                {
+                    switch(kpos)
+                    {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			case 1: 
+ 				 ktemp=iter.randomnumber;
+				 break;
+			  }
+ 			switch(vpos){
+
+                   }
+
+                    a.emplace_back(ktemp,vtemp);
+                }       
+    
+            return a;
+        }  
+    
+        template<typename T,typename U, typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true>     
+        std::vector<std::pair<T,U>> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+                std::vector<std::pair<T,U>> a;
+   
+                unsigned char kpos,vpos;
+                kpos=findcolpos(keyname);
+                vpos=findcolpos(valname);                
+                T ktemp;
+                U vtemp;
+                for(auto &iter:record)
+                {
+                    
+                    switch(kpos)
+                    {
+
+   			  }
+ 			 switch(vpos){
+			case 0: 
+ 				 vtemp=iter.id;
+				 break;
+			case 1: 
+ 				 vtemp=iter.randomnumber;
+				 break;
+
+                   }
+                    a.emplace_back(ktemp,vtemp);
+                }       
+    
+            return a;
+        }  
+    
+        template<typename T,typename U, typename std::enable_if<std::is_integral_v<T>,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true>    
+        std::vector<std::pair<T,U>> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+                std::vector<std::pair<T,U>> a;
+   
+                unsigned char kpos,vpos;
+                kpos=findcolpos(keyname);
+                vpos=findcolpos(valname);
+                T ktemp;
+                U vtemp;
+                for(auto &iter:record)
+                {
+                    switch(kpos)
+                    {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			case 1: 
+ 				 ktemp=iter.randomnumber;
+				 break;
+			  }
+			 switch(vpos){
+			case 0: 
+ 				 vtemp=iter.id;
+				 break;
+			case 1: 
+ 				 vtemp=iter.randomnumber;
+				 break;
+
+                   }
+                    a.emplace_back(ktemp,vtemp);
+                }       
+      
+            return a;
+        }   
+    
+        template<typename T,typename U, typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true>     
+        std::vector<std::pair<T,U>> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+                std::vector<std::pair<T,U>> a;
+   
+            return a;
+        }  
+    
+        template<typename T, typename std::enable_if<std::is_integral_v<T>,bool>::type = true >   
+        std::vector<std::pair<T,meta>> getvecRows([[maybe_unused]] std::string keyname)
+        {
+            std::vector<std::pair<T,meta>> a;
+     
+            unsigned char kpos;
+            kpos=findcolpos(keyname);                  
+            for(auto &iter:record)
+            { 
+                switch(kpos)
+                {
+
+   case 0: 
+ 	 a.emplace_back(iter.id,iter);
+	 break;
+case 1: 
+ 	 a.emplace_back(iter.randomnumber,iter);
+	 break;
+
+                }
+            }       
+    
+        return a;
+    }
+        template<typename T, typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true >  
+        std::vector<std::pair<std::string,meta>> getvecRows([[maybe_unused]] std::string keyname)
+        {
+            std::vector<std::pair<std::string,meta>> a;
+      
+
+        return a;
+    }
+        template<typename T,typename U,typename D,typename std::enable_if<std::is_integral_v<T>,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true, typename std::enable_if<std::is_floating_point<D>::value,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+        {
+            std::map<T,std::map<U,std::vector<D>>> a;
+    
+            unsigned char kpos,vpos,dpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            dpos=findcolpos(dataname);      
+            T ktemp;
+            U vtemp;
+            for(auto &iter:record)
+            { 
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			case 1: 
+ 				 ktemp=iter.randomnumber;
+				 break;
+			  }
+
+			 switch(vpos){
+			case 0: 
+ 				 vtemp=iter.id;
+				 break;
+			case 1: 
+ 				 vtemp=iter.randomnumber;
+				 break;
+			  }
+
+			 switch(dpos){
+
+                }
+            }       
+
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename D,typename std::enable_if<std::is_integral_v<T>,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true, typename std::enable_if<std::is_integral_v<D>,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+        {
+            std::map<T,std::map<U,std::vector<D>>> a;
+    
+            unsigned char kpos,vpos,dpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            dpos=findcolpos(dataname);          
+            T ktemp;
+            U vtemp;
+            //D vtemp;
+
+            for(auto &iter:record)
+            {
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			case 1: 
+ 				 ktemp=iter.randomnumber;
+				 break;
+			  }
+
+			 switch(vpos){
+			case 0: 
+ 				 vtemp=iter.id;
+				 break;
+			case 1: 
+ 				 vtemp=iter.randomnumber;
+				 break;
+			  }
+
+			 switch(dpos){
+			case 0: 
+ 				 a[ktemp][vtemp].emplace_back(iter.id);
+				 break;
+			case 1: 
+ 				 a[ktemp][vtemp].emplace_back(iter.randomnumber);
+				 break;
+
+                }
+            }       
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename D,typename std::enable_if<std::is_integral_v<T>,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true, typename std::enable_if<std::is_same<D,std::string>::value,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+        {
+            std::map<T,std::map<U,std::vector<D>>> a;
+   
+            unsigned char kpos,vpos,dpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            dpos=findcolpos(dataname);       
+            T ktemp;
+            U vtemp;
+            // D dtemp;
+
+            for(auto &iter:record)
+            {
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			case 1: 
+ 				 ktemp=iter.randomnumber;
+				 break;
+				  }
+
+			 switch(vpos){
+			case 0: 
+ 				 vtemp=iter.id;
+				 break;
+			case 1: 
+ 				 vtemp=iter.randomnumber;
+				 break;
+			 }
+
+			 switch(dpos){
+
+                }
+            }       
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename D,typename std::enable_if<std::is_integral_v<T>,bool>::type = true, typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true, typename std::enable_if<std::is_floating_point<D>::value,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+        {
+                std::map<T,std::map<U,std::vector<D>>> a;
+   
+                unsigned char kpos,vpos,dpos;
+                kpos=findcolpos(keyname);
+                vpos=findcolpos(valname);
+                dpos=findcolpos(dataname);
+                T ktemp;
+                U vtemp;
+            // D dtemp;
+
+                for(auto &iter:record)
+                {
+                    
+                    switch(kpos)
+                    {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			case 1: 
+ 				 ktemp=iter.randomnumber;
+				 break;
+			 }
+
+			 switch(vpos){
+			  }
+
+			 switch(dpos){
+
+                   }
+                }       
+    
+            return a;
+        }
+    
+    template<typename T,typename U,typename D,typename std::enable_if<std::is_integral_v<T>,bool>::type = true, typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true, typename std::enable_if<std::is_integral_v<D>,bool>::type = true>    
+    std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+    {
+        std::map<T,std::map<U,std::vector<D>>> a;
+
+   
+        unsigned char kpos,vpos,dpos;
+        kpos=findcolpos(keyname);
+        vpos=findcolpos(valname);
+        dpos=findcolpos(dataname);             
+        T ktemp;
+        U vtemp;
+       // D dtemp;
+
+         for(auto &iter:record)
+         {
+            switch(kpos)
+            {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			case 1: 
+ 				 ktemp=iter.randomnumber;
+				 break;
+			 }
+
+			 switch(vpos){
+			 }
+
+			 switch(dpos){
+			case 0: 
+ 				 a[ktemp][vtemp].emplace_back(iter.id);
+				 break;
+			case 1: 
+ 				 a[ktemp][vtemp].emplace_back(iter.randomnumber);
+				 break;
+
+            }
+         }       
+    
+        return a;
+    }
+        template<typename T,typename U,typename D,typename std::enable_if<std::is_integral_v<T>,bool>::type = true, typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true, typename std::enable_if<std::is_same<D,std::string>::value,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+        {
+            std::map<T,std::map<U,std::vector<D>>> a;
+   
+            unsigned char kpos,vpos,dpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            dpos=findcolpos(dataname);
+            T ktemp;
+            U vtemp;
+            // D dtemp;
+
+            for(auto &iter:record)
+            { 
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			case 1: 
+ 				 ktemp=iter.randomnumber;
+				 break;
+			  }
+
+			 switch(vpos){
+			  }
+
+			 switch(dpos){
+
+                }
+            }       
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename D,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true, typename std::enable_if<std::is_floating_point<D>::value,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+        {
+                std::map<T,std::map<U,std::vector<D>>> a;
+   
+                unsigned char kpos,vpos,dpos;
+                kpos=findcolpos(keyname);
+                vpos=findcolpos(valname);
+                dpos=findcolpos(dataname);               
+                T ktemp;
+                U vtemp;
+                //D vtemp;
+                for(auto &iter:record)
+                {
+                    switch(kpos)
+                    {
+
+   			 }
+
+			 switch(vpos){
+			case 0: 
+ 				 vtemp=iter.id;
+				 break;
+			case 1: 
+ 				 vtemp=iter.randomnumber;
+				 break;
+			  }
+
+			 switch(dpos){
+
+                    }
+                }       
+    
+
+            return a;
+        }
+    
+        template<typename T,typename U,typename D,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true, typename std::enable_if<std::is_integral_v<D>,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+        {
+            std::map<T,std::map<U,std::vector<D>>> a;
+   
+            unsigned char kpos,vpos,dpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            dpos=findcolpos(dataname);            
+            T ktemp;
+            U vtemp;
+            //D vtemp;
+
+            for(auto &iter:record)
+            {
+                
+                switch(kpos)
+                {
+
+   			  }
+
+			 switch(vpos){
+			case 0: 
+ 				 vtemp=iter.id;
+				 break;
+			case 1: 
+ 				 vtemp=iter.randomnumber;
+				 break;
+			 }
+
+			 switch(dpos){
+			case 0: 
+ 				 a[ktemp][vtemp].emplace_back(iter.id);
+				 break;
+			case 1: 
+ 				 a[ktemp][vtemp].emplace_back(iter.randomnumber);
+				 break;
+
+                }
+            }       
+    
+            return a;
+        }
+    
+    template<typename T,typename U,typename D,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true, typename std::enable_if<std::is_same<D,std::string>::value,bool>::type = true>    
+    std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+    {
+        std::map<T,std::map<U,std::vector<D>>> a;
+
+   
+        unsigned char kpos,vpos,dpos;
+        kpos=findcolpos(keyname);
+        vpos=findcolpos(valname);
+        dpos=findcolpos(dataname);
+        T ktemp;
+        U vtemp;
+        // D dtemp;
+
+         for(auto &iter:record)
+         {
+             
+            switch(kpos)
+            {
+
+   			 }
+
+			switch(vpos){
+			case 0: 
+ 				 vtemp=iter.id;
+				 break;
+			case 1: 
+ 				 vtemp=iter.randomnumber;
+				 break;
+			 }
+
+			switch(dpos){
+
+            }
+         }       
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename D,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true, typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true, typename std::enable_if<std::is_floating_point<D>::value,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+        {
+            std::map<T,std::map<U,std::vector<D>>> a;
+   
+            return a;
+        }
+        template<typename T,typename U,typename D,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true, typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true, typename std::enable_if<std::is_integral_v<D>,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+        {
+            std::map<T,std::map<U,std::vector<D>>> a;
+   
+            unsigned char kpos,vpos,dpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            dpos=findcolpos(dataname);
+            T ktemp;
+            U vtemp;
+            // D dtemp;
+
+            for(auto &iter:record)
+            {
+                
+                switch(kpos)
+                {
+
+   			  }
+
+			 switch(vpos){
+			 }
+
+			 switch(dpos){
+			case 0: 
+ 				 a[ktemp][vtemp].emplace_back(iter.id);
+				 break;
+			case 1: 
+ 				 a[ktemp][vtemp].emplace_back(iter.randomnumber);
+				 break;
+
+                }
+            }       
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename D,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true, typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true, typename std::enable_if<std::is_same<D,std::string>::value,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<D>>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname)
+        {
+            std::map<T,std::map<U,std::vector<D>>> a;
+   
+            return a;
+        }
+    
+        template<typename T,typename U,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true, typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true>    
+        std::map<T,std::vector<U>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,std::vector<U>> a;
+
+   
+            return a;
+        }
+    
+        template<typename T,typename U,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true,typename std::enable_if<std::is_floating_point<U>::value,bool>::type = true>    
+        std::map<T,std::vector<U>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,std::vector<U>> a;
+   
+            return a;
+        }
+    
+        template<typename T,typename U,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true>    
+        std::map<T,std::vector<U>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,std::vector<U>> a;
+   
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            T ktemp;
+            //U vtemp;
+
+            for(auto &iter:record)
+            {
+                
+                switch(kpos)
+                {
+
+   			  }
+
+			 switch(vpos){
+			case 0: 
+ 				 a[ktemp].emplace_back(iter.id);
+				 break;
+			case 1: 
+ 				 a[ktemp].emplace_back(iter.randomnumber);
+				 break;
+
+                }
+            }       
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename std::enable_if<std::is_integral_v<T>,bool>::type = true, typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true>    
+        std::map<T,std::vector<U>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,std::vector<U>> a;
+   
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            T ktemp;
+            //U vtemp;
+
+            for(auto &iter:record)
+            {
+                
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			case 1: 
+ 				 ktemp=iter.randomnumber;
+				 break;
+			 }
+
+			 switch(vpos){
+
+                }
+            }       
+
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename std::enable_if<std::is_integral_v<T>,bool>::type = true,typename std::enable_if<std::is_floating_point<U>::value,bool>::type = true>    
+        std::map<T,std::vector<U>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,std::vector<U>> a;
+               
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            T ktemp;
+            //U vtemp;
+
+            for(auto &iter:record)
+            {
+                
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			case 1: 
+ 				 ktemp=iter.randomnumber;
+				 break;
+			  }
+
+			 switch(vpos){
+
+                }
+            }       
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename std::enable_if<std::is_integral_v<T>,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true>    
+        std::map<T,std::vector<U>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,std::vector<U>> a;
+   
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);
+            T ktemp;
+            //U vtemp;
+
+            for(auto &iter:record)
+            {
+                
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			case 1: 
+ 				 ktemp=iter.randomnumber;
+				 break;
+			 }
+
+			 switch(vpos){
+			case 0: 
+ 				 a[ktemp].emplace_back(iter.id);
+				 break;
+			case 1: 
+ 				 a[ktemp].emplace_back(iter.randomnumber);
+				 break;
+
+                }
+            }       
+    
+            return a;
+        }
+    
+        template<typename T,typename std::enable_if<std::is_integral_v<T>,bool>::type = true>    
+        std::map<T,std::vector<meta>> getgroupRows([[maybe_unused]] std::string keyname)
+        {
+            std::map<T,std::vector<meta>> a;
+   
+            unsigned char kpos;
+            kpos=findcolpos(keyname);
+
+            for(auto &iter:record)
+            {
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 a[iter.id].emplace_back(iter);
+				 break;
+			case 1: 
+ 				 a[iter.randomnumber].emplace_back(iter);
+				 break;
+
+                }
+            }       
+    
+            return a;
+        }
+    
+        template<typename T,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true>    
+        std::map<T,std::vector<meta>> getgroupRows([[maybe_unused]] std::string keyname)
+        {
+            std::map<T,std::vector<meta>> a;
+   
+            return a;
+        }
+    
+        template<typename T,typename U,typename D,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true, typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<meta>>> getgroupRows([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,std::map<U,std::vector<meta>>> a;
+   
+            return a;
+        }
+    
+        template<typename T,typename U,typename std::enable_if<std::is_same<T,std::string>::value,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<meta>>> getgroupRows([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,std::map<U,std::vector<meta>>> a;
+   
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);            
+            T ktemp;
+            
+            for(auto &iter:record)
+            {
+                
+                switch(kpos)
+                {
+
+   	  }
+
+ switch(vpos){
+			case 0: 
+ 				 a[ktemp][iter.id].emplace_back(iter);
+				 break;
+			case 1: 
+ 				 a[ktemp][iter.randomnumber].emplace_back(iter);
+				 break;
+
+                }
+            }       
+
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename std::enable_if<std::is_integral_v<U>,bool>::type = true,typename std::enable_if<std::is_integral_v<U>,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<meta>>> getgroupRows([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,std::map<U,std::vector<meta>>> a;
+   
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);        
+        T ktemp;
+        
+            for(auto &iter:record)
+            {
+                
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			case 1: 
+ 				 ktemp=iter.randomnumber;
+				 break;
+			 }
+
+			 switch(vpos){
+			case 0: 
+ 				 a[ktemp][iter.id].emplace_back(iter);
+				 break;
+			case 1: 
+ 				 a[ktemp][iter.randomnumber].emplace_back(iter);
+				 break;
+
+                }
+            }       
+    
+            return a;
+        }
+    
+        template<typename T,typename U,typename std::enable_if<std::is_integral_v<T>,bool>::type = true,typename std::enable_if<std::is_same<U,std::string>::value,bool>::type = true>    
+        std::map<T,std::map<U,std::vector<meta>>> getgroupRows([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname)
+        {
+            std::map<T,std::map<U,std::vector<meta>>> a;
+
+   
+            unsigned char kpos,vpos;
+            kpos=findcolpos(keyname);
+            vpos=findcolpos(valname);            
+            T ktemp;
+            
+            for(auto &iter:record)
+            {
+                
+                switch(kpos)
+                {
+
+   			case 0: 
+ 				 ktemp=iter.id;
+				 break;
+			case 1: 
+ 				 ktemp=iter.randomnumber;
+				 break;
+			  }
+
+			 switch(vpos){
+
+                }
+            }       
+    
+            return a;
+        }
+    
+  };
+    
+
+}
+#endif
+   

frameworks/C++/paozhu/paozhu_benchmark/orm/orm.h

@@ -0,0 +1,4 @@
+/*build this file time Tue, 20 Dec 2022 11:40:56 GMT*/
+
+#include "Fortune.h"
+#include "World.h"

frameworks/C++/paozhu/paozhu_benchmark/view/techempower/fortunes.html

@@ -0,0 +1,5 @@
+<!DOCTYPE html><html><head><title>Fortunes</title></head><body><table><tr><th>id</th><th>message</th></tr><%c
+    for(auto &a:obj["list"].as_array()){
+%><tr><td><%c echo<<a.second["id"].to_string(); %></td><td><%c echo<<a.second["message"].to_string(); %></td></tr><%c
+    }
+%></table></body></html>

frameworks/C++/paozhu/paozhu_benchmark/viewsrc/include/regviewmethod.hpp

@@ -0,0 +1,26 @@
+#ifndef __HTTP_REG_VIEW_METHOD_HPP
+#define __HTTP_REG_VIEW_METHOD_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include<string>
+#include<map>
+#include<functional>
+#include "request.h"
+#include "viewso_param.h"
+#include "viewmethold_reg.h"
+#include "viewsrc.h"
+
+namespace http
+{
+  void _initview_method_regto(VIEW_REG  &_viewmetholdreg)
+  {
+            	 //create time: Mon, 30 Dec 2024 15:45:45 GMT
+
+	_viewmetholdreg.emplace("techempower/fortunes",http::view::techempower::fortunes);
+
+	} 
+}
+#endif

frameworks/C++/paozhu/paozhu_benchmark/viewsrc/include/viewsrc.h

@@ -0,0 +1,26 @@
+#ifndef __HTTP_VIEWSRC_ALL_METHOD_H
+#define __HTTP_VIEWSRC_ALL_METHOD_H
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include<string>
+#include<map>
+#include<functional>
+#include "request.h"
+#include "viewso_param.h"
+
+namespace http { 
+namespace view { 
+
+namespace techempower{ 
+
+	std::string fortunes(const struct view_param &vinfo,http::OBJ_VALUE &obj);
+}
+
+
+}
+
+}
+#endif

frameworks/C++/paozhu/paozhu_benchmark/viewsrc/view/techempower/fortunes.cpp

@@ -0,0 +1,50 @@
+#include<iostream>
+#include <cstdio>
+#include <string>
+#include <sstream>
+#include <map> 
+#include <vector>
+#include <ctime>
+#include <array>
+#include <sys/stat.h>
+#include <cstdlib>
+#include "request.h"
+#include "datetime.h"
+#include "cookie.h"
+#include "urlcode.h"
+#include "loadviewso.h"
+#include "viewso_param.h"
+#include "http_so_common_api.h"
+#include "viewsrc.h"
+//g++ viewsrc/view/techempower/fortunes.cpp
+namespace http {
+
+namespace view {
+	namespace techempower{
+ 		 std::string fortunes([[maybe_unused]] const struct view_param &vinfo,[[maybe_unused]] http::OBJ_VALUE &obj)
+			{
+ 
+                     std::ostringstream echo;
+
+        
+ 			 echo<<"<!DOCTYPE html><html><head><title>Fortunes</title></head><body><table><tr><th>id</th><th>message</th></tr>";
+
+    for(auto &a:obj["list"].as_array()){
+
+ 			 echo<<"<tr><td>";
+ echo<<a.second["id"].to_string(); 
+ 			 echo<<"</td><td>";
+ echo<<a.second["message"].to_string(); 
+ 			 echo<<"</td></tr>";
+
+    }
+
+ 			 echo<<"</table></body></html>";
+
+                  return echo.str();
+             }
+
+         }
+        }
+       }
+    

frameworks/C++/paozhu/paozhu_benchmark/websockets/include/loopwebsockets.hpp

@@ -0,0 +1,66 @@
+#include <iostream>
+#include <memory>
+#include <string_view>
+
+#include "orm.h"
+#include "httppeer.h"
+#include "websockets.h"
+
+namespace http
+{
+
+class loopwebsockets : public websockets_api
+{
+  public:
+    unsigned int outcount = 0;
+    loopwebsockets(std::weak_ptr<http::httppeer> p) : websockets_api(4, 0, p) {}
+    ~loopwebsockets() { std::cout << "~loopwebsockets" << std::endl; }
+
+  public:
+    void onopen() { std::cout << "onopen" << std::endl; }
+    void onclose() { std::cout << "onclose" << std::endl; }
+    void onpong() {}
+    void pushloop()
+    {
+        std::shared_ptr<http::httppeer> peer = weakpeer.lock();
+        if (peer)
+        {
+            std::cout << "timeloop:" << std::endl;
+            std::string aa = "looptests";
+            std::string outhello;
+            peer->ws->makeWSText(aa, outhello);
+            peer->send(outhello);
+
+            //   peer->send(aa);
+            if (outcount == 4)
+            {
+                timeloop_num = 0;
+                outcount     = 0;
+                return;
+            }
+            outcount++;
+        }
+        else
+        {
+            std::cout << "peer is die!" << std::endl;
+        }
+    }
+    void onfiles(std::string_view filename) { std::cout << "--------onfiles:--------" << filename << std::endl; }
+    void onmessage(std::string_view data)
+    {
+        std::cout << "onmessage:" << data << std::endl;
+        std::shared_ptr<http::httppeer> peer = weak_peer.lock();
+        if (peer)
+        {
+            std::string outhello;
+            peer->ws->makeWSText(data, outhello);
+            peer->send(outhello);
+        }
+    }
+    static std::shared_ptr<loopwebsockets> create(std::weak_ptr<http::httppeer> p)
+    {
+        return std::make_shared<loopwebsockets>(p);
+    }
+};
+
+}// namespace http

frameworks/C++/paozhu/paozhu_benchmark/websockets/include/mywebsockets.hpp

@@ -0,0 +1,83 @@
+#include <iostream>
+#include <memory>
+#include <string_view>
+
+#include "orm.h"
+#include "httppeer.h"
+#include "websockets.h"
+#include "terminal_color.h"
+// g++ -shared -fPIC mywebsockets.cpp -o mywebsockets.so
+namespace http
+{
+
+class mywebsockets : public websockets_api
+{
+  public:
+    //    unsigned int timeloop_num;
+    //    unsigned char state;
+    unsigned int outcount = 0;
+    mywebsockets(std::weak_ptr<httppeer> p) : websockets_api(4, 0, p) {}
+    ~mywebsockets() { DEBUG_LOG(" ~mywebsockets "); }
+
+  public:
+    void onopen() { DEBUG_LOG(" onopen "); }
+    void onclose() { DEBUG_LOG(" onclose "); }
+    void onpong() {}
+    void pushloop()
+    {
+        std::shared_ptr<httppeer> peer = weak_peer.lock();
+        if (peer)
+        {
+            DEBUG_LOG(" timeloop ");
+            std::string aa = "This server push msg or subscribe msg";
+            std::string outhello;
+            peer->ws->makeWSText(aa.data(), aa.length(), outhello);
+            peer->send(outhello);
+
+            //   peer->send(aa);
+            if (outcount == 4)
+            {
+                timeloop_num = 0;
+                outcount     = 0;
+                return;
+            }
+            outcount++;
+        }
+        else
+        {
+            DEBUG_LOG(" peer is die! ");
+        }
+    }
+
+    void onfiles([[maybe_unused]] std::string_view filename) { DEBUG_LOG("onfiles %zu", filename.size()); }
+    void onmessage(std::string_view data)
+    {
+        std::ostringstream oss;
+        oss << std::this_thread::get_id();
+        oss << " onmessage:" << data << std::endl;
+        std::string temp = oss.str();
+        DEBUG_LOG("%s", temp.c_str());
+        std::shared_ptr<http::httppeer> peer = weak_peer.lock();
+        if (peer)
+        {
+            std::string outhello;
+            if(data=="html")
+            {
+               std::string html_data="<h3> Websocket test 测试h3 </h3>";
+               peer->ws->makeWSText(html_data, outhello); 
+            }
+            else
+            {
+                peer->ws->makeWSText(data, outhello);
+            }
+            
+            peer->send(outhello);
+        }
+    }
+    static std::shared_ptr<mywebsockets> create(std::weak_ptr<http::httppeer> p)
+    {
+        return std::make_shared<mywebsockets>(p);
+    }
+};
+
+}// namespace http

frameworks/C++/poco/README.md

@@ -0,0 +1,15 @@
+# POCO C++ Libraries Benchmarking Test
+
+- [POCO Github Repository](https://github.com/pocoproject/poco)
+- [POCO Website](https://pocoproject.org/)
+
+## Software Versions
+
+- [buildpack-deps noble](https://hub.docker.com/_/buildpack-deps)
+- [g++ 14](https://gcc.gnu.org/gcc-14/)
+- [c++17](https://en.cppreference.com/w/cpp/17)
+- [POCO 1.13.1](https://pocoproject.org/releases/poco-1.13.1/poco-1.13.1-all.zip)
+ 
+## Test URLs
+
+- `PLAINTEXT` - [http://127.0.0.1:8080/plaintext](http://127.0.0.1:8080/plaintext) 

frameworks/C++/poco/benchmark.cpp

@@ -6,6 +6,8 @@
 #include <Poco/Net/HTTPServerRequest.h>
 #include <Poco/Net/HTTPServerResponse.h>
 #include <Poco/Util/ServerApplication.h>
+#include <Poco/Timespan.h>
+#include <Poco/Thread.h>
 
 #include <iostream>
 #include <string>
@@ -15,7 +17,9 @@
 #define PLAIN_CONTENT_TYPE   "text/plain"
 #define RES_BODY             "Hello, World!"
 #define SERVER_NAME          "poco"
+#define MAX_CONNECTIONS      16384
 
+using namespace Poco;
 using namespace Poco::Net;
 using namespace Poco::Util;
 using namespace std;
@@ -58,7 +62,12 @@ protected:
         HTTPServerParams* hsp = new HTTPServerParams;
         hsp->setMaxThreads(stoi(args[1]));
         hsp->setKeepAlive(true);
-        HTTPServer s(new MyRequestHandlerFactory, ServerSocket(stoi(args[0]), 4000), hsp);
+        hsp->setMaxKeepAliveRequests(MAX_CONNECTIONS);
+        hsp->setMaxQueued(MAX_CONNECTIONS);
+        hsp->setThreadPriority(Thread::PRIO_HIGHEST);
+        ServerSocket socket(stoi(args[0]), MAX_CONNECTIONS);
+        socket.setBlocking(false);
+        HTTPServer s(new MyRequestHandlerFactory, socket, hsp);
         s.start();
         waitForTerminationRequest();
         s.stop();

frameworks/C++/poco/poco.dockerfile

@@ -1,11 +1,11 @@
-FROM buildpack-deps:xenial
+FROM buildpack-deps:noble
 
 RUN apt-get update -yqq && apt-get install -yqq software-properties-common unzip cmake
 
-RUN apt-get install -yqq g++-4.8 libjson0-dev
-RUN update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 50
+RUN apt-get install -yqq g++-14
+RUN update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-14 50
 
-ENV POCO_VERSION 1.6.1
+ENV POCO_VERSION 1.13.3
 ENV POCO_HOME /poco
 
 WORKDIR ${POCO_HOME}
@@ -20,10 +20,10 @@ ENV LD_LIBRARY_PATH ${POCO_HOME}/lib/Linux/x86_64
 
 COPY benchmark.cpp benchmark.cpp
 
-RUN g++-4.8 \
+RUN g++-14 \
     -O3 \
     -DNDEBUG \
-    -std=c++0x \
+    -std=c++17 \
     -o \
     poco \
     benchmark.cpp \

frameworks/C/h2o/src/event_loop.c

@@ -32,13 +32,16 @@
 #include <netinet/tcp.h>
 #include <openssl/ssl.h>
 #include <sys/socket.h>
+#include <sys/syscall.h>
 #include <sys/types.h>
 
 #include "error.h"
 #include "event_loop.h"
 #include "global_data.h"
 #include "thread.h"
+#include "utility.h"
 
+#define CONN_NUM_SAMPLE_PERIOD 2500
 #define DEFAULT_TCP_FASTOPEN_QUEUE_LEN 4096
 
 static void accept_connection(h2o_socket_t *listener, const char *err);
@@ -72,6 +75,7 @@ static void accept_connection(h2o_socket_t *listener, const char *err)
 				if (!sock)
 					break;
 
+				ctx->event_loop.accepted_conn_num++;
 				ctx->event_loop.conn_num++;
 				sock->on_close.cb = on_close_connection;
 				sock->on_close.data = &ctx->event_loop.conn_num;
@@ -277,11 +281,36 @@ static void start_accept_polling(const config_t *config,
 
 void event_loop(struct thread_context_t *ctx)
 {
+	uint64_t last_sample = 0;
+
 	while (!ctx->shutdown || ctx->event_loop.conn_num) {
 		h2o_evloop_run(ctx->event_loop.h2o_ctx.loop, INT32_MAX);
 		process_messages(&ctx->global_thread_data->h2o_receiver,
 		                 &ctx->event_loop.local_messages);
+
+		const uint64_t now = h2o_now(ctx->event_loop.h2o_ctx.loop);
+
+		if (now - last_sample > CONN_NUM_SAMPLE_PERIOD || last_sample > now) {
+			const size_t i = ctx->event_loop.conn_num_sample_idx;
+
+			ctx->event_loop.conn_num_sample[i] = ctx->event_loop.conn_num;
+			ctx->event_loop.conn_num_sample_idx =
+				(i + 1) % ARRAY_SIZE(ctx->event_loop.conn_num_sample);
+			last_sample = now;
+		}
 	}
+
+	flockfile(stdout);
+	printf("Thread %ld statistics:\nAccepted connections: %zu\nConnection number samples: %zu",
+	       syscall(SYS_gettid),
+	       ctx->event_loop.accepted_conn_num,
+	       *ctx->event_loop.conn_num_sample);
+
+	for (size_t i = 1; i < ARRAY_SIZE(ctx->event_loop.conn_num_sample); i++)
+		printf(",%zu", ctx->event_loop.conn_num_sample[i]);
+
+	putc_unlocked('\n', stdout);
+	funlockfile(stdout);
 }
 
 void free_event_loop(event_loop_t *event_loop, h2o_multithread_receiver_t *h2o_receiver)

frameworks/C/h2o/src/event_loop.h

@@ -27,6 +27,8 @@
 
 #include "global_data.h"
 
+#define CONN_NUM_SAMPLES 512
+
 typedef enum {
 	SHUTDOWN,
 	TASK
@@ -41,6 +43,9 @@ typedef struct {
 	h2o_accept_ctx_t h2o_accept_ctx;
 	h2o_context_t h2o_ctx;
 	h2o_linklist_t local_messages;
+	size_t accepted_conn_num;
+	size_t conn_num_sample[CONN_NUM_SAMPLES];
+	size_t conn_num_sample_idx;
 } event_loop_t;
 
 typedef struct {

frameworks/CSharp/appmpower/appmpower-odbc-my.dockerfile

@@ -1,4 +1,4 @@
-FROM mcr.microsoft.com/dotnet/sdk:8.0.100 AS build
+FROM mcr.microsoft.com/dotnet/sdk:9.0.100 AS build
 RUN apt-get update
 RUN apt-get -yqq install clang zlib1g-dev
 RUN apt-get update
@@ -8,12 +8,12 @@ COPY src .
 RUN dotnet publish -c Release -o out /p:Database=mysql
 
 # Construct the actual image that will run
-FROM mcr.microsoft.com/dotnet/aspnet:8.0.0 AS runtime
+FROM mcr.microsoft.com/dotnet/aspnet:9.0.0 AS runtime
 
 RUN apt-get update
 # The following installs standard versions unixodbc and pgsqlodbc
 # unixodbc still needs to be installed even if compiled locally
-RUN apt-get install -y unixodbc wget curl
+RUN apt-get install -y unixodbc-dev unixodbc wget curl
 RUN apt-get update
 
 WORKDIR /odbc
@@ -45,6 +45,8 @@ WORKDIR /app
 COPY --from=build /app/out ./
 
 RUN cp /usr/lib/libm* /app
+#RUN cp /usr/lib/aarch64-linux-gnu/libodbc* /app
+RUN cp /usr/lib/x86_64-linux-gnu/libodbc* /app
 
 EXPOSE 8080
 

frameworks/CSharp/appmpower/appmpower-odbc-pg.dockerfile

@@ -1,4 +1,4 @@
-FROM mcr.microsoft.com/dotnet/sdk:8.0.100 AS build
+FROM mcr.microsoft.com/dotnet/sdk:9.0.100 AS build
 RUN apt-get update
 RUN apt-get -yqq install clang zlib1g-dev libkrb5-dev libtinfo5
 
@@ -7,10 +7,10 @@ COPY src .
 RUN dotnet publish -c Release -o out /p:Database=postgresql
 
 # Construct the actual image that will run
-FROM mcr.microsoft.com/dotnet/aspnet:8.0.0 AS runtime
+FROM mcr.microsoft.com/dotnet/aspnet:9.0.0 AS runtime
 
 RUN apt-get update
-RUN apt-get install -y unixodbc odbc-postgresql
+RUN apt-get install -y unixodbc-dev unixodbc odbc-postgresql
 # unixodbc still needs to be installed even if compiled locally
 
 ENV PATH=/usr/local/unixODBC/bin:$PATH
@@ -27,6 +27,10 @@ ENV ASPNETCORE_URLS http://+:8080
 WORKDIR /app
 COPY --from=build /app/out ./
 
+#RUN cp /usr/lib/aarch64-linux-gnu/libodbc* /app
+RUN cp /usr/lib/x86_64-linux-gnu/libodbc* /app
+
+
 EXPOSE 8080
 
 ENTRYPOINT ["./appMpower"]

frameworks/CSharp/appmpower/appmpower.dockerfile

@@ -1,4 +1,4 @@
-FROM mcr.microsoft.com/dotnet/sdk:8.0.100 AS build
+FROM mcr.microsoft.com/dotnet/sdk:9.0.100 AS build
 RUN apt-get update
 RUN apt-get -yqq install clang zlib1g-dev libkrb5-dev libtinfo5
 
@@ -8,7 +8,7 @@ COPY src .
 RUN dotnet publish -c Release -o out
 
 # Construct the actual image that will run
-FROM mcr.microsoft.com/dotnet/aspnet:8.0.0 AS runtime
+FROM mcr.microsoft.com/dotnet/aspnet:9.0.0 AS runtime
 # Full PGO
 ENV DOTNET_TieredPGO 1 
 ENV DOTNET_TC_QuickJitForLoops 1 

frameworks/CSharp/appmpower/src/appMpower.Orm/NativeMethods.cs

@@ -17,6 +17,9 @@ public static class NativeMethods
 
     private readonly static WorldSerializer _worldSerializer = new WorldSerializer();
     private readonly static WorldsSerializer _worldsSerializer = new WorldsSerializer();
+    private readonly static FortunesSerializer _fortunesSerializer = new FortunesSerializer();
+    private static readonly byte[] _delimiter = new byte[] { 0xFF, 0xFF, 0xFF, 0xFF };
+
 
     [UnmanagedCallersOnly(EntryPoint = "Dbms")]
     public static void Dbms(int dbms)
@@ -66,6 +69,7 @@ public static class NativeMethods
         */
     }
 
+    /*
     [UnmanagedCallersOnly(EntryPoint = "Fortunes")]
     public static unsafe IntPtr Fortunes(int* length, IntPtr* handlePointer)
     {
@@ -81,6 +85,61 @@ public static class NativeMethods
 
         return byteArrayPointer;
     }
+    */
+
+    [UnmanagedCallersOnly(EntryPoint = "Fortunes")]
+    public static unsafe IntPtr Fortunes(int* length, IntPtr* handlePointer)
+    {
+        List<Fortune> fortunes = RawDb.LoadFortunesRows().GetAwaiter().GetResult(); 
+
+        int totalSize = 0;
+
+        foreach (var fortune in fortunes)
+        {
+            totalSize += sizeof(int) // for Id
+                       + Encoding.UTF8.GetByteCount(fortune.Message ?? "") // for Message
+                       + _delimiter.Length; // for delimiter
+        }
+
+        // Allocate the total buffer
+        byte[] buffer = new byte[totalSize];
+        int offset = 0;
+
+        // Write each object to the buffer
+        foreach (var fortune in fortunes)
+        {
+            // Write Id
+            BitConverter.TryWriteBytes(buffer.AsSpan(offset, sizeof(int)), fortune.Id);
+            offset += sizeof(int);
+
+            // Write Message
+            int descriptionLength = Encoding.UTF8.GetBytes(fortune.Message ?? "", buffer.AsSpan(offset));
+            offset += descriptionLength;
+
+            // Write Delimiter
+            _delimiter.CopyTo(buffer, offset);
+            offset += _delimiter.Length;
+        }
+
+        byte[] byteArray = buffer.ToArray();
+        *length = byteArray.Length; 
+
+        /*
+        var memoryStream = new MemoryStream();
+        using var utf8JsonWriter = new Utf8JsonWriter(memoryStream, _jsonWriterOptions);
+
+        _fortunesSerializer.Serialize(utf8JsonWriter, fortunes);
+
+        byte[] byteArray = memoryStream.ToArray();
+        *length = (int)utf8JsonWriter.BytesCommitted; 
+        */
+
+        GCHandle handle = GCHandle.Alloc(byteArray, GCHandleType.Pinned);
+        IntPtr byteArrayPointer = handle.AddrOfPinnedObject();
+        *handlePointer = GCHandle.ToIntPtr(handle);
+
+        return byteArrayPointer;
+    }
 
     [UnmanagedCallersOnly(EntryPoint = "Query")]
     public static unsafe IntPtr Query(int queries, int* length, IntPtr* handlePointer)

frameworks/CSharp/appmpower/src/appMpower.Orm/Serializers/FortunesSerializer.cs

@@ -0,0 +1,24 @@
+using System.Text.Json;
+using appMpower.Orm.Objects;
+
+namespace appMpower.Orm.Serializers
+{
+   public class FortunesSerializer : IJsonSerializer<List<Fortune>>
+   {
+      public void Serialize(Utf8JsonWriter utf8JsonWriter, List<Fortune> fortunes)
+      {
+         utf8JsonWriter.WriteStartArray();
+
+         foreach (Fortune fortune in fortunes)
+         {
+            utf8JsonWriter.WriteStartObject();
+            utf8JsonWriter.WriteNumber("id", fortune.Id);
+            utf8JsonWriter.WriteString("message", fortune.Message);
+            utf8JsonWriter.WriteEndObject();
+         }
+
+         utf8JsonWriter.WriteEndArray();
+         utf8JsonWriter.Flush();
+      }
+   }
+}

frameworks/CSharp/appmpower/src/appMpower.Orm/appMpower.Orm.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
 
     <PublishAot>true</PublishAot>
@@ -36,7 +36,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="System.Data.Odbc" Version="8.0.0" />
+    <PackageReference Include="System.Data.Odbc" Version="9.0.0" />
   </ItemGroup>
 
 </Project>

frameworks/CSharp/appmpower/src/appMpower/Middleware/FortunesMiddleware.cs

@@ -2,7 +2,11 @@ using System;
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
 using System.Text;
+using System.Text.Encodings.Web;
+using System.Text.Json;
+using System.Text.Unicode;
 using System.Threading.Tasks;
+using appMpower.Objects;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.Primitives;
@@ -11,11 +15,21 @@ namespace appMpower;
 
 public class FortunesMiddleware
 {
+    static readonly HtmlEncoder htmlEncoder = CreateHtmlEncoder();
+    static HtmlEncoder CreateHtmlEncoder()
+    {
+        var settings = new TextEncoderSettings(UnicodeRanges.BasicLatin, UnicodeRanges.Katakana, UnicodeRanges.Hiragana);
+        settings.AllowCharacter('\u2014'); // allow EM DASH through
+        return HtmlEncoder.Create(settings);
+    }
+
     private readonly static KeyValuePair<string, StringValues> _headerServer =
          new KeyValuePair<string, StringValues>("Server", new StringValues("k"));
     private readonly static KeyValuePair<string, StringValues> _headerContentType =
          new KeyValuePair<string, StringValues>("Content-Type", new StringValues("text/html; charset=UTF-8"));
 
+    private static readonly byte[] _delimiter = new byte[] { 0xFF, 0xFF, 0xFF, 0xFF };
+
     private readonly RequestDelegate _next;
 
     public FortunesMiddleware(RequestDelegate next)
@@ -27,6 +41,66 @@ public class FortunesMiddleware
     {
         if (httpContext.Request.Path.StartsWithSegments("/fortunes", StringComparison.Ordinal))
         {
+            int payloadLength;
+            IntPtr handlePointer; 
+
+            IntPtr bytePointer = NativeMethods.Fortunes(out payloadLength, out handlePointer);
+
+            /*
+            byte[] json = new byte[payloadLength];
+            Marshal.Copy(bytePointer, json, 0, payloadLength);
+            NativeMethods.FreeHandlePointer(handlePointer);
+
+            string s = Encoding.UTF8.GetString(json, 0, json.Length);
+
+            var options = new JsonSerializerOptions
+            {
+                PropertyNameCaseInsensitive = true
+            };
+
+            List<Fortune> fortunes = JsonSerializer.Deserialize<List<Fortune>>(s, options);
+
+            var response = httpContext.Response; 
+            response.Headers.Add(_headerServer);
+
+            var result = Results.Extensions.RazorSlice<Slices.Fortunes, List<Fortune>>(fortunes);
+            result.HtmlEncoder = htmlEncoder;
+
+            return result.ExecuteAsync(httpContext);
+            */
+
+            byte[] byteArray = new byte[payloadLength];
+            Marshal.Copy(bytePointer, byteArray, 0, payloadLength);
+
+            List<Fortune> fortunes = new List<Fortune>();
+
+            // Convert the byte array into segments split by the delimiter
+            int delimiterLength = _delimiter.Length;
+            int start = 0;
+            int index;
+
+            while ((index = FindDelimiterIndex(byteArray, _delimiter, start)) >= 0)
+            {
+                // Use a span over the segment of bytes for the current object
+                var objectDataSpan = new ReadOnlySpan<byte>(byteArray, start, index - start);
+                Fortune fortune = ConvertBytesToObject(objectDataSpan);
+                fortunes.Add(fortune);
+
+                // Move past the delimiter
+                start = index + delimiterLength;
+            }
+
+            NativeMethods.FreeHandlePointer(handlePointer);
+
+            var response = httpContext.Response; 
+            response.Headers.Add(_headerServer);
+
+            var result = Results.Extensions.RazorSlice<Slices.Fortunes, List<Fortune>>(fortunes);
+            result.HtmlEncoder = htmlEncoder;
+
+            return result.ExecuteAsync(httpContext);
+
+            /*
             var response = httpContext.Response; 
             response.Headers.Add(_headerServer);
             response.Headers.Add(_headerContentType);
@@ -43,10 +117,51 @@ public class FortunesMiddleware
                 new KeyValuePair<string, StringValues>("Content-Length", payloadLength.ToString()));
 
             return response.Body.WriteAsync(json, 0, payloadLength);
+            */
         }
 
         return _next(httpContext);
     }
+
+    private static int FindDelimiterIndex(byte[] array, byte[] delimiter, int startIndex)
+    {
+        int endIndex = array.Length - delimiter.Length;
+
+        for (int i = startIndex; i <= endIndex; i++)
+        {
+            bool isMatch = true;
+
+            for (int j = 0; j < delimiter.Length; j++)
+            {
+                if (array[i + j] != delimiter[j])
+                {
+                    isMatch = false;
+                    break;
+                }
+            }
+
+            if (isMatch)
+            {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    private static Fortune ConvertBytesToObject(ReadOnlySpan<byte> data)
+    {
+        int offset = 0;
+
+        // Read Id
+        int id = BitConverter.ToInt32(data.Slice(offset, sizeof(int)));
+        offset += sizeof(int);
+
+        // Read Message (remaining bytes in the span)
+        string message = Encoding.UTF8.GetString(data.Slice(offset));
+
+        return new Fortune(id, message);
+    }
 }
 
 public static class FortunesMiddlewareExtensions

frameworks/CSharp/appmpower/src/appMpower/Objects/Fortune.cs

@@ -0,0 +1,22 @@
+using System;
+
+namespace appMpower.Objects
+{
+   public struct Fortune : IComparable<Fortune>, IComparable
+   {
+      public Fortune(int id, string message)
+      {
+         Id = id;
+         Message = message;
+      }
+
+      public int Id { get; set; }
+
+      public string Message { get; set; }
+
+      public int CompareTo(object obj) => throw new InvalidOperationException("The non-generic CompareTo should not be used");
+
+      // Performance critical, using culture insensitive comparison
+      public int CompareTo(Fortune other) => string.CompareOrdinal(Message, other.Message);
+   }
+}

frameworks/CSharp/appmpower/src/appMpower/Slices/Fortunes.cshtml

@@ -0,0 +1,2 @@
+@inherits RazorSliceHttpResult<List<appMpower.Objects.Fortune>>
+<!DOCTYPE html><html><head><title>Fortunes</title></head><body><table><tr><th>id</th><th>message</th></tr>@foreach (var item in Model){<tr><td>@WriteNumber(item.Id, default, CultureInfo.InvariantCulture, false)</td><td>@item.Message</td></tr>}</table></body></html>

frameworks/CSharp/appmpower/src/appMpower/Slices/_ViewImports.cshtml

@@ -0,0 +1,10 @@
+@inherits RazorSliceHttpResult
+
+@using System.Globalization;
+@using Microsoft.AspNetCore.Razor;
+@using Microsoft.AspNetCore.Http.HttpResults;
+@using RazorSlices;
+@using appMpower.Objects;
+
+@tagHelperPrefix __disable_tagHelpers__:
+@removeTagHelper *, Microsoft.AspNetCore.Mvc.Razor

frameworks/CSharp/appmpower/src/appMpower/appMpower.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <OutputType>Exe</OutputType>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
@@ -24,6 +24,7 @@
 
   <ItemGroup>
     <ProjectReference Include = "..\appMpower.Orm\appMpower.Orm.csproj" />
+    <PackageReference Include="RazorSlices" Version="0.8.1" />
   </ItemGroup>
 
   <PropertyGroup>

frameworks/CSharp/aspnetcore/README.md

@@ -6,5 +6,5 @@ See [.NET Core](http://dot.net) and [ASP.NET Core](https://github.com/dotnet/asp
 
 **Language**
 
-* C# 8.0
+* C# 13.0
 

frameworks/CSharp/aspnetcore/benchmark_config.json

@@ -30,6 +30,7 @@
         "json_url": "/json",
         "db_url": "/db",
         "query_url": "/queries/",
+        "fortune_url": "/fortunes",
         "update_url": "/updates/",
         "cached_query_url": "/cached-worlds/",
         "port": 8080,

frameworks/CSharp/aspnetcore/src/Minimal/Minimal.csproj

@@ -9,7 +9,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Npgsql" Version="8.0.5" />
+    <PackageReference Include="Npgsql" Version="9.0.2" />
     <PackageReference Include="Dapper" Version="2.1.35" />
     <PackageReference Include="RazorSlices" Version="0.8.1" />
   </ItemGroup>

frameworks/CSharp/aspnetcore/src/Mvc/Mvc.csproj

@@ -9,8 +9,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Npgsql" Version="8.0.5" />
-    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="9.0.0-rc.2" />
+    <PackageReference Include="Npgsql" Version="9.0.2" />
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="9.0.2" />
   </ItemGroup>
 
 </Project>

frameworks/CSharp/aspnetcore/src/Platform/BenchmarkApplication.Caching.cs

@@ -6,7 +6,7 @@ using System.Threading.Tasks;
 
 namespace PlatformBenchmarks;
 
-public partial class BenchmarkApplication
+public sealed partial class BenchmarkApplication
 {
     private static async Task Caching(PipeWriter pipeWriter, int count)
     {

frameworks/CSharp/aspnetcore/src/Platform/BenchmarkApplication.Fortunes.cs

@@ -1,7 +1,7 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
-#if !AOT
+using System;
 using System.IO.Pipelines;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
@@ -9,7 +9,7 @@ using RazorSlices;
 
 namespace PlatformBenchmarks;
 
-public partial class BenchmarkApplication
+public sealed partial class BenchmarkApplication
 {
     private async Task FortunesRaw(PipeWriter pipeWriter)
     {
@@ -19,7 +19,7 @@ public partial class BenchmarkApplication
             FortunesTemplateFactory);
     }
 
-    private ValueTask OutputFortunes<TModel>(PipeWriter pipeWriter, TModel model, SliceFactory<TModel> templateFactory)
+    private ValueTask OutputFortunes<TModel>(PipeWriter pipeWriter, TModel model, Func<TModel, RazorSlice<TModel>> templateFactory)
     {
         // Render headers
         var preamble = """
@@ -39,7 +39,7 @@ public partial class BenchmarkApplication
         // Kestrel PipeWriter span size is 4K, headers above already written to first span & template output is ~1350 bytes,
         // so 2K chunk size should result in only a single span and chunk being used.
         var chunkedWriter = GetChunkedWriter(pipeWriter, chunkSizeHint: 2048);
-        var renderTask = template.RenderAsync(chunkedWriter, null, HtmlEncoder);
+        var renderTask = template.RenderAsync(chunkedWriter, HtmlEncoder);
 
         if (renderTask.IsCompletedSuccessfully)
         {
@@ -51,18 +51,17 @@ public partial class BenchmarkApplication
         return AwaitTemplateRenderTask(renderTask, chunkedWriter, template);
     }
 
-    private static async ValueTask AwaitTemplateRenderTask(ValueTask renderTask, ChunkedBufferWriter<WriterAdapter> chunkedWriter, RazorSlice template)
+    private static async ValueTask AwaitTemplateRenderTask(ValueTask renderTask, ChunkedPipeWriter chunkedWriter, RazorSlice template)
     {
         await renderTask;
         EndTemplateRendering(chunkedWriter, template);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void EndTemplateRendering(ChunkedBufferWriter<WriterAdapter> chunkedWriter, RazorSlice template)
+    private static void EndTemplateRendering(ChunkedPipeWriter chunkedWriter, RazorSlice template)
     {
-        chunkedWriter.End();
+        chunkedWriter.Complete();
         ReturnChunkedWriter(chunkedWriter);
         template.Dispose();
     }
 }
-#endif

frameworks/CSharp/aspnetcore/src/Platform/BenchmarkApplication.HttpConnection.cs

@@ -12,7 +12,7 @@ using Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http;
 
 namespace PlatformBenchmarks;
 
-public partial class BenchmarkApplication : IHttpConnection
+public sealed partial class BenchmarkApplication : IHttpConnection
 {
     private State _state;
 
@@ -193,15 +193,15 @@ public partial class BenchmarkApplication : IHttpConnection
         => new(new(pipeWriter), sizeHint);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static ChunkedBufferWriter<WriterAdapter> GetChunkedWriter(PipeWriter pipeWriter, int chunkSizeHint)
+    private static ChunkedPipeWriter GetChunkedWriter(PipeWriter pipeWriter, int chunkSizeHint)
     {
         var writer = ChunkedWriterPool.Get();
-        writer.SetOutput(new WriterAdapter(pipeWriter), chunkSizeHint);
+        writer.SetOutput(pipeWriter, chunkSizeHint);
         return writer;
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void ReturnChunkedWriter(ChunkedBufferWriter<WriterAdapter> writer) => ChunkedWriterPool.Return(writer);
+    private static void ReturnChunkedWriter(ChunkedPipeWriter writer) => ChunkedWriterPool.Return(writer);
 
     private struct WriterAdapter : IBufferWriter<byte>
     {

frameworks/CSharp/aspnetcore/src/Platform/BenchmarkApplication.Json.cs

@@ -9,7 +9,7 @@ using System.Threading.Tasks;
 
 namespace PlatformBenchmarks;
 
-public partial class BenchmarkApplication
+public sealed partial class BenchmarkApplication
 {
     private readonly static uint _jsonPayloadSize = (uint)JsonSerializer.SerializeToUtf8Bytes(
         new JsonMessage { message = "Hello, World!" },

frameworks/CSharp/aspnetcore/src/Platform/BenchmarkApplication.MultipleQueries.cs

@@ -8,7 +8,7 @@ using System.Text.Json.Serialization.Metadata;
 
 namespace PlatformBenchmarks;
 
-public partial class BenchmarkApplication
+public sealed partial class BenchmarkApplication
 {
     private static async Task MultipleQueries(PipeWriter pipeWriter, int count)
     {

frameworks/CSharp/aspnetcore/src/Platform/BenchmarkApplication.Plaintext.cs

@@ -7,7 +7,7 @@ using System.Threading.Tasks;
 
 namespace PlatformBenchmarks;
 
-public partial class BenchmarkApplication
+public sealed partial class BenchmarkApplication
 {
     private static ReadOnlySpan<byte> _plaintextPreamble =>
         "HTTP/1.1 200 OK\r\n"u8 +

frameworks/CSharp/aspnetcore/src/Platform/BenchmarkApplication.SingleQuery.cs

@@ -7,7 +7,7 @@ using System.Threading.Tasks;
 
 namespace PlatformBenchmarks;
 
-public partial class BenchmarkApplication
+public sealed partial class BenchmarkApplication
 {
     private static async Task SingleQuery(PipeWriter pipeWriter)
     {

frameworks/CSharp/aspnetcore/src/Platform/BenchmarkApplication.Updates.cs

@@ -7,7 +7,7 @@ using System.Threading.Tasks;
 
 namespace PlatformBenchmarks;
 
-public partial class BenchmarkApplication
+public sealed partial class BenchmarkApplication
 {
     private static async Task Updates(PipeWriter pipeWriter, int count)
     {

frameworks/CSharp/aspnetcore/src/Platform/BenchmarkApplication.cs

@@ -10,9 +10,8 @@ using System.Text.Json.Serialization;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http;
 using Microsoft.Extensions.ObjectPool;
-#if !AOT
+using Platform.Templates;
 using RazorSlices;
-#endif
 
 namespace PlatformBenchmarks
 {
@@ -42,26 +41,24 @@ namespace PlatformBenchmarks
 
         public static RawDb RawDb { get; set; }
 
-        private static readonly DefaultObjectPool<ChunkedBufferWriter<WriterAdapter>> ChunkedWriterPool
+        private static readonly DefaultObjectPool<ChunkedPipeWriter> ChunkedWriterPool
             = new(new ChunkedWriterObjectPolicy());
 
-        private sealed class ChunkedWriterObjectPolicy : IPooledObjectPolicy<ChunkedBufferWriter<WriterAdapter>>
+        private sealed class ChunkedWriterObjectPolicy : IPooledObjectPolicy<ChunkedPipeWriter>
         {
-            public ChunkedBufferWriter<WriterAdapter> Create() => new();
+            public ChunkedPipeWriter Create() => new();
 
-            public bool Return(ChunkedBufferWriter<WriterAdapter> writer)
+            public bool Return(ChunkedPipeWriter writer)
             {
                 writer.Reset();
                 return true;
             }
         }
 
-#if !AOT
 #if NPGSQL
-        private readonly static SliceFactory<List<FortuneUtf8>> FortunesTemplateFactory = RazorSlice.ResolveSliceFactory<List<FortuneUtf8>>("/Templates/FortunesUtf8.cshtml");
+        private readonly static Func<List<FortuneUtf8>, RazorSlice<List<FortuneUtf8>>> FortunesTemplateFactory = FortunesUtf8.Create;
 #else
-        private readonly static SliceFactory<List<FortuneUtf16>> FortunesTemplateFactory = RazorSlice.ResolveSliceFactory<List<FortuneUtf16>>("/Templates/FortunesUtf16.cshtml");
-#endif
+        private readonly static Func<List<FortuneUtf16>, RazorSlice<List<FortuneUtf16>>> FortunesTemplateFactory = FortunesUtf16.Create;
 #endif
 
         [ThreadStatic]
@@ -167,9 +164,7 @@ namespace PlatformBenchmarks
 
         private Task ProcessRequestAsync() => _requestType switch
         {
-#if !AOT
             RequestType.FortunesRaw => FortunesRaw(Writer),
-#endif
             RequestType.SingleQuery => SingleQuery(Writer),
             RequestType.Caching => Caching(Writer, _queries),
             RequestType.Updates => Updates(Writer, _queries),

frameworks/CSharp/aspnetcore/src/Platform/ChunkedBufferWriter.cs → frameworks/CSharp/aspnetcore/src/Platform/ChunkedPipeWriter.cs

@@ -5,35 +5,40 @@ using System;
 using System.Buffers;
 using System.Buffers.Text;
 using System.Diagnostics;
+using System.IO.Pipelines;
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace PlatformBenchmarks;
 
-internal sealed class ChunkedBufferWriter<TWriter> : IBufferWriter<byte> where TWriter : IBufferWriter<byte>
+internal sealed class ChunkedPipeWriter : PipeWriter
 {
     private const int DefaultChunkSizeHint = 2048;
     private static readonly StandardFormat DefaultHexFormat = GetHexFormat(DefaultChunkSizeHint);
     private static ReadOnlySpan<byte> ChunkTerminator => "\r\n"u8;
 
-    private TWriter _output;
+    private PipeWriter _output;
     private int _chunkSizeHint;
     private StandardFormat _hexFormat = DefaultHexFormat;
     private Memory<byte> _currentFullChunk;
     private Memory<byte> _currentChunk;
     private int _buffered;
+    private long _unflushedBytes;
     private bool _ended = false;
 
     public Memory<byte> Memory => _currentChunk;
 
-    public TWriter Output => _output;
+    public PipeWriter Output => _output;
 
     public int Buffered => _buffered;
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void SetOutput(TWriter output, int chunkSizeHint = DefaultChunkSizeHint)
+    public void SetOutput(PipeWriter output, int chunkSizeHint = DefaultChunkSizeHint)
     {
         _buffered = 0;
+        _unflushedBytes = 0;
         _chunkSizeHint = chunkSizeHint;
         _output = output;
 
@@ -44,6 +49,7 @@ internal sealed class ChunkedBufferWriter<TWriter> : IBufferWriter<byte> where T
     public void Reset()
     {
         _buffered = 0;
+        _unflushedBytes = 0;
         _output = default;
         _ended = false;
         _hexFormat = DefaultHexFormat;
@@ -51,16 +57,21 @@ internal sealed class ChunkedBufferWriter<TWriter> : IBufferWriter<byte> where T
         _currentChunk = default;
     }
 
+    public override bool CanGetUnflushedBytes => true;
+
+    public override long UnflushedBytes => _unflushedBytes;
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void Advance(int count)
+    public override void Advance(int count)
     {
         ThrowIfEnded();
 
         _buffered += count;
+        _unflushedBytes += count;
         _currentChunk = _currentChunk[count..];
     }
 
-    public Memory<byte> GetMemory(int sizeHint = 0)
+    public override Memory<byte> GetMemory(int sizeHint = 0)
     {
         ThrowIfEnded();
 
@@ -71,9 +82,14 @@ internal sealed class ChunkedBufferWriter<TWriter> : IBufferWriter<byte> where T
         return _currentChunk;
     }
 
-    public Span<byte> GetSpan(int sizeHint = 0) => GetMemory(sizeHint).Span;
+    public override Span<byte> GetSpan(int sizeHint = 0) => GetMemory(sizeHint).Span;
+
+    public override void CancelPendingFlush()
+    {
+        _output.CancelPendingFlush();
+    }
 
-    public void End()
+    public override void Complete(Exception exception = null)
     {
         ThrowIfEnded();
 
@@ -82,6 +98,17 @@ internal sealed class ChunkedBufferWriter<TWriter> : IBufferWriter<byte> where T
         _ended = true;
     }
 
+    public override ValueTask<FlushResult> FlushAsync(CancellationToken cancellationToken = default)
+    {
+        CommitCurrentChunk(isFinal: false);
+
+        var flushTask = _output.FlushAsync(cancellationToken);
+
+        _unflushedBytes = 0;
+
+        return flushTask;
+    }
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static StandardFormat GetHexFormat(int maxValue)
     {

frameworks/CSharp/aspnetcore/src/Platform/Platform.csproj

@@ -6,7 +6,6 @@
     <IsTestAssetProject>true</IsTestAssetProject>
     <LangVersion>preview</LangVersion>
     <UserSecretsId>38063504-d08c-495a-89c9-daaad2f60f31</UserSecretsId>
-    <DefineConstants Condition="'$(PublishAot)' == 'true'">AOT;$(DefineConstants)</DefineConstants>
   </PropertyGroup>
 
   <PropertyGroup>
@@ -19,14 +18,14 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Npgsql" Version="8.0.5" />
+    <PackageReference Include="Npgsql" Version="9.0.2" />
     <PackageReference Include="MySqlConnector" Version="2.3.7" />
     <PackageReference Include="Dapper" Version="2.1.35" />
-    <PackageReference Include="RazorSlices" Version="0.7.0" Condition="$(PublishAot) != 'true'" />
+    <PackageReference Include="RazorSlices" Version="0.8.1" />
   </ItemGroup>
 
-  <PropertyGroup Condition="$(PublishAot) == 'true'">
-    <DefaultItemExcludes>$(MSBuildThisFileDirectory)Templates/**;$(DefaultItemExcludes)</DefaultItemExcludes>
-  </PropertyGroup>
+  <ItemGroup Condition="$(PublishAot) == 'true'">
+    <RuntimeHostConfigurationOption Include="System.Threading.ThreadPool.HillClimbing.Disable" Value="true" />
+  </ItemGroup>
 
 </Project>

frameworks/CSharp/fastendpoints/Benchmarks/Benchmarks.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
     <NoWarn>CA2016;IDE1006</NoWarn>

frameworks/CSharp/fastendpoints/Benchmarks/Endpoints/JsonEndpoint.cs

@@ -1,6 +1,6 @@
 namespace Benchmarks.Endpoints;
 
-public sealed class JsonEndpoint : Endpoint<EmptyRequest, object>
+sealed class JsonEndpoint : Ep.NoReq.Res<object>
 {
     public override void Configure()
     {
@@ -8,9 +8,10 @@ public sealed class JsonEndpoint : Endpoint<EmptyRequest, object>
         AllowAnonymous();
     }
 
-    public override Task HandleAsync(EmptyRequest _, CancellationToken __)
+    public override Task HandleAsync(CancellationToken ct)
     {
         HttpContext.Response.ContentLength = 27;
+
         return SendAsync(new { message = "Hello, World!" });
     }
 }

frameworks/CSharp/fastendpoints/Benchmarks/Endpoints/PlainTextEndpoint.cs

@@ -1,8 +1,8 @@
 namespace Benchmarks.Endpoints;
 
-public sealed class PlainTextEndpoint : Endpoint<EmptyRequest, EmptyResponse>
+sealed class PlainTextEndpoint : Ep.NoReq.Res<byte[]>
 {
-    private static readonly byte[] payload = System.Text.Encoding.UTF8.GetBytes("Hello, World!");
+    static readonly byte[] _payload = "Hello, World!"u8.ToArray();
 
     public override void Configure()
     {
@@ -10,11 +10,12 @@ public sealed class PlainTextEndpoint : Endpoint<EmptyRequest, EmptyResponse>
         AllowAnonymous();
     }
 
-    public override Task HandleAsync(EmptyRequest _, CancellationToken __)
+    public override Task HandleAsync(CancellationToken ct)
     {
         HttpContext.Response.StatusCode = StatusCodes.Status200OK;
         HttpContext.Response.ContentType = "text/plain";
-        HttpContext.Response.ContentLength = payload.Length;
-        return HttpContext.Response.Body.WriteAsync(payload, 0, payload.Length);
+        HttpContext.Response.ContentLength = _payload.Length;
+
+        return HttpContext.Response.Body.WriteAsync(_payload, 0, _payload.Length);
     }
 }

frameworks/CSharp/fastendpoints/Benchmarks/Program.cs

@@ -1,9 +1,9 @@
 global using FastEndpoints;
 
-var builder = WebApplication.CreateBuilder();
-builder.Logging.ClearProviders();
-builder.Services.AddFastEndpoints();
+var bld = WebApplication.CreateBuilder();
+bld.Logging.ClearProviders();
+bld.Services.AddFastEndpoints();
 
-var app = builder.Build();
+var app = bld.Build();
 app.UseFastEndpoints();
-app.Run("http://0.0.0.0:8080");
+app.Run("http://0.0.0.0:8080");

frameworks/CSharp/fastendpoints/README.md

@@ -5,11 +5,11 @@ This includes tests for plaintext and json serialization.
 
 **Language**
 
-* C# 12.0
+* C# 13.0
 
 **Platforms**
 
-* .NET 8 (Windows and Linux)
+* .NET 9 (Windows and Linux)
 
 **Web Servers**
 
@@ -18,7 +18,7 @@ This includes tests for plaintext and json serialization.
 **Web Stack**
 
 * [FastEndpoints](https://fast-endpoints.com/)
-* ASP.NET 8
+* ASP.NET 9
 
 ## Paths & Source for Tests
 

frameworks/CSharp/fastendpoints/fastendpoints.dockerfile

@@ -1,9 +1,13 @@
-FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
+FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
 WORKDIR /app
 COPY Benchmarks .
 RUN dotnet publish -c Release -o out
 
-FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS runtime
+FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS runtime
+ENV DOTNET_GCDynamicAdaptationMode=0
+ENV DOTNET_ReadyToRun=0
+ENV DOTNET_HillClimbing_Disable=1
+
 WORKDIR /app
 COPY --from=build /app/out ./
 

frameworks/CSharp/genhttp/Benchmarks/Benchmarks.csproj

@@ -1,40 +1,37 @@
 <Project Sdk="Microsoft.NET.Sdk">
-  
-  <PropertyGroup>
-    
-    <TargetFramework>net8.0</TargetFramework>
-    <LangVersion>10.0</LangVersion>
-    
-    <AssemblyTitle>GenHTTP Benchmarks</AssemblyTitle>
-    <Description>Test suite to be executed with TechEmpower FrameworkBenchmarks.</Description>
-    
-    <StartupObject>Benchmarks.Program</StartupObject>    
-    <OutputType>Exe</OutputType>
-    
-    <ServerGarbageCollection>true</ServerGarbageCollection>
-	  <TieredPGO>true</TieredPGO>
-    
-  </PropertyGroup>
-  
-  <ItemGroup>
-    <None Remove="Resources\Fortunes.html" />
-    <None Remove="Resources\Template.html" />
-  </ItemGroup>
-  
-  <ItemGroup>
-    <EmbeddedResource Include="Resources\Template.html" />
-    <EmbeddedResource Include="Resources\Fortunes.html" />
-  </ItemGroup>
-    
-  <ItemGroup>
-	  
-    <PackageReference Include="GenHTTP.Core" Version="8.5.2" />
-    <PackageReference Include="GenHTTP.Modules.Razor" Version="8.5.0" />
-    <PackageReference Include="GenHTTP.Modules.Webservices" Version="8.5.0" />
-	  
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.6" />
-    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="8.0.4" />
-	  
-  </ItemGroup>
-  
+
+    <PropertyGroup>
+
+        <TargetFramework>net9.0</TargetFramework>
+        <LangVersion>13.0</LangVersion>
+        <ImplicitUsings>true</ImplicitUsings>
+        <OutputType>Exe</OutputType>
+
+        <AssemblyTitle>GenHTTP Benchmarks</AssemblyTitle>
+        <Description>Test suite to be executed with TechEmpower FrameworkBenchmarks.</Description>
+
+        <ServerGarbageCollection>true</ServerGarbageCollection>
+        <TieredPGO>true</TieredPGO>
+
+    </PropertyGroup>
+
+    <ItemGroup>
+        <None Remove="Resources\Fortunes.html" />
+        <None Remove="Resources\Template.html" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <EmbeddedResource Include="Resources\Template.html" />
+    </ItemGroup>
+
+    <ItemGroup>
+
+        <PackageReference Include="GenHTTP.Core" Version="9.6.2" />
+        <PackageReference Include="GenHTTP.Modules.Webservices" Version="9.6.2" />
+
+        <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.1" />
+        <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="9.0.3" />
+
+    </ItemGroup>
+
 </Project>

frameworks/CSharp/genhttp/Benchmarks/Model/DatabaseContext.cs

@@ -1,52 +1,43 @@
 using Microsoft.EntityFrameworkCore;
 
-namespace Benchmarks.Model
+namespace Benchmarks.Model;
+
+public sealed class DatabaseContext : DbContext
 {
+    private static DbContextOptions<DatabaseContext> _options;
 
-    public sealed class DatabaseContext : DbContext
-    {
-        private static DbContextOptions<DatabaseContext> _Options;
+    private static DbContextOptions<DatabaseContext> _noTrackingOptions;
 
-        private static DbContextOptions<DatabaseContext> _NoTrackingOptions;
+    #region Factory
 
-        #region Factory
+    public static DatabaseContext Create() => new(_options ??= GetOptions(true));
 
-        public static DatabaseContext Create()
-        {
-            return new DatabaseContext(_Options ??= GetOptions(true));
-        }
-
-        public static DatabaseContext CreateNoTracking()
-        {
-            return new DatabaseContext(_NoTrackingOptions ??= GetOptions(false));
-        }
+    public static DatabaseContext CreateNoTracking() => new(_noTrackingOptions ??= GetOptions(false));
 
-        private static DbContextOptions<DatabaseContext> GetOptions(bool tracking)
-        {
-            var optionsBuilder = new DbContextOptionsBuilder<DatabaseContext>();
-
-            optionsBuilder.UseNpgsql("Server=tfb-database;Database=hello_world;User Id=benchmarkdbuser;Password=benchmarkdbpass;Maximum Pool Size=256;NoResetOnClose=true;Enlist=false;Max Auto Prepare=4");
+    private static DbContextOptions<DatabaseContext> GetOptions(bool tracking)
+    {
+        var optionsBuilder = new DbContextOptionsBuilder<DatabaseContext>();
 
-            if (!tracking)
-            {
-                optionsBuilder.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);
-            }
+        optionsBuilder.UseNpgsql("Server=tfb-database;Database=hello_world;User Id=benchmarkdbuser;Password=benchmarkdbpass;SSL Mode=Disable;Maximum Pool Size=512;NoResetOnClose=true;Enlist=false;Max Auto Prepare=4");
 
-            return optionsBuilder.Options;
+        if (!tracking)
+        {
+            optionsBuilder.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);
         }
 
-        private DatabaseContext(DbContextOptions options) : base(options) { }
+        return optionsBuilder.Options;
+    }
 
-        #endregion
+    private DatabaseContext(DbContextOptions options) : base(options) { }
 
-        #region Entities
+    #endregion
 
-        public DbSet<World> World { get; set; }
+    #region Entities
 
-        public DbSet<Fortune> Fortune { get; set; }
+    public DbSet<World> World { get; set; }
 
-        #endregion
+    public DbSet<Fortune> Fortune { get; set; }
 
-    }
+    #endregion
 
 }

frameworks/CSharp/genhttp/Benchmarks/Model/Fortune.cs

@@ -1,25 +1,17 @@
-using System;
-using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 
-namespace Benchmarks.Model
-{
-
-    [Table("fortune")]
-    public class Fortune : IComparable<Fortune>, IComparable
-    {
-
-        [Column("id")]
-        public int ID { get; set; }
+namespace Benchmarks.Model;
 
-        [Column("message")]
-        [StringLength(2048)]
-        public string Message { get; set; }
-
-        public int CompareTo(object obj) => CompareTo((Fortune)obj);
+[Table("fortune")]
+public class Fortune
+{
 
-        public int CompareTo(Fortune other) => string.CompareOrdinal(Message, other.Message);
+    [Column("id")]
+    public int Id { get; set; }
 
-    }
+    [Column("message")]
+    [StringLength(2048)]
+    public string Message { get; set; }
 
 }

frameworks/CSharp/genhttp/Benchmarks/Model/World.cs

@@ -1,18 +1,15 @@
 using System.ComponentModel.DataAnnotations.Schema;
 
-namespace Benchmarks.Model
-{
-
-    [Table("world")]
-    public class World
-    {
+namespace Benchmarks.Model;
 
-        [Column("id")]
-        public int Id { get; set; }
+[Table("world")]
+public class World
+{
 
-        [Column("randomnumber")]
-        public int RandomNumber { get; set; }
+    [Column("id")]
+    public int Id { get; set; }
 
-    }
+    [Column("randomnumber")]
+    public int RandomNumber { get; set; }
 
-}
+}

frameworks/CSharp/genhttp/Benchmarks/Program.cs

@@ -1,35 +1,22 @@
-using GenHTTP.Engine;
+using Benchmarks.Tests;
+using Benchmarks.Utilities;
+
+using GenHTTP.Engine.Internal;
 
 using GenHTTP.Modules.IO;
 using GenHTTP.Modules.Layouting;
 using GenHTTP.Modules.Webservices;
 
-using Benchmarks.Tests;
-using Benchmarks.Utilities;
-
-namespace Benchmarks
-{
-
-    public static class Program
-    {
-
-        public static int Main(string[] args)
-        { 
-            var tests = Layout.Create()
-                              .Add("plaintext", Content.From(Resource.FromString("Hello, World!")))
-                              .Add("fortunes", new FortuneHandlerBuilder())
-                              .AddService<JsonResource>("json")
-                              .AddService<DbResource>("db")
-                              .AddService<QueryResource>("queries")
-                              .AddService<UpdateResource>("updates")
-                              .AddService<CacheResource>("cached-worlds")
-                              .Add(ServerHeader.Create());
-
-            return Host.Create()
-                       .Handler(tests)
-                       .Run();
-        }
-
-    }
-
-}
+var tests = Layout.Create()
+                  .Add("plaintext", Content.From(Resource.FromString("Hello, World!")))
+                  .Add("json", new JsonHandler())
+                  .Add("fortunes", new FortuneHandler())
+                  .AddService<DbResource>("db")
+                  .AddService<QueryResource>("queries")
+                  .AddService<UpdateResource>("updates")
+                  .AddService<CacheResource>("cached-worlds")
+                  .Add(ServerHeader.Create());
+
+return await Host.Create()
+                 .Handler(tests)
+                 .RunAsync();

frameworks/CSharp/genhttp/Benchmarks/Resources/Fortunes.html

@@ -1,7 +0,0 @@
-<table>
-    <tr><th>id</th><th>message</th></tr>
-    @foreach (var cookie in Model.Cookies)
-    {
-    <tr><td>@cookie.ID</td><td>@HttpUtility.HtmlEncode(cookie.Message)</td></tr>
-    }
-</table>

frameworks/CSharp/genhttp/Benchmarks/Resources/Template.html

@@ -1,9 +1,22 @@
 <!DOCTYPE html>
 <html>
 <head>
-    <title>@Model.Meta.Title</title>
+    <title>Fortunes</title>
 </head>
 <body>
-    @Model.Content
+
+<table>
+    <tr>
+        <th>id</th>
+        <th>message</th>
+    </tr>
+    {for cookie in cookies:
+    <tr>
+        <td>{ cookie.id }</td>
+        <td>{ cookie.message }</td>
+    </tr>
+    }
+</table>
+
 </body>
-</html>
+</html>

frameworks/CSharp/genhttp/Benchmarks/Tests/CacheResource.cs

@@ -1,84 +1,84 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-
+using Benchmarks.Model;
+using GenHTTP.Modules.Webservices;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Caching.Memory;
 
-using Benchmarks.Model;
-
-using GenHTTP.Modules.Webservices;
+namespace Benchmarks.Tests;
 
-namespace Benchmarks.Tests
+public sealed class CacheResource
 {
+    private static readonly Random Random = new();
 
-    public sealed class CacheResource
+    private static readonly MemoryCache Cache = new(new MemoryCacheOptions
     {
-        private static readonly Random _Random = new Random();
-
-        private static readonly MemoryCache _Cache = new MemoryCache(new MemoryCacheOptions() { ExpirationScanFrequency = TimeSpan.FromMinutes(60) });
-
-        private static readonly object[] _CacheKeys = Enumerable.Range(0, 10001).Select((i) => new CacheKey(i)).ToArray();
-
-        public sealed class CacheKey : IEquatable<CacheKey>
-        {
-            private readonly int _value;
-
-            public CacheKey(int value) => _value = value;
+        ExpirationScanFrequency = TimeSpan.FromMinutes(60)
+    });
 
-            public bool Equals(CacheKey key) => key._value == _value;
+    private static readonly object[] CacheKeys = Enumerable.Range(0, 10001).Select(i => new CacheKey(i)).ToArray();
 
-            public override bool Equals(object obj) => ReferenceEquals(obj, this);
+    [ResourceMethod(":queries")]
+    public ValueTask<List<World>> GetWorldsFromPath(string queries) => GetWorlds(queries);
 
-            public override int GetHashCode() => _value;
+    [ResourceMethod]
+    public async ValueTask<List<World>> GetWorlds(string queries)
+    {
+        var count = 1;
 
-            public override string ToString() => _value.ToString();
+        int.TryParse(queries, out count);
 
+        if (count < 1)
+        {
+            count = 1;
         }
+        else if (count > 500)
+        {
+            count = 500;
+        }
+
+        var result = new List<World>(count);
 
-        [ResourceMethod(":queries")]
-        public ValueTask<List<World>> GetWorldsFromPath(string queries) => GetWorlds(queries);
+        await using var context = DatabaseContext.CreateNoTracking();
 
-        [ResourceMethod]
-        public async ValueTask<List<World>> GetWorlds(string queries)
+        for (var i = 0; i < count; i++)
         {
-            var count = 1;
+            var id = Random.Next(1, 10001);
 
-            int.TryParse(queries, out count);
+            var key = CacheKeys[id];
 
-            if (count < 1) count = 1;
-            else if (count > 500) count = 500;
+            var data = Cache.Get<World>(key);
 
-            var result = new List<World>(count);
+            if (data != null)
+            {
+                result.Add(data);
+            }
+            else
+            {
+                var resolved = await context.World.FirstOrDefaultAsync(w => w.Id == id).ConfigureAwait(false);
 
-            using var context = DatabaseContext.CreateNoTracking();
+                Cache.Set(key, resolved);
 
-            for (var i = 0; i < count; i++)
-            {
-                var id = _Random.Next(1, 10001);
+                result.Add(resolved);
+            }
+        }
 
-                var key = _CacheKeys[id];
+        return result;
+    }
 
-                var data = _Cache.Get<World>(key);
+    public sealed class CacheKey : IEquatable<CacheKey>
+    {
+        private readonly int _value;
 
-                if (data != null)
-                {
-                    result.Add(data);
-                }
-                else
-                {
-                    var resolved = await context.World.FirstOrDefaultAsync(w => w.Id == id).ConfigureAwait(false);
+        public CacheKey(int value)
+        {
+            _value = value;
+        }
 
-                    _Cache.Set(key, resolved);
+        public bool Equals(CacheKey key) => key._value == _value;
 
-                    result.Add(resolved);
-                }
-            }
+        public override bool Equals(object obj) => ReferenceEquals(obj, this);
 
-            return result;
-        }
+        public override int GetHashCode() => _value;
 
+        public override string ToString() => _value.ToString();
     }
-
 }

frameworks/CSharp/genhttp/Benchmarks/Tests/DbResource.cs

@@ -1,29 +1,21 @@
-using System;
-using System.Threading.Tasks;
-
-using Microsoft.EntityFrameworkCore;
-
+using Benchmarks.Model;
 using GenHTTP.Modules.Webservices;
+using Microsoft.EntityFrameworkCore;
 
-using Benchmarks.Model;
+namespace Benchmarks.Tests;
 
-namespace Benchmarks.Tests
+public sealed class DbResource
 {
+    private static readonly Random Random = new();
 
-    public sealed class DbResource
+    [ResourceMethod]
+    public async ValueTask<World> GetRandomWorld()
     {
-        private static readonly Random _Random = new();
-
-        [ResourceMethod]
-        public async ValueTask<World> GetRandomWorld()
-        {
-            var id = _Random.Next(1, 10001);
-
-            using var context = DatabaseContext.CreateNoTracking();
+        var id = Random.Next(1, 10001);
 
-            return await context.World.FirstOrDefaultAsync(w => w.Id == id).ConfigureAwait(false);
-        }
+        await using var context = DatabaseContext.CreateNoTracking();
 
+        return await context.World.FirstOrDefaultAsync(w => w.Id == id).ConfigureAwait(false);
     }
 
 }

frameworks/CSharp/genhttp/Benchmarks/Tests/FortuneHandler.cs

@@ -1,116 +1,85 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using System.Linq;
-using System.Web;
-using System.IO;
-
-using Microsoft.EntityFrameworkCore;
-
+using System.Web;
+using Benchmarks.Model;
+using Cottle;
 using GenHTTP.Api.Content;
-using GenHTTP.Api.Content.Templating;
 using GenHTTP.Api.Protocol;
 
 using GenHTTP.Modules.IO;
-using GenHTTP.Modules.Razor;
-
-using Benchmarks.Model;
+using GenHTTP.Modules.Pages;
+using GenHTTP.Modules.Pages.Rendering;
 
-namespace Benchmarks.Tests
-{
+using Microsoft.EntityFrameworkCore;
 
-    #region Factory
+namespace Benchmarks.Tests;
 
-    public class FortuneHandlerBuilder : IHandlerBuilder
-    {
+public class FortuneHandler : IHandler
+{
 
-        public IHandler Build(IHandler parent)
-        {
-            return new FortuneHandler(parent);
-        }
+    #region Get-/Setters
 
-    }
+    private TemplateRenderer Template { get; }
 
     #endregion
 
-    #region Supporting data structures
+    #region Initialization
 
-    public sealed class FortuneModel : BasicModel
+    public FortuneHandler()
     {
+        var resource = Resource.FromAssembly("Template.html").Build();
 
-        public List<Fortune> Cookies { get; }
-
-        public FortuneModel(IRequest request, IHandler handler, List<Fortune> cookies) : base(request, handler)
-        {
-            Cookies = cookies;
-        }
-
+        Template = Renderer.From(resource);
     }
 
     #endregion
 
-    public class FortuneHandler : IHandler, IPageRenderer
-    {
-
-        #region Get-/Setters
-
-        public IHandler Parent { get; }
+    #region Functionality
 
-        private IHandler Page { get; }
+    public ValueTask PrepareAsync() => new();
 
-        private IRenderer<TemplateModel> Template { get; }
-
-        #endregion
-
-        #region Initialization
-
-        public FortuneHandler(IHandler parent)
+    public async ValueTask<IResponse> HandleAsync(IRequest request)
+    {
+        var data = new Dictionary<Value, Value>
         {
-            Parent = parent;
+            ["cookies"] = Value.FromEnumerable(await GetFortunes())
+        };
 
-            Page = ModRazor.Page(Resource.FromAssembly("Fortunes.html"), (r, h) => GetFortunes(r, h))
-                           .Title("Fortunes")
-                           .AddAssemblyReference<HttpUtility>()
-                           .AddUsing("System.Web")
-                           .Build(this);
+        return request.GetPage(await Template.RenderAsync(data)).Build();
+    }
 
-            Template = ModRazor.Template<TemplateModel>(Resource.FromAssembly("Template.html")).Build();
-        }
+    private static async ValueTask<List<Value>> GetFortunes()
+    {
+        await using var context = DatabaseContext.CreateNoTracking();
 
-        #endregion
+        var fortunes = await context.Fortune.ToListAsync().ConfigureAwait(false);
 
-        #region Functionality
+        var result = new List<Value>(fortunes.Count + 1);
 
-        public async ValueTask PrepareAsync()
+        foreach (var fortune in fortunes)
         {
-            await Page.PrepareAsync();
-            await Template.PrepareAsync();
+            result.Add(Value.FromDictionary(new Dictionary<Value, Value>()
+            {
+                ["id"] = fortune.Id,
+                ["message"] = HttpUtility.HtmlEncode(fortune.Message)
+            }));
         }
 
-        public ValueTask<ulong> CalculateChecksumAsync() => new(17);
-
-        public IAsyncEnumerable<ContentElement> GetContentAsync(IRequest request) => AsyncEnumerable.Empty<ContentElement>();
-
-        public ValueTask<string> RenderAsync(TemplateModel model) => Template.RenderAsync(model);
-
-        public ValueTask RenderAsync(TemplateModel model, Stream target) => Template.RenderAsync(model, target);
-
-        public ValueTask<IResponse> HandleAsync(IRequest request) => Page.HandleAsync(request);
-
-        private static async ValueTask<FortuneModel> GetFortunes(IRequest request, IHandler handler)
+        result.Add(Value.FromDictionary(new Dictionary<Value, Value>()
         {
-            using var context = DatabaseContext.CreateNoTracking();
-
-            var fortunes = await context.Fortune.ToListAsync().ConfigureAwait(false);
-
-            fortunes.Add(new Fortune() { Message = "Additional fortune added at request time." });
-
-            fortunes.Sort();
+            ["id"] = 0,
+            ["message"] = "Additional fortune added at request time."
+        }));
 
-            return new FortuneModel(request, handler, fortunes);
-        }
+        result.Sort((one, two) =>
+        {
+            var firstMessage = one.Fields["message"].AsString;
+            var secondMessage = two.Fields["message"].AsString;
 
-        #endregion
+            return string.Compare(firstMessage, secondMessage, StringComparison.Ordinal);
+        });
 
+        return result;
     }
 
+    #endregion
+
 }

frameworks/CSharp/genhttp/Benchmarks/Tests/JsonHandler.cs

@@ -0,0 +1,39 @@
+using System.Text.Json;
+
+using GenHTTP.Api.Content;
+using GenHTTP.Api.Protocol;
+
+using GenHTTP.Modules.Conversion.Serializers.Json;
+
+namespace Benchmarks.Tests;
+
+public sealed class JsonResult
+{
+
+    public string Message { get; set; }
+}
+
+public sealed class JsonHandler : IHandler
+{
+    private static readonly FlexibleContentType _ContentType = new(ContentType.ApplicationJson, "utf-8");
+
+    private static readonly JsonSerializerOptions _Options = new();
+
+    public ValueTask PrepareAsync() => new();
+
+    public ValueTask<IResponse> HandleAsync(IRequest request)
+    {
+        var result = new JsonResult()
+        {
+            Message = "Hello, World!"
+        };
+
+        var response = request.Respond()
+                              .Content(new JsonContent(result, _Options))
+                              .Type(_ContentType)
+                              .Build();
+
+        return new(response);
+    }
+
+}

frameworks/CSharp/genhttp/Benchmarks/Tests/JsonResource.cs

@@ -1,21 +0,0 @@
-using GenHTTP.Modules.Webservices;
-
-namespace Benchmarks.Tests
-{
-
-    public sealed class JsonResult
-    {
-
-        public string Message { get; set; }
-
-    }
-
-    public sealed class JsonResource
-    {
-
-        [ResourceMethod]
-        public JsonResult GetMessage() => new() { Message = "Hello, World!" };
-
-    }
-
-}

frameworks/CSharp/genhttp/Benchmarks/Tests/QueryResource.cs

@@ -1,47 +1,44 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
+using Benchmarks.Model;
+using GenHTTP.Modules.Webservices;
 using Microsoft.EntityFrameworkCore;
 
-using Benchmarks.Model;
-
-using GenHTTP.Modules.Webservices;
+namespace Benchmarks.Tests;
 
-namespace Benchmarks.Tests
+public sealed class QueryResource
 {
+    private static readonly Random Random = new();
+
+    [ResourceMethod(":queries")]
+    public ValueTask<List<World>> GetWorldsFromPath(string queries) => GetWorlds(queries);
 
-    public sealed class QueryResource
+    [ResourceMethod]
+    public async ValueTask<List<World>> GetWorlds(string queries)
     {
-        private static readonly Random _Random = new Random();
+        var count = 1;
 
-        [ResourceMethod(":queries")]
-        public ValueTask<List<World>> GetWorldsFromPath(string queries) => GetWorlds(queries);
+        int.TryParse(queries, out count);
 
-        [ResourceMethod]
-        public async ValueTask<List<World>> GetWorlds(string queries)
+        if (count < 1)
         {
-            var count = 1;
-
-            int.TryParse(queries, out count);
-
-            if (count < 1) count = 1;
-            else if (count > 500) count = 500;
-
-            var result = new List<World>(count);
+            count = 1;
+        }
+        else if (count > 500)
+        {
+            count = 500;
+        }
 
-            using var context = DatabaseContext.CreateNoTracking();
+        var result = new List<World>(count);
 
-            for (int _ = 0; _ < count; _++)
-            {
-                var id = _Random.Next(1, 10001);
+        using var context = DatabaseContext.CreateNoTracking();
 
-                result.Add(await context.World.FirstOrDefaultAsync(w => w.Id == id).ConfigureAwait(false));
-            }
+        for (var _ = 0; _ < count; _++)
+        {
+            var id = Random.Next(1, 10001);
 
-            return result;
+            result.Add(await context.World.FirstOrDefaultAsync(w => w.Id == id).ConfigureAwait(false));
         }
 
+        return result;
     }
 
-}
+}

frameworks/CSharp/genhttp/Benchmarks/Tests/UpdateResource.cs

@@ -1,66 +1,64 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-
+using Benchmarks.Model;
+using GenHTTP.Modules.Webservices;
 using Microsoft.EntityFrameworkCore;
 
-using Benchmarks.Model;
+namespace Benchmarks.Tests;
 
-using GenHTTP.Modules.Webservices;
-
-namespace Benchmarks.Tests
+public sealed class UpdateResource
 {
+    private static readonly Random Random = new();
+
+    [ResourceMethod(":queries")]
+    public ValueTask<List<World>> UpdateWorldsFromPath(string queries) => UpdateWorlds(queries);
 
-    public sealed class UpdateResource
+    [ResourceMethod]
+    public async ValueTask<List<World>> UpdateWorlds(string queries)
     {
-        private static Random _Random = new Random();
+        var count = 1;
 
-        [ResourceMethod(":queries")]
-        public ValueTask<List<World>> UpdateWorldsFromPath(string queries) => UpdateWorlds(queries);
+        int.TryParse(queries, out count);
 
-        [ResourceMethod]
-        public async ValueTask<List<World>> UpdateWorlds(string queries)
+        if (count < 1)
         {
-            var count = 1;
-
-            int.TryParse(queries, out count);
-
-            if (count < 1) count = 1;
-            else if (count > 500) count = 500;
+            count = 1;
+        }
+        else if (count > 500)
+        {
+            count = 500;
+        }
 
-            var result = new List<World>(count);
+        var result = new List<World>(count);
 
-            var ids = Enumerable.Range(1, 10000).Select(x => _Random.Next(1, 10001)).Distinct().Take(count).ToArray();
+        var ids = Enumerable.Range(1, 10000).Select(x => Random.Next(1, 10001)).Distinct().Take(count).ToArray();
 
-            using (var context = DatabaseContext.Create())
+        using (var context = DatabaseContext.Create())
+        {
+            foreach (var id in ids)
             {
-                foreach (var id in ids)
-                {
-                    var record = await context.World.FirstOrDefaultAsync(w => w.Id == id).ConfigureAwait(false);
+                var record = await context.World.FirstOrDefaultAsync(w => w.Id == id).ConfigureAwait(false);
 
-                    var old = record.RandomNumber;
+                var old = record.RandomNumber;
 
-                    var current = old;
+                var current = old;
 
-                    for (int i = 0; i < 5; i++)
-                    {
-                        current = _Random.Next(1, 10001);
+                for (var i = 0; i < 5; i++)
+                {
+                    current = Random.Next(1, 10001);
 
-                        if (current != old) break;
+                    if (current != old)
+                    {
+                        break;
                     }
+                }
 
-                    record.RandomNumber = current;
+                record.RandomNumber = current;
 
-                    result.Add(record);
+                result.Add(record);
 
-                    await context.SaveChangesAsync();
-                }
+                await context.SaveChangesAsync();
             }
-
-            return result;
         }
 
+        return result;
     }
-
-}
+}

frameworks/CSharp/genhttp/Benchmarks/Utilities/ServerHeader.cs

@@ -1,11 +1,7 @@
-namespace Benchmarks.Utilities
-{
-
-    public static class ServerHeader
-    {
+namespace Benchmarks.Utilities;
 
-        public static ServerHeaderConcernBuilder Create() => new ServerHeaderConcernBuilder();
-
-    }
+public static class ServerHeader
+{
 
+    public static ServerHeaderConcernBuilder Create() => new();
 }

frameworks/CSharp/genhttp/Benchmarks/Utilities/ServerHeaderConcern.cs

@@ -1,55 +1,42 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-
-using GenHTTP.Api.Content;
+using GenHTTP.Api.Content;
 using GenHTTP.Api.Protocol;
 
-namespace Benchmarks.Utilities
-{
-
-    public sealed class ServerHeaderConcern : IConcern
-    {
+namespace Benchmarks.Utilities;
 
-        #region Get-/Setters
+public sealed class ServerHeaderConcern : IConcern
+{
 
-        public IHandler Content { get; }
+    #region Initialization
 
-        public IHandler Parent { get; }
+    public ServerHeaderConcern(IHandler content)
+    {
+        Content = content;
+    }
 
-        #endregion
+    #endregion
 
-        #region Initialization
+    #region Get-/Setters
 
-        public ServerHeaderConcern(IHandler parent, Func<IHandler, IHandler> contentFactory)
-        {
-            Parent = parent;
-            Content = contentFactory(this);
-        }
+    public IHandler Content { get; }
 
-        #endregion
+    #endregion
 
-        #region Functionality
+    #region Functionality
 
-        public IAsyncEnumerable<ContentElement> GetContentAsync(IRequest request) => Content.GetContentAsync(request);
+    public ValueTask PrepareAsync() => Content.PrepareAsync();
 
-        public ValueTask PrepareAsync() => Content.PrepareAsync();
+    public async ValueTask<IResponse> HandleAsync(IRequest request)
+    {
+        var response = await Content.HandleAsync(request);
 
-        public async ValueTask<IResponse> HandleAsync(IRequest request)
+        if (response != null)
         {
-            var response = await Content.HandleAsync(request);
-
-            if (response != null)
-            {
-                response.Headers.Add("Server", "TFB");
-            }
-
-            return response;
+            response.Headers.Add("Server", "TFB");
         }
 
-        #endregion
-
+        return response;
     }
 
+    #endregion
+
 }

frameworks/CSharp/genhttp/Benchmarks/Utilities/ServerHeaderConcernBuilder.cs

@@ -1,18 +1,10 @@
-using System;
+using GenHTTP.Api.Content;
 
-using GenHTTP.Api.Content;
+namespace Benchmarks.Utilities;
 
-namespace Benchmarks.Utilities
+public sealed class ServerHeaderConcernBuilder : IConcernBuilder
 {
 
-    public sealed class ServerHeaderConcernBuilder : IConcernBuilder
-    {
-
-        public IConcern Build(IHandler parent, Func<IHandler, IHandler> contentFactory)
-        {
-            return new ServerHeaderConcern(parent, contentFactory);
-        }
-
-    }
+    public IConcern Build(IHandler content) => new ServerHeaderConcern(content);
 
 }

frameworks/CSharp/genhttp/README.md

@@ -6,11 +6,11 @@ See the [GenHTTP website](https://genhttp.org) for more information.
 
 **Language**
 
-* C# 8.0
+* C# 13.0
 
 **Platforms**
 
-* .NET Core
+* .NET 8/9
 
 **Web Servers**
 

frameworks/CSharp/genhttp/benchmark_config.json

@@ -17,7 +17,7 @@
       "language": "C#",
       "orm": "Raw",
       "platform": ".NET",
-      "webserver": "GenHTTP",
+      "webserver": "Kestrel",
       "os": "Linux",
       "database_os": "Linux",
       "display_name": "GenHTTP",

frameworks/CSharp/genhttp/config.toml

@@ -16,5 +16,5 @@ database_os = "Linux"
 os = "Linux"
 orm = "Raw"
 platform = ".NET"
-webserver = "GenHTTP"
+webserver = "Kestrel"
 versus = "None"

frameworks/CSharp/genhttp/genhttp.dockerfile

@@ -1,19 +1,24 @@
-FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
-WORKDIR /app
-COPY Benchmarks .
-RUN dotnet publish -c Release -o out
+FROM mcr.microsoft.com/dotnet/sdk:9.0-alpine AS build
+WORKDIR /source
+
+# copy csproj and restore as distinct layers
+COPY Benchmarks/*.csproj .
+RUN dotnet restore -r linux-musl-x64
+
+# copy and publish app and libraries
+COPY Benchmarks/ .
+RUN dotnet publish -c release -o /app -r linux-musl-x64 --no-restore --self-contained
 
-FROM mcr.microsoft.com/dotnet/runtime:8.0 AS runtime
-ENV DOTNET_SYSTEM_NET_SOCKETS_INLINE_COMPLETIONS 1
+# final stage/image
+FROM mcr.microsoft.com/dotnet/runtime-deps:9.0-alpine
 
-# Full PGO
-ENV DOTNET_TieredPGO 1 
-ENV DOTNET_TC_QuickJitForLoops 1 
-ENV DOTNET_ReadyToRun 0
+ENV DOTNET_GCDynamicAdaptationMode=0
+ENV DOTNET_ReadyToRun=0
+ENV DOTNET_HillClimbing_Disable=1
 
 WORKDIR /app
-COPY --from=build /app/out ./
+COPY --from=build /app .
 
-EXPOSE 8080
+ENTRYPOINT ["./Benchmarks"]
 
-ENTRYPOINT ["dotnet", "Benchmarks.dll"]
+EXPOSE 8080

frameworks/CSharp/reaper/reaper.dockerfile

@@ -1,4 +1,4 @@
-FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
+FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
 WORKDIR /src
 COPY src .
 RUN apt-get update \
@@ -7,7 +7,7 @@ RUN apt-get update \
 WORKDIR "/src/Benchmark"
 RUN dotnet publish "Benchmark.csproj" -c Release -o /app/publish
 
-FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS final
+FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS final
 WORKDIR /app
 EXPOSE 8080
 COPY --from=build /app/publish .

frameworks/CSharp/reaper/src/Benchmark/Benchmark.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
     <PropertyGroup>
-        <TargetFramework>net8.0</TargetFramework>
+        <TargetFramework>net9.0</TargetFramework>
         <Nullable>enable</Nullable>
         <ImplicitUsings>enable</ImplicitUsings>
         <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
@@ -18,8 +18,8 @@
     </ItemGroup>
     
     <ItemGroup>
-        <PackageReference Include="Reaper.Core" Version="0.1.0-alpha.0.6" />
-        <PackageReference Include="Reaper.SourceGenerator" Version="0.1.0-alpha.0.6" />
+        <PackageReference Include="Reaper.Core" Version="0.1.0-alpha.0.43" />
+        <PackageReference Include="Reaper.SourceGenerator" Version="0.1.0-alpha.0.43" />
     </ItemGroup>
 
 </Project>

frameworks/CSharp/reaper/src/Benchmark/JsonEndpoint.cs

@@ -11,9 +11,10 @@ public class JsonResponse
 [ReaperRoute(HttpVerbs.Get, "/json")]
 public class JsonEndpoint : ReaperEndpointXR<JsonResponse>
 {
-    public override Task<JsonResponse> HandleAsync()
+    public override Task ExecuteAsync()
     {
         Context.Response.ContentLength = 27;
-        return Task.FromResult(new JsonResponse { Message = "Hello, World!" });
+        Result = new JsonResponse { Message = "Hello, World!" };
+        return Task.CompletedTask;
     }
 }

frameworks/CSharp/reaper/src/Benchmark/PlainTextEndpoint.cs

@@ -6,11 +6,12 @@ namespace Benchmark;
 [ReaperRoute(HttpVerbs.Get, "/plaintext")]
 public class PlainTextEndpoint : ReaperEndpointXR<string>
 {
-    public override Task<string> HandleAsync()
+    public override Task ExecuteAsync()
     {
         Context.Response.StatusCode = 200;
         Context.Response.ContentType = "text/plain";
         Context.Response.ContentLength = 13;
-        return Task.FromResult("Hello, World!");
+        Result = "Hello, World!";
+        return Task.CompletedTask;
     }
 }

frameworks/CSharp/reaper/src/Benchmark/Program.cs

@@ -1,14 +1,8 @@
-using System.Text.Json.Serialization;
-using Benchmark;
 using Reaper;
 
 var builder = WebApplication.CreateSlimBuilder(args);
 builder.Logging.ClearProviders();
 builder.Logging.Configure(o => o.ActivityTrackingOptions = ActivityTrackingOptions.None);
-builder.Services.ConfigureHttpJsonOptions(o =>
-{
-    o.SerializerOptions.TypeInfoResolverChain.Insert(0, SourceGenerationContext.Default);
-});
 builder.UseReaper();
 
 var app = builder.Build();
@@ -16,7 +10,4 @@ var app = builder.Build();
 app.UseReaperMiddleware();
 app.MapReaperEndpoints();
 
-app.Run();
-
-[JsonSerializable(typeof(JsonResponse))]
-internal partial class SourceGenerationContext : JsonSerializerContext { }
+app.Run();

frameworks/CSharp/reaper/src/Benchmark/appsettings.Development.json

@@ -5,4 +5,4 @@
       "Microsoft.AspNetCore": "Warning"
     }
   }
-}
+}

frameworks/CSharp/sisk/benchmark_config.json

@@ -1,21 +1,39 @@
 {
-  "framework": "sisk",
-  "tests": [{
-    "default": {
-      "plaintext_url": "/plaintext",
-      "json_url": "/json",
-      "port": 8080,
-      "approach": "Realistic",
-      "classification": "Fullstack",
-      "database": "None",
-      "framework": "Sisk",
-      "language": "C#",
-      "orm": "Raw",
-      "platform": ".NET",
-      "webserver": "Sisk",
-      "os": "Linux",
-      "database_os": "Linux",
-      "display_name": "Sisk Framework"
-    }
-  }]
+    "framework": "sisk",
+    "tests": [
+        {
+            "default": {
+                "plaintext_url": "/plaintext",
+                "json_url": "/json",
+                "port": 8080,
+                "approach": "Realistic",
+                "classification": "Micro",
+                "database": "None",
+                "framework": "Sisk",
+                "language": "C#",
+                "orm": "Raw",
+                "platform": ".NET",
+                "webserver": "HttpListener",
+                "os": "Linux",
+                "database_os": "Linux",
+                "display_name": "Sisk Framework"
+            },
+            "cadente": {
+                "plaintext_url": "/plaintext",
+                "json_url": "/json",
+                "port": 8080,
+                "approach": "Realistic",
+                "classification": "Platform",
+                "database": "None",
+                "framework": "Sisk",
+                "language": "C#",
+                "orm": "Raw",
+                "platform": ".NET",
+                "webserver": "Cadente",
+                "os": "Linux",
+                "database_os": "Linux",
+                "display_name": "Sisk Framework (Cadente)"
+            }
+        }
+    ]
 }

frameworks/CSharp/sisk/config.toml

@@ -5,11 +5,24 @@ name = "sisk"
 urls.plaintext = "/plaintext"
 urls.json = "/json"
 approach = "Realistic"
-classification = "Fullstack"
+classification = "Micro"
 database = "None"
 database_os = "Linux"
 os = "Linux"
 orm = "Raw"
 platform = ".NET"
-webserver = "Sisk"
+webserver = "HttpListener"
 versus = "None"
+
+[cadente]
+urls.plaintext = "/plaintext"
+urls.json = "/json"
+approach = "Realistic"
+classification = "Platform"
+database = "None"
+database_os = "Linux"
+os = "Linux"
+orm = "Raw"
+platform = ".NET"
+webserver = "Cadente"
+versus = "None"

frameworks/CSharp/sisk/sisk-cadente.dockerfile

@@ -0,0 +1,23 @@
+FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
+WORKDIR /source
+
+# copy csproj and restore as distinct layers
+COPY sisk-cadente/*.csproj .
+RUN dotnet restore -r linux-musl-x64
+
+# copy and publish app and libraries
+COPY sisk-cadente/ .
+RUN dotnet publish -c release -o /app
+
+ENV DOTNET_GCDynamicAdaptationMode=0
+ENV DOTNET_ReadyToRun=0
+ENV DOTNET_HillClimbing_Disable=1
+
+# final stage/image
+FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS runtime
+WORKDIR /app
+COPY --from=build /app .
+
+ENTRYPOINT ["dotnet", "./sisk.dll"]
+
+EXPOSE 8080

frameworks/CSharp/sisk/sisk-cadente/Program.cs

@@ -0,0 +1,44 @@
+using System.Net;
+using System.Text;
+using System.Text.Json;
+using Sisk.Cadente;
+
+HttpHost.QueueSize = 4096;
+
+var host = new HttpHost ( new IPEndPoint ( IPAddress.Any, 8080 ) );
+host.ContextCreated += Host_ContextCreated;
+
+host.Start ();
+Thread.Sleep ( Timeout.Infinite );
+
+void Host_ContextCreated ( HttpHost sender, HttpHostContext session ) {
+    var request = session.Request;
+    
+    if (request.Path == "/plaintext") {
+        SerializePlainTextResponse ( session.Response );
+    }
+    else if (request.Path == "/json") {
+        SerializeJsonResponse ( session.Response );
+    }
+    else {
+        session.Response.StatusCode = 404;
+    }
+}
+
+static void SerializePlainTextResponse ( HttpHostContext.HttpResponse response ) {
+
+    var messageBytes = Encoding.UTF8.GetBytes ( "Hello, World!" );
+
+    response.Headers.Add ( new HttpHeader ( "Content-Type", "text/plain; charset=UTF-8" ) );
+    response.ResponseStream = new MemoryStream ( messageBytes );
+}
+
+static void SerializeJsonResponse ( HttpHostContext.HttpResponse response ) {
+
+    var contentBytes = JsonSerializer.SerializeToUtf8Bytes ( new {
+        message = "Hello, World!"
+    } );
+    
+    response.Headers.Add ( new HttpHeader ( "Content-Type", "application/json" ) );
+    response.ResponseStream = new MemoryStream ( contentBytes );
+}

frameworks/CSharp/sisk/sisk-cadente/sisk.csproj

@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>net9.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <ServerGarbageCollection>true</ServerGarbageCollection>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Sisk.Cadente" Version="0.1.64-alpha4" />
+    </ItemGroup>
+
+</Project>

frameworks/CSharp/sisk/sisk/Program.cs

@@ -1,26 +1,26 @@
-using Sisk.Core.Http;
+using System.Net.Http.Json;
+using System.Text;
+using Sisk.Core.Http;
 using Sisk.Core.Routing;
-using System.Net.Http.Json;
 
-var app = HttpServer.CreateBuilder(host =>
-{
-    host.UseListeningPort("http://+:8080/");
-});
+var app = HttpServer.CreateBuilder ( host => {
+    host.UseListeningPort ( "http://+:8080/" );
+    host.UseConfiguration ( config => {
+        config.AccessLogsStream = null;
+    } );
+} ).Build ();
 
-app.Router.SetRoute(RouteMethod.Get, "/plaintext", PlainText);
-app.Router.SetRoute(RouteMethod.Get, "/json", Json);
+app.Router.SetRoute ( RouteMethod.Get, "/plaintext", PlainText );
+app.Router.SetRoute ( RouteMethod.Get, "/json", Json );
 
-app.Start();
+app.Start ();
 
-static HttpResponse PlainText(HttpRequest request)
-{
-    return new HttpResponse().WithContent("Hello, world!");
+static HttpResponse PlainText ( HttpRequest request ) {
+    return new HttpResponse ( new StringContent ( "Hello, World!", Encoding.UTF8, "text/plain" ) );
 }
 
-static HttpResponse Json(HttpRequest request)
-{
-    return new HttpResponse().WithContent(JsonContent.Create(new
-    {
-        message = "Hello, world!"
-    }));
+static HttpResponse Json ( HttpRequest request ) {
+    return new HttpResponse ( JsonContent.Create ( new {
+        message = "Hello, World!"
+    } ) );
 }

frameworks/CSharp/sisk/sisk/sisk.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
 	<PropertyGroup>
 		<OutputType>Exe</OutputType>
@@ -9,7 +9,7 @@
 	</PropertyGroup>
 
 	<ItemGroup>
-	  <PackageReference Include="Sisk.HttpServer" Version="0.16.2" />
+		<PackageReference Include="Sisk.HttpServer" Version="1.4.0-beta3" />
 	</ItemGroup>
 
 </Project>

frameworks/Crystal/amber/README.md

@@ -8,17 +8,12 @@ This is the [Amber](https://amberframework.org) test of the Framework Benchmarks
 
 The purpose of Amber is not to create yet another framework, but to take advantage of the beautiful Crystal language capabilities and provide engineers an efficient, cohesive, and well maintain web framework for the crystal community that embraces the language philosophies, conventions, and guides.
 
-Amber Crystal borrows concepts that already have been battle tested, successful, and embrace new concepts through team and community collaboration and analysis, that aligns with Crystal philosophies.
+Amber borrows concepts that already have been battle tested, successful, and embrace new concepts through team and community collaboration and analysis, that aligns with Crystal philosophies.
 
-## Contributors
+Updated for Amber 1.4.1 and Crystal 1.14.0
 
-- Dru Jensen [drujensen](https://github.com/drujensen) 
-- Elias Perez [eliasjpr](https://github.com/eliasjpr) 
-- Isaac Sloan [elorest](https://github.com/elorest) 
-- Faustino Aguilar [faustinoaq](https://github.com/faustinoaq) 
-- Nick Franken [fridgerator](https://github.com/fridgerator)
-- Mark Siemers [marksiemers](https://github.com/marksiemers)
-- Robert Carpenter [robacarp](https://github.com/robacarp) 
+## Contributors
+- Seth Tucker [crimson-knight](https://github.com/crimson-knight)
 
 See more [Amber contributors](https://github.com/amberframework/amber/graphs/contributors)
 

frameworks/Crystal/amber/config/initializers/database.cr

@@ -1,7 +1,7 @@
 require "granite/adapter/pg"
 
-cpu_count = System.cpu_count
-pool_size = 56 // cpu_count
+cpu_count = System.cpu_count - 1 # Always leave 1 core for the system
+pool_size = cpu_count * 4 # 4x the number of cores, should be plenty of room for concurrency
 database_url = ENV["DATABASE_URL"]
 url = "#{database_url}?initial_pool_size=#{pool_size}&max_idle_pool_size=#{pool_size}"
 

frameworks/Crystal/amber/shard.lock

@@ -28,10 +28,6 @@ shards:
     git: https://github.com/crystal-lang/crystal-db.git
     version: 0.11.0
 
-  dotenv:
-    git: https://github.com/gdotdesign/cr-dotenv.git
-    version: 1.0.0
-
   exception_page:
     git: https://github.com/crystal-loot/exception_page.git
     version: 0.3.1
@@ -44,22 +40,10 @@ shards:
     git: https://github.com/amberframework/granite.git
     version: 0.23.3
 
-  i18n:
-    git: https://github.com/crimson-knight/i18n.cr.git
-    version: 0.4.1
-
-  ifrit:
-    git: https://github.com/imdrasil/ifrit.git
-    version: 0.1.3
-
   inflector:
     git: https://github.com/phoffer/inflector.cr.git
     version: 1.0.0
 
-  jennifer:
-    git: https://github.com/imdrasil/jennifer.cr.git
-    version: 0.13.0
-
   json_mapping:
     git: https://github.com/crystal-lang/json_mapping.cr.git
     version: 0.1.1
@@ -74,7 +58,7 @@ shards:
 
   micrate:
     git: https://github.com/amberframework/micrate.git
-    version: 0.15.0
+    version: 0.15.1
 
   mysql:
     git: https://github.com/crystal-lang/crystal-mysql.git
@@ -82,7 +66,7 @@ shards:
 
   optarg:
     git: https://github.com/amberframework/optarg.git
-    version: 0.9.3
+    version: 0.9.5
 
   pg:
     git: https://github.com/will/crystal-pg.git
@@ -96,10 +80,6 @@ shards:
     git: https://github.com/stefanwille/crystal-redis.git
     version: 2.8.3
 
-  sam:
-    git: https://github.com/imdrasil/sam.cr.git
-    version: 0.5.0
-
   shell-table:
     git: https://github.com/luckyframework/shell-table.cr.git
     version: 0.9.3
@@ -116,10 +96,6 @@ shards:
     git: https://github.com/amberframework/teeplate.git
     version: 0.11.2
 
-  wordsmith:
-    git: https://github.com/luckyframework/wordsmith.git
-    version: 0.4.0
-
   yaml_mapping:
     git: https://github.com/crystal-lang/yaml_mapping.cr.git
     version: 0.1.1