Merge pull request #9488 from hggq/master

[Paozhu] update new files

frameworks/C++/paozhu/paozhu.dockerfile

@@ -1,4 +1,4 @@
-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
 
@@ -6,6 +6,7 @@ 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 psmisc
 
 RUN locale-gen en_US.UTF-8
 ENV LANG en_US.UTF-8
@@ -18,37 +19,95 @@ WORKDIR /
 # RUN wget https://github.com/hggq/paozhu/releases/download/v1.5.8/benchmark.zip
 RUN git clone https://github.com/hggq/paozhu
 # RUN unzip benchmark.zip
-RUN rm -Rf ./paozhu/controller
-RUN rm -Rf ./paozhu/libs
-RUN mkdir ./paozhu/libs
-RUN mkdir ./paozhu/libs/types
+# 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
 
-RUN mkdir ./paozhu/controller
-RUN mkdir ./paozhu/controller/include
-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/controller ./paozhu/
+# COPY ./paozhu_benchmark/libs ./paozhu/
+# COPY ./paozhu_benchmark/view ./paozhu/
+# COPY ./paozhu_benchmark/viewsrc ./paozhu/
 
-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/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
+# 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/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/
+
+# 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)
@@ -117,13 +123,11 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR}/viewsrc/include)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/websockets/include)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
 
-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 +142,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,6 +189,7 @@ 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)
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/bin)
@@ -181,15 +202,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()
 
@@ -265,7 +283,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()
@@ -324,19 +342,54 @@ if(ZLIB_FOUND)
   target_link_libraries(paozhu z)
 endif()
 
-find_path(MYSQL_ROOT_DIR mysql)
+
+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)
 
-FIND_PATH(MYSQL_INCLUDE_DIR mysql.h
-  /usr/local/include/mysql
-  /usr/include/mysql
-  /usr/local/mysql/include
-)
+
+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
+  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
 )
 
@@ -371,7 +424,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 +456,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 +496,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 +520,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 +546,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 +609,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

@@ -44,6 +44,16 @@ 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;
+    
+
+    }
+    
 }
 
 #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,9 @@
+#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
+
+#endif

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

@@ -0,0 +1,39 @@
+#include <iostream>
+#include <list>
+#include <map>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <memory>
+#include <string_view>
+#include "httppeer.h"
+namespace http
+{
+std::map<std::string, bool> _block_ip_tables;
+std::map<std::string, bool> _block_host_tables;
+bool check_blockip(const std::string &client_ip)
+{
+    if (client_ip.size() > 0)
+    {
+        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/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,6 +13,9 @@ 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
@@ -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/models/Fortune.cpp

@@ -0,0 +1,16 @@
+#include "mysqlmodel.hpp" 
+#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):mysqlclientDB(dbtag){}
+			 Fortune::Fortune():mysqlclientDB(){}
+
+
+	  }

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

@@ -0,0 +1,16 @@
+#include "mysqlmodel.hpp" 
+#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):mysqlclientDB(dbtag){}
+			 World::World():mysqlclientDB(){}
+
+
+	  }

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

@@ -0,0 +1,16 @@
+#ifndef ORM_DEFAULT_FORTUNE_H
+#define ORM_DEFAULT_FORTUNE_H
+#include "mysqlmodel.hpp" 
+#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 mysqlclientDB<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 "mysqlmodel.hpp" 
+#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 mysqlclientDB<World,worldbase>{
+		 public:
+		 World(std::string dbtag);
+		 World();
+		};
+};
+#endif

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

