Merge pull request #40 from TechEmpower/master

aa

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
 
@@ -18,37 +18,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)
@@ -59,7 +65,7 @@ endif ()
 if(${mode} AND (CMAKE_BUILD_TYPE STREQUAL "Debug"))
 
     if(CMAKE_SYSTEM_NAME MATCHES "Windows")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DASIO_STANDALONE -DDEBUG ${BOOST_OPEN} ${GD_OPEN}")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DASIO_STANDALONE -DBENCHMARK -DDEBUG ${BOOST_OPEN} ${GD_OPEN}")
         if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
             set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /fsanitize=address")
         elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
@@ -67,20 +73,20 @@ if(${mode} AND (CMAKE_BUILD_TYPE STREQUAL "Debug"))
         endif ()
     else()
         set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall -Wextra")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pthread -g -fsanitize=address -DASIO_STANDALONE -DDEBUG ${BOOST_OPEN} ${GD_OPEN} -I/usr/local/include -I/usr/local/mysql/include   -I/usr/include -I/usr/include/mysql " )
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pthread -g -fsanitize=address -DASIO_STANDALONE -DBENCHMARK -DDEBUG ${BOOST_OPEN} ${GD_OPEN} -I/usr/local/include -I/usr/local/mysql/include   -I/usr/include -I/usr/include/mysql " )
     endif ()
     message("Debug mode:${CMAKE_CXX_FLAGS_DEBUG}")
 
 elseif(${mode} AND (CMAKE_BUILD_TYPE STREQUAL "Release"))
 
     if (CMAKE_SYSTEM_NAME MATCHES "Windows")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DASIO_STANDALONE ${BOOST_OPEN} ${GD_OPEN} -O3")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DASIO_STANDALONE ${BOOST_OPEN} ${GD_OPEN} -DBENCHMARK  -O3")
         if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
             set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pthread")
         endif ()
     else ()
         set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -Wall -Wextra -O3")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread  -DASIO_STANDALONE ${BOOST_OPEN} ${GD_OPEN}  -I/usr/local/include -I/usr/local/mysql/include -I/usr/include -I/usr/include/mysql  " )
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread  -DASIO_STANDALONE ${BOOST_OPEN} ${GD_OPEN} -DBENCHMARK -I/usr/local/include -I/usr/local/mysql/include -I/usr/include -I/usr/include/mysql  " )
         file(MAKE_DIRECTORY /usr/local/etc/paozhu)
         file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/conf/ DESTINATION /usr/local/etc/paozhu/)
     endif ()
@@ -89,7 +95,7 @@ elseif(${mode} AND (CMAKE_BUILD_TYPE STREQUAL "Release"))
 else()
     set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall -Wextra")
     message("Debug mode:${CMAKE_CXX_FLAGS_DEBUG}")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pthread  -g -fsanitize=address  -DASIO_STANDALONE -DDEBUG ${BOOST_OPEN} ${GD_OPEN} -I/usr/local/include -I/usr/local/mysql/include   -I/usr/include  -I/usr/include/mysql  " )
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pthread  -g -fsanitize=address  -DASIO_STANDALONE -DBENCHMARK -DDEBUG ${BOOST_OPEN} ${GD_OPEN} -I/usr/local/include -I/usr/local/mysql/include   -I/usr/include  -I/usr/include/mysql  " )
 
     if(NOT CMAKE_SYSTEM_NAME MATCHES "Windows")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address")
@@ -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

frameworks/C/h2o/src/event_loop.c

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

frameworks/C/h2o/src/event_loop.h

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

frameworks/Crystal/amber/README.md

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

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

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

frameworks/Crystal/amber/shard.lock

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

frameworks/Crystal/amber/shard.yml

@@ -15,26 +15,10 @@ dependencies:
     github: amberframework/amber
     version: 1.4.1
 
-  jennifer:
-    github: imdrasil/jennifer.cr
-    version: "~> 0.13.0"
-
-  sam:
-    github: imdrasil/sam.cr
-    version: 0.5.0
-
   pg:
     github: will/crystal-pg
     version: "= 0.26.0"
 
-  mysql:
-    github: crystal-lang/crystal-mysql
-    version: 0.14.0
-
-  dotenv:
-    github: gdotdesign/cr-dotenv
-    version: 1.0.0
-
   granite:
     github: amberframework/granite
     version: 0.23.3

frameworks/Crystal/spider-gazelle/shard.lock

@@ -2,11 +2,11 @@ version: 2.0
 shards:
   action-controller:
     git: https://github.com/spider-gazelle/action-controller.git
-    version: 5.6.2
+    version: 7.4.3
 
   active-model:
     git: https://github.com/spider-gazelle/active-model.git
-    version: 4.2.3
+    version: 4.3.2
 
   backtracer:
     git: https://github.com/sija/backtracer.cr.git
@@ -14,27 +14,23 @@ shards:
 
   db:
     git: https://github.com/crystal-lang/crystal-db.git
-    version: 0.11.0
+    version: 0.13.1
 
   eventbus:
     git: https://github.com/spider-gazelle/eventbus.git
-    version: 0.9.9+git.commit.086b2ba92475b88e8481b0387eb56c735cbfd7bd
+    version: 1.0.0+git.commit.af63536d718348885a553dc4aa6debccc2946289
 
   exception_page:
     git: https://github.com/crystal-loot/exception_page.git
-    version: 0.3.0
-
-  future:
-    git: https://github.com/crystal-community/future.cr.git
-    version: 1.0.0
+    version: 0.5.0
 
   habitat:
     git: https://github.com/luckyframework/habitat.git
-    version: 0.4.7
+    version: 0.4.9
 
   hot_topic:
     git: https://github.com/jgaskins/hot_topic.git
-    version: 0.1.0+git.commit.c4577d949221d535f29162343bf503b578308954
+    version: 0.1.0+git.commit.3c901e77b6e000930398738260a2944b6f5785dc
 
   http-params-serializable:
     git: https://github.com/place-labs/http-params-serializable.git
@@ -42,7 +38,7 @@ shards:
 
   json-schema:
     git: https://github.com/spider-gazelle/json-schema.git
-    version: 1.3.0
+    version: 1.3.1
 
   kilt:
     git: https://github.com/jeromegn/kilt.git
@@ -50,21 +46,21 @@ shards:
 
   lucky_router:
     git: https://github.com/luckyframework/lucky_router.git
-    version: 0.5.2
+    version: 0.6.0
 
   pg:
     git: https://github.com/will/crystal-pg.git
-    version: 0.26.0
+    version: 0.28.0
 
   pg-orm:
     git: https://github.com/spider-gazelle/pg-orm.git
-    version: 1.0.0+git.commit.2bbafec9579f175880281279d33168360176540c
+    version: 1.1.2+git.commit.9b340ee269cd4a10ed6c5b51235cbaf45fc380e1
 
   pool:
     git: https://github.com/ysbaddaden/pool.git
-    version: 0.3.0
+    version: 0.2.4
 
   redis:
     git: https://github.com/stefanwille/crystal-redis.git
-    version: 2.8.3
+    version: 2.9.1
 

frameworks/Crystal/spider-gazelle/spider-gazelle.dockerfile

@@ -1,5 +1,4 @@
-FROM 84codes/crystal:1.7.2-alpine
-RUN apk add --update --no-cache bash gmp-dev
+FROM crystallang/crystal:1.14.0
 
 WORKDIR /usr/src/app
 
@@ -10,7 +9,7 @@ COPY run.sh run.sh
 # Build App
 RUN shards build --release --no-debug
 
-ENV DATABASE_URL postgres://benchmarkdbuser:benchmarkdbpass@tfb-database:5432/hello_world?initial_pool_size=56&max_idle_pool_size=56
+ENV DATABASE_URL postgres://benchmarkdbuser:benchmarkdbpass@tfb-database:5432/hello_world?initial_pool_size=5&max_idle_pool_size=5
 
 ENV SG_ENV production
 

frameworks/Java/httpserver-robaho/pom.xml

@@ -40,7 +40,7 @@
         <dependency>
             <groupId>io.github.robaho</groupId>
             <artifactId>httpserver</artifactId>
-            <version>1.0.6</version>
+            <version>1.0.17</version>
             <scope>compile</scope>
         </dependency>
     </dependencies>

frameworks/Java/solon/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>org.noear</groupId>
         <artifactId>solon-parent</artifactId>
-        <version>3.0.4</version>
+        <version>3.0.5</version>
     </parent>
 
     <groupId>hello</groupId>
@@ -21,7 +21,12 @@
     <dependencies>
         <dependency>
             <groupId>org.noear</groupId>
-            <artifactId>solon-web</artifactId>
+            <artifactId>solon-lib</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.noear</groupId>
+            <artifactId>solon-boot-smarthttp</artifactId>
         </dependency>
 
         <dependency>

frameworks/JavaScript/ultimate-express/package-lock.json

@@ -13,7 +13,7 @@
         "lru-cache": "^10.0.1",
         "mariadb": "^3.2.0",
         "postgres": "^3.3.5",
-        "ultimate-express": "^1.3.9"
+        "ultimate-express": "^1.3.17"
       }
     },
     "node_modules/@fastify/merge-json-schemas": {
@@ -201,17 +201,25 @@
         "node": ">= 0.8"
       }
     },
-    "node_modules/call-bind": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.7.tgz",
-      "integrity": "sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==",
-      "license": "MIT",
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.1.tgz",
+      "integrity": "sha512-BhYE+WDaywFg2TBWYNXAE+8B1ATnThNBqXHP5nQu0jWJdVvY2hvkpyB3qOmtmDePiS5/BDQ8wASEWGMWRG148g==",
       "dependencies": {
-        "es-define-property": "^1.0.0",
         "es-errors": "^1.3.0",
-        "function-bind": "^1.1.2",
-        "get-intrinsic": "^1.2.4",
-        "set-function-length": "^1.2.1"
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/call-bound": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.3.tgz",
+      "integrity": "sha512-YTd+6wGlNlPxSuri7Y6X8tY2dmm12UMH66RpKMhiX6rsk5wXXnYgbUcOt8kiS31/AjfoTOvCsE+w8nZQLQnzHA==",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "get-intrinsic": "^1.2.6"
       },
       "engines": {
         "node": ">= 0.4"
@@ -221,10 +229,9 @@
       }
     },
     "node_modules/cookie": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/cookie/-/cookie-1.0.1.tgz",
-      "integrity": "sha512-Xd8lFX4LM9QEEwxQpF9J9NTUh8pmdJO0cyRJhFiDoLTk2eH8FXlRv2IFGYVadZpqI3j8fhNrSdKCeYPxiAhLXw==",
-      "license": "MIT",
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-1.0.2.tgz",
+      "integrity": "sha512-9Kr/j4O16ISv8zBBhJoi4bXOYNTkFLOqSL3UDB0njXxCXNezjeyVrJyGOWtgfs/q2km1gwBcfH8q1yEGoMYunA==",
       "engines": {
         "node": ">=18"
       }
@@ -238,23 +245,6 @@
         "node": ">=6.6.0"
       }
     },
-    "node_modules/define-data-property": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
-      "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
-      "license": "MIT",
-      "dependencies": {
-        "es-define-property": "^1.0.0",
-        "es-errors": "^1.3.0",
-        "gopd": "^1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/denque": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/denque/-/denque-2.1.0.tgz",
@@ -264,6 +254,19 @@
         "node": ">=0.10"
       }
     },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/encodeurl": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
@@ -274,13 +277,9 @@
       }
     },
     "node_modules/es-define-property": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.0.tgz",
-      "integrity": "sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==",
-      "license": "MIT",
-      "dependencies": {
-        "get-intrinsic": "^1.2.4"
-      },
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
       "engines": {
         "node": ">= 0.4"
       }
@@ -289,7 +288,17 @@
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
       "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
