From 57dfce007e44a9bc55202a8265115f11c4c226ab Mon Sep 17 00:00:00 2001 From: hzq Date: Wed, 1 Jan 2025 13:07:08 +0800 Subject: [PATCH] paozhu update --- frameworks/C++/paozhu/paozhu.dockerfile | 43 +- .../paozhu/paozhu_benchmark/CMakeLists.txt | 145 +- .../common/autocontrolmethod.hpp | 10 + .../common/autorestfulpaths.hpp | 40 + .../paozhu_benchmark/common/cost_define.h | 9 + .../paozhu_benchmark/common/httphook.cpp | 39 + .../common/json_reflect_headers.h | 0 .../common/websockets_method_reg.hpp | 19 + .../paozhu/paozhu_benchmark/conf/server.conf | 10 +- .../paozhu_benchmark/models/Fortune.cpp | 16 + .../paozhu/paozhu_benchmark/models/World.cpp | 16 + .../paozhu_benchmark/models/include/Fortune.h | 16 + .../paozhu_benchmark/models/include/World.h | 16 + .../orm/include/fortunebase.h | 2687 +++++++++++++++++ .../paozhu_benchmark/orm/include/worldbase.h | 2509 +++++++++++++++ .../C++/paozhu/paozhu_benchmark/orm/orm.h | 4 + .../view/techempower/fortunes.html | 5 + .../viewsrc/include/regviewmethod.hpp | 26 + .../viewsrc/include/viewsrc.h | 26 + .../viewsrc/view/techempower/fortunes.cpp | 50 + .../websockets/include/loopwebsockets.hpp | 66 + .../websockets/include/mywebsockets.hpp | 83 + 22 files changed, 5796 insertions(+), 39 deletions(-) create mode 100755 frameworks/C++/paozhu/paozhu_benchmark/common/autorestfulpaths.hpp create mode 100755 frameworks/C++/paozhu/paozhu_benchmark/common/cost_define.h create mode 100755 frameworks/C++/paozhu/paozhu_benchmark/common/httphook.cpp mode change 100644 => 100755 frameworks/C++/paozhu/paozhu_benchmark/common/json_reflect_headers.h create mode 100755 frameworks/C++/paozhu/paozhu_benchmark/common/websockets_method_reg.hpp create mode 100755 frameworks/C++/paozhu/paozhu_benchmark/models/Fortune.cpp create mode 100755 frameworks/C++/paozhu/paozhu_benchmark/models/World.cpp create mode 100755 frameworks/C++/paozhu/paozhu_benchmark/models/include/Fortune.h create mode 100755 frameworks/C++/paozhu/paozhu_benchmark/models/include/World.h create mode 100755 frameworks/C++/paozhu/paozhu_benchmark/orm/include/fortunebase.h create mode 100755 frameworks/C++/paozhu/paozhu_benchmark/orm/include/worldbase.h create mode 100755 frameworks/C++/paozhu/paozhu_benchmark/orm/orm.h create mode 100755 frameworks/C++/paozhu/paozhu_benchmark/view/techempower/fortunes.html create mode 100755 frameworks/C++/paozhu/paozhu_benchmark/viewsrc/include/regviewmethod.hpp create mode 100755 frameworks/C++/paozhu/paozhu_benchmark/viewsrc/include/viewsrc.h create mode 100755 frameworks/C++/paozhu/paozhu_benchmark/viewsrc/view/techempower/fortunes.cpp create mode 100755 frameworks/C++/paozhu/paozhu_benchmark/websockets/include/loopwebsockets.hpp create mode 100755 frameworks/C++/paozhu/paozhu_benchmark/websockets/include/mywebsockets.hpp diff --git a/frameworks/C++/paozhu/paozhu.dockerfile b/frameworks/C++/paozhu/paozhu.dockerfile index 8086f6eafe6..480d726d314 100644 --- a/frameworks/C++/paozhu/paozhu.dockerfile +++ b/frameworks/C++/paozhu/paozhu.dockerfile @@ -20,23 +20,40 @@ 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/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/controller ./paozhu/ +COPY ./paozhu_benchmark/libs ./paozhu/ +COPY ./paozhu_benchmark/view ./paozhu/ +COPY ./paozhu_benchmark/viewsrc ./paozhu/ -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/orm ./paozhu/ +COPY ./paozhu_benchmark/models ./paozhu/ +COPY ./paozhu_benchmark/common ./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/ + +# RUN mkdir ./paozhu/libs +# RUN mkdir ./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/libs/types/techempower_json.h ./paozhu/libs/types/ +# COPY ./paozhu_benchmark/libs/types/techempower_json_jsonreflect.cpp ./paozhu/libs/types/ + +# COPY ./paozhu_benchmark/common/autocontrolmethod.hpp ./paozhu/common/ +# COPY ./paozhu_benchmark/common/reghttpmethod_pre.hpp ./paozhu/common/ +# COPY ./paozhu_benchmark/common/reghttpmethod.hpp ./paozhu/common/ +# COPY ./paozhu_benchmark/common/json_reflect_headers.h ./paozhu/common/ COPY ./paozhu_benchmark/conf/server.conf ./paozhu/conf/server.conf COPY ./paozhu_benchmark/conf/orm.conf ./paozhu/conf/orm.conf diff --git a/frameworks/C++/paozhu/paozhu_benchmark/CMakeLists.txt b/frameworks/C++/paozhu/paozhu_benchmark/CMakeLists.txt index b8bf972dbc2..a4fabfb1ae6 100755 --- a/frameworks/C++/paozhu/paozhu_benchmark/CMakeLists.txt +++ b/frameworks/C++/paozhu/paozhu_benchmark/CMakeLists.txt @@ -117,13 +117,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 +136,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") @@ -175,21 +189,18 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/bin) if(${mode} AND (CMAKE_BUILD_TYPE STREQUAL "Release")) - add_executable(paozhu ${CMAKE_CURRENT_SOURCE_DIR}/test/testbenchmark.cpp ${common_list} ${viewsrc_list} ${FRAMEWORK_CPP_PATH} ${orm_list} ${reflect_list} ${src_list} ${source_list} ${controller_list}) + add_executable(paozhu ${CMAKE_CURRENT_SOURCE_DIR}/test/testdaemon.cpp ${common_list} ${viewsrc_list} ${FRAMEWORK_CPP_PATH} ${orm_list} ${reflect_list} ${src_list} ${source_list} ${controller_list}) else() add_executable(paozhu ${CMAKE_CURRENT_SOURCE_DIR}/test/test.cpp ${common_list} ${viewsrc_list} ${FRAMEWORK_CPP_PATH} ${orm_list} ${reflect_list} ${src_list} ${source_list} ${controller_list}) 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 +276,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 +335,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 +417,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 +449,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 +489,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 +513,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 +539,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() diff --git a/frameworks/C++/paozhu/paozhu_benchmark/common/autocontrolmethod.hpp b/frameworks/C++/paozhu/paozhu_benchmark/common/autocontrolmethod.hpp index faddf242daa..46d8979692a 100755 --- a/frameworks/C++/paozhu/paozhu_benchmark/common/autocontrolmethod.hpp +++ b/frameworks/C++/paozhu/paozhu_benchmark/common/autocontrolmethod.hpp @@ -44,6 +44,16 @@ namespace http } + + void _initauto_domain_httpmethodregto(std::map> &domain_methodcallback) + { + struct regmethold_t temp; + std::map methodcallback; + std::map>::iterator domain_iterator; + + + } + } #endif diff --git a/frameworks/C++/paozhu/paozhu_benchmark/common/autorestfulpaths.hpp b/frameworks/C++/paozhu/paozhu_benchmark/common/autorestfulpaths.hpp new file mode 100755 index 00000000000..dabbdbda827 --- /dev/null +++ b/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> &restfulmethod) + { + + + if(restfulmethod.size()) + {} + + + } + + void _initauto_domain_httprestful_paths(std::map>> &restfulmethod) + { + std::map> temp_path; + std::map>>::iterator domain_iterator; + + domain_iterator=restfulmethod.begin(); + temp_path.clear(); + + + } + +} + +#endif + + \ No newline at end of file diff --git a/frameworks/C++/paozhu/paozhu_benchmark/common/cost_define.h b/frameworks/C++/paozhu/paozhu_benchmark/common/cost_define.h new file mode 100755 index 00000000000..47fb182f0e0 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/frameworks/C++/paozhu/paozhu_benchmark/common/httphook.cpp b/frameworks/C++/paozhu/paozhu_benchmark/common/httphook.cpp new file mode 100755 index 00000000000..3440c23f84b --- /dev/null +++ b/frameworks/C++/paozhu/paozhu_benchmark/common/httphook.cpp @@ -0,0 +1,39 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "httppeer.h" +namespace http +{ +std::map _block_ip_tables; +std::map _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 peer) +{ + if (peer->host.size() > 0) + { + return false; + } + return false; +} +bool hook_host_http2(std::shared_ptr peer) +{ + if (peer->host.size() > 0) + { + return false; + } + return false; +} +}// namespace http diff --git a/frameworks/C++/paozhu/paozhu_benchmark/common/json_reflect_headers.h b/frameworks/C++/paozhu/paozhu_benchmark/common/json_reflect_headers.h old mode 100644 new mode 100755 diff --git a/frameworks/C++/paozhu/paozhu_benchmark/common/websockets_method_reg.hpp b/frameworks/C++/paozhu/paozhu_benchmark/common/websockets_method_reg.hpp new file mode 100755 index 00000000000..b8e9c718ea9 --- /dev/null +++ b/frameworks/C++/paozhu/paozhu_benchmark/common/websockets_method_reg.hpp @@ -0,0 +1,19 @@ +#pragma once +#include +#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 p) -> std::shared_ptr + { return http::mywebsockets::create(p); }); + // methodcallback.emplace("looptest",[](std::weak_ptr p)->std::shared_ptr{ + // return http::loopwebsockets::create(p); + // }); +} + +}// namespace http \ No newline at end of file diff --git a/frameworks/C++/paozhu/paozhu_benchmark/conf/server.conf b/frameworks/C++/paozhu/paozhu_benchmark/conf/server.conf index e76a18093e9..9013265e678 100755 --- a/frameworks/C++/paozhu/paozhu_benchmark/conf/server.conf +++ b/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= \ No newline at end of file diff --git a/frameworks/C++/paozhu/paozhu_benchmark/models/Fortune.cpp b/frameworks/C++/paozhu/paozhu_benchmark/models/Fortune.cpp new file mode 100755 index 00000000000..160924992af --- /dev/null +++ b/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(){} + + + } diff --git a/frameworks/C++/paozhu/paozhu_benchmark/models/World.cpp b/frameworks/C++/paozhu/paozhu_benchmark/models/World.cpp new file mode 100755 index 00000000000..aa18f46cab6 --- /dev/null +++ b/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(){} + + + } diff --git a/frameworks/C++/paozhu/paozhu_benchmark/models/include/Fortune.h b/frameworks/C++/paozhu/paozhu_benchmark/models/include/Fortune.h new file mode 100755 index 00000000000..27865161b32 --- /dev/null +++ b/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{ + public: + Fortune(std::string dbtag); + Fortune(); + }; +}; +#endif diff --git a/frameworks/C++/paozhu/paozhu_benchmark/models/include/World.h b/frameworks/C++/paozhu/paozhu_benchmark/models/include/World.h new file mode 100755 index 00000000000..ba44dee7888 --- /dev/null +++ b/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{ + public: + World(std::string dbtag); + World(); + }; +}; +#endif diff --git a/frameworks/C++/paozhu/paozhu_benchmark/orm/include/fortunebase.h b/frameworks/C++/paozhu/paozhu_benchmark/orm/include/fortunebase.h new file mode 100755 index 00000000000..8a09ecc4564 --- /dev/null +++ b/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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "mysql.h" +namespace orm { + + +struct fortunebase +{ + struct meta{ + unsigned int id= 0; // + std::string message=""; // + } data; + std::vector record; +std::string _rmstag="default";//this value must be default or tag value, tag in mysqlconnect config file . +std::vector _keypos{0x00}; +MYSQL_ROW _row; +std::vector::iterator begin(){ return record.begin(); } +std::vector::iterator end(){ return record.end(); } +std::vector::const_iterator begin() const{ return record.begin(); } +std::vector::const_iterator end() const{ return record.end(); } +const std::array colnames={"id","message"}; +const std::array 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;i0){ + tempsql<<"`,`"; + }else{ + tempsql<<"`"; + } + tempsql<0){ + tempsql<<"`"; + } + tempsql<<") VALUES ("; + + if(data.id==0){ +tempsql<<"null"; + }else{ + tempsql<0){ + tempsql<<"`,`"; + }else{ + tempsql<<"`"; + } + tempsql<0){ + tempsql<<"`"; + } + tempsql<<") VALUES ("; + + if(insert_data.id==0){ +tempsql<<"null"; + }else{ + tempsql< &insert_data){ + unsigned int j=0; + std::ostringstream tempsql; + tempsql<<"INSERT INTO "; + tempsql<0){ + tempsql<<"`,`"; + }else{ + tempsql<<"`"; + } + tempsql<0){ + tempsql<<"`"; + } + tempsql<<") VALUES "; + + for(unsigned int i=0;i0) + { + tempsql<<","; + } + tempsql<<"("; + + + if(insert_data[i].id==0){ + tempsql<<"null"; + }else{ + tempsql< keypos; + for(;jj0){ + 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;jj0){ tempsql<<","; } +if(data.id==0){ + tempsql<<"`id`=0"; + }else{ + tempsql<<"`id`="<0){ tempsql<<","; } +tempsql<<"`message`='"< 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< 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<0){ + for(;jj0) + { + tempsql<<","; + } + tempsql<0){ + if(findcolpos(keyname)<255) + { + if(j>0) + { + tempsql<<","; + } + tempsql< data_toarray(std::string fileld=""){ + std::vector temparray; + std::string keyname; + unsigned char jj=0; + std::vector keypos; + if(fileld.size()>1){ + for(;jj0){ + keypos.emplace_back(findcolpos(keyname)); + keyname.clear(); + } + }else{ + for(jj=0;jj data_tomap(std::string fileld=""){ + std::map tempsql; + std::string keyname; + unsigned char jj=0; + std::vector keypos; + if(fileld.size()>1){ + for(;jj0){ + keypos.emplace_back(findcolpos(keyname)); + keyname.clear(); + } + }else{ + for(jj=0;jj keypos; + if(fileld.size()>0){ + for(;jj0){ + keypos.emplace_back(findcolpos(keyname)); + keyname.clear(); + } + }else{ + for(jj=0;jj0){ tempsql<<","; } +if(data.id==0){ + tempsql<<"\"id\":0"; + }else{ + tempsql<<"\"id\":"<0){ tempsql<<","; } +tempsql<<"\"message\":\""< list_content; + for(;json_offset0) + { + data=metatemp; + } + if(json_offset>=json_content.size()) + { + break; + } + for(;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_offset1) + { + 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()) + { + 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 keypos; + if(fileld.size()>0){ + for(;jj0){ + keypos.emplace_back(findcolpos(keyname)); + keyname.clear(); + } + }else{ + for(jj=0;jj0){ + tempsql<<",{"; + }else{ + tempsql<<"{"; + } + + for(jj=0;jj0){ tempsql<<","; } +if(record[n].id==0){ + tempsql<<"\"id\":0"; + }else{ + tempsql<<"\"id\":"<0){ tempsql<<","; } +tempsql<<"\"message\":\""< func,std::string fileld=""){ + std::ostringstream tempsql; + std::string keyname; + unsigned char jj=0; + std::vector keypos; + if(fileld.size()>0){ + for(;jj0){ + keypos.emplace_back(findcolpos(keyname)); + keyname.clear(); + } + }else{ + for(jj=0;jj0){ + tempsql<<",{"; + }else{ + tempsql<<"{"; + } + tempsql<0){ tempsql<<","; } +if(record[n].id==0){ + tempsql<<"\"id\":0"; + }else{ + tempsql<<"\"id\":"<0){ tempsql<<","; } +tempsql<<"\"message\":\""< getRecord(){ + return record; +} + + + template::value,bool>::type = true> + T& ref_meta([[maybe_unused]] std::string key_name) + { + if(key_name=="message") + { + return data.message; + } + return nullptr; + } + + + template,bool>::type = true> + T& ref_meta([[maybe_unused]] std::string key_name) + { + if(key_name=="id") + { + return data.id; + } + return nullptr; + } + + + template,bool>::type = true > + T& ref_meta([[maybe_unused]] std::string key_name) + { + return nullptr; + } + + template,bool>::type = true > + std::vector getCol([[maybe_unused]] std::string keyname) + { + std::vector a; + + + unsigned char kpos; + kpos=findcolpos(keyname); + for(auto &iter:record) + { + switch(kpos) + { + case 0: + a.emplace_back(iter.id); + break; + + } + } + + return a; + } + + template,bool>::type = true > + std::vector getCol([[maybe_unused]] std::string keyname) + { + std::vector a; + + + return a; + } + + template,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,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,bool>::type = true > + T getVal(std::string keyname) + { + unsigned char kpos; + kpos=findcolpos(keyname); + + switch(kpos) + { + + + } + + + return 0.0; + } + + template,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::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::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::value,bool>::type = true > + std::vector getCol([[maybe_unused]] std::string keyname) + { + std::vector 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<0){ + a<<'"'; + } + + return a.str(); + } + + template::value,bool>::type = true,typename std::enable_if::value,bool>::type = true> + std::map getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map 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::value,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map 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,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map 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,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map 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::value,bool>::type = true,typename std::enable_if,bool>::type = true> + std::map getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map 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,bool>::type = true,typename std::enable_if,bool>::type = true> + std::map getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map 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,bool>::type = true > + std::map getmapRows([[maybe_unused]] std::string keyname) + { + std::map a; + + unsigned char kpos; + kpos=findcolpos(keyname); + for(auto &iter:record) + { + switch(kpos) + { + + case 0: + a.emplace(iter.id,iter); + break; + + } + } + + return a; + } + + template::value,bool>::type = true > + std::map getmapRows([[maybe_unused]] std::string keyname) + { + std::map 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::value,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::vector> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::vector> 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,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::vector> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::vector> 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,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::vector> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::vector> 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::value,bool>::type = true,typename std::enable_if,bool>::type = true> + std::vector> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::vector> 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,bool>::type = true,typename std::enable_if,bool>::type = true> + std::vector> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::vector> 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::value,bool>::type = true,typename std::enable_if::value,bool>::type = true> + std::vector> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::vector> 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,bool>::type = true > + std::vector> getvecRows([[maybe_unused]] std::string keyname) + { + std::vector> 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::value,bool>::type = true > + std::vector> getvecRows([[maybe_unused]] std::string keyname) + { + std::vector> 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,bool>::type = true,typename std::enable_if,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> 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,bool>::type = true,typename std::enable_if,bool>::type = true, typename std::enable_if,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> 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,bool>::type = true,typename std::enable_if,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> 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,bool>::type = true, typename std::enable_if::value,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> 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,bool>::type = true, typename std::enable_if::value,bool>::type = true, typename std::enable_if,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> 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,bool>::type = true, typename std::enable_if::value,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> 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::value,bool>::type = true,typename std::enable_if,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> 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::value,bool>::type = true,typename std::enable_if,bool>::type = true, typename std::enable_if,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> 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::value,bool>::type = true,typename std::enable_if,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> 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::value,bool>::type = true, typename std::enable_if::value,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> 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::value,bool>::type = true, typename std::enable_if::value,bool>::type = true, typename std::enable_if,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> 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::value,bool>::type = true, typename std::enable_if::value,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> 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::value,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map> 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::value,bool>::type = true,typename std::enable_if::value,bool>::type = true> + std::map> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map> 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::value,bool>::type = true,typename std::enable_if,bool>::type = true> + std::map> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map> 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,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map> 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,bool>::type = true,typename std::enable_if::value,bool>::type = true> + std::map> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map> 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,bool>::type = true,typename std::enable_if,bool>::type = true> + std::map> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map> 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,bool>::type = true> + std::map> getgroupRows([[maybe_unused]] std::string keyname) + { + std::map> 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::value,bool>::type = true> + std::map> getgroupRows([[maybe_unused]] std::string keyname) + { + std::map> 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::value,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map>> getgroupRows([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map>> 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::value,bool>::type = true,typename std::enable_if,bool>::type = true> + std::map>> getgroupRows([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map>> 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,bool>::type = true,typename std::enable_if,bool>::type = true> + std::map>> getgroupRows([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map>> 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,bool>::type = true,typename std::enable_if::value,bool>::type = true> + std::map>> getgroupRows([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map>> 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 + \ No newline at end of file diff --git a/frameworks/C++/paozhu/paozhu_benchmark/orm/include/worldbase.h b/frameworks/C++/paozhu/paozhu_benchmark/orm/include/worldbase.h new file mode 100755 index 00000000000..2bba08096e2 --- /dev/null +++ b/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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "mysql.h" +namespace orm { + + +struct worldbase +{ + struct meta{ + unsigned int id= 0; // + int randomnumber= 0; // + } data; + std::vector record; +std::string _rmstag="default";//this value must be default or tag value, tag in mysqlconnect config file . +std::vector _keypos{0x00}; +MYSQL_ROW _row; +std::vector::iterator begin(){ return record.begin(); } +std::vector::iterator end(){ return record.end(); } +std::vector::const_iterator begin() const{ return record.begin(); } +std::vector::const_iterator end() const{ return record.end(); } +const std::array colnames={"id","randomnumber"}; +const std::array 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;i0){ + tempsql<<"`,`"; + }else{ + tempsql<<"`"; + } + tempsql<0){ + tempsql<<"`"; + } + tempsql<<") VALUES ("; + + if(data.id==0){ +tempsql<<"null"; + }else{ + tempsql<0){ + tempsql<<"`,`"; + }else{ + tempsql<<"`"; + } + tempsql<0){ + tempsql<<"`"; + } + tempsql<<") VALUES ("; + + if(insert_data.id==0){ +tempsql<<"null"; + }else{ + tempsql< &insert_data){ + unsigned int j=0; + std::ostringstream tempsql; + tempsql<<"INSERT INTO "; + tempsql<0){ + tempsql<<"`,`"; + }else{ + tempsql<<"`"; + } + tempsql<0){ + tempsql<<"`"; + } + tempsql<<") VALUES "; + + for(unsigned int i=0;i0) + { + tempsql<<","; + } + tempsql<<"("; + + + if(insert_data[i].id==0){ + tempsql<<"null"; + }else{ + tempsql<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;jj0){ tempsql<<","; } +if(data.id==0){ + tempsql<<"`id`=0"; + }else{ + tempsql<<"`id`="<0){ tempsql<<","; } +if(data.randomnumber==0){ + tempsql<<"`randomnumber`=0"; + }else{ + tempsql<<"`randomnumber`="< 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< 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<0){ + for(;jj0) + { + tempsql<<","; + } + tempsql<0){ + if(findcolpos(keyname)<255) + { + if(j>0) + { + tempsql<<","; + } + tempsql< data_toarray(std::string fileld=""){ + std::vector temparray; + std::string keyname; + unsigned char jj=0; + std::vector keypos; + if(fileld.size()>1){ + for(;jj0){ + keypos.emplace_back(findcolpos(keyname)); + keyname.clear(); + } + }else{ + for(jj=0;jj data_tomap(std::string fileld=""){ + std::map tempsql; + std::string keyname; + unsigned char jj=0; + std::vector keypos; + if(fileld.size()>1){ + for(;jj0){ + keypos.emplace_back(findcolpos(keyname)); + keyname.clear(); + } + }else{ + for(jj=0;jj keypos; + if(fileld.size()>0){ + for(;jj0){ + keypos.emplace_back(findcolpos(keyname)); + keyname.clear(); + } + }else{ + for(jj=0;jj0){ tempsql<<","; } +if(data.id==0){ + tempsql<<"\"id\":0"; + }else{ + tempsql<<"\"id\":"<0){ tempsql<<","; } +if(data.randomnumber==0){ + tempsql<<"\"randomnumber\":0"; + }else{ + tempsql<<"\"randomnumber\":"< list_content; + for(;json_offset0) + { + data=metatemp; + } + if(json_offset>=json_content.size()) + { + break; + } + for(;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_offset1) + { + 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()) + { + 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 keypos; + if(fileld.size()>0){ + for(;jj0){ + keypos.emplace_back(findcolpos(keyname)); + keyname.clear(); + } + }else{ + for(jj=0;jj0){ + tempsql<<",{"; + }else{ + tempsql<<"{"; + } + + for(jj=0;jj0){ tempsql<<","; } +if(record[n].id==0){ + tempsql<<"\"id\":0"; + }else{ + tempsql<<"\"id\":"<0){ tempsql<<","; } +if(record[n].randomnumber==0){ + tempsql<<"\"randomnumber\":0"; + }else{ + tempsql<<"\"randomnumber\":"< func,std::string fileld=""){ + std::ostringstream tempsql; + std::string keyname; + unsigned char jj=0; + std::vector keypos; + if(fileld.size()>0){ + for(;jj0){ + keypos.emplace_back(findcolpos(keyname)); + keyname.clear(); + } + }else{ + for(jj=0;jj0){ + tempsql<<",{"; + }else{ + tempsql<<"{"; + } + tempsql<0){ tempsql<<","; } +if(record[n].id==0){ + tempsql<<"\"id\":0"; + }else{ + tempsql<<"\"id\":"<0){ tempsql<<","; } +if(record[n].randomnumber==0){ + tempsql<<"\"randomnumber\":0"; + }else{ + tempsql<<"\"randomnumber\":"< getRecord(){ + return record; +} + + + template::value,bool>::type = true> + T& ref_meta([[maybe_unused]] std::string key_name) + { + return nullptr; + } + + + template,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,bool>::type = true > + T& ref_meta([[maybe_unused]] std::string key_name) + { + return nullptr; + } + + template,bool>::type = true > + std::vector getCol([[maybe_unused]] std::string keyname) + { + std::vector 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,bool>::type = true > + std::vector getCol([[maybe_unused]] std::string keyname) + { + std::vector a; + + + return a; + } + + template,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,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,bool>::type = true > + T getVal(std::string keyname) + { + unsigned char kpos; + kpos=findcolpos(keyname); + + switch(kpos) + { + + + } + + + return 0.0; + } + + template,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::value,bool>::type = true > + std::string getVal(std::string keyname) + { + unsigned char kpos; + kpos=findcolpos(keyname); + + switch(kpos) + { + + + } + return ""; + } + + template::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::value,bool>::type = true > + std::vector getCol([[maybe_unused]] std::string keyname) + { + std::vector 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<0){ + a<<'"'; + } + + return a.str(); + } + + template::value,bool>::type = true,typename std::enable_if::value,bool>::type = true> + std::map getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map a; + + return a; + } + + + template::value,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map a; + + return a; + } + + template,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map 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,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map 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::value,bool>::type = true,typename std::enable_if,bool>::type = true> + std::map getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map 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,bool>::type = true,typename std::enable_if,bool>::type = true> + std::map getCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map 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,bool>::type = true > + std::map getmapRows([[maybe_unused]] std::string keyname) + { + std::map 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::value,bool>::type = true > + std::map getmapRows([[maybe_unused]] std::string keyname) + { + std::map a; + + + + return a; + } + + template::value,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::vector> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::vector> a; + + + return a; + } + + template,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::vector> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::vector> 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,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::vector> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::vector> 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::value,bool>::type = true,typename std::enable_if,bool>::type = true> + std::vector> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::vector> 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,bool>::type = true,typename std::enable_if,bool>::type = true> + std::vector> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::vector> 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::value,bool>::type = true,typename std::enable_if::value,bool>::type = true> + std::vector> getvecCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::vector> a; + + return a; + } + + template,bool>::type = true > + std::vector> getvecRows([[maybe_unused]] std::string keyname) + { + std::vector> 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::value,bool>::type = true > + std::vector> getvecRows([[maybe_unused]] std::string keyname) + { + std::vector> a; + + + return a; + } + template,bool>::type = true,typename std::enable_if,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> 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,bool>::type = true,typename std::enable_if,bool>::type = true, typename std::enable_if,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> 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,bool>::type = true,typename std::enable_if,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> 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,bool>::type = true, typename std::enable_if::value,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> 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,bool>::type = true, typename std::enable_if::value,bool>::type = true, typename std::enable_if,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> 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,bool>::type = true, typename std::enable_if::value,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> 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::value,bool>::type = true,typename std::enable_if,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> 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::value,bool>::type = true,typename std::enable_if,bool>::type = true, typename std::enable_if,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> 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::value,bool>::type = true,typename std::enable_if,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> 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::value,bool>::type = true, typename std::enable_if::value,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> a; + + return a; + } + template::value,bool>::type = true, typename std::enable_if::value,bool>::type = true, typename std::enable_if,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> 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::value,bool>::type = true, typename std::enable_if::value,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map>> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname,[[maybe_unused]] std::string dataname) + { + std::map>> a; + + return a; + } + + template::value,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map> a; + + + return a; + } + + template::value,bool>::type = true,typename std::enable_if::value,bool>::type = true> + std::map> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map> a; + + return a; + } + + template::value,bool>::type = true,typename std::enable_if,bool>::type = true> + std::map> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map> 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,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map> 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,bool>::type = true,typename std::enable_if::value,bool>::type = true> + std::map> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map> 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,bool>::type = true,typename std::enable_if,bool>::type = true> + std::map> getgroupCols([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map> 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,bool>::type = true> + std::map> getgroupRows([[maybe_unused]] std::string keyname) + { + std::map> 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::value,bool>::type = true> + std::map> getgroupRows([[maybe_unused]] std::string keyname) + { + std::map> a; + + return a; + } + + template::value,bool>::type = true, typename std::enable_if::value,bool>::type = true> + std::map>> getgroupRows([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map>> a; + + return a; + } + + template::value,bool>::type = true,typename std::enable_if,bool>::type = true> + std::map>> getgroupRows([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map>> 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,bool>::type = true,typename std::enable_if,bool>::type = true> + std::map>> getgroupRows([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map>> 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,bool>::type = true,typename std::enable_if::value,bool>::type = true> + std::map>> getgroupRows([[maybe_unused]] std::string keyname,[[maybe_unused]] std::string valname) + { + std::map>> 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 + \ No newline at end of file diff --git a/frameworks/C++/paozhu/paozhu_benchmark/orm/orm.h b/frameworks/C++/paozhu/paozhu_benchmark/orm/orm.h new file mode 100755 index 00000000000..816b9ae4dc9 --- /dev/null +++ b/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" diff --git a/frameworks/C++/paozhu/paozhu_benchmark/view/techempower/fortunes.html b/frameworks/C++/paozhu/paozhu_benchmark/view/techempower/fortunes.html new file mode 100755 index 00000000000..b9079541143 --- /dev/null +++ b/frameworks/C++/paozhu/paozhu_benchmark/view/techempower/fortunes.html @@ -0,0 +1,5 @@ +Fortunes<%c + for(auto &a:obj["list"].as_array()){ +%><%c + } +%>
idmessage
<%c echo<<%c echo<
\ No newline at end of file diff --git a/frameworks/C++/paozhu/paozhu_benchmark/viewsrc/include/regviewmethod.hpp b/frameworks/C++/paozhu/paozhu_benchmark/viewsrc/include/regviewmethod.hpp new file mode 100755 index 00000000000..98a52eeada1 --- /dev/null +++ b/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 +#include +#include +#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 \ No newline at end of file diff --git a/frameworks/C++/paozhu/paozhu_benchmark/viewsrc/include/viewsrc.h b/frameworks/C++/paozhu/paozhu_benchmark/viewsrc/include/viewsrc.h new file mode 100755 index 00000000000..8991765bf19 --- /dev/null +++ b/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 +#include +#include +#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 \ No newline at end of file diff --git a/frameworks/C++/paozhu/paozhu_benchmark/viewsrc/view/techempower/fortunes.cpp b/frameworks/C++/paozhu/paozhu_benchmark/viewsrc/view/techempower/fortunes.cpp new file mode 100755 index 00000000000..b29f89356b5 --- /dev/null +++ b/frameworks/C++/paozhu/paozhu_benchmark/viewsrc/view/techempower/fortunes.cpp @@ -0,0 +1,50 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#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<<"Fortunes"; + + for(auto &a:obj["list"].as_array()){ + + echo<<""; + + } + + echo<<"
idmessage
"; + echo<"; + echo<
"; + + return echo.str(); + } + + } + } + } + \ No newline at end of file diff --git a/frameworks/C++/paozhu/paozhu_benchmark/websockets/include/loopwebsockets.hpp b/frameworks/C++/paozhu/paozhu_benchmark/websockets/include/loopwebsockets.hpp new file mode 100755 index 00000000000..388449b6a33 --- /dev/null +++ b/frameworks/C++/paozhu/paozhu_benchmark/websockets/include/loopwebsockets.hpp @@ -0,0 +1,66 @@ +#include +#include +#include + +#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 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 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 peer = weak_peer.lock(); + if (peer) + { + std::string outhello; + peer->ws->makeWSText(data, outhello); + peer->send(outhello); + } + } + static std::shared_ptr create(std::weak_ptr p) + { + return std::make_shared(p); + } +}; + +}// namespace http diff --git a/frameworks/C++/paozhu/paozhu_benchmark/websockets/include/mywebsockets.hpp b/frameworks/C++/paozhu/paozhu_benchmark/websockets/include/mywebsockets.hpp new file mode 100755 index 00000000000..4ebd42b88f3 --- /dev/null +++ b/frameworks/C++/paozhu/paozhu_benchmark/websockets/include/mywebsockets.hpp @@ -0,0 +1,83 @@ +#include +#include +#include + +#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 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 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 peer = weak_peer.lock(); + if (peer) + { + std::string outhello; + if(data=="html") + { + std::string html_data="

Websocket test 测试h3

"; + peer->ws->makeWSText(html_data, outhello); + } + else + { + peer->ws->makeWSText(data, outhello); + } + + peer->send(outhello); + } + } + static std::shared_ptr create(std::weak_ptr p) + { + return std::make_shared(p); + } +}; + +}// namespace http \ No newline at end of file