@@ -0,0 +1,2687 @@
+#ifndef ORM_DEFAULT_FORTUNEBASEMATA_H
+#define ORM_DEFAULT_FORTUNEBASEMATA_H
+/*
+*This file is auto create from cli
+*本文件为自动生成 Fri, 26 Jan 2024 02:59:30 GMT
+***/
+#include <iostream>
+#include <cstdio>
+#include <sstream>
+#include <array>
+#include <map> 
+#include <string_view> 
+#include <string> 
+#include <vector>
+#include <ctime>
+#include <array>
+#include "mysql.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 .
+std::vector<unsigned char> _keypos{0x00};
+MYSQL_ROW _row;
+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(); }
+const std::array<std::string,2> colnames={"id","message"};
+const std::array<unsigned char,2> colnamestype= {3,253};
+std::string tablename="fortune";
+std::string 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;
+     }
+     void _setColnamevalue()
+      {
+        for(unsigned char i=0;i<_keypos.size();i++)
+        {
+            switch(_keypos[i]){
+        	case 0:
+		 try{
+			data.id=std::stoul(_row[i]);
+		}catch (...) { 
+			data.id=0;
+			 }
+			break;
+	case 1:
+		 try{
+			data.message.append((_row[i]==NULL?"":_row[i]));
+		}catch (...) { 
+			data.message.clear();
+			 }
+			break;
+	default:
+		 { }
+			
+
+                 }
+
+                 if(i>210){
+                     break;
+                 }
+          }
+   } 
+         void _addnewrowvalue(){
+           fortunebase::meta metatemp;   
+
+          for(unsigned char i=0;i<_keypos.size();i++){
+ 
+                 switch(_keypos[i]){
+
+        	case 0:
+		 try{
+			metatemp.id=std::stoul(_row[i]);
+		}catch (...) { 
+			metatemp.id=0;
+			 }
+			break;
+	case 1:
+		 try{
+			metatemp.message.append((_row[i]==NULL?"":_row[i]));
+		}catch (...) { 
+			metatemp.message.clear();
+			 }
+			break;
+	default:
+		 { }
+			
+
+                  }
+                 if(i>210){
+                     break;
+                 }
+          }
+           record.emplace_back(std::move(metatemp)); 
+   } 
+
+  inline  std::string stringaddslash(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(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<colnames.size();j++){
+                            if(j>0){
+                                tempsql<<"`,`";
+                            }else{
+                                tempsql<<"`";
+                            }
+                            tempsql<<colnames[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( meta &insert_data){
+      unsigned int j=0;
+                std::ostringstream tempsql;
+                tempsql<<"INSERT INTO ";
+                    tempsql<<tablename;
+                   tempsql<<" (";
+                    for(;j<colnames.size();j++){
+                            if(j>0){
+                                tempsql<<"`,`";
+                            }else{
+                                tempsql<<"`";
+                            }
+                            tempsql<<colnames[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( std::vector<meta> &insert_data){
+      unsigned int j=0;
+                std::ostringstream tempsql;
+                tempsql<<"INSERT INTO ";
+                    tempsql<<tablename;
+                   tempsql<<" (";
+                    for(;j<colnames.size();j++){
+                            if(j>0){
+                                tempsql<<"`,`";
+                            }else{
+                                tempsql<<"`";
+                            }
+                            tempsql<<colnames[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){
+       //int j=0;
+            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 == 254)
+                    {
+                        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 == 254)
+                    {
+                        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 < colnames.size(); j++)
+        {
+            if (j > 0)
+            {
+                tempsql << "`,`";
+            }
+            else
+            {
+                tempsql << "`";
+            }
+            tempsql << colnames[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 < colnames.size(); j++)
+        {
+            if (j > 0)
+            {
+                tempsql << "`,`";
+            }
+            else
+            {
+                tempsql << "`";
+            }
+            tempsql << colnames[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<colnames.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<colnames.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<colnames.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<colnames.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<colnames.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/worldbase.h

@@ -0,0 +1,2509 @@
+#ifndef ORM_DEFAULT_WORLDBASEMATA_H
+#define ORM_DEFAULT_WORLDBASEMATA_H
+/*
+*This file is auto create from cli
+*本文件为自动生成 Fri, 26 Jan 2024 02:59:30 GMT
+***/
+#include <iostream>
+#include <cstdio>
+#include <sstream>
+#include <array>
+#include <map> 
+#include <string_view> 
+#include <string> 
+#include <vector>
+#include <ctime>
+#include <array>
+#include "mysql.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 .
+std::vector<unsigned char> _keypos{0x00};
+MYSQL_ROW _row;
+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(); }
+const std::array<std::string,2> colnames={"id","randomnumber"};
+const std::array<unsigned char,2> colnamestype= {3,3};
+std::string tablename="world";
+std::string 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;
+     }
+     void _setColnamevalue()
+      {
+        for(unsigned char i=0;i<_keypos.size();i++)
+        {
+            switch(_keypos[i]){
+        	case 0:
+		 try{
+			data.id=std::stoul(_row[i]);
+		}catch (...) { 
+			data.id=0;
+			 }
+			break;
+	case 1:
+		 try{
+			data.randomnumber=std::stoi(_row[i]);
+		}catch (...) { 
+			data.randomnumber=0;
+			 }
+			break;
+	default:
+		 { }
+			
+
+                 }
+
+                 if(i>210){
+                     break;
+                 }
+          }
+   } 
+         void _addnewrowvalue(){
+           worldbase::meta metatemp;   
+
+          for(unsigned char i=0;i<_keypos.size();i++){
+ 
+                 switch(_keypos[i]){
+
+        	case 0:
+		 try{
+			metatemp.id=std::stoul(_row[i]);
+		}catch (...) { 
+			metatemp.id=0;
+			 }
+			break;
+	case 1:
+		 try{
+			metatemp.randomnumber=std::stoi(_row[i]);
+		}catch (...) { 
+			metatemp.randomnumber=0;
+			 }
+			break;
+	default:
+		 { }
+			
+
+                  }
+                 if(i>210){
+                     break;
+                 }
+          }
+           record.emplace_back(std::move(metatemp)); 
+   } 
+
+  inline  std::string stringaddslash(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(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<colnames.size();j++){
+                            if(j>0){
+                                tempsql<<"`,`";
+                            }else{
+                                tempsql<<"`";
+                            }
+                            tempsql<<colnames[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( meta &insert_data){
+      unsigned int j=0;
+                std::ostringstream tempsql;
+                tempsql<<"INSERT INTO ";
+                    tempsql<<tablename;
+                   tempsql<<" (";
+                    for(;j<colnames.size();j++){
+                            if(j>0){
+                                tempsql<<"`,`";
+                            }else{
+                                tempsql<<"`";
+                            }
+                            tempsql<<colnames[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( std::vector<meta> &insert_data){
+      unsigned int j=0;
+                std::ostringstream tempsql;
+                tempsql<<"INSERT INTO ";
+                    tempsql<<tablename;
+                   tempsql<<" (";
+                    for(;j<colnames.size();j++){
+                            if(j>0){
+                                tempsql<<"`,`";
+                            }else{
+                                tempsql<<"`";
+                            }
+                            tempsql<<colnames[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){
+       //int j=0;
+            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 == 254)
+                    {
+                        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 == 254)
+                    {
+                        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 < colnames.size(); j++)
+        {
+            if (j > 0)
+            {
+                tempsql << "`,`";
+            }
+            else
+            {
+                tempsql << "`";
+            }
+            tempsql << colnames[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 < colnames.size(); j++)
+        {
+            if (j > 0)
+            {
+                tempsql << "`,`";
+            }
+            else
+            {
+                tempsql << "`";
+            }
+            tempsql << colnames[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<colnames.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<colnames.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<colnames.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<colnames.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<colnames.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