-      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.0.0.tgz",
+      "integrity": "sha512-MZ4iQ6JwHOBQjahnjwaC1ZtIBH+2ohjamzAO3oaHcXYup7qxjF2fixyH+Q71voWHeOkI2q/TnJao/KfXYIZWbw==",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
       "engines": {
         "node": ">= 0.4"
       }
@@ -377,22 +386,25 @@
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
       "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
-      "license": "MIT",
       "funding": {
         "url": "https://github.com/sponsors/ljharb"
       }
     },
     "node_modules/get-intrinsic": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.4.tgz",
-      "integrity": "sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==",
-      "license": "MIT",
+      "version": "1.2.7",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.7.tgz",
+      "integrity": "sha512-VW6Pxhsrk0KAOqs3WEd0klDiF/+V7gQOpAvY1jVU/LHmaD/kQO4523aiJuikX/QAKYiW6x8Jh+RJej1almdtCA==",
       "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-define-property": "^1.0.1",
         "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.0.0",
         "function-bind": "^1.1.2",
-        "has-proto": "^1.0.1",
-        "has-symbols": "^1.0.3",
-        "hasown": "^2.0.0"
+        "get-proto": "^1.0.0",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
       },
       "engines": {
         "node": ">= 0.4"
@@ -401,35 +413,22 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/gopd": {
+    "node_modules/get-proto": {
       "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz",
-      "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==",
-      "license": "MIT",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
       "dependencies": {
-        "get-intrinsic": "^1.1.3"
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
       },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/has-property-descriptors": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
-      "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
-      "license": "MIT",
-      "dependencies": {
-        "es-define-property": "^1.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+      "engines": {
+        "node": ">= 0.4"
       }
     },
-    "node_modules/has-proto": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.3.tgz",
-      "integrity": "sha512-SJ1amZAJUiZS+PhsVLf5tGydlaVB8EdFpaSO4gmiUKUOxk8qzn5AIy4ZeJUmh22znIdk/uMAUT2pl3FxzVUH+Q==",
-      "license": "MIT",
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
       "engines": {
         "node": ">= 0.4"
       },
@@ -438,10 +437,9 @@
       }
     },
     "node_modules/has-symbols": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz",
-      "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==",
-      "license": "MIT",
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
       "engines": {
         "node": ">= 0.4"
       },
@@ -453,7 +451,6 @@
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
       "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
-      "license": "MIT",
       "dependencies": {
         "function-bind": "^1.1.2"
       },
@@ -519,6 +516,14 @@
         "node": ">= 14"
       }
     },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/media-typer": {
       "version": "0.3.0",
       "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
@@ -568,7 +573,6 @@
       "version": "1.13.3",
       "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.3.tgz",
       "integrity": "sha512-kDCGIbxkDSXE3euJZZXzc6to7fCrKHNI/hSRQnRuQ+BWjFNzZwiFF8fj/6o2t2G9/jTj8PSIYTfCLelLZEeRpA==",
-      "license": "MIT",
       "engines": {
         "node": ">= 0.4"
       },
@@ -603,10 +607,9 @@
       }
     },
     "node_modules/qs": {
-      "version": "6.13.0",
-      "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz",
-      "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==",
-      "license": "BSD-3-Clause",
+      "version": "6.13.1",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.1.tgz",
+      "integrity": "sha512-EJPeIn0CYrGu+hli1xilKAPXODtJ12T0sP63Ijx2/khC2JtuaN3JyNIpvmnkmaEtha9ocbG4A4cMcr+TvqvwQg==",
       "dependencies": {
         "side-channel": "^1.0.6"
       },
@@ -647,33 +650,66 @@
       "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
       "license": "MIT"
     },
-    "node_modules/set-function-length": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
-      "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==",
-      "license": "MIT",
+    "node_modules/side-channel": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
+      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
       "dependencies": {
-        "define-data-property": "^1.1.4",
         "es-errors": "^1.3.0",
-        "function-bind": "^1.1.2",
-        "get-intrinsic": "^1.2.4",
-        "gopd": "^1.0.1",
-        "has-property-descriptors": "^1.0.2"
+        "object-inspect": "^1.13.3",
+        "side-channel-list": "^1.0.0",
+        "side-channel-map": "^1.0.1",
+        "side-channel-weakmap": "^1.0.2"
       },
       "engines": {
         "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/side-channel": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.6.tgz",
-      "integrity": "sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==",
-      "license": "MIT",
+    "node_modules/side-channel-list": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
+      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-map": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
       "dependencies": {
-        "call-bind": "^1.0.7",
+        "call-bound": "^1.0.2",
         "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.4",
-        "object-inspect": "^1.13.1"
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-weakmap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3",
+        "side-channel-map": "^1.0.1"
       },
       "engines": {
         "node": ">= 0.4"
@@ -711,17 +747,16 @@
       }
     },
     "node_modules/ultimate-express": {
-      "version": "1.3.9",
-      "resolved": "https://registry.npmjs.org/ultimate-express/-/ultimate-express-1.3.9.tgz",
-      "integrity": "sha512-jr4TMDsQM2nlG/1VMkesy70kTLIVecUeX8dzkh0JoSQ2wilhUaVbCM3I6qvKCNHD+UsYXI6QFhgKmSum1k19hw==",
-      "license": "Apache-2.0",
+      "version": "1.3.17",
+      "resolved": "https://registry.npmjs.org/ultimate-express/-/ultimate-express-1.3.17.tgz",
+      "integrity": "sha512-LRqSl+wE9xtuP+S03wSZXmYoQwyCXohGzL8zy3aQs4CChfnbDOQ9tbZwz4iCineUGwp7LFj7h5Oi1eqWiB6XGw==",
       "dependencies": {
         "@types/express": "^4.0.0",
         "accepts": "^1.3.8",
-        "acorn": "^8.12.1",
+        "acorn": "^8.14.0",
         "bytes": "^3.1.2",
-        "cookie": "^1.0.1",
-        "cookie-signature": "^1.2.1",
+        "cookie": "^1.0.2",
+        "cookie-signature": "^1.2.2",
         "encodeurl": "^2.0.0",
         "etag": "^1.8.1",
         "fast-querystring": "^1.1.2",
@@ -730,12 +765,12 @@
         "mime-types": "^2.1.35",
         "ms": "^2.1.3",
         "proxy-addr": "^2.0.7",
-        "qs": "^6.13.0",
+        "qs": "^6.13.1",
         "range-parser": "^1.2.1",
         "statuses": "^2.0.1",
-        "tseep": "^1.2.2",
+        "tseep": "^1.3.1",
         "type-is": "^1.6.18",
-        "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.49.0",
+        "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.51.0",
         "vary": "^1.1.2"
       },
       "engines": {

frameworks/JavaScript/ultimate-express/package.json

@@ -12,7 +12,7 @@
     "lru-cache": "^10.0.1",
     "mariadb": "^3.2.0",
     "postgres": "^3.3.5",
-    "ultimate-express": "^1.3.9"
+    "ultimate-express": "^1.3.17"
   },
   "type": "module"
 }

frameworks/JavaScript/ultimate-express/ultimate-express-mysql.dockerfile

@@ -1,5 +1,5 @@
 # syntax=docker/dockerfile:1
-FROM node:20-slim
+FROM node:22-slim
 
 WORKDIR /app
 
@@ -15,4 +15,4 @@ USER node
 
 EXPOSE 8080
 
-CMD ["node", "clustered.js"]
+CMD ["node", "clustered.js"]

frameworks/JavaScript/ultimate-express/ultimate-express-postgres.dockerfile

@@ -1,5 +1,5 @@
 # syntax=docker/dockerfile:1
-FROM node:20-slim
+FROM node:22-slim
 
 WORKDIR /app
 
@@ -15,4 +15,4 @@ USER node
 
 EXPOSE 8080
 
-CMD ["node", "clustered.js"]
+CMD ["node", "clustered.js"]

frameworks/JavaScript/ultimate-express/ultimate-express.dockerfile

@@ -1,5 +1,5 @@
 # syntax=docker/dockerfile:1
-FROM node:20-slim
+FROM node:22-slim
 
 WORKDIR /app
 
@@ -13,4 +13,4 @@ USER node
 
 EXPOSE 8080
 
-CMD ["node", "clustered.js"]
+CMD ["node", "clustered.js"]

frameworks/Kotlin/hexagon/build.gradle

@@ -1,7 +1,7 @@
 
 plugins {
-    id "org.jetbrains.kotlin.jvm" version "2.0.20" apply false
-    id "org.graalvm.buildtools.native" version "0.10.3" apply false
+    id "org.jetbrains.kotlin.jvm" version "2.0.21" apply false
+    id "org.graalvm.buildtools.native" version "0.10.4" apply false
 }
 
 version = "1.0.0"
@@ -9,13 +9,13 @@ description = "TFB benchmark"
 group = "com.hexagonkt"
 
 ext {
-    hexagonVersion = "3.7.0"
-    jettyVersion = "12.0.13"
-    nettyVersion = "4.1.113.Final"
+    hexagonVersion = "3.7.3"
+    jettyVersion = "12.0.16"
+    nettyVersion = "4.1.116.Final"
 
-    hikariVersion = "5.1.0"
+    hikariVersion = "6.2.1"
     postgresqlVersion = "42.7.4"
-    vertxVersion = "4.5.10"
+    vertxVersion = "4.5.11"
     cache2kVersion = "2.6.1.Final"
 
     applicationClass = "com.hexagonkt.BenchmarkKt"
@@ -30,5 +30,5 @@ subprojects {
 }
 
 tasks.wrapper {
-    gradleVersion = "8.10"
+    gradleVersion = "8.10.2"
 }

frameworks/Kotlin/hexagon/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

frameworks/Kotlin/hexagon/hexagon-helidon-pgclient.dockerfile

@@ -1,7 +1,7 @@
 #
 # BUILD
 #
-FROM docker.io/bellsoft/liberica-runtime-container:jdk-all-22-cds-musl AS build
+FROM docker.io/bellsoft/liberica-runtime-container:jdk-all-23-cds-musl AS build
 USER root
 WORKDIR /hexagon
 
@@ -12,7 +12,7 @@ RUN ./gradlew --quiet -x test installDist
 #
 # RUNTIME
 #
-FROM docker.io/bellsoft/liberica-runtime-container:jre-22-musl
+FROM docker.io/bellsoft/liberica-runtime-container:jre-23-musl
 ARG PROJECT=hexagon_helidon_pgclient
 
 ENV POSTGRESQL_DB_HOST tfb-database

frameworks/Kotlin/hexagon/hexagon-helidon.dockerfile

@@ -1,7 +1,7 @@
 #
 # BUILD
 #
-FROM docker.io/bellsoft/liberica-runtime-container:jdk-all-22-cds-musl AS build
+FROM docker.io/bellsoft/liberica-runtime-container:jdk-all-23-cds-musl AS build
 USER root
 WORKDIR /hexagon
 
@@ -12,7 +12,7 @@ RUN ./gradlew --quiet -x test installDist
 #
 # RUNTIME
 #
-FROM docker.io/bellsoft/liberica-runtime-container:jre-22-musl
+FROM docker.io/bellsoft/liberica-runtime-container:jre-23-musl
 ARG PROJECT=hexagon_helidon_postgresql
 
 ENV POSTGRESQL_DB_HOST tfb-database

frameworks/Kotlin/hexagon/hexagon-tomcat.dockerfile

@@ -12,7 +12,7 @@ RUN ./gradlew --quiet -x test war
 #
 # RUNTIME
 #
-FROM docker.io/tomcat:11.0.0-jre21-temurin-noble
+FROM docker.io/tomcat:11-jre21-temurin-noble
 ARG MODULE=/hexagon/hexagon_tomcat_postgresql
 
 ENV POSTGRESQL_DB_HOST tfb-database

frameworks/Kotlin/hexagon/store_pgclient/src/main/kotlin/BenchmarkPgClientStore.kt

@@ -19,9 +19,10 @@ class BenchmarkPgClientStore(
 ) : BenchmarkStore(settings) {
 
     companion object {
-        private const val SELECT_WORLD: String = "select * from world where id = $1"
+        private const val LOAD_WORLDS: String = "select id, randomNumber from world"
+        private const val SELECT_WORLD: String = "select id, randomNumber from world where id = $1"
         private const val UPDATE_WORLD: String = "update world set randomNumber = $1 where id = $2"
-        private const val SELECT_ALL_FORTUNES: String = "select * from fortune"
+        private const val SELECT_ALL_FORTUNES: String = "select id, message from fortune"
     }
 
     private val connectOptions: PgConnectOptions by lazy {
@@ -81,13 +82,12 @@ class BenchmarkPgClientStore(
                 .toCompletionStage()
                 .toCompletableFuture()
                 .get()
-
         }
     }
 
     override fun initWorldsCache(cache: Cache<Int, CachedWorld>) {
         dataSource
-            .preparedQuery("select * from world")
+            .preparedQuery(LOAD_WORLDS)
             .execute()
             .map { rowSet ->
                 rowSet.map { row ->

frameworks/Kotlin/hexagon/store_sql/src/main/kotlin/BenchmarkSqlStore.kt

@@ -16,9 +16,10 @@ class BenchmarkSqlStore(
 ) : BenchmarkStore(settings) {
 
     companion object {
-        private const val SELECT_WORLD: String = "select * from world where id = ?"
+        private const val LOAD_WORLDS: String = "select id, randomNumber from world"
+        private const val SELECT_WORLD: String = "select id, randomNumber from world where id = ?"
         private const val UPDATE_WORLD: String = "update world set randomNumber = ? where id = ?"
-        private const val SELECT_ALL_FORTUNES: String = "select * from fortune"
+        private const val SELECT_ALL_FORTUNES: String = "select id, message from fortune"
     }
 
     private val dataSource: HikariDataSource by lazy {
@@ -63,19 +64,17 @@ class BenchmarkSqlStore(
     override fun replaceWorlds(worlds: List<World>) {
         dataSource.connection.use { con: Connection ->
             val stmtSelect = con.prepareStatement(SELECT_WORLD)
-            val stmtUpdate = con.prepareStatement(UPDATE_WORLD)
-
             worlds.forEach {
-                val worldId = it.id
-                val newRandomNumber = it.randomNumber
-
-                stmtSelect.setInt(1, worldId)
+                stmtSelect.setInt(1, it.id)
                 val rs = stmtSelect.executeQuery()
                 rs.next()
                 rs.getInt(2) // Read 'randomNumber' to comply with Test type 5, point 6
+            }
 
-                stmtUpdate.setInt(1, newRandomNumber)
-                stmtUpdate.setInt(2, worldId)
+            val stmtUpdate = con.prepareStatement(UPDATE_WORLD)
+            worlds.forEach {
+                stmtUpdate.setInt(1, it.randomNumber)
+                stmtUpdate.setInt(2, it.id)
                 stmtUpdate.executeUpdate()
             }
         }
@@ -83,7 +82,7 @@ class BenchmarkSqlStore(
 
     override fun initWorldsCache(cache: Cache<Int, CachedWorld>) {
         dataSource.connection.use { con: Connection ->
-            val stmtSelect = con.prepareStatement("select * from world")
+            val stmtSelect = con.prepareStatement(LOAD_WORLDS)
             val rs = stmtSelect.executeQuery()
 
             while (rs.next()) {

frameworks/Kotlin/ktor/benchmark_config.json

@@ -25,6 +25,29 @@
         "notes": "http://ktor.io/",
         "versus": "netty"
       },
+      "r2dbc": {
+        "plaintext_url": "/plaintext",
+        "json_url": "/json",
+        "db_url": "/db",
+        "query_url": "/queries?queries=",
+        "update_url": "/updates?queries=",
+        "fortune_url": "/fortunes",
+
+        "port": 9090,
+        "approach": "Realistic",
+        "classification": "Micro",
+        "database": "Postgres",
+        "framework": "ktor",
+        "language": "Kotlin",
+        "orm": "Raw",
+        "platform": "Netty",
+        "webserver": "None",
+        "os": "Linux",
+        "database_os": "Linux",
+        "display_name": "ktor-netty-r2dbc",
+        "notes": "http://ktor.io/",
+        "versus": "netty"
+      },
       "jetty": {
         "plaintext_url": "/plaintext",
         "json_url": "/json",

frameworks/Kotlin/ktor/ktor-asyncdb/build.gradle.kts

@@ -1,6 +1,6 @@
 plugins {
     application
-    kotlin("jvm") version "1.9.22"
+    kotlin("jvm") version "2.0.21"
     kotlin("plugin.serialization") version "2.0.0"
     id("com.github.johnrengelman.shadow") version "8.1.0"
 }
@@ -17,8 +17,7 @@ application {
 }
 
 val ktor_version = "2.3.12"
-val kotlinx_serialization_version = "1.6.3"
-val vertx_pg_client = "4.5.8"
+val kotlinx_serialization_version = "1.7.3"
 
 dependencies {
     implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:$kotlinx_serialization_version")
@@ -26,11 +25,17 @@ dependencies {
     implementation("io.ktor:ktor-server-netty:$ktor_version")
     implementation("io.ktor:ktor-server-default-headers:$ktor_version")
     implementation("io.ktor:ktor-server-html-builder:$ktor_version")
-    implementation("com.github.jasync-sql:jasync-postgresql:2.2.0")
+    implementation("com.github.jasync-sql:jasync-postgresql:2.2.4")
+}
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(21)
+    }
 }
 
 tasks.shadowJar {
-    archiveBaseName.set("bench")
+    archiveBaseName.set("ktor-asyncdb")
     archiveClassifier.set("")
     archiveVersion.set("")
 }

frameworks/Kotlin/ktor/ktor-asyncdb/gradle.properties

@@ -1,4 +1,4 @@
 kotlin.code.style=official
 
-kotlin_version=1.9.22
+kotlin_version=2.0.21
 ktor_version=2.3.12

frameworks/Kotlin/ktor/ktor-asyncdb/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,5 @@
-#Fri Dec 07 21:01:17 MST 2018
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.0.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.11.1-bin.zip

frameworks/Kotlin/ktor/ktor-asyncdb/settings.gradle

@@ -1,14 +0,0 @@
-pluginManagement {
-    resolutionStrategy {
-        eachPlugin {
-            if (requested.id.id == "org.jetbrains.kotlin.jvm") {
-                useModule("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version")
-            }
-            if (requested.id.id == "kotlinx-serialization") {
-                useModule("org.jetbrains.kotlin:kotlin-serialization:$kotlin_version")
-            }
-        }
-    }
-}
-
-rootProject.name = 'tech-empower-framework-benchmark'

frameworks/Kotlin/ktor/ktor-asyncdb/settings.gradle.kts

@@ -0,0 +1 @@
+rootProject.name = "tech-empower-framework-benchmark"

frameworks/Kotlin/ktor/ktor-cio.dockerfile

@@ -1,13 +1,13 @@
-FROM maven:3.9.7-amazoncorretto-17-debian as maven
+FROM maven:3.9.9-amazoncorretto-21-debian-bookworm as maven
 WORKDIR /ktor
 COPY ktor/pom.xml pom.xml
 COPY ktor/src src
 RUN mvn clean package -q
 
-FROM amazoncorretto:17.0.11-al2023-headless
+FROM amazoncorretto:21-al2023-headless
 WORKDIR /ktor
 COPY --from=maven /ktor/target/tech-empower-framework-benchmark-1.0-SNAPSHOT-cio-bundle.jar app.jar
 
 EXPOSE 9090
 
-CMD ["java", "-jar", "app.jar"]
+CMD ["java", "-server","-XX:+UseNUMA", "-XX:+UseParallelGC", "-XX:+AlwaysPreTouch", "-jar", "app.jar"]

frameworks/Kotlin/ktor/ktor-exposed/app/build.gradle.kts

@@ -9,7 +9,7 @@ repositories {
     mavenCentral()
 }
 
-val ktorVersion = "3.0.1"
+val ktorVersion = "3.0.3"
 val kotlinxSerializationVersion = "1.7.3"
 val exposedVersion = "0.56.0"
 

frameworks/Kotlin/ktor/ktor-exposed/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.0.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.11.1-bin.zip
 networkTimeout=10000
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

frameworks/Kotlin/ktor/ktor-jasync.dockerfile

@@ -1,13 +1,15 @@
-FROM maven:3.9.7-amazoncorretto-17-debian
+FROM gradle:jdk21 as build
 WORKDIR /app
 COPY ktor-asyncdb/gradle gradle
 COPY ktor-asyncdb/build.gradle.kts build.gradle.kts
-COPY ktor-asyncdb/gradle.properties gradle.properties
 COPY ktor-asyncdb/gradlew gradlew
-COPY ktor-asyncdb/settings.gradle settings.gradle
 COPY ktor-asyncdb/src src
 RUN /app/gradlew --no-daemon shadowJar
 
+FROM amazoncorretto:21-al2023-headless
+WORKDIR /app
+COPY --from=build /app/build/libs/ktor-asyncdb.jar ktor-asyncdb.jar
+
 EXPOSE 9090
 
-CMD ["java", "-server", "-XX:+UseParallelGC", "-Xms2G","-Xmx2G", "-jar", "/app/build/libs/bench.jar", "jasync-sql"]
+CMD ["java", "-server", "-XX:+UseNUMA", "-XX:+UseParallelGC", "-XX:+AlwaysPreTouch", "-jar", "ktor-asyncdb.jar", "jasync-sql"]

frameworks/Kotlin/ktor/ktor-jetty.dockerfile

@@ -1,13 +1,13 @@
-FROM maven:3.9.7-amazoncorretto-17-debian as maven
+FROM maven:3.9.9-amazoncorretto-21-debian-bookworm as maven
 WORKDIR /ktor
 COPY ktor/pom.xml pom.xml
 COPY ktor/src src
 RUN mvn clean package -q
 
-FROM amazoncorretto:17.0.11-al2023-headless
+FROM amazoncorretto:21-al2023-headless
 WORKDIR /ktor
 COPY --from=maven /ktor/target/tech-empower-framework-benchmark-1.0-SNAPSHOT-jetty-bundle.jar app.jar
 
 EXPOSE 9090
 
-CMD ["java", "-jar", "app.jar"]
+CMD ["java", "-server","-XX:+UseNUMA", "-XX:+UseParallelGC", "-XX:+AlwaysPreTouch", "-jar", "app.jar"]

frameworks/Kotlin/ktor/ktor-pgclient.dockerfile

@@ -1,4 +1,4 @@
-FROM maven:3.9.7-amazoncorretto-17-debian as build
+FROM gradle:jdk21 as build
 WORKDIR /app
 COPY ktor-pgclient/gradle gradle
 COPY ktor-pgclient/build.gradle.kts build.gradle.kts
@@ -6,10 +6,10 @@ COPY ktor-pgclient/gradlew gradlew
 COPY ktor-pgclient/src src
 RUN /app/gradlew --no-daemon shadowJar
 
-FROM amazoncorretto:17.0.11-al2023-headless
+FROM amazoncorretto:21-al2023-headless
 WORKDIR /app
 COPY --from=build /app/build/libs/ktor-pgclient.jar ktor-pgclient.jar
 
 EXPOSE 8080
 
-CMD ["java", "-server", "-XX:MaxRAMFraction=1", "-XX:-UseBiasedLocking", "-XX:+UseNUMA", "-XX:+UseParallelGC", "-XX:+AlwaysPreTouch", "-jar", "ktor-pgclient.jar"]
+CMD ["java", "-server","-XX:+UseNUMA", "-XX:+UseParallelGC", "-XX:+AlwaysPreTouch", "-jar", "ktor-pgclient.jar"]

frameworks/Kotlin/ktor/ktor-pgclient/build.gradle.kts

@@ -1,6 +1,6 @@
 plugins {
     application
-    kotlin("jvm") version "1.9.22"
+    kotlin("jvm") version "2.0.21"
     kotlin("plugin.serialization") version "2.0.0"
     id("com.github.johnrengelman.shadow") version "8.1.0"
 }
@@ -17,19 +17,22 @@ application {
 }
 
 val ktor_version = "2.3.12"
+val vertx_version = "4.5.11"
 
 dependencies {
-    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.3")
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.3")
     implementation("io.ktor:ktor-server-netty:$ktor_version")
     implementation("io.ktor:ktor-server-html-builder-jvm:$ktor_version")
     implementation("io.ktor:ktor-server-default-headers-jvm:$ktor_version")
-    implementation("io.vertx:vertx-pg-client:4.5.8")
-    implementation("io.vertx:vertx-lang-kotlin:4.5.8")
-    implementation("io.vertx:vertx-lang-kotlin-coroutines:4.5.8")
+    implementation("io.vertx:vertx-pg-client:$vertx_version")
+    implementation("io.vertx:vertx-lang-kotlin:$vertx_version")
+    implementation("io.vertx:vertx-lang-kotlin-coroutines:$vertx_version")
 }
 
-tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>().configureEach {
-    kotlinOptions.jvmTarget = "17"
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(21)
+    }
 }
 
 tasks.shadowJar {

frameworks/Kotlin/ktor/ktor-pgclient/gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.0.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.11.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

frameworks/Kotlin/ktor/ktor-r2dbc.dockerfile

@@ -0,0 +1,13 @@
+FROM maven:3.9.9-amazoncorretto-21-debian-bookworm as maven
+WORKDIR /ktor-r2dbc
+COPY ktor-r2dbc/pom.xml pom.xml
+COPY ktor-r2dbc/src src
+RUN mvn clean package -q
+
+FROM amazoncorretto:21-al2023-headless
+WORKDIR /ktor-r2dbc
+COPY --from=maven /ktor-r2dbc/target/tech-empower-framework-benchmark-1.0-SNAPSHOT-netty-bundle.jar app.jar
+
+EXPOSE 9090
+
+CMD ["java", "-server","-XX:+UseNUMA", "-XX:+UseParallelGC", "-XX:+AlwaysPreTouch", "-jar", "app.jar"]

frameworks/Kotlin/ktor/ktor-r2dbc/README.md

@@ -0,0 +1,50 @@
+# Ktor
+
+Ktor is a framework for building servers and clients in connected systems using Kotlin programming language.
+More information is available at [ktor.io](http://ktor.io). 
+
+# Setup
+
+* Java 21
+* Postgres server
+
+# Requirements
+
+* Maven 3
+* JDK 21
+* Kotlin
+* ktor
+* netty
+* R2DBC
+
+Maven is downloaded automatically via Maven Wrapper script (`mvnw`), add dependencies are specified in `pom.xml` so will be downloaded automatically from maven central and jcenter repositories.
+
+# Deployment
+
+Run maven to build a bundle
+
+```bash
+./mvnw package
+```
+
+Once bundle build complete and mysql server is running you can launch the application
+
+```bash
+java -jar target/tech-empower-framework-benchmark-1.0-SNAPSHOT.jar
+```
+
+Please note that the server holds tty so you may need nohup. See `setup.sh` for details.
+
+# Contact
+
+[Leonid Stashevsky](https://github.com/e5l)
+
+[Sergey Mashkov](https://github.com/cy6erGn0m)
+
+[Ilya Ryzhenkov](https://github.com/orangy)
+
+[Ilya Nemtsev](https://github.com/inemtsev)
+
+Slack ktor channel https://kotlinlang.slack.com/messages/ktor (you need an [invite](http://slack.kotlinlang.org/) to join)
+
+

frameworks/Kotlin/ktor/ktor-r2dbc/pom.xml

@@ -0,0 +1,174 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>org.jetbrains.ktor</groupId>
+    <artifactId>tech-empower-framework-benchmark</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+
+    <name>org.jetbrains.ktor tech-empower-framework-benchmark</name>
+
+    <properties>
+        <kotlin.version>2.0.21</kotlin.version>
+        <kotlin.coroutines.version>1.10.1</kotlin.coroutines.version>
+        <ktor.version>3.0.3</ktor.version>
+        <serialization.version>1.7.3</serialization.version>
+        <kotlinx.html.version>0.11.0</kotlinx.html.version>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <logback.version>1.5.12</logback.version>
+        <reactor.version>3.7.1</reactor.version>
+        <postgresql.version>42.7.4</postgresql.version>
+        <r2dbc.version>1.0.7.RELEASE</r2dbc.version>
+        <r2dbc.pool.version>1.0.2.RELEASE</r2dbc.pool.version>
+
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.jetbrains.kotlin</groupId>
+            <artifactId>kotlin-reflect</artifactId>
+            <version>${kotlin.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains.kotlinx</groupId>
+            <artifactId>kotlinx-serialization-core</artifactId>
+            <version>${serialization.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains.kotlinx</groupId>
+            <artifactId>kotlinx-serialization-json</artifactId>
+            <version>${serialization.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains.kotlinx</groupId>
+            <artifactId>kotlinx-html-jvm</artifactId>
+            <version>${kotlinx.html.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains.kotlinx</groupId>
+            <artifactId>kotlinx-coroutines-core</artifactId>
+            <version>${kotlin.coroutines.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains.kotlinx</groupId>
+            <artifactId>kotlinx-coroutines-reactor</artifactId>
+            <version>${kotlin.coroutines.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.ktor</groupId>
+            <artifactId>ktor-server-default-headers-jvm</artifactId>
+            <version>${ktor.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.ktor</groupId>
+            <artifactId>ktor-server-html-builder-jvm</artifactId>
+            <version>${ktor.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.postgresql</groupId>
+            <artifactId>r2dbc-postgresql</artifactId>
+            <version>${r2dbc.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.r2dbc</groupId>
+            <artifactId>r2dbc-pool</artifactId>
+            <version>${r2dbc.pool.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.projectreactor</groupId>
+            <artifactId>reactor-core</artifactId>
+            <version>${reactor.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-classic</artifactId>
+            <version>${logback.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.ktor</groupId>
+            <artifactId>ktor-server-netty-jvm</artifactId>
+            <version>${ktor.version}</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <sourceDirectory>src/main/kotlin</sourceDirectory>
+
+        <plugins>
+            <plugin>
+                <groupId>org.jetbrains.kotlin</groupId>
+                <artifactId>kotlin-maven-plugin</artifactId>
+                <version>${kotlin.version}</version>
+                <executions>
+                    <execution>
+                        <id>compile</id>
+                        <phase>compile</phase>
+                        <goals>
+                            <goal>compile</goal>
+                        </goals>
+                    </execution>
+                    <execution>
+                        <id>test-compile</id>
+                        <phase>test-compile</phase>
+                        <goals>
+                            <goal>test-compile</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <compilerPlugins>
+                        <plugin>kotlinx-serialization</plugin>
+                    </compilerPlugins>
+                </configuration>
+                <dependencies>
+                    <dependency>
+                        <groupId>org.jetbrains.kotlin</groupId>
+                        <artifactId>kotlin-maven-serialization</artifactId>
+                        <version>${kotlin.version}</version>
+                    </dependency>
+                </dependencies>
+            </plugin>
+            <plugin>
+                <artifactId>maven-jar-plugin</artifactId>
+                <configuration>
+                    <skip>true</skip>
+                </configuration>
+                <executions>
+                    <execution>
+                        <id>default-jar</id>
+                        <phase>none</phase>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <artifactId>maven-assembly-plugin</artifactId>
+                <version>3.0.0</version>
+
+                <executions>
+                    <execution>
+                        <id>netty</id>
+                        <goals>
+                            <goal>single</goal>
+                        </goals>
+
+                        <phase>package</phase>
+
+                        <configuration>
+                            <descriptors>
+                                <descriptor>src/main/assembly/netty-bundle.xml</descriptor>
+                            </descriptors>
+                            <archive>
+                                <manifest>
+                                    <mainClass>io.ktor.server.netty.EngineMain</mainClass>
+                                </manifest>
+                            </archive>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>

frameworks/Kotlin/ktor/ktor-r2dbc/src/main/assembly/netty-bundle.xml

@@ -0,0 +1,29 @@
+<assembly xmlns="http://maven.apache.org/ASSEMBLY/2.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+          xsi:schemaLocation="http://maven.apache.org/ASSEMBLY/2.0.0 http://maven.apache.org/xsd/assembly-2.0.0.xsd">
+    <id>netty-bundle</id>
+
+    <formats>
+        <format>jar</format>
+    </formats>
+
+    <includeBaseDirectory>false</includeBaseDirectory>
+
+    <dependencySets>
+        <dependencySet>
+            <unpack>true</unpack>
+            <scope>runtime</scope>
+
+            <excludes>
+                <exclude>*:ktor-server-jetty</exclude>
+                <exclude>*:ktor-server-cio</exclude>
+            </excludes>
+        </dependencySet>
+    </dependencySets>
+
+    <fileSets>
+        <fileSet>
+            <directory>${project.build.outputDirectory}</directory>
+            <outputDirectory>/</outputDirectory>
+        </fileSet>
+    </fileSets>
+</assembly>

frameworks/Kotlin/ktor/ktor-r2dbc/src/main/kotlin/org/jetbrains/ktor/benchmarks/Hello.kt

@@ -0,0 +1,186 @@
+package org.jetbrains.ktor.benchmarks
+
+import io.ktor.http.*
+import io.ktor.http.content.*
+import io.ktor.server.application.*
+import io.ktor.server.config.*
+import io.ktor.server.html.*
+import io.ktor.server.plugins.defaultheaders.*
+import io.ktor.server.response.*
+import io.ktor.server.routing.*
+import io.r2dbc.pool.ConnectionPool
+import io.r2dbc.pool.ConnectionPoolConfiguration
+import io.r2dbc.postgresql.PostgresqlConnectionConfiguration
+import io.r2dbc.postgresql.PostgresqlConnectionFactory
+import io.r2dbc.postgresql.client.SSLMode
+import io.r2dbc.spi.Connection
+import io.r2dbc.spi.ConnectionFactory
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.reactive.awaitFirst
+import kotlinx.coroutines.reactive.awaitFirstOrNull
+import kotlinx.html.*
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import org.jetbrains.ktor.benchmarks.Constants.DB_ROWS
+import org.jetbrains.ktor.benchmarks.Constants.FORTUNES_QUERY
+import org.jetbrains.ktor.benchmarks.Constants.UPDATE_QUERY
+import org.jetbrains.ktor.benchmarks.Constants.WORLD_QUERY
+import org.jetbrains.ktor.benchmarks.models.Fortune
+import org.jetbrains.ktor.benchmarks.models.Message
+import org.jetbrains.ktor.benchmarks.models.World
+import reactor.core.publisher.Flux
+import reactor.core.publisher.Mono
+import kotlin.random.Random
+
+fun Application.main() {
+    val config = ApplicationConfig("application.conf")
+    val dbConnFactory = configurePostgresR2DBC(config)
+
+    install(DefaultHeaders)
+
+    val helloWorldContent = TextContent("Hello, World!", ContentType.Text.Plain)
+
+    routing {
+        get("/plaintext") {
+            call.respond(helloWorldContent)
+        }
+
+        get("/json") {
+            call.respondText(Json.encodeToString(Message("Hello, world!")), ContentType.Application.Json)
+        }
+
+        get("/db") {
+            val random = Random.Default
+            val request = getWorld(dbConnFactory, random)
+            val result = request.awaitFirstOrNull()
+
+            call.respondText(Json.encodeToString(result), ContentType.Application.Json)
+        }
+
+        fun selectWorlds(queries: Int, random: Random): Flow<World> = flow {
+            repeat(queries) {
+                emit(getWorld(dbConnFactory, random).awaitFirst())
+            }
+        }
+
+        get("/queries") {
+            val queries = call.queries()
+            val random = Random.Default
+
+            val result = buildList {
+                selectWorlds(queries, random).collect {
+                    add(it)
+                }
+            }
+
+            call.respondText(Json.encodeToString(result), ContentType.Application.Json)
+        }
+
+        get("/fortunes") {
+            val result = mutableListOf<Fortune>()
+
+            val request = Flux.usingWhen(dbConnFactory.create(), { connection ->
+                Flux.from(connection.createStatement(FORTUNES_QUERY).execute()).flatMap { r ->
+                    Flux.from(r.map { row, _ ->
+                        Fortune(
+                            row.get(0, Int::class.java)!!, row.get(1, String::class.java)!!
+                        )
+                    })
+                }
+            }, { connection -> connection.close() })
+
+            request.collectList().awaitFirstOrNull()?.let { result.addAll(it) }
+
+            result.add(Fortune(0, "Additional fortune added at request time."))
+            result.sortBy { it.message }
+            call.respondHtml {
+                head { title { +"Fortunes" } }
+                body {
+                    table {
+                        tr {
+                            th { +"id" }
+                            th { +"message" }
+                        }
+                        for (fortune in result) {
+                            tr {
+                                td { +fortune.id.toString() }
+                                td { +fortune.message }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        get("/updates") {
+            val queries = call.queries()
+            val random = Random.Default
+
+            val worlds = selectWorlds(queries, random)
+
+            val worldsUpdated = buildList {
+                worlds.collect { world ->
+                    world.randomNumber = random.nextInt(DB_ROWS) + 1
+                    add(world)
+
+                    Mono.usingWhen(dbConnFactory.create(), { connection ->
+                        Mono.from(
+                            connection.createStatement(UPDATE_QUERY)
+                                .bind(0, world.randomNumber)
+                                .bind(1, world.id)
+                                .execute()
+                        ).flatMap { Mono.from(it.rowsUpdated) }
+                    }, Connection::close).awaitFirstOrNull()
+                }
+            }
+
+            call.respondText(Json.encodeToString(worldsUpdated), ContentType.Application.Json)
+        }
+    }
+}
+
+private fun getWorld(
+    dbConnFactory: ConnectionFactory, random: Random
+): Mono<World> = Mono.usingWhen(dbConnFactory.create(), { connection ->
+    Mono.from(connection.createStatement(WORLD_QUERY).bind(0, random.nextInt(DB_ROWS) + 1).execute()).flatMap { r ->
+        Mono.from(r.map { row, _ ->
+            World(
+                row.get(0, Int::class.java)!!, row.get(1, Int::class.java)!!
+            )
+        })
+    }
+}, Connection::close)
+
+private fun configurePostgresR2DBC(config: ApplicationConfig): ConnectionFactory {
+    val cfo = PostgresqlConnectionConfiguration.builder()
+        .host(config.property("db.host").getString())
+        .port(config.property("db.port").getString().toInt())
+        .database(config.property("db.database").getString())
+        .username(config.property("db.username").getString())
+        .password(config.property("db.password").getString())
+        .loopResources { NioClientEventLoopResources(Runtime.getRuntime().availableProcessors()).cacheLoops() }
+        .sslMode(SSLMode.DISABLE)
+        .tcpKeepAlive(true)
+        .tcpNoDelay(true)
+        .build()
+
+    val cf = PostgresqlConnectionFactory(cfo)
+
+    val cp = ConnectionPoolConfiguration.builder(cf)
+        .initialSize(config.property("db.initPoolSize").getString().toInt())
+        .maxSize(config.property("db.maxPoolSize").getString().toInt())
+        .build()
+
+    return ConnectionPool(cp)
+}
+
+private fun ApplicationCall.queries() = request.queryParameters["queries"]?.toIntOrNull()?.coerceIn(1, 500) ?: 1
+
+
+object Constants {
+    const val WORLD_QUERY = "SELECT id, randomnumber FROM world WHERE id = $1"
+    const val FORTUNES_QUERY = "SELECT id, message FROM fortune"
+    const val UPDATE_QUERY = "UPDATE world SET randomnumber = $1 WHERE id = $2"
+    const val DB_ROWS = 10000
+}

frameworks/Kotlin/ktor/ktor-r2dbc/src/main/kotlin/org/jetbrains/ktor/benchmarks/NioClientEventLoopResources.java

@@ -0,0 +1,123 @@
+package org.jetbrains.ktor.benchmarks;
+
+import io.netty.channel.Channel;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.DatagramChannel;
+import io.netty.channel.socket.ServerSocketChannel;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.channel.socket.nio.NioDatagramChannel;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+import io.netty.channel.socket.nio.NioSocketChannel;
+import io.netty.util.concurrent.DefaultThreadFactory;
+import io.netty.util.concurrent.Future;
+import io.netty.util.concurrent.ThreadPerTaskExecutor;
+import reactor.core.publisher.Mono;
+import reactor.netty.FutureMono;
+import reactor.netty.resources.LoopResources;
+
+import java.time.Duration;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * Copied from GitHub issue comment: https://github.com/r2dbc/r2dbc-pool/issues/190#issuecomment-1566845190
+ */
+public class NioClientEventLoopResources implements LoopResources {
+    public static final String THREAD_PREFIX = "prefix-";
+    final int threads;
+    final AtomicReference<EventLoopGroup> loops = new AtomicReference<>();
+    final AtomicBoolean running;
+
+    NioClientEventLoopResources(int threads) {
+        this.running = new AtomicBoolean(true);
+        this.threads = threads;
+    }
+
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public Mono<Void> disposeLater(Duration quietPeriod, Duration timeout) {
+        return Mono.defer(() -> {
+        long quietPeriodMillis = quietPeriod.toMillis();
+        long timeoutMillis = timeout.toMillis();
+        EventLoopGroup serverLoopsGroup = loops.get();
+        Mono<?> slMono = Mono.empty();
+        if (running.compareAndSet(true, false)) {
+            if (serverLoopsGroup != null) {
+                slMono = FutureMono.from((Future) serverLoopsGroup.shutdownGracefully(
+                        quietPeriodMillis, timeoutMillis, TimeUnit.MILLISECONDS));
+            }
+        }
+        return Mono.when(slMono);
+    });
+    }
+
+    @Override
+    public boolean isDisposed() {
+        return !running.get();
+    }
+
+    @Override
+    public EventLoopGroup onClient(boolean useNative) {
+        return cacheLoops();
+    }
+
+    @Override
+    public EventLoopGroup onServer(boolean useNative) {
+        throw new UnsupportedOperationException("This event loop is designed only for client DB calls.");
+    }
+
+    @Override
+    public EventLoopGroup onServerSelect(boolean useNative) {
+        throw new UnsupportedOperationException("This event loop is designed only for client DB calls.");
+    }
+
+    @Override
+    public <CHANNEL extends Channel> CHANNEL onChannel(Class<CHANNEL> channelType, EventLoopGroup group) {
+        if (channelType.equals(SocketChannel.class)) {
+                return (CHANNEL) new NioSocketChannel();
+            }
+            if (channelType.equals(ServerSocketChannel.class)) {
+                    return (CHANNEL) new NioServerSocketChannel();
+                }
+                if (channelType.equals(DatagramChannel.class)) {
+                        return (CHANNEL) new NioDatagramChannel();
+                    }
+                    throw new IllegalArgumentException("Unsupported channel type: " + channelType.getSimpleName());
+    }
+
+    @Override
+    public <CHANNEL extends Channel> Class<? extends CHANNEL> onChannelClass(Class<CHANNEL> channelType,
+        EventLoopGroup group) {
+        if (channelType.equals(SocketChannel.class)) {
+                return (Class<? extends CHANNEL>) NioSocketChannel.class;
+            }
+            if (channelType.equals(ServerSocketChannel.class)) {
+                    return (Class<? extends CHANNEL>) NioServerSocketChannel.class;
+                }
+                if (channelType.equals(DatagramChannel.class)) {
+                        return (Class<? extends CHANNEL>) NioDatagramChannel.class;
+                    }
+                    throw new IllegalArgumentException("Unsupported channel type: " + channelType.getSimpleName());
+    }
+
+    @SuppressWarnings("FutureReturnValueIgnored")
+    EventLoopGroup cacheLoops() {
+        EventLoopGroup eventLoopGroup = loops.get();
+        if (null == eventLoopGroup) {
+            EventLoopGroup newEventLoopGroup = createNewEventLoopGroup();
+            if (!loops.compareAndSet(null, newEventLoopGroup)) {
+                //"FutureReturnValueIgnored" this is deliberate
+                newEventLoopGroup.shutdownGracefully(0, 0, TimeUnit.MILLISECONDS);
+            }
+            eventLoopGroup = cacheLoops();
+        }
+        return eventLoopGroup;
+    }
+
+    private NioEventLoopGroup createNewEventLoopGroup() {
+        return new NioEventLoopGroup(threads, new ThreadPerTaskExecutor(new DefaultThreadFactory(THREAD_PREFIX)));
+    }
+}

frameworks/Kotlin/ktor/ktor-r2dbc/src/main/kotlin/org/jetbrains/ktor/benchmarks/models/Fortune.kt

@@ -0,0 +1,6 @@
+package org.jetbrains.ktor.benchmarks.models
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+class Fortune(val id: Int, var message: String)

frameworks/Kotlin/ktor/ktor-r2dbc/src/main/kotlin/org/jetbrains/ktor/benchmarks/models/Message.kt

@@ -0,0 +1,6 @@
+package org.jetbrains.ktor.benchmarks.models
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+class Message(val message: String)

frameworks/Kotlin/ktor/ktor-r2dbc/src/main/kotlin/org/jetbrains/ktor/benchmarks/models/World.kt

@@ -0,0 +1,6 @@
+package org.jetbrains.ktor.benchmarks.models
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+class World(val id: Int, var randomNumber: Int)

frameworks/Kotlin/ktor/ktor-r2dbc/src/main/resources/application.conf

@@ -0,0 +1,26 @@
+ktor {
+    deployment {
+        port = 9090
+        autoreload = false
+        watch = [ ]
+        shareWorkGroup = true
+    }
+
+    application {
+        modules = [ org.jetbrains.ktor.benchmarks.HelloKt.main ]
+    }
+}
+
+db {
+    driver = "pool"
+    protocol = "postgresql"
+    ssl = "false"
+    host = "tfb-database"
+    port = 5432
+    database = "hello_world"
+    initPoolSize = 512
+    maxPoolSize = 512
+    username = "benchmarkdbuser"
+    password = "benchmarkdbpass"
+    //url = "r2dbc:postgresql://"${db.host}":"${db.port}"/"${db.database}"?loggerLevel=OFF&disableColumnSanitiser=true&assumeMinServerVersion=16&sslmode=disable&maxSize="${db.poolSize}
+}

frameworks/Kotlin/ktor/ktor-r2dbc/src/main/resources/logback.xml

@@ -0,0 +1,21 @@
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{YYYY-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+        </encoder>
+    </appender>
+
+     <appender name="ASYNC" class="ch.qos.logback.classic.AsyncAppender">
+         <neverBlock>true</neverBlock>
+         <appender-ref ref="STDOUT" />
+     </appender>
+
+
+    <root level="INFO">
+        <appender-ref ref="ASYNC"/>
+    </root>
+
+    <logger name="org.eclipse.jetty" level="INFO"/>
+    <logger name="io.netty" level="INFO"/>
+
+</configuration>

frameworks/Kotlin/ktor/ktor/README.md

@@ -5,13 +5,13 @@ More information is available at [ktor.io](http://ktor.io).
 
 # Setup
 
-* Java 17
-* MySQL server
+* Java 21
+* Postgres server
 
 # Requirements
 
 * Maven 3
-* JDK 17
+* JDK 21
 * Kotlin
 * ktor
 * netty 

frameworks/Kotlin/ktor/ktor/pom.xml

@@ -13,7 +13,7 @@
 
     <properties>
         <kotlin.version>2.0.21</kotlin.version>
-        <ktor.version>3.0.2</ktor.version>
+        <ktor.version>3.0.3</ktor.version>
         <serialization.version>1.7.3</serialization.version>
         <kotlinx.html.version>0.11.0</kotlinx.html.version>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

frameworks/Kotlin/ktor/ktor/src/main/kotlin/org/jetbrains/ktor/benchmarks/Hello.kt

@@ -38,7 +38,7 @@ fun Application.main() {
 
     install(DefaultHeaders)
 
-    val helloWorldContent = TextContent("Hello, World!", ContentType.Text.Plain).also { it.contentLength }
+    val helloWorldContent = TextContent("Hello, World!", ContentType.Text.Plain)
 
     routing {
         get("/plaintext") {

frameworks/PHP/amp/amp.dockerfile

@@ -1,4 +1,4 @@
-FROM ubuntu:22.04
+FROM ubuntu:24.04
 
 ARG DEBIAN_FRONTEND=noninteractive
 
@@ -6,24 +6,23 @@ RUN apt-get update -yqq && apt-get install -yqq software-properties-common > /de
 RUN LC_ALL=C.UTF-8 add-apt-repository ppa:ondrej/php
 RUN apt-get update -yqq > /dev/null && \
     apt-get install -yqq git unzip wget curl build-essential \
-    php8.3-cli php8.3-mbstring php8.3-dev php8.3-xml php8.3-curl > /dev/null
+    php8.4-cli php8.4-mbstring php8.4-dev php8.4-xml php8.4-curl > /dev/null
 
 # An extension is required!
 # We deal with concurrencies over 1k, which stream_select doesn't support.
 RUN wget http://pear.php.net/go-pear.phar --quiet && php go-pear.phar
 #RUN apt-get install -y libuv1-dev > /dev/null
 RUN apt-get install -y libevent-dev > /dev/null
-#RUN pecl install uv-0.2.4 > /dev/null && echo "extension=uv.so" > /etc/php/8.3/cli/conf.d/uv.ini
-RUN pecl install event-3.1.3 > /dev/null && echo "extension=event.so" > /etc/php/8.3/cli/conf.d/event.ini
+#RUN pecl install uv-0.2.4 > /dev/null && echo "extension=uv.so" > /etc/php/8.4/cli/conf.d/uv.ini
+RUN pecl install event-3.1.4 > /dev/null && echo "extension=event.so" > /etc/php/8.4/cli/conf.d/event.ini
 
-ADD ./ /amp
 WORKDIR /amp
-
-COPY deploy/conf/* /etc/php/8.3/cli/conf.d/
+COPY --link . .
+COPY deploy/conf/* /etc/php/8.4/cli/conf.d/
 
 COPY --from=composer:latest /usr/bin/composer /usr/local/bin/composer
 
-RUN composer install --prefer-dist --optimize-autoloader --no-dev 
+RUN composer install --prefer-dist --optimize-autoloader --no-dev --quiet
 
 EXPOSE 8080
 

frameworks/PHP/fat-free/composer.json

@@ -1,5 +1,5 @@
 {
     "require": {
-        "bcosca/fatfree-core": "3.8.0"
+        "bcosca/fatfree-core": "^3.8"
     }
-}
+}

frameworks/PHP/fat-free/fat-free-raw.dockerfile

@@ -1,16 +1,16 @@
-FROM ubuntu:22.04
+FROM ubuntu:24.04
 
 ARG DEBIAN_FRONTEND=noninteractive
 
 RUN apt-get update -yqq && apt-get install -yqq software-properties-common > /dev/null
 RUN LC_ALL=C.UTF-8 add-apt-repository ppa:ondrej/php
 RUN apt-get update -yqq > /dev/null && \
-    apt-get install -yqq nginx git unzip php8.3 php8.3-common php8.3-cli php8.3-fpm php8.3-mysql  > /dev/null
+    apt-get install -yqq nginx git unzip php8.4 php8.4-common php8.4-cli php8.4-fpm php8.4-mysql  > /dev/null
 
-COPY deploy/conf/* /etc/php/8.3/fpm/
+COPY deploy/conf/* /etc/php/8.4/fpm/
 
-ADD ./ /fat-free
 WORKDIR /fat-free
+COPY --link . .
 
 ENV F3DIR="/fat-free/src"
 
@@ -18,11 +18,11 @@ COPY --from=composer:latest /usr/bin/composer /usr/local/bin/composer
 
 RUN composer install --optimize-autoloader --classmap-authoritative --no-dev --quiet
 
-RUN if [ $(nproc) = 2 ]; then sed -i "s|pm.max_children = 1024|pm.max_children = 512|g" /etc/php/8.3/fpm/php-fpm.conf ; fi;
+RUN if [ $(nproc) = 2 ]; then sed -i "s|pm.max_children = 1024|pm.max_children = 512|g" /etc/php/8.4/fpm/php-fpm.conf ; fi;
 
 RUN chmod -R 777 /fat-free
 
 EXPOSE 8080
 
-CMD service php8.3-fpm start && \
+CMD service php8.4-fpm start && \
     nginx -c /fat-free/deploy/nginx.conf

frameworks/PHP/fat-free/fat-free.dockerfile

@@ -1,16 +1,16 @@
-FROM ubuntu:22.04
+FROM ubuntu:24.04
 
 ARG DEBIAN_FRONTEND=noninteractive
 
 RUN apt-get update -yqq && apt-get install -yqq software-properties-common > /dev/null
 RUN LC_ALL=C.UTF-8 add-apt-repository ppa:ondrej/php
 RUN apt-get update -yqq > /dev/null && \
-    apt-get install -yqq nginx git unzip php8.3 php8.3-common php8.3-cli php8.3-fpm php8.3-mysql  > /dev/null
+    apt-get install -yqq nginx git unzip php8.4 php8.4-common php8.4-cli php8.4-fpm php8.4-mysql  > /dev/null
 
-COPY deploy/conf/* /etc/php/8.3/fpm/
+COPY deploy/conf/* /etc/php/8.4/fpm/
 
-ADD ./ /fat-free
 WORKDIR /fat-free
+COPY --link . .
 
 ENV F3DIR="/fat-free/src"
 
@@ -19,11 +19,11 @@ COPY --from=composer:latest /usr/bin/composer /usr/local/bin/composer
 
 RUN composer install --optimize-autoloader --classmap-authoritative --no-dev --quiet
 
-RUN if [ $(nproc) = 2 ]; then sed -i "s|pm.max_children = 1024|pm.max_children = 512|g" /etc/php/8.3/fpm/php-fpm.conf ; fi;
+RUN if [ $(nproc) = 2 ]; then sed -i "s|pm.max_children = 1024|pm.max_children = 512|g" /etc/php/8.4/fpm/php-fpm.conf ; fi;
 
 RUN chmod -R 777 /fat-free
 
 EXPOSE 8080
 
-CMD service php8.3-fpm start && \
+CMD service php8.4-fpm start && \
     nginx -c /fat-free/deploy/nginx.conf

frameworks/PHP/kumbiaphp/composer.json

@@ -1,5 +1,5 @@
 {
 	"require": {
-		"joanhey/adapterman": "^0.6"
+		"joanhey/adapterman": "^0.7"
 	}
 }

frameworks/PHP/kumbiaphp/deploy/conf/cliphp.ini

@@ -13,4 +13,4 @@ memory_limit = 512M
 opcache.jit_buffer_size=128M
 opcache.jit=tracing
 
-disable_functions=header,header_remove,headers_sent,http_response_code,setcookie,session_create_id,session_id,session_name,session_save_path,session_status,session_start,session_write_close,session_regenerate_id,set_time_limit
+disable_functions=header,header_remove,headers_sent,headers_list,http_response_code,setcookie,session_create_id,session_id,session_name,session_save_path,session_status,session_start,session_write_close,session_regenerate_id,session_unset,session_get_cookie_params,session_set_cookie_params,set_time_limit

frameworks/PHP/kumbiaphp/kumbiaphp-raw.dockerfile

@@ -1,4 +1,4 @@
-FROM ubuntu:22.04
+FROM ubuntu:24.04
 
 ARG DEBIAN_FRONTEND=noninteractive
 
@@ -7,17 +7,17 @@ RUN LC_ALL=C.UTF-8 add-apt-repository ppa:ondrej/php > /dev/null && \
     apt-get update -yqq > /dev/null && apt-get upgrade -yqq > /dev/null
 
 RUN apt-get install -yqq nginx git unzip \
-    php8.3-fpm php8.3-mysql > /dev/null
+    php8.4-fpm php8.4-mysql > /dev/null
 
-COPY --link deploy/conf/* /etc/php/8.3/fpm/
+COPY --link deploy/conf/* /etc/php/8.4/fpm/
 WORKDIR /kumbiaphp
 COPY --link . .
 
 RUN git clone -b v1.2.1 --single-branch --depth 1 -q https://github.com/KumbiaPHP/KumbiaPHP.git vendor/Kumbia
 
-RUN if [ $(nproc) = 2 ]; then sed -i "s|pm.max_children = 1024|pm.max_children = 512|g" /etc/php/8.3/fpm/php-fpm.conf ; fi;
+RUN if [ $(nproc) = 2 ]; then sed -i "s|pm.max_children = 1024|pm.max_children = 512|g" /etc/php/8.4/fpm/php-fpm.conf ; fi;
 
 EXPOSE 8080
 
-CMD service php8.3-fpm start && \
+CMD service php8.4-fpm start && \
     nginx -c /kumbiaphp/deploy/nginx.conf

frameworks/PHP/kumbiaphp/kumbiaphp-workerman-mysql.dockerfile

@@ -1,4 +1,4 @@
-FROM ubuntu:22.04
+FROM ubuntu:24.04
 
 ARG DEBIAN_FRONTEND=noninteractive
 
@@ -6,14 +6,14 @@ RUN apt-get update -yqq && apt-get install -yqq software-properties-common > /de
 RUN LC_ALL=C.UTF-8 add-apt-repository ppa:ondrej/php > /dev/null && \
     apt-get update -yqq > /dev/null && apt-get upgrade -yqq > /dev/null
 
-RUN apt-get install -yqq git php8.3-cli php8.3-mysql php8.3-xml > /dev/null
+RUN apt-get install -yqq git php8.4-cli php8.4-mysql php8.4-xml > /dev/null
 
 COPY --from=composer:latest /usr/bin/composer /usr/local/bin/composer
 
-RUN apt-get install -y php-pear php8.3-dev libevent-dev > /dev/null
-RUN pecl install event-3.1.3 > /dev/null && echo "extension=event.so" > /etc/php/8.3/cli/conf.d/event.ini
+RUN apt-get install -y php-pear php8.4-dev libevent-dev > /dev/null
+RUN pecl install event-3.1.4 > /dev/null && echo "extension=event.so" > /etc/php/8.4/cli/conf.d/event.ini
 
-COPY deploy/conf/cliphp.ini /etc/php/8.3/cli/php.ini
+COPY deploy/conf/cliphp.ini /etc/php/8.4/cli/php.ini
 
 ADD ./ /kumbiaphp
 WORKDIR /kumbiaphp

frameworks/PHP/kumbiaphp/kumbiaphp-workerman.dockerfile

@@ -1,18 +1,18 @@
-FROM ubuntu:22.04
+FROM ubuntu:24.04
 
 ARG DEBIAN_FRONTEND=noninteractive
 
 RUN apt-get update -yqq && apt-get install -yqq software-properties-common > /dev/null
 RUN LC_ALL=C.UTF-8 add-apt-repository ppa:ondrej/php
 RUN apt-get update -yqq > /dev/null && \
-    apt-get install -yqq git php8.3-cli php8.3-pgsql php8.3-xml > /dev/null
+    apt-get install -yqq git php8.4-cli php8.4-pgsql php8.4-xml > /dev/null
 
 COPY --from=composer:latest /usr/bin/composer /usr/local/bin/composer
 
-RUN apt-get install -y php-pear php8.3-dev libevent-dev > /dev/null
-RUN pecl install event-3.1.3 > /dev/null && echo "extension=event.so" > /etc/php/8.3/cli/conf.d/event.ini
+RUN apt-get install -y php-pear php8.4-dev libevent-dev > /dev/null
+RUN pecl install event-3.1.4 > /dev/null && echo "extension=event.so" > /etc/php/8.4/cli/conf.d/event.ini
 
-COPY deploy/conf/cliphp.ini /etc/php/8.3/cli/php.ini
+COPY deploy/conf/cliphp.ini /etc/php/8.4/cli/php.ini
 
 ADD ./ /kumbiaphp
 WORKDIR /kumbiaphp

frameworks/PHP/kumbiaphp/kumbiaphp.dockerfile

@@ -1,4 +1,4 @@
-FROM ubuntu:22.04
+FROM ubuntu:24.04
 
 ARG DEBIAN_FRONTEND=noninteractive
 
@@ -7,18 +7,18 @@ RUN LC_ALL=C.UTF-8 add-apt-repository ppa:ondrej/php > /dev/null && \
     apt-get update -yqq > /dev/null && apt-get upgrade -yqq > /dev/null
 
 RUN apt-get install -yqq nginx git unzip \
-    php8.3-fpm php8.3-mysql > /dev/null
+    php8.4-fpm php8.4-mysql > /dev/null
 
-COPY --link deploy/conf/* /etc/php/8.3/fpm/
+COPY --link deploy/conf/* /etc/php/8.4/fpm/
 WORKDIR /kumbiaphp
 COPY --link . .
 
 RUN git clone -b v1.2.1 --single-branch --depth 1 https://github.com/KumbiaPHP/KumbiaPHP.git vendor/Kumbia
-RUN git clone -b dev --single-branch --depth 1 https://github.com/KumbiaPHP/ActiveRecord.git vendor/Kumbia/ActiveRecord
+RUN git clone -b master --single-branch --depth 1 https://github.com/KumbiaPHP/ActiveRecord.git vendor/Kumbia/ActiveRecord
 
-RUN if [ $(nproc) = 2 ]; then sed -i "s|pm.max_children = 1024|pm.max_children = 512|g" /etc/php/8.3/fpm/php-fpm.conf ; fi;
+RUN if [ $(nproc) = 2 ]; then sed -i "s|pm.max_children = 1024|pm.max_children = 512|g" /etc/php/8.4/fpm/php-fpm.conf ; fi;
 
 EXPOSE 8080
 
-CMD service php8.3-fpm start && \
+CMD service php8.4-fpm start && \
     nginx -c /kumbiaphp/deploy/nginx.conf

frameworks/PHP/laravel/benchmark_config.json

@@ -160,7 +160,8 @@
 			"database_os": "Linux",
 			"display_name": "laravel-ripple",
 			"notes": "",
-			"versus": "php"
+			"versus": "php",
+			"tags": ["broken"]
 		}
 	}]
 }

frameworks/PHP/laravel/deploy/conf/cli-php.ini

@@ -13,4 +13,4 @@ memory_limit = 512M
 opcache.jit_buffer_size = 128M
 opcache.jit = tracing
 
-disable_functions=header,header_remove,headers_sent,http_response_code,setcookie,session_create_id,session_id,session_name,session_save_path,session_status,session_start,session_write_close,session_regenerate_id,set_time_limit
+disable_functions=header,header_remove,headers_sent,headers_list,http_response_code,setcookie,session_create_id,session_id,session_name,session_save_path,session_status,session_start,session_write_close,session_regenerate_id,session_unset,session_get_cookie_params,session_set_cookie_params,set_time_limit

frameworks/PHP/laravel/laravel-laravel-s.dockerfile

@@ -1,4 +1,4 @@
-FROM phpswoole/swoole:5.1.3-php8.3
+FROM phpswoole/swoole:php8.4
 
 RUN docker-php-ext-install pcntl opcache curl > /dev/null
 

frameworks/PHP/laravel/laravel-swoole.dockerfile

@@ -1,4 +1,4 @@
-FROM phpswoole/swoole:5.1.3-php8.3
+FROM phpswoole/swoole:php8.4
 
 RUN docker-php-ext-install pcntl opcache curl > /dev/null
 

frameworks/PHP/laravel/laravel-workerman.dockerfile

@@ -7,12 +7,12 @@ RUN LC_ALL=C.UTF-8 add-apt-repository ppa:ondrej/php > /dev/null && \
     apt-get update -yqq > /dev/null && apt-get upgrade -yqq > /dev/null
 
 RUN apt-get install -yqq git unzip \
-    php8.3-cli php8.3-mysql php8.3-mbstring php8.3-xml php8.3-curl > /dev/null
+    php8.4-cli php8.4-mysql php8.4-mbstring php8.4-xml php8.4-curl > /dev/null
 
 COPY --from=composer --link /usr/bin/composer /usr/local/bin/composer
 
-RUN apt-get install -y php-pear php8.3-dev libevent-dev > /dev/null
-RUN pecl install event-3.1.3 > /dev/null && echo "extension=event.so" > /etc/php/8.3/cli/conf.d/event.ini
+RUN apt-get install -y php-pear php8.4-dev libevent-dev > /dev/null
+RUN pecl install event-3.1.4 > /dev/null && echo "extension=event.so" > /etc/php/8.4/cli/conf.d/event.ini
 
 WORKDIR /laravel
 COPY --link . .
@@ -26,7 +26,7 @@ RUN mkdir -p bootstrap/cache \
 RUN composer require joanhey/adapterman --update-no-dev --no-scripts --quiet
 RUN php artisan optimize
 
-COPY --link deploy/conf/cli-php.ini /etc/php/8.3/cli/php.ini
+COPY --link deploy/conf/cli-php.ini /etc/php/8.4/cli/php.ini
 
 EXPOSE 8080
 

frameworks/PHP/laravel/laravel.dockerfile

@@ -7,15 +7,15 @@ RUN LC_ALL=C.UTF-8 add-apt-repository ppa:ondrej/php > /dev/null && \
     apt-get update -yqq > /dev/null && apt-get upgrade -yqq > /dev/null
 
 RUN apt-get install -yqq nginx git unzip \
-    php8.3-cli php8.3-fpm php8.3-mysql  php8.3-mbstring php8.3-xml  php8.3-curl > /dev/null
+    php8.4-cli php8.4-fpm php8.4-mysql  php8.4-mbstring php8.4-xml  php8.4-curl > /dev/null
 
 COPY --from=composer --link /usr/bin/composer /usr/local/bin/composer
 
-COPY --link deploy/conf/* /etc/php/8.3/fpm/
+COPY --link deploy/conf/* /etc/php/8.4/fpm/
 WORKDIR /laravel
 COPY --link . .
 
-RUN if [ $(nproc) = 2 ]; then sed -i "s|pm.max_children = 1024|pm.max_children = 512|g" /etc/php/8.3/fpm/php-fpm.conf ; fi;
+RUN if [ $(nproc) = 2 ]; then sed -i "s|pm.max_children = 1024|pm.max_children = 512|g" /etc/php/8.4/fpm/php-fpm.conf ; fi;
 
 RUN mkdir -p bootstrap/cache \
             storage/logs \
@@ -29,7 +29,7 @@ RUN php artisan optimize
 EXPOSE 8080
 
 # Uncomment next line for Laravel console error logging to be viewable in docker logs
-# RUN echo "catch_workers_output = yes" >> /etc/php/8.3/fpm/php-fpm.conf
+# RUN echo "catch_workers_output = yes" >> /etc/php/8.4/fpm/php-fpm.conf
 
-CMD service php8.3-fpm start && \
+CMD service php8.4-fpm start && \
     nginx -c /laravel/deploy/nginx.conf

frameworks/PHP/leaf/deploy/conf/cli-php.ini

@@ -13,4 +13,4 @@ memory_limit = 512M
 opcache.jit_buffer_size = 128M
 opcache.jit = tracing
 
-disable_functions=header,header_remove,headers_sent,http_response_code,setcookie,session_create_id,session_id,session_name,session_save_path,session_status,session_start,session_write_close,session_regenerate_id,set_time_limit
+disable_functions=header,header_remove,headers_sent,headers_list,http_response_code,setcookie,session_create_id,session_id,session_name,session_save_path,session_status,session_start,session_write_close,session_regenerate_id,session_unset,session_get_cookie_params,session_set_cookie_params,set_time_limit

frameworks/PHP/leaf/leaf-workerman.dockerfile

@@ -7,15 +7,15 @@ RUN LC_ALL=C.UTF-8 add-apt-repository ppa:ondrej/php > /dev/null && \
     apt-get update -yqq > /dev/null && apt-get upgrade -yqq > /dev/null
 
 RUN apt-get update -yqq > /dev/null && apt-get install -yqq git \
-    php8.3-cli php8.3-mysql php8.3-mbstring php8.3-xml php8.3-curl php8.3-zip > /dev/null
+    php8.4-cli php8.4-mysql php8.4-mbstring php8.4-xml php8.4-curl php8.4-zip > /dev/null
 
 COPY --from=composer:latest /usr/bin/composer /usr/local/bin/composer
 
-RUN apt-get install -y libevent-dev php8.3-dev > /dev/null \
+RUN apt-get install -y libevent-dev php8.4-dev > /dev/null \
     && pecl install event-3.1.4 > /dev/null \
-    && echo "extension=event.so" > /etc/php/8.3/cli/conf.d/event.ini
+    && echo "extension=event.so" > /etc/php/8.4/cli/conf.d/event.ini
 
-COPY --link deploy/conf/cli-php.ini /etc/php/8.3/cli/php.ini
+COPY --link deploy/conf/cli-php.ini /etc/php/8.4/cli/php.ini
 
 WORKDIR /leaf
 COPY --link . .
@@ -23,7 +23,7 @@ COPY --link . .
 EXPOSE 8080
 
 RUN composer install --optimize-autoloader --classmap-authoritative --no-dev --quiet
-RUN composer require joanhey/adapterman:^0.6 --quiet
+RUN composer require joanhey/adapterman:^0.7 --quiet
 
 
 RUN sed -i 's|app()->run(); //| //$app->run(); //|g' index.php

frameworks/PHP/leaf/leaf.dockerfile

@@ -7,16 +7,16 @@ RUN LC_ALL=C.UTF-8 add-apt-repository ppa:ondrej/php > /dev/null && \
     apt-get update -yqq > /dev/null && apt-get upgrade -yqq > /dev/null
 
 RUN apt-get install -yqq nginx git unzip \
-    php8.3-cli php8.3-fpm php8.3-mysql php8.3-xml php8.3-curl php8.3-zip > /dev/null
+    php8.4-cli php8.4-fpm php8.4-mysql php8.4-xml php8.4-curl php8.4-zip > /dev/null
 
 COPY --from=composer:latest /usr/bin/composer /usr/local/bin/composer
 
-COPY --link deploy/conf/* /etc/php/8.3/fpm/
+COPY --link deploy/conf/* /etc/php/8.4/fpm/
 
 WORKDIR /leaf
 COPY --link . .
 
-RUN if [ $(nproc) = 2 ]; then sed -i "s|pm.max_children = 1024|pm.max_children = 512|g" /etc/php/8.3/fpm/php-fpm.conf ; fi;
+RUN if [ $(nproc) = 2 ]; then sed -i "s|pm.max_children = 1024|pm.max_children = 512|g" /etc/php/8.4/fpm/php-fpm.conf ; fi;
 
 RUN composer install --optimize-autoloader --classmap-authoritative --no-dev --quiet
 
@@ -24,5 +24,5 @@ RUN chmod -R 777 /leaf
 
 EXPOSE 8080
 
-CMD service php8.3-fpm start && \
+CMD service php8.4-fpm start && \
     nginx -c /leaf/deploy/nginx.conf

frameworks/PHP/lumen/deploy/conf/cli-php.ini

@@ -13,4 +13,4 @@ memory_limit = 512M
 opcache.jit_buffer_size = 128M
 opcache.jit = tracing
 
-disable_functions=header,header_remove,headers_sent,http_response_code,setcookie,session_create_id,session_id,session_name,session_save_path,session_status,session_start,session_write_close,session_regenerate_id,set_time_limit
+disable_functions=header,header_remove,headers_sent,headers_list,http_response_code,setcookie,session_create_id,session_id,session_name,session_save_path,session_status,session_start,session_write_close,session_regenerate_id,session_unset,session_get_cookie_params,session_set_cookie_params,set_time_limit

frameworks/PHP/lumen/lumen-laravel-s.dockerfile

@@ -1,4 +1,4 @@
-FROM phpswoole/swoole:5.1.3-php8.3
+FROM phpswoole/swoole:php8.4
 
 RUN docker-php-ext-install pcntl opcache curl > /dev/null
 

frameworks/PHP/lumen/lumen-swoole.dockerfile

@@ -1,4 +1,4 @@
-FROM phpswoole/swoole:5.1.3-php8.3
+FROM phpswoole/swoole:php8.4
 
 RUN docker-php-ext-install pcntl opcache curl > /dev/null
 

frameworks/PHP/lumen/lumen-workerman.dockerfile

@@ -7,19 +7,19 @@ RUN LC_ALL=C.UTF-8 add-apt-repository ppa:ondrej/php > /dev/null && \
     apt-get update -yqq > /dev/null && apt-get upgrade -yqq > /dev/null
 
 RUN apt-get install -yqq nginx git unzip \
-    php8.3-cli php8.3-mysql php8.3-mbstring php8.3-xml php8.3-dev > /dev/null
+    php8.4-cli php8.4-mysql php8.4-mbstring php8.4-xml php8.4-dev > /dev/null
 
 COPY --from=composer:latest /usr/bin/composer /usr/local/bin/composer
 
-RUN apt-get install -y php-pear php8.3-dev libevent-dev > /dev/null
-RUN pecl install event-3.1.3 > /dev/null && echo "extension=event.so" > /etc/php/8.3/cli/conf.d/event.ini
+RUN apt-get install -y php-pear php8.4-dev libevent-dev > /dev/null
+RUN pecl install event-3.1.4 > /dev/null && echo "extension=event.so" > /etc/php/8.4/cli/conf.d/event.ini
 
 WORKDIR /lumen
 COPY --link . .
 
 
 RUN composer install --optimize-autoloader --classmap-authoritative --no-dev --quiet
-RUN composer require joanhey/adapterman:^0.6 --quiet
+RUN composer require joanhey/adapterman:^0.7 --quiet
 
 RUN mkdir -p storage \
             storage/framework/sessions \

frameworks/PHP/lumen/lumen.dockerfile

@@ -7,17 +7,17 @@ RUN LC_ALL=C.UTF-8 add-apt-repository ppa:ondrej/php > /dev/null && \
     apt-get update -yqq > /dev/null && apt-get upgrade -yqq > /dev/null
 
 RUN apt-get install -yqq nginx git unzip \
-    php8.3-cli php8.3-fpm php8.3-mysql php8.3-mbstring php8.3-xml php8.3-dev > /dev/null
+    php8.4-cli php8.4-fpm php8.4-mysql php8.4-mbstring php8.4-xml php8.4-dev > /dev/null
 
 COPY --from=composer:latest /usr/bin/composer /usr/local/bin/composer
 
-COPY deploy/conf/* /etc/php/8.3/fpm/
+COPY deploy/conf/* /etc/php/8.4/fpm/
 
 WORKDIR /lumen
 COPY --link . .
 
 
-RUN if [ $(nproc) = 2 ]; then sed -i "s|pm.max_children = 1024|pm.max_children = 512|g" /etc/php/8.3/fpm/php-fpm.conf ; fi;
+RUN if [ $(nproc) = 2 ]; then sed -i "s|pm.max_children = 1024|pm.max_children = 512|g" /etc/php/8.4/fpm/php-fpm.conf ; fi;
 
 RUN composer install --optimize-autoloader --classmap-authoritative --no-dev --quiet
 
@@ -30,5 +30,5 @@ RUN chmod -R 777 /lumen
 
 EXPOSE 8080
 
-CMD service php8.3-fpm start && \
+CMD service php8.4-fpm start && \
     nginx -c /lumen/deploy/nginx.conf

frameworks/PHP/nette/composer.json

@@ -6,18 +6,17 @@
 	"license": ["MIT", "BSD-3-Clause", "GPL-2.0", "GPL-3.0"],
 	"require": {
 		"php": ">= 7.2",
-		"nette/application": "^3.1",
-		"nette/bootstrap": "^3.1",
-		"nette/caching": "^3.1",
-		"nette/database": "^3.1",
+		"nette/application": "^3.2",
+		"nette/bootstrap": "^3.2",
+		"nette/caching": "^3.3",
+		"nette/database": "^3.2",
 		"nette/di": "^3.0",
-		"nette/finder": "^2.5",
+		"nette/finder": "^3.0",
 		"nette/forms": "^3.1",
 		"nette/http": "^3.1",
-		"nette/mail": "^3.1",
-		"nette/robot-loader": "^3.3",
+		"nette/mail": "^4.0",
 		"nette/security": "^3.1",
-		"nette/utils": "^3.2",
+		"nette/utils": "^4.0",
 		"latte/latte": "^2.11 || ^3.0",
 		"tracy/tracy": "^2.8"
 	},

frameworks/PHP/nette/nette.dockerfile

@@ -1,28 +1,27 @@
-FROM ubuntu:22.04
+FROM ubuntu:24.04
 
 ARG DEBIAN_FRONTEND=noninteractive
 
 RUN apt-get update -yqq && apt-get install -yqq software-properties-common > /dev/null
 RUN LC_ALL=C.UTF-8 add-apt-repository ppa:ondrej/php
 RUN apt-get install -yqq nginx git unzip \
-    php8.3-fpm php8.3-mysql php8.3-xml php8.3-mbstring php8.3-intl php8.3-dev  php8.3-curl > /dev/null
+    php8.4-fpm php8.4-mysql php8.4-xml php8.4-mbstring php8.4-intl php8.4-dev  php8.4-curl > /dev/null
 
-COPY deploy/conf/* /etc/php/8.3/fpm/
+COPY deploy/conf/* /etc/php/8.4/fpm/
 
-ADD ./ /nette
 WORKDIR /nette
-
+COPY --link . .
 #ENV NETTE_DIR="/nette/src"
 
 COPY --from=composer:latest /usr/bin/composer /usr/local/bin/composer
 
 RUN composer install --optimize-autoloader --classmap-authoritative --no-dev --quiet
 
-RUN if [ $(nproc) = 2 ]; then sed -i "s|pm.max_children = 1024|pm.max_children = 512|g" /etc/php/8.3/fpm/php-fpm.conf ; fi;
+RUN if [ $(nproc) = 2 ]; then sed -i "s|pm.max_children = 1024|pm.max_children = 512|g" /etc/php/8.4/fpm/php-fpm.conf ; fi;
 
 RUN chmod -R 777 /nette
 
 EXPOSE 8080
 
-CMD service php8.3-fpm start && \
+CMD service php8.4-fpm start && \
     nginx -c /nette/deploy/nginx.conf 2>&1 > /dev/stderr

frameworks/PHP/php-ngx/php-ngx-mysql.dockerfile

@@ -10,11 +10,11 @@ RUN LC_ALL=C.UTF-8 add-apt-repository ppa:ondrej/php > /dev/null && \
 RUN apt-get update -yqq > /dev/null && \
     apt-get install -yqq wget git libxml2-dev systemtap-sdt-dev \
                     zlib1g-dev libpcre3-dev libargon2-dev libsodium-dev libkrb5-dev \
-                    php8.3-cli php8.3-dev libphp8.3-embed php8.3-mysql > /dev/null
+                    php8.4-cli php8.4-dev libphp8.4-embed php8.4-mysql > /dev/null
 
-ENV NGINX_VERSION 1.26.0
+ENV NGINX_VERSION 1.27.3
 
-RUN git clone -b v0.0.29 --single-branch --depth 1 https://github.com/rryqszq4/ngx-php.git > /dev/null
+RUN git clone -b v0.0.30 --single-branch --depth 1 https://github.com/rryqszq4/ngx-php.git > /dev/null
 
 RUN wget -q http://nginx.org/download/nginx-${NGINX_VERSION}.tar.gz && \
     tar -zxf nginx-${NGINX_VERSION}.tar.gz && \
@@ -27,7 +27,7 @@ RUN wget -q http://nginx.org/download/nginx-${NGINX_VERSION}.tar.gz && \
             --add-module=/ngx-php > /dev/null && \
     make > /dev/null && make install > /dev/null
 
-RUN sed -i "s|opcache.jit=off|;opcache.jit=off|g" /etc/php/8.3/embed/conf.d/10-opcache.ini
+RUN sed -i "s|opcache.jit=off|;opcache.jit=off|g" /etc/php/8.4/embed/conf.d/10-opcache.ini
 
 COPY --link . .
 
@@ -36,4 +36,4 @@ RUN export WORKERS=$(( 4 * $(nproc) )) && \
 
 EXPOSE 8080
 
-CMD /nginx/sbin/nginx -c /deploy/nginx.conf 
+CMD /nginx/sbin/nginx -c /deploy/nginx.conf

frameworks/PHP/php-ngx/php-ngx-pgsql.dockerfile

@@ -10,11 +10,11 @@ RUN LC_ALL=C.UTF-8 add-apt-repository ppa:ondrej/php > /dev/null && \
 RUN apt-get update -yqq > /dev/null && \
     apt-get install -yqq wget git libxml2-dev systemtap-sdt-dev \
                     zlib1g-dev libpcre3-dev libargon2-dev libsodium-dev libkrb5-dev \
-                    php8.3-cli php8.3-dev libphp8.3-embed php8.3-pgsql > /dev/null
+                    php8.4-cli php8.4-dev libphp8.4-embed php8.4-pgsql > /dev/null
 
-ENV NGINX_VERSION 1.26.0
+ENV NGINX_VERSION 1.27.3
 
-RUN git clone -b v0.0.29 --single-branch --depth 1 https://github.com/rryqszq4/ngx-php.git > /dev/null
+RUN git clone -b v0.0.30 --single-branch --depth 1 https://github.com/rryqszq4/ngx-php.git > /dev/null
 
 RUN wget -q http://nginx.org/download/nginx-${NGINX_VERSION}.tar.gz && \
     tar -zxf nginx-${NGINX_VERSION}.tar.gz && \
@@ -27,7 +27,7 @@ RUN wget -q http://nginx.org/download/nginx-${NGINX_VERSION}.tar.gz && \
             --add-module=/ngx-php > /dev/null && \
     make > /dev/null && make install > /dev/null
 
-RUN sed -i "s|opcache.jit=off|;opcache.jit=off|g" /etc/php/8.3/embed/conf.d/10-opcache.ini
+RUN sed -i "s|opcache.jit=off|;opcache.jit=off|g" /etc/php/8.4/embed/conf.d/10-opcache.ini
 
 COPY --link . .