From b84d8aea9d5094562a7d0f73c4282d0c588b3894 Mon Sep 17 00:00:00 2001 From: hzq Date: Fri, 17 Jan 2025 15:36:24 +0800 Subject: [PATCH 01/12] update new test --- frameworks/C++/paozhu/paozhu.dockerfile | 28 +- .../common/autocontrolmethod.hpp | 27 +- .../controller/include/techempower.h | 20 +- .../controller/src/techempower.cpp | 389 +- .../paozhu_benchmark/models/Fortune.cpp | 20 +- .../paozhu/paozhu_benchmark/models/World.cpp | 20 +- .../paozhu_benchmark/models/include/Fortune.h | 18 +- .../paozhu_benchmark/models/include/World.h | 18 +- .../orm/include/fortunebase.h | 4811 +++++++++-------- .../paozhu_benchmark/orm/include/worldbase.h | 4649 ++++++++-------- 10 files changed, 5140 insertions(+), 4860 deletions(-) mode change 100755 => 100644 frameworks/C++/paozhu/paozhu_benchmark/controller/include/techempower.h diff --git a/frameworks/C++/paozhu/paozhu.dockerfile b/frameworks/C++/paozhu/paozhu.dockerfile index 7381d0e9ac9..6b91336fdaa 100644 --- a/frameworks/C++/paozhu/paozhu.dockerfile +++ b/frameworks/C++/paozhu/paozhu.dockerfile @@ -18,24 +18,24 @@ 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 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 rm -Rf ./paozhu/controller +RUN rm -Rf ./paozhu/libs +RUN rm -Rf ./paozhu/view +RUN rm -Rf ./paozhu/viewsrc +RUN rm -Rf ./paozhu/orm +RUN rm -Rf ./paozhu/models +RUN rm -Rf ./paozhu/common -# COPY ./paozhu_benchmark/controller ./paozhu/ -# COPY ./paozhu_benchmark/libs ./paozhu/ -# COPY ./paozhu_benchmark/view ./paozhu/ -# COPY ./paozhu_benchmark/viewsrc ./paozhu/ +COPY ./paozhu_benchmark/controller ./paozhu/ +COPY ./paozhu_benchmark/libs ./paozhu/ +COPY ./paozhu_benchmark/view ./paozhu/ +COPY ./paozhu_benchmark/viewsrc ./paozhu/ -# COPY ./paozhu_benchmark/orm ./paozhu/ -# COPY ./paozhu_benchmark/models ./paozhu/ -# COPY ./paozhu_benchmark/common ./paozhu/ +COPY ./paozhu_benchmark/orm ./paozhu/ +COPY ./paozhu_benchmark/models ./paozhu/ +COPY ./paozhu_benchmark/common ./paozhu/ # RUN ls -l ./paozhu # RUN pwd diff --git a/frameworks/C++/paozhu/paozhu_benchmark/common/autocontrolmethod.hpp b/frameworks/C++/paozhu/paozhu_benchmark/common/autocontrolmethod.hpp index 46d8979692a..b793d7f8d5e 100755 --- a/frameworks/C++/paozhu/paozhu_benchmark/common/autocontrolmethod.hpp +++ b/frameworks/C++/paozhu/paozhu_benchmark/common/autocontrolmethod.hpp @@ -9,14 +9,21 @@ #include "httppeer.h" #include "techempower.h" + +namespace http +{ + + void _initauto_control_httpmethodregto(std::map &methodcallback) + { + struct regmethold_t temp; -namespace http -{ - void _initauto_control_httpmethodregto(std::map &methodcallback) - { - struct regmethold_t temp; + } + + void _initauto_co_control_httpmethodregto(std::map &methodcallback) + { + struct regmethold_co_t temp; temp.pre = nullptr; temp.regfun = techempowerplaintext; methodcallback.emplace("plaintext",temp); @@ -54,8 +61,16 @@ namespace http } -} + void _initauto_co_domain_httpmethodregto(std::map> &domain_methodcallback) + { + struct regmethold_co_t temp; + std::map methodcallback; + std::map>::iterator domain_iterator; + + } + +} #endif \ No newline at end of file diff --git a/frameworks/C++/paozhu/paozhu_benchmark/controller/include/techempower.h b/frameworks/C++/paozhu/paozhu_benchmark/controller/include/techempower.h old mode 100755 new mode 100644 index f1697f616b9..ce43babe19f --- a/frameworks/C++/paozhu/paozhu_benchmark/controller/include/techempower.h +++ b/frameworks/C++/paozhu/paozhu_benchmark/controller/include/techempower.h @@ -5,15 +5,13 @@ #include "httppeer.h" namespace http -{ - - - std::string techempowerplaintext(std::shared_ptr peer); - std::string techempowerjson(std::shared_ptr peer); - std::string techempowerdb(std::shared_ptr peer); - std::string techempowerqueries(std::shared_ptr peer); - std::string techempowerfortunes(std::shared_ptr peer); - std::string techempowerupdates(std::shared_ptr peer); - std::string techempowercached_queries(std::shared_ptr peer); - std::string techempowercached_db(std::shared_ptr peer); +{ + asio::awaitable techempowerplaintext(std::shared_ptr peer); + asio::awaitable techempowerjson(std::shared_ptr peer); + asio::awaitable techempowerdb(std::shared_ptr peer); + asio::awaitable techempowerqueries(std::shared_ptr peer); + asio::awaitable techempowerfortunes(std::shared_ptr peer); + asio::awaitable techempowerupdates(std::shared_ptr peer); + asio::awaitable techempowercached_queries(std::shared_ptr peer); + asio::awaitable techempowercached_db(std::shared_ptr peer); } diff --git a/frameworks/C++/paozhu/paozhu_benchmark/controller/src/techempower.cpp b/frameworks/C++/paozhu/paozhu_benchmark/controller/src/techempower.cpp index f8dfe230acd..f3111732864 100755 --- a/frameworks/C++/paozhu/paozhu_benchmark/controller/src/techempower.cpp +++ b/frameworks/C++/paozhu/paozhu_benchmark/controller/src/techempower.cpp @@ -6,236 +6,245 @@ #include #include "httppeer.h" #include "techempower.h" +#include "techempower_json.h" #include "datetime.h" #include "func.h" #include "pzcache.h" #include "json_reflect_headers.h" -#include "techempower_json.h" namespace http { - //@urlpath(null,plaintext) - std::string techempowerplaintext(std::shared_ptr peer) +//@urlpath(null,plaintext) +asio::awaitable techempowerplaintext(std::shared_ptr peer) +{ + peer->type("text/plain; charset=UTF-8"); + peer->set_header("Date", get_gmttime()); + peer->output = "Hello, World!"; + co_return ""; +} + +//@urlpath(null,json) +asio::awaitable techempowerjson(std::shared_ptr peer) +{ + peer->type("application/json; charset=UTF-8"); + peer->set_header("Date", get_gmttime()); + struct techempower_outjson_t a; + a.message = "Hello, World!"; + peer->output = json_encode(a); + co_return ""; +} + +//@urlpath(null,db) +asio::awaitable techempowerdb(std::shared_ptr peer) +{ + peer->type("application/json; charset=UTF-8"); + peer->set_header("Date", get_gmttime()); + auto myworld = orm::World(); + unsigned int rd_num = rand_range(1, 10000); + myworld.where("id", rd_num); + myworld.limit(1); + co_await myworld.async_fetch_one(); + peer->output = myworld.data_tojson(); + co_return ""; +} + +//@urlpath(null,queries) +asio::awaitable techempowerqueries(std::shared_ptr peer) +{ + peer->type("application/json; charset=UTF-8"); + peer->set_header("Date", get_gmttime()); + + unsigned int get_num = peer->get["queries"].to_int(); + if (get_num == 0) { - peer->type("text/plain; charset=UTF-8"); - peer->set_header("Date", get_gmttime()); - peer->output = "Hello, World!"; - return ""; + get_num = 1; } - - //@urlpath(null,json) - std::string techempowerjson(std::shared_ptr peer) + else if (get_num > 500) { - peer->type("application/json; charset=UTF-8"); - peer->set_header("Date", get_gmttime()); - struct techempower_outjson_t a; - a.message = "Hello, World!"; - peer->output = json_encode(a); - return ""; + get_num = 500; } - - //@urlpath(null,db) - std::string techempowerdb(std::shared_ptr peer) + auto myworld = orm::World(); + myworld.record.reserve(get_num); + for (unsigned int i = 0; i < get_num; i++) { - peer->type("application/json; charset=UTF-8"); - peer->set_header("Date", get_gmttime()); - auto myworld = orm::World(); + myworld.wheresql.clear(); unsigned int rd_num = rand_range(1, 10000); - myworld.get_one(rd_num); - - peer->output = myworld.data_tojson(); - return ""; + myworld.where("id", rd_num); + co_await myworld.async_fetch_append(); } - //@urlpath(null,queries) - std::string techempowerqueries(std::shared_ptr peer) - { - peer->type("application/json; charset=UTF-8"); - peer->set_header("Date", get_gmttime()); + peer->output = myworld.to_json(); + co_return ""; +} - unsigned int get_num = peer->get["queries"].to_int(); - if (get_num == 0) - { - get_num = 1; - } - else if (get_num > 500) - { - get_num = 500; - } - auto myworld = orm::World(); - myworld.record.reserve(get_num); - for (unsigned int i = 0; i < get_num; i++) - { - myworld.wheresql.clear(); - unsigned int rd_num = rand_range(1, 10000); - myworld.where("id", rd_num).fetch_append(); - } - - peer->output = myworld.to_json(); - return ""; +//@urlpath(null,fortunes) +asio::awaitable techempowerfortunes(std::shared_ptr peer) +{ + peer->type("text/html; charset=UTF-8"); + peer->set_header("Date", get_gmttime()); + + auto myfortune = orm::Fortune(); + co_await myfortune.async_fetch(); + myfortune.data.id = 0; + myfortune.data.message = "Additional fortune added at request time."; + myfortune.record.push_back(myfortune.data); + + std::sort(myfortune.record.begin(), myfortune.record.end(), [](const auto &lhs, const auto &rhs) + { return lhs.message < rhs.message; }); + peer->val["list"].set_array(); + OBJ_ARRAY item; + for (unsigned int i = 0; i < myfortune.record.size(); i++) + { + item["id"] = myfortune.record[i].id; + item["message"] = html_encode(myfortune.record[i].message); + peer->val["list"].push(item); } + peer->view("techempower/fortunes"); + // peer->output = "Fortunes"; + // for (unsigned int i = 0; i < myfortune.record.size(); i++) + // { + // peer->output += ""; + // } + // peer->output += "
idmessage
" + std::to_string(myfortune.record[i].id) + "" + html_encode(myfortune.record[i].message) + "
"; + co_return ""; +} + +//@urlpath(null,updates) +asio::awaitable techempowerupdates(std::shared_ptr peer) +{ + peer->type("application/json; charset=UTF-8"); + peer->set_header("Date", get_gmttime()); + unsigned int get_num = peer->get["queries"].to_int(); - //@urlpath(null,fortunes) - std::string techempowerfortunes(std::shared_ptr peer) + if (get_num == 0) { - peer->type("text/html; charset=UTF-8"); - peer->set_header("Date", get_gmttime()); - - auto myfortune = orm::Fortune(); - myfortune.fetch(); - myfortune.data.id = 0; - myfortune.data.message = "Additional fortune added at request time."; - myfortune.record.push_back(myfortune.data); - - std::sort(myfortune.record.begin(), myfortune.record.end(), [](const auto &lhs, const auto &rhs) - { return lhs.message < rhs.message; }); - peer->val["list"].set_array(); - OBJ_ARRAY item; - for (unsigned int i = 0; i < myfortune.record.size(); i++) - { - item["id"] = myfortune.record[i].id; - item["message"] = html_encode(myfortune.record[i].message); - peer->val["list"].push(item); - } - - peer->view("techempower/fortunes"); - return ""; + get_num = 1; } - - //@urlpath(null,updates) - std::string techempowerupdates(std::shared_ptr peer) + else if (get_num > 500) { - peer->type("application/json; charset=UTF-8"); - peer->set_header("Date", get_gmttime()); - unsigned int get_num = peer->get["queries"].to_int(); - - if (get_num == 0) - { - get_num = 1; - } - else if (get_num > 500) - { - get_num = 500; - } - auto myworld = orm::World(); - myworld.record.clear(); - myworld.record.reserve(get_num); - for (unsigned int i = 0; i < get_num; i++) + get_num = 500; + } + auto myworld = orm::World(); + myworld.record.clear(); + myworld.record.reserve(get_num); + for (unsigned int i = 0; i < get_num; i++) + { + myworld.wheresql.clear(); + myworld.where("id", rand_range(1, 10000)); + co_await myworld.async_fetch_append(); + if (myworld.effect() > 0) { - myworld.wheresql.clear(); - myworld.where("id", rand_range(1, 10000)).fetch_append(); - if (myworld.effect() > 0) - { - unsigned int j = myworld.record.size() - 1; - myworld.data.randomnumber = rand_range(1, 10000); - myworld.record[j].randomnumber = myworld.data.randomnumber; - myworld.update("randomnumber"); - } + unsigned int j = myworld.record.size() - 1; + myworld.data.randomnumber = rand_range(1, 10000); + myworld.record[j].randomnumber = myworld.data.randomnumber; + co_await myworld.async_update("randomnumber"); } - peer->output = myworld.to_json(); - return ""; } + peer->output = myworld.to_json(); + co_return ""; +} - //@urlpath(null,cached-queries) - std::string techempowercached_queries(std::shared_ptr peer) - { - peer->type("application/json; charset=UTF-8"); - peer->set_header("Date", get_gmttime()); +//@urlpath(null,cached-queries) +asio::awaitable techempowercached_queries(std::shared_ptr peer) +{ + peer->type("application/json; charset=UTF-8"); + peer->set_header("Date", get_gmttime()); - unsigned int get_num = peer->get["count"].to_int(); - if (get_num == 0) - { - get_num = 1; - } - else if (get_num > 500) - { - get_num = 500; - } - auto myworld = orm::World(); - std::string mycacheid = "alldatacache"; + unsigned int get_num = peer->get["count"].to_int(); + if (get_num == 0) + { + get_num = 1; + } + else if (get_num > 500) + { + get_num = 500; + } + auto myworld = orm::World(); + std::string mycacheid = "alldatacache"; - pzcache> &temp_cache = pzcache>::conn(); + pzcache> &temp_cache = pzcache>::conn(); - std::vector allcachedata_array; - allcachedata_array.reserve(10000); - // create rand data to cache - if (temp_cache.check(mycacheid) > -1) - { - allcachedata_array = temp_cache.get(mycacheid); - } - else - { - allcachedata_array.resize(10000); - for (unsigned int i = 0; i < 10000; i++) - { - allcachedata_array[i].id = i + 1; - allcachedata_array[i].randomnumber = rand_range(1, 10000); - } - temp_cache.save(mycacheid, allcachedata_array, 120); - } - // get rand data from cache - mycacheid = "my" + std::to_string(get_num); - myworld.record.reserve(get_num); - if (temp_cache.check(mycacheid) > -1) + std::vector allcachedata_array; + allcachedata_array.reserve(10000); + //create rand data to cache + if (temp_cache.check(mycacheid) > -1) + { + allcachedata_array = temp_cache.get(mycacheid); + } + else + { + allcachedata_array.resize(10000); + for (unsigned int i = 0; i < 10000; i++) { - myworld.record = temp_cache.get(mycacheid); + allcachedata_array[i].id = i + 1; + allcachedata_array[i].randomnumber = rand_range(1, 10000); } - else + temp_cache.save(mycacheid, allcachedata_array, 360); + } + //get rand data from cache + mycacheid = "my" + std::to_string(get_num); + myworld.record.reserve(get_num); + if (temp_cache.check(mycacheid) > -1) + { + myworld.record = temp_cache.get(mycacheid); + } + else + { + if (allcachedata_array.size() == 10000) { - if (allcachedata_array.size() == 10000) + for (unsigned int i = 0; i < get_num; i++) { - for (unsigned int i = 0; i < get_num; i++) - { - unsigned int temp_rid = rand_range(0, 9999); - myworld.record.push_back(allcachedata_array[temp_rid]); - } + unsigned int temp_rid = rand_range(0, 9999); + myworld.record.push_back(allcachedata_array[temp_rid]); } - temp_cache.save(mycacheid, myworld.record, 120); } - - peer->output = myworld.to_json(); - return ""; + temp_cache.save(mycacheid, myworld.record, 360); } - //@urlpath(null,cached-db) - std::string techempowercached_db(std::shared_ptr peer) + peer->output = myworld.to_json(); + co_return ""; +} + +//@urlpath(null,cached-db) +asio::awaitable techempowercached_db(std::shared_ptr peer) +{ + peer->type("application/json; charset=UTF-8"); + peer->set_header("Date", get_gmttime()); + //this test from database to cache + unsigned int get_num = peer->get["count"].to_int(); + if (get_num == 0) { - peer->type("application/json; charset=UTF-8"); - peer->set_header("Date", get_gmttime()); - // this test from database to cache - unsigned int get_num = peer->get["count"].to_int(); - if (get_num == 0) - { - get_num = 1; - } - else if (get_num > 500) - { - get_num = 500; - } - auto myworld = orm::World(); - std::string mycacheid = "my" + std::to_string(get_num); + get_num = 1; + } + else if (get_num > 500) + { + get_num = 500; + } + auto myworld = orm::World(); + std::string mycacheid = "my" + std::to_string(get_num); - pzcache> &temp_cache = pzcache>::conn(); + pzcache> &temp_cache = pzcache>::conn(); - myworld.record.reserve(get_num); - if (temp_cache.check(mycacheid) > -1) - { - myworld.record = temp_cache.get(mycacheid); - } - else + myworld.record.reserve(get_num); + if (temp_cache.check(mycacheid) > -1) + { + myworld.record = temp_cache.get(mycacheid); + } + else + { + std::vector cacheid; + for (unsigned int i = 0; i < get_num; i++) { - std::vector cacheid; - for (unsigned int i = 0; i < get_num; i++) - { - cacheid.push_back(rand_range(1, 10000)); - } - - std::string sqlstr = array_to_sql(cacheid); - myworld.whereIn("id", sqlstr).fetch(); - temp_cache.save(mycacheid, myworld.record, 120); + cacheid.push_back(rand_range(1, 10000)); } - peer->output = myworld.to_json(); - return ""; + std::string sqlstr = array_to_sql(cacheid); + myworld.whereIn("id", sqlstr); + co_await myworld.async_fetch(); + temp_cache.save(mycacheid, myworld.record, 360); } -} // namespace http \ No newline at end of file + peer->output = myworld.to_json(); + co_return ""; +} + +}// namespace http \ 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 index 160924992af..361a81acb35 100755 --- a/frameworks/C++/paozhu/paozhu_benchmark/models/Fortune.cpp +++ b/frameworks/C++/paozhu/paozhu_benchmark/models/Fortune.cpp @@ -1,16 +1,14 @@ -#include "mysqlmodel.hpp" +#include "mysqlorm.hpp" #include "fortunebase.h" #include "Fortune.h" /* 如果此文件存在不会自动覆盖，没有则会自动生成。 -*If this file exists, it will not be overwritten automatically. If not, it will be generated automatically. */ + *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(){} - - - } +namespace orm +{ + +Fortune::Fortune(std::string dbtag) : mysql_orm(dbtag) {} +Fortune::Fortune() : mysql_orm() {} + +}// namespace orm diff --git a/frameworks/C++/paozhu/paozhu_benchmark/models/World.cpp b/frameworks/C++/paozhu/paozhu_benchmark/models/World.cpp index aa18f46cab6..8dc5de8396a 100755 --- a/frameworks/C++/paozhu/paozhu_benchmark/models/World.cpp +++ b/frameworks/C++/paozhu/paozhu_benchmark/models/World.cpp @@ -1,16 +1,14 @@ -#include "mysqlmodel.hpp" +#include "mysqlorm.hpp" #include "worldbase.h" #include "World.h" /* 如果此文件存在不会自动覆盖，没有则会自动生成。 -*If this file exists, it will not be overwritten automatically. If not, it will be generated automatically. */ + *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(){} - - - } +namespace orm +{ + +World::World(std::string dbtag) : mysql_orm(dbtag) {} +World::World() : mysql_orm() {} + +}// namespace orm diff --git a/frameworks/C++/paozhu/paozhu_benchmark/models/include/Fortune.h b/frameworks/C++/paozhu/paozhu_benchmark/models/include/Fortune.h index 27865161b32..548dbed843a 100755 --- a/frameworks/C++/paozhu/paozhu_benchmark/models/include/Fortune.h +++ b/frameworks/C++/paozhu/paozhu_benchmark/models/include/Fortune.h @@ -1,16 +1,18 @@ #ifndef ORM_DEFAULT_FORTUNE_H #define ORM_DEFAULT_FORTUNE_H -#include "mysqlmodel.hpp" +#include "mysqlorm.hpp" #include "fortunebase.h" /* 如果此文件存在不会自动覆盖，没有则会自动生成。 -*If this file exists, it will not be overwritten automatically. If not, it will be generated automatically. */ + *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(); - }; +namespace orm +{ +class Fortune : public mysql_orm +{ + public: + Fortune(std::string dbtag); + Fortune(); }; +};// namespace orm #endif diff --git a/frameworks/C++/paozhu/paozhu_benchmark/models/include/World.h b/frameworks/C++/paozhu/paozhu_benchmark/models/include/World.h index ba44dee7888..15ae378052a 100755 --- a/frameworks/C++/paozhu/paozhu_benchmark/models/include/World.h +++ b/frameworks/C++/paozhu/paozhu_benchmark/models/include/World.h @@ -1,16 +1,18 @@ #ifndef ORM_DEFAULT_WORLD_H #define ORM_DEFAULT_WORLD_H -#include "mysqlmodel.hpp" +#include "mysqlorm.hpp" #include "worldbase.h" /* 如果此文件存在不会自动覆盖，没有则会自动生成。 -*If this file exists, it will not be overwritten automatically. If not, it will be generated automatically. */ + *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(); - }; +namespace orm +{ +class World : public mysql_orm +{ + public: + World(std::string dbtag); + World(); }; +};// namespace orm #endif diff --git a/frameworks/C++/paozhu/paozhu_benchmark/orm/include/fortunebase.h b/frameworks/C++/paozhu/paozhu_benchmark/orm/include/fortunebase.h index 8a09ecc4564..544034baf9d 100755 --- a/frameworks/C++/paozhu/paozhu_benchmark/orm/include/fortunebase.h +++ b/frameworks/C++/paozhu/paozhu_benchmark/orm/include/fortunebase.h @@ -1,378 +1,213 @@ #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 -***/ + *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 #include #include -#include "mysql.h" -namespace orm { - - + +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){ + 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}; + + 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(); } + + void assign_field_value(unsigned char index_pos, unsigned char *result_temp_data, unsigned int value_size, meta &data_temp) + { + /* + unsigned int id = 0; // + std::string message = "";// + */ + //bool is_minus = false; + switch (index_pos) + { + case 0: + data_temp.id = 0; + for (size_t i = 0; i < value_size; i++) + { + if (result_temp_data[i] >= '0' && result_temp_data[i] <= '9') + { + data_temp.id = data_temp.id * 10 + (result_temp_data[i] - '0'); + } + } + break; + case 1: + + data_temp.message.clear(); + data_temp.message.resize(value_size); + for (size_t i = 0; i < value_size; i++) + { + data_temp.message[i] = result_temp_data[i]; + } + break; + default: + break; + } + } + + std::string getPKname() + { + return "id"; + } + + void record_reset() + { + record.clear(); + } + void data_reset() + { + fortunebase::meta metatemp; + data = metatemp; + } + + std::string soft_remove_sql([[maybe_unused]] const std::string &fieldsql) + { + std::string temp; + + return temp; + } + + inline std::string stringaddslash(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(;jj 0) + { + tempsql << "`,`"; + } + else + { + tempsql << "`"; + } + tempsql << colnames[j]; + } + if (j > 0) + { + tempsql << "`"; + } + tempsql << ") VALUES ("; - } - 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;jj0){ tempsql<<","; } -if(data.id==0){ - tempsql<<"`id`=0"; - }else{ - tempsql<<"`id`="<0){ tempsql<<","; } -tempsql<<"`message`='"< 0) - { - tempsql << ",\n"; - } - tempsql << "("; - if(record[i].id==0){ - tempsql<<"null"; - }else{ - tempsql< &insert_data) { unsigned int j = 0; std::ostringstream tempsql; @@ -437,2251 +267,2528 @@ tempsql<<"`message`='"< 0) { - tempsql << ",\n"; + tempsql << ","; } 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_offset keypos; + for (; jj < fileld.size(); jj++) { - for(;json_offset0) - { - data=metatemp; - } - if(json_offset>=json_content.size()) + if (fileld[jj] == 0x20) { - break; + + continue; } - for(;json_offset 0) + { + unsigned char bpos_i = findcolpos(keyname); +#ifdef DEBUG + if (bpos_i == 254) { - - 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()) - { - 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) + for (jj = 0; jj < keypos.size(); jj++) { - data=record[0]; + 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:; + } } } - else + + 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(json_content[json_offset]=='{') + if (j > 0) { - json_offset+=1; - std::string json_key_name,json_value_name; - - - for(;json_offset 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(json_content[json_offset]==0x20||json_content[json_offset]==0x0A||json_content[json_offset]==0x0D||json_content[json_offset]=='\t') + if (findcolpos(keyname) < 255) + { + if (j > 0) { - continue; + tempsql << ","; } - else + 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 data_toarray(std::string fileld = "") + { + std::vector temparray; + std::string keyname; + unsigned char jj = 0; + std::vector 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 data_tomap(std::string fileld = "") + { + std::map tempsql; + std::string keyname; + unsigned char jj = 0; + std::vector 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 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 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) { - 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) { - 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()) + 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') { - break; + continue; } - json_value_name.clear(); - if(json_content[json_offset]==0x22) + 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) { - - 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; - } + json_offset += 1; } - else + } + else + { + if (json_content[json_offset] != '{' && json_content[json_offset] != ']') { - if(json_content[json_offset]!='{'&&json_content[json_offset]!=']') + for (; json_offset < json_content.size(); json_offset++) { - for(;json_offset 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 keypos; - if(fileld.size()>0){ - for(;jj 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 func, std::string fileld = "") + { + std::ostringstream tempsql; + std::string keyname; + unsigned char jj = 0; + std::vector 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 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 << 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 ::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; - } - if(keyname.size()>0){ - 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; + } - } - } - - 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) - { + 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; - 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, vpos; + kpos = findcolpos(keyname); + vpos = findcolpos(valname); + T ktemp; + U vtemp; + for (auto &iter : record) { + switch (kpos) + { - - unsigned char kpos; - kpos=findcolpos(keyname); - switch(kpos) + case 1: + ktemp = iter.message; + break; + } + switch (vpos) { - case 0: - return iter.id; - break; + case 1: + vtemp = iter.message; + break; + } - } + a.emplace_back(ktemp, vtemp); + } - return 0; - } - - template,bool>::type = true > - T getVal(std::string keyname) - { - unsigned char kpos; - kpos=findcolpos(keyname); - - switch(kpos) - { + return a; + } - - } - - - 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) - { + template , bool>::type = true> + std::vector> getvecRows([[maybe_unused]] std::string keyname) + { + std::vector> a; - case 1: - return data.message; - break; + unsigned char kpos; + kpos = findcolpos(keyname); + for (auto &iter : record) + { + switch (kpos) + { - } - 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 0: + a.emplace_back(iter.id, iter); + break; + } + } - case 1: - return iter.message; - break; + return a; + } + template ::value, bool>::type = true> + std::vector> getvecRows([[maybe_unused]] std::string keyname) + { + std::vector> a; - } - - - - 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) - { + unsigned char kpos; + kpos = findcolpos(keyname); + for (auto &iter : record) + { + switch (kpos) + { - case 1: - a.emplace_back(iter.message); - break; - } - } + case 1: + a.emplace_back(iter.message, iter); + break; + } + } return a; } - - std::string getstrCol(std::string keyname,[[maybe_unused]] bool isyinhao=false) + 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) { - std::ostringstream a; - - unsigned char kpos; - kpos=findcolpos(keyname); - int j=0; - if(isyinhao&&record.size()>0) + switch (kpos) { - a<<'"'; + + case 0: + ktemp = iter.id; + break; } - for(auto &iter:record) + + switch (vpos) { - if(j>0) - { - if(isyinhao) - { - a<<"\",\""; - }else{ - a<<','; - } - } - switch(kpos) - { + case 0: + vtemp = iter.id; + break; + } - 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) - { + return a; + } - case 1: - ktemp=iter.message; - break; - } - switch(vpos){ - case 1: - vtemp=iter.message; - break; + 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; - } - 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){ + unsigned char kpos, vpos, dpos; + kpos = findcolpos(keyname); + vpos = findcolpos(valname); + dpos = findcolpos(dataname); + T ktemp; + U vtemp; + //D vtemp; - } - 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){ + 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; + } + } - } - 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; + 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; - } - 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) - { + unsigned char kpos, vpos, dpos; + kpos = findcolpos(keyname); + vpos = findcolpos(valname); + dpos = findcolpos(dataname); + T ktemp; + U vtemp; + // D dtemp; - case 1: - ktemp=iter.message; - break; - } - switch(vpos){ - case 0: - vtemp=iter.id; - break; + 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; + } + } - } - 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; + 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; - } - 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) - { + unsigned char kpos, vpos, dpos; + kpos = findcolpos(keyname); + vpos = findcolpos(valname); + dpos = findcolpos(dataname); + T ktemp; + U vtemp; + // D dtemp; + + for (auto &iter : record) + { - case 0: - a.emplace(iter.id,iter); - break; + switch (kpos) + { - } - } - - 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 0: + ktemp = iter.id; + break; + } - case 1: - a.emplace(iter.message,iter); - break; + switch (vpos) + { + case 1: + vtemp = iter.message; + break; + } - } - //a.emplace(ktemp,iter); - } - + switch (dpos) + { + } + } 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) + + 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) { - std::vector> a; - - unsigned char kpos,vpos; - kpos=findcolpos(keyname); - vpos=findcolpos(valname); - std::string ktemp; - U vtemp; - for(auto &iter:record) + switch (kpos) { - 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; + } - case 0: - ktemp=iter.id; - break; - } - switch(vpos){ + switch (vpos) + { + case 1: + vtemp = iter.message; + break; + } - } + switch (dpos) + { + case 0: + a[ktemp][vtemp].emplace_back(iter.id); + break; + } + } - a.emplace_back(ktemp,vtemp); - } + 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; - 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) + for (auto &iter : record) { - std::vector> a; + switch (kpos) + { - - 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 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) - { + switch (vpos) + { + case 1: + vtemp = iter.message; + break; + } - 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) - { + switch (dpos) + { + case 1: + a[ktemp][vtemp].emplace_back(iter.message); + break; + } + } - 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) - { + return a; + } - 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) - { + 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) + { + } + } - case 0: - a.emplace_back(iter.id,iter); - break; + 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; - } - } - - return a; - } - template::value,bool>::type = true > - std::vector> getvecRows([[maybe_unused]] std::string keyname) + for (auto &iter : record) { - std::vector> a; - - unsigned char kpos; - kpos=findcolpos(keyname); - for(auto &iter:record) + + switch (kpos) { - switch(kpos) - { - case 1: - a.emplace_back(iter.message,iter); - break; + 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,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){ + 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; - - 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) + for (auto &iter : record) { - 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(kpos) - { - case 0: - ktemp=iter.id; - break; - } + case 1: + ktemp = iter.message; + break; + } - switch(vpos){ - case 0: - vtemp=iter.id; - break; - } + switch (vpos) + { + case 1: + vtemp = iter.message; + break; + } - switch(dpos){ - case 0: - a[ktemp][vtemp].emplace_back(iter.id); - break; + switch (dpos) + { + } + } - } - } - - 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) - { + 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; - case 0: - ktemp=iter.id; - break; - } + unsigned char kpos, vpos, dpos; + kpos = findcolpos(keyname); + vpos = findcolpos(valname); + dpos = findcolpos(dataname); + T ktemp; + U vtemp; + // D dtemp; - switch(vpos){ - case 0: - vtemp=iter.id; - break; - } + for (auto &iter : record) + { - switch(dpos){ - case 1: - a[ktemp][vtemp].emplace_back(iter.message); - break; + switch (kpos) + { - } - } - - 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 1: + ktemp = iter.message; + break; + } - case 0: - ktemp=iter.id; - break; - } + switch (vpos) + { + case 1: + vtemp = iter.message; + break; + } - switch(vpos){ - case 1: - vtemp=iter.message; - break; - } + switch (dpos) + { + case 0: + a[ktemp][vtemp].emplace_back(iter.id); + break; + } + } - switch(dpos){ + return a; + } - } - } - - 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) + 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; + std::map>> a; - - unsigned char kpos,vpos,dpos; - kpos=findcolpos(keyname); - vpos=findcolpos(valname); - dpos=findcolpos(dataname); + unsigned char kpos, vpos, dpos; + kpos = findcolpos(keyname); + vpos = findcolpos(valname); + dpos = findcolpos(dataname); T ktemp; U vtemp; - // D dtemp; + // D dtemp; - for(auto &iter:record) - { - switch(kpos) + for (auto &iter : record) + { + switch (kpos) { - case 0: - ktemp=iter.id; - break; - } - - switch(vpos){ - case 1: - vtemp=iter.message; - break; - } + case 1: + ktemp = iter.message; + break; + } - switch(dpos){ - case 0: - a[ktemp][vtemp].emplace_back(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,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; - } + 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; - switch(vpos){ - case 1: - vtemp=iter.message; - break; - } + unsigned char kpos, vpos; + kpos = findcolpos(keyname); + vpos = findcolpos(valname); + T ktemp; + //U vtemp; - switch(dpos){ - case 1: - a[ktemp][vtemp].emplace_back(iter.message); - break; + for (auto &iter : record) + { + switch (kpos) + { - } - } - - 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; + } - case 1: - ktemp=iter.message; - break; - } + switch (vpos) + { + case 1: + a[ktemp].emplace_back(iter.message); + break; + } + } - switch(vpos){ - case 0: - vtemp=iter.id; - break; - } + return a; + } - switch(dpos){ + 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; - 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) + for (auto &iter : record) { - 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(kpos) - { - case 1: - ktemp=iter.message; - break; - } + case 1: + ktemp = iter.message; + break; + } - switch(vpos){ - case 0: - vtemp=iter.id; - break; - } + switch (vpos) + { + } + } - switch(dpos){ - case 0: - a[ktemp][vtemp].emplace_back(iter.id); - break; + return a; + } - } - } - - 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) + 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; + std::map> a; - - unsigned char kpos,vpos,dpos; - kpos=findcolpos(keyname); - vpos=findcolpos(valname); - dpos=findcolpos(dataname); + unsigned char kpos, vpos; + kpos = findcolpos(keyname); + vpos = findcolpos(valname); T ktemp; - U vtemp; - // D dtemp; - - for(auto &iter:record) - { - - switch(kpos) - { + //U vtemp; - case 1: - ktemp=iter.message; - break; - } + for (auto &iter : record) + { - switch(vpos){ - case 0: - vtemp=iter.id; - break; - } + switch (kpos) + { - switch(dpos){ - case 1: - a[ktemp][vtemp].emplace_back(iter.message); - break; + case 1: + ktemp = iter.message; + break; + } + switch (vpos) + { + case 0: + a[ktemp].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) + + 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) { - 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(kpos) - { - case 1: - ktemp=iter.message; - break; - } + case 0: + ktemp = iter.id; + break; + } + + switch (vpos) + { + case 1: + a[ktemp].emplace_back(iter.message); + break; + } + } - switch(vpos){ - case 1: - vtemp=iter.message; - break; - } + return a; + } - switch(dpos){ + 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; - - 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) + for (auto &iter : record) { - 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(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; + case 0: + ktemp = 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) - { + switch (vpos) + { + } + } - case 1: - ktemp=iter.message; - break; - } + return a; + } - switch(vpos){ - case 1: - vtemp=iter.message; - break; - } + 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; - switch(dpos){ - case 1: - a[ktemp][vtemp].emplace_back(iter.message); - break; + unsigned char kpos, vpos; + kpos = findcolpos(keyname); + vpos = findcolpos(valname); + T ktemp; + //U vtemp; - } - } - - 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) + for (auto &iter : record) { - std::map> a; - - unsigned char kpos,vpos; - kpos=findcolpos(keyname); - vpos=findcolpos(valname); - T ktemp; - //U vtemp; + switch (kpos) + { + + case 0: + ktemp = iter.id; + break; + } - for(auto &iter:record) + switch (vpos) { - switch(kpos) - { + case 0: + a[ktemp].emplace_back(iter.id); + break; + } + } + + return a; + } - case 1: - ktemp=iter.message; - break; - } + template , bool>::type = true> + std::map> getgroupRows([[maybe_unused]] std::string keyname) + { + std::map> a; - switch(vpos){ - case 1: - a[ktemp].emplace_back(iter.message); - break; + unsigned char kpos; + kpos = findcolpos(keyname); - } - } - - 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) + for (auto &iter : record) { - std::map> a; - - unsigned char kpos,vpos; - kpos=findcolpos(keyname); - vpos=findcolpos(valname); - T ktemp; - //U vtemp; - - for(auto &iter:record) + switch (kpos) { - switch(kpos) - { - case 1: - ktemp=iter.message; - break; - } + case 0: + a[iter.id].emplace_back(iter); + break; + } + } + + return a; + } - switch(vpos){ + template ::value, bool>::type = true> + std::map> getgroupRows([[maybe_unused]] std::string keyname) + { + std::map> a; - } - } + unsigned char kpos; + kpos = findcolpos(keyname); - - 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) + for (auto &iter : record) { - std::map> a; - - unsigned char kpos,vpos; - kpos=findcolpos(keyname); - vpos=findcolpos(valname); - T ktemp; - //U vtemp; - for(auto &iter:record) + switch (kpos) { - - 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 1: + a[iter.message].emplace_back(iter); + break; + } + } - case 0: - ktemp=iter.id; - break; - } + return a; + } - switch(vpos){ - case 1: - a[ktemp].emplace_back(iter.message); - break; + 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; - - 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) + for (auto &iter : record) { - std::map> a; - - unsigned char kpos,vpos; - kpos=findcolpos(keyname); - vpos=findcolpos(valname); - T ktemp; - //U vtemp; - for(auto &iter:record) + switch (kpos) { - - switch(kpos) - { - case 0: - ktemp=iter.id; - break; - } + case 1: + ktemp = iter.message; + break; + } - switch(vpos){ + switch (vpos) + { + case 1: + a[ktemp][iter.message].emplace_back(iter); + break; + } + } - } - } - - 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) - { + return a; + } - case 0: - ktemp=iter.id; - break; - } + 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; - switch(vpos){ - case 0: - a[ktemp].emplace_back(iter.id); - break; + unsigned char kpos, vpos; + kpos = findcolpos(keyname); + vpos = findcolpos(valname); + T ktemp; - } - } - - return a; - } - - template,bool>::type = true> - std::map> getgroupRows([[maybe_unused]] std::string keyname) + for (auto &iter : record) { - std::map> a; - - unsigned char kpos; - kpos=findcolpos(keyname); - for(auto &iter:record) + switch (kpos) { - switch(kpos) - { - case 0: - a[iter.id].emplace_back(iter); - break; + case 1: + ktemp = iter.message; + break; + } - } - } - - return a; + switch (vpos) + { + case 0: + a[ktemp][iter.id].emplace_back(iter); + break; + } } - - 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) - { + return a; + } - case 1: - a[iter.message].emplace_back(iter); - break; + 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; - } - } - - 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) + unsigned char kpos, vpos; + kpos = findcolpos(keyname); + vpos = findcolpos(valname); + T ktemp; + + for (auto &iter : record) { - std::map>> a; - - unsigned char kpos,vpos; - kpos=findcolpos(keyname); - vpos=findcolpos(valname); - T ktemp; - for(auto &iter:record) + switch (kpos) { - - 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 0: + ktemp = iter.id; + break; + } - case 1: - ktemp=iter.message; - break; - } + switch (vpos) + { + case 0: + a[ktemp][iter.id].emplace_back(iter); + 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; - - 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); + 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) - { + for (auto &iter : record) + { - case 0: - ktemp=iter.id; - break; - } + switch (kpos) + { - switch(vpos){ - case 1: - a[ktemp][iter.message].emplace_back(iter); - break; + case 0: + ktemp = iter.id; + break; + } - } - } - - return a; + switch (vpos) + { + case 1: + a[ktemp][iter.message].emplace_back(iter); + break; + } } - - }; - -} + return a; + } +}; + +}// namespace orm #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 index 2bba08096e2..dc44d63a6a0 100755 --- a/frameworks/C++/paozhu/paozhu_benchmark/orm/include/worldbase.h +++ b/frameworks/C++/paozhu/paozhu_benchmark/orm/include/worldbase.h @@ -1,398 +1,235 @@ #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 -***/ + *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 #include #include -#include "mysql.h" -namespace orm { - - + +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){ + 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}; + + 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(); } + + void assign_field_value(unsigned char index_pos, unsigned char *result_temp_data, unsigned int value_size, meta &data_temp) + { + /* + unsigned int id = 0;// + int randomnumber = 0;// + */ + bool is_minus = false; + switch (index_pos) + { + case 0: + data_temp.id = 0; + for (size_t i = 0; i < value_size; i++) + { + if (result_temp_data[i] >= '0' && result_temp_data[i] <= '9') + { + data_temp.id = data_temp.id * 10 + (result_temp_data[i] - '0'); + } + } + break; + case 1: + + data_temp.randomnumber = 0; + + is_minus = false; + if (value_size > 0) + { + if (result_temp_data[0] == '-') + { + is_minus = true; + } + } + for (std::size_t i = 0; i < value_size; i++) + { + if (result_temp_data[i] >= '0' && result_temp_data[i] <= '9') + { + data_temp.randomnumber = data_temp.randomnumber * 10 + (result_temp_data[i] - '0'); + } + } + if (is_minus) + { + data_temp.randomnumber = ~(data_temp.randomnumber - 1); + } + break; + default: + break; + } + } + + 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; - 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) + { + tempsql << "`,`"; + } + else + { + tempsql << "`"; + } + tempsql << colnames[j]; + } + if (j > 0) + { + tempsql << "`"; + } + tempsql << ") VALUES ("; - } - 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;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 << ",\n"; - } - tempsql << "("; - if(record[i].id==0){ - tempsql<<"null"; - }else{ - tempsql< &insert_data) { unsigned int j = 0; std::ostringstream tempsql; @@ -461,2049 +296,2365 @@ if(data.randomnumber==0){ } tempsql << ") VALUES "; - for (unsigned int i = 0; i < record.size(); i++) + for (unsigned int i = 0; i < insert_data.size(); i++) { if (i > 0) { - tempsql << ",\n"; + tempsql << ","; } 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) + if (fileld[jj] == 0x20) { - data=metatemp; + + continue; } - if(json_offset>=json_content.size()) + keyname.push_back(fileld[jj]); + } + if (keyname.size() > 0) + { + unsigned char bpos_i = findcolpos(keyname); +#ifdef DEBUG + if (bpos_i == 254) { - break; + std::cout << "\033[1m\033[31m-----------\n" + << keyname << " not in " << tablename << " table Field.\n-----------\033[0m" + << std::endl; } - 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 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:; } - record.emplace_back(data); - - json_offset+=1; } - if(record.size()>1) + } + + 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 { - data=record[0]; + tempsql << "`"; } + tempsql << colnames[j]; } - else + 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) { - if(json_content[json_offset]=='{') + for (; jj < fileld.size(); jj++) { - json_offset+=1; - std::string json_key_name,json_value_name; - - - for(;json_offset 0) { - 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()) - { - 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(); + tempsql << keyname; + tempsql << "=new."; + tempsql << keyname; } - }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) + } + keyname.push_back(fileld[jj]); + } + if (keyname.size() > 0) + { + if (findcolpos(keyname) < 255) { - switch(kpos) + if (j > 0) { - case 0: - a.emplace_back(iter.id); - break; - case 1: - a.emplace_back(iter.randomnumber); - break; - + tempsql << ","; } + tempsql << keyname; + tempsql << "=new."; + tempsql << keyname; } - - 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 tempsql.str(); + } - return 0; - } - - template,bool>::type = true > - T getVal(std::string keyname) - { - unsigned char kpos; - kpos=findcolpos(keyname); - - switch(kpos) + std::vector data_toarray(std::string fileld = "") + { + std::vector temparray; + std::string keyname; + unsigned char jj = 0; + std::vector 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) { - - } - - - 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) + 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"); } - - - - return 0.0; - } - - template::value,bool>::type = true > - std::string getVal(std::string keyname) - { - unsigned char kpos; - kpos=findcolpos(keyname); - - switch(kpos) + else { - - + temparray.push_back(std::to_string(data.id)); } - 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) + break; + case 1: + if (data.randomnumber == 0) { - - + temparray.push_back("0"); } - - - - return ""; - } - - template::value,bool>::type = true > - std::vector getCol([[maybe_unused]] std::string keyname) - { - std::vector a; + else + { + temparray.push_back(std::to_string(data.randomnumber)); + } + break; - + default:; + } + } - return a; + return temparray; } - - std::string getstrCol(std::string keyname,[[maybe_unused]] bool isyinhao=false) + + std::map data_tomap(std::string fileld = "") + { + std::map tempsql; + std::string keyname; + unsigned char jj = 0; + std::vector keypos; + if (fileld.size() > 1) { - std::ostringstream a; - - unsigned char kpos; - kpos=findcolpos(keyname); - int j=0; - if(isyinhao&&record.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) { - a<<'"'; + keypos.emplace_back(findcolpos(keyname)); + keyname.clear(); } - for(auto &iter:record) + } + else + { + for (jj = 0; jj < colnames.size(); jj++) { - 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) + 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 { - - case 0: - ktemp=iter.id; - break; -case 1: - ktemp=iter.randomnumber; - break; - } - switch(vpos){ + 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 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 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 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 func, std::string fileld = "") + { + std::ostringstream tempsql; + std::string keyname; + unsigned char jj = 0; + std::vector 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 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 << 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 ::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) + { + } + } - } - 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){ + 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; - } - 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) - { + 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 (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) - { + switch (dpos) + { + } + } - 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; + return a; + } - } - 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) - { + 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; - case 0: - a.emplace(iter.id,iter); - break; - case 1: - a.emplace(iter.randomnumber,iter); - break; + unsigned char kpos, vpos, dpos; + kpos = findcolpos(keyname); + vpos = findcolpos(valname); + dpos = findcolpos(dataname); + T ktemp; + U vtemp; + //D vtemp; - } - } - - return a; - } - - template::value,bool>::type = true > - std::map getmapRows([[maybe_unused]] std::string keyname) + for (auto &iter : record) { - std::map a; - + 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::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) - { + 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; - 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) - { + unsigned char kpos, vpos, dpos; + kpos = findcolpos(keyname); + vpos = findcolpos(valname); + dpos = findcolpos(dataname); + T ktemp; + U vtemp; + // D dtemp; - } - 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) - { + for (auto &iter : record) + { - 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) - { + switch (kpos) + { + } + + switch (vpos) + { + case 0: + vtemp = iter.id; + break; + case 1: + vtemp = iter.randomnumber; + break; + } - case 0: - a.emplace_back(iter.id,iter); - break; -case 1: - a.emplace_back(iter.randomnumber,iter); - break; + switch (dpos) + { + } + } - } - } - return a; } - template::value,bool>::type = true > - std::vector> getvecRows([[maybe_unused]] std::string keyname) - { - std::vector> 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,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){ + 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; - - 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) + for (auto &iter : record) { - 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(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; + switch (vpos) + { + } - } - } - - 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) - { + switch (dpos) + { + case 0: + a[ktemp][vtemp].emplace_back(iter.id); + break; + case 1: + a[ktemp][vtemp].emplace_back(iter.randomnumber); + break; + } + } - 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; + } - } - } - - 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) - { + 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; - case 0: - ktemp=iter.id; - break; - case 1: - ktemp=iter.randomnumber; - break; - } + return a; + } - switch(vpos){ - } + 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; - switch(dpos){ + return a; + } - } - } - - 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) + 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; + std::map> a; - - unsigned char kpos,vpos,dpos; - kpos=findcolpos(keyname); - vpos=findcolpos(valname); - dpos=findcolpos(dataname); - T ktemp; - U vtemp; - // D dtemp; + return a; + } - for(auto &iter:record) - { - switch(kpos) - { + 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; - case 0: - ktemp=iter.id; - break; - case 1: - ktemp=iter.randomnumber; - break; - } + unsigned char kpos, vpos; + kpos = findcolpos(keyname); + vpos = findcolpos(valname); + T ktemp; + //U vtemp; - switch(vpos){ - } + for (auto &iter : record) + { - switch(dpos){ - case 0: - a[ktemp][vtemp].emplace_back(iter.id); - break; - case 1: - a[ktemp][vtemp].emplace_back(iter.randomnumber); - break; + 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, 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; - } + 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; - switch(vpos){ - } + unsigned char kpos, vpos; + kpos = findcolpos(keyname); + vpos = findcolpos(valname); + T ktemp; + //U vtemp; - switch(dpos){ + for (auto &iter : record) + { - } - } - - 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 (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 (vpos) + { + } + } - switch(dpos){ + 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; - 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) + unsigned char kpos, vpos; + kpos = findcolpos(keyname); + vpos = findcolpos(valname); + T ktemp; + //U vtemp; + + for (auto &iter : record) { - 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(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; + case 0: + ktemp = iter.id; + break; + case 1: + ktemp = iter.randomnumber; + break; + } - } - } - - return a; + switch (vpos) + { + } } - - 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; + return a; + } - for(auto &iter:record) - { - - switch(kpos) - { + 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; - switch(vpos){ - case 0: - vtemp=iter.id; - break; - case 1: - vtemp=iter.randomnumber; - break; - } + for (auto &iter : record) + { - switch(dpos){ + switch (kpos) + { + case 0: + ktemp = iter.id; + break; + case 1: + ktemp = 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, 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 (vpos) { - - switch(kpos) - { + case 0: + a[ktemp].emplace_back(iter.id); + break; + case 1: + a[ktemp].emplace_back(iter.randomnumber); + break; + } + } - } + return a; + } - switch(vpos){ - } + template , bool>::type = true> + std::map> getgroupRows([[maybe_unused]] std::string keyname) + { + std::map> a; - switch(dpos){ - case 0: - a[ktemp][vtemp].emplace_back(iter.id); - break; - case 1: - a[ktemp][vtemp].emplace_back(iter.randomnumber); - break; + unsigned char kpos; + kpos = findcolpos(keyname); - } - } - - 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) + for (auto &iter : record) { - std::map> a; + switch (kpos) + { - - 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; + case 0: + a[iter.id].emplace_back(iter); + break; + case 1: + a[iter.randomnumber].emplace_back(iter); + break; + } } - - 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) - { + return a; + } - } + template ::value, bool>::type = true> + std::map> getgroupRows([[maybe_unused]] std::string keyname) + { + std::map> a; - switch(vpos){ - case 0: - a[ktemp].emplace_back(iter.id); - break; - case 1: - a[ktemp].emplace_back(iter.randomnumber); - break; + return a; + } - } - } - - 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) - { + 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; - case 0: - ktemp=iter.id; - break; - case 1: - ktemp=iter.randomnumber; - break; - } + return a; + } - switch(vpos){ + 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; - - 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) + for (auto &iter : record) { - std::map> a; - - unsigned char kpos,vpos; - kpos=findcolpos(keyname); - vpos=findcolpos(valname); - T ktemp; - //U vtemp; - for(auto &iter:record) + switch (kpos) { - - 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; + } + } - switch(vpos){ + return a; + } - } - } - - 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) - { + 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; - 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; + unsigned char kpos, vpos; + kpos = findcolpos(keyname); + vpos = findcolpos(valname); + T ktemp; - } - } - - return a; - } - - template,bool>::type = true> - std::map> getgroupRows([[maybe_unused]] std::string keyname) + for (auto &iter : record) { - std::map> a; - - unsigned char kpos; - kpos=findcolpos(keyname); - for(auto &iter:record) + switch (kpos) { - 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) - { + 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; + } + } - 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; - - 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); + 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) - { + for (auto &iter : record) + { - case 0: - ktemp=iter.id; - break; - case 1: - ktemp=iter.randomnumber; - break; - } + switch (kpos) + { - switch(vpos){ + case 0: + ktemp = iter.id; + break; + case 1: + ktemp = iter.randomnumber; + break; + } - } - } - - return a; + switch (vpos) + { + } } - - }; - -} + return a; + } +}; + +}// namespace orm #endif - \ No newline at end of file From 9efccbd363ec7a3b8fc8ef53e140f514c6e45297 Mon Sep 17 00:00:00 2001 From: hzq Date: Fri, 17 Jan 2025 16:09:21 +0800 Subject: [PATCH 02/12] update new test --- frameworks/C++/paozhu/paozhu.dockerfile | 78 ++++++++++++------------- 1 file changed, 39 insertions(+), 39 deletions(-) diff --git a/frameworks/C++/paozhu/paozhu.dockerfile b/frameworks/C++/paozhu/paozhu.dockerfile index 6b91336fdaa..a6eab1e0235 100644 --- a/frameworks/C++/paozhu/paozhu.dockerfile +++ b/frameworks/C++/paozhu/paozhu.dockerfile @@ -39,29 +39,29 @@ 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/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 +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/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/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/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 @@ -69,37 +69,37 @@ 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 +RUN mkdir ./paozhu/view +RUN mkdir ./paozhu/view/techempower -# COPY ./paozhu_benchmark/view/techempower/fortunes.html ./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 +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/ +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 +RUN mkdir ./paozhu/orm +RUN mkdir ./paozhu/orm/include -# COPY ./paozhu_benchmark/orm/orm.h ./paozhu/orm/ -# COPY ./paozhu_benchmark/orm/include/fortunebase.h ./paozhu/orm/include/ -# COPY ./paozhu_benchmark/orm/include/worldbase.h ./paozhu/orm/include/ +COPY ./paozhu_benchmark/orm/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 +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/ +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 From 657adc066be7e1c15566130eef23c947a318801e Mon Sep 17 00:00:00 2001 From: hzq Date: Fri, 17 Jan 2025 16:34:44 +0800 Subject: [PATCH 03/12] fix directory error --- frameworks/C++/paozhu/paozhu.dockerfile | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/frameworks/C++/paozhu/paozhu.dockerfile b/frameworks/C++/paozhu/paozhu.dockerfile index a6eab1e0235..af820de7002 100644 --- a/frameworks/C++/paozhu/paozhu.dockerfile +++ b/frameworks/C++/paozhu/paozhu.dockerfile @@ -20,7 +20,7 @@ RUN git clone https://github.com/hggq/paozhu # RUN unzip benchmark.zip RUN rm -Rf ./paozhu/controller RUN rm -Rf ./paozhu/libs -RUN rm -Rf ./paozhu/view +# RUN rm -Rf ./paozhu/view RUN rm -Rf ./paozhu/viewsrc RUN rm -Rf ./paozhu/orm RUN rm -Rf ./paozhu/models @@ -28,14 +28,14 @@ RUN rm -Rf ./paozhu/common -COPY ./paozhu_benchmark/controller ./paozhu/ -COPY ./paozhu_benchmark/libs ./paozhu/ -COPY ./paozhu_benchmark/view ./paozhu/ -COPY ./paozhu_benchmark/viewsrc ./paozhu/ +# COPY ./paozhu_benchmark/controller ./paozhu/ +# COPY ./paozhu_benchmark/libs ./paozhu/ +# COPY ./paozhu_benchmark/view ./paozhu/ +# COPY ./paozhu_benchmark/viewsrc ./paozhu/ -COPY ./paozhu_benchmark/orm ./paozhu/ -COPY ./paozhu_benchmark/models ./paozhu/ -COPY ./paozhu_benchmark/common ./paozhu/ +# COPY ./paozhu_benchmark/orm ./paozhu/ +# COPY ./paozhu_benchmark/models ./paozhu/ +# COPY ./paozhu_benchmark/common ./paozhu/ # RUN ls -l ./paozhu # RUN pwd @@ -69,10 +69,10 @@ 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 +# RUN mkdir ./paozhu/view +# RUN mkdir ./paozhu/view/techempower -COPY ./paozhu_benchmark/view/techempower/fortunes.html ./paozhu/view/techempower/ +# COPY ./paozhu_benchmark/view/techempower/fortunes.html ./paozhu/view/techempower/ RUN mkdir ./paozhu/viewsrc RUN mkdir ./paozhu/viewsrc/include From 18e6cef68e82241b0f9b122360c1db09cac0361a Mon Sep 17 00:00:00 2001 From: hzq Date: Fri, 17 Jan 2025 17:40:37 +0800 Subject: [PATCH 04/12] fix db update error --- .../paozhu/paozhu_benchmark/conf/server.conf | 22 +++++++++---------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/frameworks/C++/paozhu/paozhu_benchmark/conf/server.conf b/frameworks/C++/paozhu/paozhu_benchmark/conf/server.conf index 9013265e678..265e2193570 100755 --- a/frameworks/C++/paozhu/paozhu_benchmark/conf/server.conf +++ b/frameworks/C++/paozhu/paozhu_benchmark/conf/server.conf @@ -18,19 +18,19 @@ clean_cron =m5t600 ;5-minute interval clean 600 seconds ago inactive connection links_restart_process =n9998877ts1te5 ;More than 15000 connections, restart the process from 1:00 am to 5:00 am session_type=1 ;session save type 0.file 1.memory 2.redis 3.memcache 4.reserve static_file_compress_cache=1 ;1 enable, Cache static file compress(gzip,br) content to cache directory -modelspath=/root/benchmark/models -serverpath=/root/benchmark -viewpath=/root/benchmark/view -viewsopath=/root/benchmark/module/view +modelspath=/paozhu/models +serverpath=/paozhu +viewpath=/paozhu/view +viewsopath=/paozhu/module/view -controlpath=/root/benchmark/controller -controlsopath=/root/benchmark/module/controller +controlpath=/paozhu/controller +controlsopath=/paozhu/module/controller -temppath=/root/benchmark/temp -logpath=/root/benchmark/log -wwwpath=/root/benchmark/www/default -pluginspath=/root/benchmark/plugins -libspath=/root/benchmark/libs +temppath=/paozhu/temp +logpath=/paozhu/log +wwwpath=/paozhu/www/default +pluginspath=/paozhu/plugins +libspath=/paozhu/libs directorylist=0 index=index.html ;usehtmlcache=1 From 1b12a50087d5bd8e93c2122502508fd40ea4a858 Mon Sep 17 00:00:00 2001 From: hzq Date: Fri, 17 Jan 2025 18:19:59 +0800 Subject: [PATCH 05/12] fix db update error --- frameworks/C++/paozhu/paozhu_benchmark/conf/orm.conf | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/frameworks/C++/paozhu/paozhu_benchmark/conf/orm.conf b/frameworks/C++/paozhu/paozhu_benchmark/conf/orm.conf index 1700d25a66e..a2a992d9361 100644 --- a/frameworks/C++/paozhu/paozhu_benchmark/conf/orm.conf +++ b/frameworks/C++/paozhu/paozhu_benchmark/conf/orm.conf @@ -6,7 +6,8 @@ dbname=hello_world user=benchmarkdbuser password=benchmarkdbpass pretable= -maxpool=5 +maxpool=120 +minpool=20 dbtype=mysql type=second @@ -16,5 +17,6 @@ dbname=hello_world user=benchmarkdbuser password=benchmarkdbpass pretable= -maxpool=20 +maxpool=120 +minpool=20 dbtype=mysql From 0665a5b5bf6bceb9572057c27af50033eaa00d79 Mon Sep 17 00:00:00 2001 From: hzq Date: Fri, 17 Jan 2025 22:29:26 +0800 Subject: [PATCH 06/12] fix db update error --- .../controller/src/techempower.cpp | 33 ++++++++++++++++--- 1 file changed, 28 insertions(+), 5 deletions(-) diff --git a/frameworks/C++/paozhu/paozhu_benchmark/controller/src/techempower.cpp b/frameworks/C++/paozhu/paozhu_benchmark/controller/src/techempower.cpp index f3111732864..706d1db0edc 100755 --- a/frameworks/C++/paozhu/paozhu_benchmark/controller/src/techempower.cpp +++ b/frameworks/C++/paozhu/paozhu_benchmark/controller/src/techempower.cpp @@ -42,7 +42,12 @@ asio::awaitable techempowerdb(std::shared_ptr peer) unsigned int rd_num = rand_range(1, 10000); myworld.where("id", rd_num); myworld.limit(1); - co_await myworld.async_fetch_one(); + std::size_t n = co_await myworld.async_fetch_one(); + if (n == 0) + { + n = co_await myworld.async_fetch_one(); + } + peer->output = myworld.data_tojson(); co_return ""; } @@ -69,7 +74,11 @@ asio::awaitable techempowerqueries(std::shared_ptr peer) myworld.wheresql.clear(); unsigned int rd_num = rand_range(1, 10000); myworld.where("id", rd_num); - co_await myworld.async_fetch_append(); + std::size_t n = co_await myworld.async_fetch_append(); + if (n == 0) + { + n = co_await myworld.async_fetch_append(); + } } peer->output = myworld.to_json(); @@ -83,7 +92,12 @@ asio::awaitable techempowerfortunes(std::shared_ptr peer) peer->set_header("Date", get_gmttime()); auto myfortune = orm::Fortune(); - co_await myfortune.async_fetch(); + std::size_t n = co_await myfortune.async_fetch(); + if (n == 0) + { + n = co_await myfortune.async_fetch(); + } + myfortune.data.id = 0; myfortune.data.message = "Additional fortune added at request time."; myfortune.record.push_back(myfortune.data); @@ -130,13 +144,22 @@ asio::awaitable techempowerupdates(std::shared_ptr peer) { myworld.wheresql.clear(); myworld.where("id", rand_range(1, 10000)); - co_await myworld.async_fetch_append(); + std::size_t n = co_await myworld.async_fetch_append(); + if (n == 0) + { + n = co_await myworld.async_fetch_append(); + } if (myworld.effect() > 0) { unsigned int j = myworld.record.size() - 1; myworld.data.randomnumber = rand_range(1, 10000); myworld.record[j].randomnumber = myworld.data.randomnumber; - co_await myworld.async_update("randomnumber"); + + n = co_await myworld.async_update("randomnumber"); + if (n == 0) + { + n = co_await myworld.async_update("randomnumber"); + } } } peer->output = myworld.to_json(); From 25f0f394bb080e418abe5c49590e8b3881882a37 Mon Sep 17 00:00:00 2001 From: hzq Date: Fri, 17 Jan 2025 22:56:30 +0800 Subject: [PATCH 07/12] fix db update error --- .../C++/paozhu/paozhu_benchmark/conf/orm.conf | 8 ++--- .../controller/src/techempower.cpp | 33 +++---------------- 2 files changed, 9 insertions(+), 32 deletions(-) diff --git a/frameworks/C++/paozhu/paozhu_benchmark/conf/orm.conf b/frameworks/C++/paozhu/paozhu_benchmark/conf/orm.conf index a2a992d9361..8d3e8dd66ae 100644 --- a/frameworks/C++/paozhu/paozhu_benchmark/conf/orm.conf +++ b/frameworks/C++/paozhu/paozhu_benchmark/conf/orm.conf @@ -6,8 +6,8 @@ dbname=hello_world user=benchmarkdbuser password=benchmarkdbpass pretable= -maxpool=120 -minpool=20 +maxpool=220 +minpool=30 dbtype=mysql type=second @@ -17,6 +17,6 @@ dbname=hello_world user=benchmarkdbuser password=benchmarkdbpass pretable= -maxpool=120 -minpool=20 +maxpool=220 +minpool=30 dbtype=mysql diff --git a/frameworks/C++/paozhu/paozhu_benchmark/controller/src/techempower.cpp b/frameworks/C++/paozhu/paozhu_benchmark/controller/src/techempower.cpp index 706d1db0edc..f3111732864 100755 --- a/frameworks/C++/paozhu/paozhu_benchmark/controller/src/techempower.cpp +++ b/frameworks/C++/paozhu/paozhu_benchmark/controller/src/techempower.cpp @@ -42,12 +42,7 @@ asio::awaitable techempowerdb(std::shared_ptr peer) unsigned int rd_num = rand_range(1, 10000); myworld.where("id", rd_num); myworld.limit(1); - std::size_t n = co_await myworld.async_fetch_one(); - if (n == 0) - { - n = co_await myworld.async_fetch_one(); - } - + co_await myworld.async_fetch_one(); peer->output = myworld.data_tojson(); co_return ""; } @@ -74,11 +69,7 @@ asio::awaitable techempowerqueries(std::shared_ptr peer) myworld.wheresql.clear(); unsigned int rd_num = rand_range(1, 10000); myworld.where("id", rd_num); - std::size_t n = co_await myworld.async_fetch_append(); - if (n == 0) - { - n = co_await myworld.async_fetch_append(); - } + co_await myworld.async_fetch_append(); } peer->output = myworld.to_json(); @@ -92,12 +83,7 @@ asio::awaitable techempowerfortunes(std::shared_ptr peer) peer->set_header("Date", get_gmttime()); auto myfortune = orm::Fortune(); - std::size_t n = co_await myfortune.async_fetch(); - if (n == 0) - { - n = co_await myfortune.async_fetch(); - } - + co_await myfortune.async_fetch(); myfortune.data.id = 0; myfortune.data.message = "Additional fortune added at request time."; myfortune.record.push_back(myfortune.data); @@ -144,22 +130,13 @@ asio::awaitable techempowerupdates(std::shared_ptr peer) { myworld.wheresql.clear(); myworld.where("id", rand_range(1, 10000)); - std::size_t n = co_await myworld.async_fetch_append(); - if (n == 0) - { - n = co_await myworld.async_fetch_append(); - } + co_await myworld.async_fetch_append(); if (myworld.effect() > 0) { unsigned int j = myworld.record.size() - 1; myworld.data.randomnumber = rand_range(1, 10000); myworld.record[j].randomnumber = myworld.data.randomnumber; - - n = co_await myworld.async_update("randomnumber"); - if (n == 0) - { - n = co_await myworld.async_update("randomnumber"); - } + co_await myworld.async_update("randomnumber"); } } peer->output = myworld.to_json(); From 8825d8caa466081b74bbf9799ce76e3e213ae863 Mon Sep 17 00:00:00 2001 From: hzq Date: Sat, 18 Jan 2025 20:48:26 +0800 Subject: [PATCH 08/12] fix paozhu --- frameworks/C++/paozhu/paozhu_benchmark/conf/orm.conf | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/frameworks/C++/paozhu/paozhu_benchmark/conf/orm.conf b/frameworks/C++/paozhu/paozhu_benchmark/conf/orm.conf index 8d3e8dd66ae..b8eae8460ab 100644 --- a/frameworks/C++/paozhu/paozhu_benchmark/conf/orm.conf +++ b/frameworks/C++/paozhu/paozhu_benchmark/conf/orm.conf @@ -6,7 +6,7 @@ dbname=hello_world user=benchmarkdbuser password=benchmarkdbpass pretable= -maxpool=220 +maxpool=120 minpool=30 dbtype=mysql @@ -17,6 +17,6 @@ dbname=hello_world user=benchmarkdbuser password=benchmarkdbpass pretable= -maxpool=220 +maxpool=120 minpool=30 dbtype=mysql From 1516b0344eae95ce6265dcfdda9e37d3039f1b55 Mon Sep 17 00:00:00 2001 From: hzq Date: Sun, 2 Mar 2025 18:18:29 +0800 Subject: [PATCH 09/12] update paozhu --- .../paozhu/paozhu_benchmark/CMakeLists.txt | 175 +- .../paozhu_benchmark/common/cost_define.h | 3 + .../paozhu_benchmark/common/httphook.cpp | 15 +- .../paozhu_benchmark/models/Fortune.cpp | 16 +- .../paozhu/paozhu_benchmark/models/World.cpp | 16 +- .../paozhu_benchmark/models/fortune_mysql.h | 9788 +++++++++++++++++ .../paozhu_benchmark/models/include/Fortune.h | 20 +- .../paozhu_benchmark/models/include/World.h | 20 +- .../paozhu_benchmark/models/world_mysql.h | 9628 ++++++++++++++++ .../orm/include/fortunebase.h | 4600 ++++---- .../paozhu_benchmark/orm/include/worldbase.h | 4362 ++++---- 11 files changed, 23850 insertions(+), 4793 deletions(-) mode change 100755 => 100644 frameworks/C++/paozhu/paozhu_benchmark/models/Fortune.cpp mode change 100755 => 100644 frameworks/C++/paozhu/paozhu_benchmark/models/World.cpp create mode 100644 frameworks/C++/paozhu/paozhu_benchmark/models/fortune_mysql.h mode change 100755 => 100644 frameworks/C++/paozhu/paozhu_benchmark/models/include/Fortune.h mode change 100755 => 100644 frameworks/C++/paozhu/paozhu_benchmark/models/include/World.h create mode 100644 frameworks/C++/paozhu/paozhu_benchmark/models/world_mysql.h mode change 100755 => 100644 frameworks/C++/paozhu/paozhu_benchmark/orm/include/fortunebase.h mode change 100755 => 100644 frameworks/C++/paozhu/paozhu_benchmark/orm/include/worldbase.h diff --git a/frameworks/C++/paozhu/paozhu_benchmark/CMakeLists.txt b/frameworks/C++/paozhu/paozhu_benchmark/CMakeLists.txt index 611a71394bb..a25af789299 100755 --- a/frameworks/C++/paozhu/paozhu_benchmark/CMakeLists.txt +++ b/frameworks/C++/paozhu/paozhu_benchmark/CMakeLists.txt @@ -73,7 +73,7 @@ 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 -DBENCHMARK -DDEBUG ${BOOST_OPEN} ${GD_OPEN} -I/usr/local/include -I/usr/local/mysql/include -I/usr/include -I/usr/include/mysql " ) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pthread -g -fsanitize=address -DASIO_STANDALONE -DBENCHMARK -DDEBUG ${BOOST_OPEN} ${GD_OPEN} -I/usr/local/include -I/usr/include " ) endif () message("Debug mode:${CMAKE_CXX_FLAGS_DEBUG}") @@ -86,7 +86,7 @@ elseif(${mode} AND (CMAKE_BUILD_TYPE STREQUAL "Release")) 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} -DBENCHMARK -I/usr/local/include -I/usr/local/mysql/include -I/usr/include -I/usr/include/mysql " ) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread -DASIO_STANDALONE ${BOOST_OPEN} ${GD_OPEN} -DBENCHMARK -I/usr/local/include -I/usr/include " ) file(MAKE_DIRECTORY /usr/local/etc/paozhu) file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/conf/ DESTINATION /usr/local/etc/paozhu/) endif () @@ -95,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 -DBENCHMARK -DDEBUG ${BOOST_OPEN} ${GD_OPEN} -I/usr/local/include -I/usr/local/mysql/include -I/usr/include -I/usr/include/mysql " ) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pthread -g -fsanitize=address -DASIO_STANDALONE -DBENCHMARK -DDEBUG ${BOOST_OPEN} ${GD_OPEN} -I/usr/local/include -I/usr/include " ) if(NOT CMAKE_SYSTEM_NAME MATCHES "Windows") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address") @@ -122,6 +122,7 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR}/vendor/httpcli) include_directories(${CMAKE_CURRENT_SOURCE_DIR}/viewsrc/include) include_directories(${CMAKE_CURRENT_SOURCE_DIR}/websockets/include) include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include) +include_directories(${CMAKE_CURRENT_SOURCE_DIR}/orm) if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/bin/paozhu_pre) file(REMOVE_RECURSE ${CMAKE_CURRENT_SOURCE_DIR}/bin/paozhu_pre) @@ -191,7 +192,7 @@ include_sub_directories_recursively(${CMAKE_CURRENT_SOURCE_DIR}/libs) include_sub_directories_recursively(${CMAKE_CURRENT_SOURCE_DIR}/include) include_sub_directories_recursively(${CMAKE_CURRENT_SOURCE_DIR}/common) -add_executable(paozhu_cli ${CMAKE_CURRENT_SOURCE_DIR}/vendor/httpcli/http_cli.cpp) +add_executable(paozhu_cli ${CMAKE_CURRENT_SOURCE_DIR}/vendor/httpcli/http_cli.cpp ${CMAKE_CURRENT_SOURCE_DIR}/vendor/httpserver/src/mysql_conn.cpp ${CMAKE_CURRENT_SOURCE_DIR}/vendor/httpserver/src/mysql_conn_pool.cpp ${CMAKE_CURRENT_SOURCE_DIR}/vendor/httpserver/src/clientdatacache.cpp) set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/bin) @@ -230,14 +231,17 @@ if (ENABLE_VCPKG) target_link_libraries(paozhu ZLIB::ZLIB) # find_package(libmysql REQUIRED) - find_package(unofficial-libmariadb CONFIG REQUIRED) - find_path(MYSQL_ROOT_DIR mysql) + # find_package(unofficial-libmariadb CONFIG REQUIRED) + # find_path(MYSQL_ROOT_DIR mysql) # target_link_libraries(paozhu ${MYSQL_LIBRARIES}) # target_link_libraries(paozhu_cli ${MYSQL_LIBRARIES}) - target_link_libraries(paozhu unofficial::libmariadb) - target_link_libraries(paozhu_cli unofficial::libmariadb) - target_include_directories(paozhu PUBLIC ${MYSQL_ROOT_DIR}/mysql) - target_include_directories(paozhu_cli PUBLIC ${MYSQL_ROOT_DIR}/mysql) + # target_link_libraries(paozhu unofficial::libmariadb) + # target_link_libraries(paozhu_cli unofficial::libmariadb) + # target_include_directories(paozhu PUBLIC ${MYSQL_ROOT_DIR}/mysql) + # target_include_directories(paozhu_cli PUBLIC ${MYSQL_ROOT_DIR}/mysql) + + target_link_libraries(paozhu_cli asio::asio) + target_link_libraries(paozhu_cli OpenSSL::Crypto OpenSSL::SSL) if (ENABLE_GD STREQUAL "ON") find_package(PkgConfig) @@ -331,6 +335,9 @@ if(OPENSSL_FOUND) INCLUDE_DIRECTORIES("${OPENSSL_INCLUDE_DIR}") target_link_libraries (paozhu ${OPENSSL_SSL_LIBRARY}) target_link_libraries (paozhu ${OPENSSL_CRYPTO_LIBRARY}) + + target_link_libraries (paozhu_cli ${OPENSSL_SSL_LIBRARY}) + target_link_libraries (paozhu_cli ${OPENSSL_CRYPTO_LIBRARY}) endif() @@ -343,80 +350,80 @@ if(ZLIB_FOUND) endif() -if(CMAKE_SYSTEM_NAME MATCHES "Darwin") - if (IS_DIRECTORY "/usr/local/mysql/include") - MESSAGE( STATUS "/usr/local/mysql") - set(MYSQL_INCLUDE_DIR "/usr/local/mysql/include") - include_sub_directories_recursively(/usr/local/mysql/include) - endif() - - if (IS_DIRECTORY "/usr/local/opt/mysql-client") - MESSAGE( STATUS "/usr/local/opt/mysql-client") - set(MYSQL_INCLUDE_DIR "/usr/local/opt/mysql-client/include") - include_sub_directories_recursively(/usr/local/opt/mysql-client/include) - endif() - - if (IS_DIRECTORY "/opt/homebrew/opt/mysql") - MESSAGE( STATUS "/opt/homebrew/opt/mysql") - set(MYSQL_INCLUDE_DIR "/opt/homebrew/opt/mysql/include") - include_sub_directories_recursively(/opt/homebrew/opt/mysql/include) - endif() - - - if (IS_DIRECTORY "/opt/homebrew/opt/mysql-client") - MESSAGE( STATUS "/opt/homebrew/opt/mysql-client") - set(MYSQL_INCLUDE_DIR "/opt/homebrew/opt/mysql-client/include") - include_sub_directories_recursively(/opt/homebrew/opt/mysql-client/include) - endif() - MESSAGE( STATUS "MYSQL_ROOT_DIR = ${MYSQL_ROOT_DIR} ") -else() - find_path(MYSQL_ROOT_DIR mysql) -endif() - - -FIND_PATH(MYSQL_INCLUDE_DIR NAMES mysql.h - PATHS /usr/local/include/mysql /usr/include/mysql /opt/homebrew/opt/mysql/include /usr/local/opt/mysql-client/include /opt/homebrew/opt/mysql-client/include -) - -MESSAGE( STATUS "MYSQL_ROOT_DIR = ${MYSQL_ROOT_DIR} ") -find_package_handle_standard_args(mysql REQUIRED_VARS MYSQL_ROOT_DIR) - - -if(NOT MYSQL_INCLUDE_DIR) - message(STATUS "Could not find \"mysql.h\" from searching ") -endif() - -SET(MYSQL_NAMES mysqlclient) -FIND_LIBRARY(MYSQL_LIBRARY - NAMES ${MYSQL_NAMES} - PATHS /usr/lib /usr/local/lib /usr/local/mysql/lib /usr/local/opt/mysql/lib /opt/homebrew/opt/mysql/lib /opt/homebrew/opt/mysql-client/lib - PATH_SUFFIXES mysql -) - -IF (MYSQL_INCLUDE_DIR AND MYSQL_LIBRARY) - SET(MYSQL_FOUND TRUE) - SET( MYSQL_LIBRARIES ${MYSQL_LIBRARY} ) -ELSE (MYSQL_INCLUDE_DIR AND MYSQL_LIBRARY) - SET(MYSQL_FOUND FALSE) - SET( MYSQL_LIBRARIES ) -ENDIF (MYSQL_INCLUDE_DIR AND MYSQL_LIBRARY) - -IF (MYSQL_FOUND) - IF (NOT MYSQL_FIND_QUIETLY) - MESSAGE(STATUS "Found MySQL: ${MYSQL_LIBRARY}") - ENDIF (NOT MYSQL_FIND_QUIETLY) -ELSE (MYSQL_FOUND) - IF (MYSQL_FIND_REQUIRED) - MESSAGE(STATUS "Looked for MySQL libraries named ${MYSQL_NAMES}.") - MESSAGE(FATAL_ERROR "Could NOT find MySQL library") - ENDIF (MYSQL_FIND_REQUIRED) -ENDIF (MYSQL_FOUND) - -target_include_directories(paozhu PUBLIC ${MYSQL_INCLUDE_DIR}) -target_link_libraries(paozhu ${MYSQL_LIBRARY}) - -target_include_directories(paozhu_cli PUBLIC ${MYSQL_INCLUDE_DIR}) -target_link_libraries(paozhu_cli ${MYSQL_LIBRARY}) +#if(CMAKE_SYSTEM_NAME MATCHES "Darwin") +# if (IS_DIRECTORY "/usr/local/mysql/include") +# MESSAGE( STATUS "/usr/local/mysql") +# set(MYSQL_INCLUDE_DIR "/usr/local/mysql/include") +# include_sub_directories_recursively(/usr/local/mysql/include) +# endif() +# +# if (IS_DIRECTORY "/usr/local/opt/mysql-client") +# MESSAGE( STATUS "/usr/local/opt/mysql-client") +# set(MYSQL_INCLUDE_DIR "/usr/local/opt/mysql-client/include") +# include_sub_directories_recursively(/usr/local/opt/mysql-client/include) +# endif() +# +# if (IS_DIRECTORY "/opt/homebrew/opt/mysql") +# MESSAGE( STATUS "/opt/homebrew/opt/mysql") +# set(MYSQL_INCLUDE_DIR "/opt/homebrew/opt/mysql/include") +# include_sub_directories_recursively(/opt/homebrew/opt/mysql/include) +# endif() +# +# +# if (IS_DIRECTORY "/opt/homebrew/opt/mysql-client") +# MESSAGE( STATUS "/opt/homebrew/opt/mysql-client") +# set(MYSQL_INCLUDE_DIR "/opt/homebrew/opt/mysql-client/include") +# include_sub_directories_recursively(/opt/homebrew/opt/mysql-client/include) +# endif() +# MESSAGE( STATUS "MYSQL_ROOT_DIR = ${MYSQL_ROOT_DIR} ") +#else() +# find_path(MYSQL_ROOT_DIR mysql) +#endif() +# +# +# FIND_PATH(MYSQL_INCLUDE_DIR NAMES mysql.h +# PATHS /usr/local/include/mysql /usr/include/mysql /opt/homebrew/opt/mysql/include /usr/local/opt/mysql-client/include /opt/homebrew/opt/mysql-client/include +# ) +# +# MESSAGE( STATUS "MYSQL_ROOT_DIR = ${MYSQL_ROOT_DIR} ") +# find_package_handle_standard_args(mysql REQUIRED_VARS MYSQL_ROOT_DIR) +# +# +# if(NOT MYSQL_INCLUDE_DIR) +# message(STATUS "Could not find \"mysql.h\" from searching ") +# endif() +# +# SET(MYSQL_NAMES mysqlclient) +# FIND_LIBRARY(MYSQL_LIBRARY +# NAMES ${MYSQL_NAMES} +# PATHS /usr/lib /usr/local/lib /usr/local/mysql/lib /usr/local/opt/mysql/lib /opt/homebrew/opt/mysql/lib /opt/homebrew/opt/mysql-client/lib +# PATH_SUFFIXES mysql +# ) +# +# IF (MYSQL_INCLUDE_DIR AND MYSQL_LIBRARY) +# SET(MYSQL_FOUND TRUE) +# SET( MYSQL_LIBRARIES ${MYSQL_LIBRARY} ) +# ELSE (MYSQL_INCLUDE_DIR AND MYSQL_LIBRARY) +# SET(MYSQL_FOUND FALSE) +# SET( MYSQL_LIBRARIES ) +# ENDIF (MYSQL_INCLUDE_DIR AND MYSQL_LIBRARY) +# +# IF (MYSQL_FOUND) +# IF (NOT MYSQL_FIND_QUIETLY) +# MESSAGE(STATUS "Found MySQL: ${MYSQL_LIBRARY}") +# ENDIF (NOT MYSQL_FIND_QUIETLY) +# ELSE (MYSQL_FOUND) +# IF (MYSQL_FIND_REQUIRED) +# MESSAGE(STATUS "Looked for MySQL libraries named ${MYSQL_NAMES}.") +# MESSAGE(FATAL_ERROR "Could NOT find MySQL library") +# ENDIF (MYSQL_FIND_REQUIRED) +# ENDIF (MYSQL_FOUND) +# +# target_include_directories(paozhu PUBLIC ${MYSQL_INCLUDE_DIR}) +# target_link_libraries(paozhu ${MYSQL_LIBRARY}) +# +# target_include_directories(paozhu_cli PUBLIC ${MYSQL_INCLUDE_DIR}) +# target_link_libraries(paozhu_cli ${MYSQL_LIBRARY}) diff --git a/frameworks/C++/paozhu/paozhu_benchmark/common/cost_define.h b/frameworks/C++/paozhu/paozhu_benchmark/common/cost_define.h index 47fb182f0e0..ef54468d7be 100755 --- a/frameworks/C++/paozhu/paozhu_benchmark/common/cost_define.h +++ b/frameworks/C++/paozhu/paozhu_benchmark/common/cost_define.h @@ -6,4 +6,7 @@ #define CONST_HTTP_HEADER_BODY_SIZE 16384 #define CONST_PHP_BODY_POST_SIZE 16777216 +#define CONST_HTTP_BODY_POST_SIZE 33554432 +#define CONST_HTTP_JSON_POST_SIZE 2097152 + #endif \ 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 index 3440c23f84b..327ecab4b71 100755 --- a/frameworks/C++/paozhu/paozhu_benchmark/common/httphook.cpp +++ b/frameworks/C++/paozhu/paozhu_benchmark/common/httphook.cpp @@ -8,13 +8,24 @@ #include #include #include "httppeer.h" +#include "client_session.h" namespace http { std::map _block_ip_tables; std::map _block_host_tables; -bool check_blockip(const std::string &client_ip) +std::map _passport_ip_tables; +std::map _passport_host_tables; +bool check_blockip(std::shared_ptr peer_session) { - if (client_ip.size() > 0) + if (peer_session->isssl) + { + return false; + } + return false; +} +bool check_pressl_blockip(std::shared_ptr peer_session) +{ + if (peer_session->isssl) { return false; } diff --git a/frameworks/C++/paozhu/paozhu_benchmark/models/Fortune.cpp b/frameworks/C++/paozhu/paozhu_benchmark/models/Fortune.cpp old mode 100755 new mode 100644 index 361a81acb35..4bb6dd1bc5c --- a/frameworks/C++/paozhu/paozhu_benchmark/models/Fortune.cpp +++ b/frameworks/C++/paozhu/paozhu_benchmark/models/Fortune.cpp @@ -1,14 +1,16 @@ -#include "mysqlorm.hpp" + +#include "fortune_mysql.h" #include "fortunebase.h" #include "Fortune.h" /* 如果此文件存在不会自动覆盖，没有则会自动生成。 - *If this file exists, it will not be overwritten automatically. If not, it will be generated automatically. */ +*If this file exists, it will not be overwritten automatically. If not, it will be generated automatically. */ -namespace orm -{ + + namespace orm{ + + Fortune::Fortune(std::string dbtag):fortune_mysql(dbtag){ mod=this; } + Fortune::Fortune():fortune_mysql(){ mod=this; } -Fortune::Fortune(std::string dbtag) : mysql_orm(dbtag) {} -Fortune::Fortune() : mysql_orm() {} -}// namespace orm + } diff --git a/frameworks/C++/paozhu/paozhu_benchmark/models/World.cpp b/frameworks/C++/paozhu/paozhu_benchmark/models/World.cpp old mode 100755 new mode 100644 index 8dc5de8396a..970e3427398 --- a/frameworks/C++/paozhu/paozhu_benchmark/models/World.cpp +++ b/frameworks/C++/paozhu/paozhu_benchmark/models/World.cpp @@ -1,14 +1,16 @@ -#include "mysqlorm.hpp" + +#include "world_mysql.h" #include "worldbase.h" #include "World.h" /* 如果此文件存在不会自动覆盖，没有则会自动生成。 - *If this file exists, it will not be overwritten automatically. If not, it will be generated automatically. */ +*If this file exists, it will not be overwritten automatically. If not, it will be generated automatically. */ -namespace orm -{ + + namespace orm{ + + World::World(std::string dbtag):world_mysql(dbtag){ mod=this; } + World::World():world_mysql(){ mod=this; } -World::World(std::string dbtag) : mysql_orm(dbtag) {} -World::World() : mysql_orm() {} -}// namespace orm + } diff --git a/frameworks/C++/paozhu/paozhu_benchmark/models/fortune_mysql.h b/frameworks/C++/paozhu/paozhu_benchmark/models/fortune_mysql.h new file mode 100644 index 00000000000..18cba5958fc --- /dev/null +++ b/frameworks/C++/paozhu/paozhu_benchmark/models/fortune_mysql.h @@ -0,0 +1,9788 @@ +#ifndef _ORM_DEFAULT_FORTUNE_OPERATE_H +#define _ORM_DEFAULT_FORTUNE_OPERATE_H + +#include +#include +#include +#include +#include +#include +#include +#include "request.h" +#include "unicode.h" +#include "datetime.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "mysql_conn.h" +#include "mysql_conn_pool.h" +#include "orm_cache.hpp" +/*baseincludefile*/ +namespace orm +{ +// mysql Operational SQL middleware +/*tagnamespace*/ +//{ /*tagnamespace_replace*/ + template + class fortune_mysql : public B_BASE + { + public: + fortune_mysql(const std::string &tag) : dbtag(tag) + { + std::map> &conn_pool_obj = get_orm_conn_pool_obj(); + auto iter = conn_pool_obj.find(dbtag); + if (iter != conn_pool_obj.end()) + { + conn_obj = iter->second; + } + else + { + conn_obj = nullptr; + iserror = true; + error_msg = "conn_pool not found " + dbtag; + } + } + fortune_mysql() : dbtag(B_BASE::_rmstag) + { + std::map> &conn_pool_obj = get_orm_conn_pool_obj(); + auto iter = conn_pool_obj.find(dbtag); + if (iter != conn_pool_obj.end()) + { + conn_obj = iter->second; + } + else + { + conn_obj = nullptr; + iserror = true; + error_msg = "conn_pool not found " + dbtag; + } + } + M_MODEL &switchDB(const std::string &temptag) + { + std::map> &conn_pool_obj = get_orm_conn_pool_obj(); + auto iter = conn_pool_obj.find(temptag); + if (iter != conn_pool_obj.end()) + { + conn_obj = iter->second; + } + else + { + conn_obj = nullptr; + iserror = true; + error_msg = "conn_pool not found " + temptag; + } + } + M_MODEL &set_table(const std::string &table_name) + { + if (original_tablename.empty()) + { + original_tablename = B_BASE::tablename; + } + if (table_name.size() > 0) + { + B_BASE::tablename = table_name; + } + return *mod; + } + M_MODEL &reset_table() + { + if (original_tablename.empty()) + { + return *mod; + } + B_BASE::tablename = original_tablename; + return *mod; + } + unsigned int count() + { + std::string countsql; + countsql = "SELECT count(*) as total_countnum FROM "; + countsql.append(B_BASE::tablename); + countsql.append(" WHERE "); + if (wheresql.empty()) + { + countsql.append(" 1 "); + } + else + { + countsql.append(wheresql); + } + if (!groupsql.empty()) + { + countsql.append(groupsql); + } + if (!limitsql.empty()) + { + countsql.append(limitsql); + } + + if (iserror) + { + return 0; + } + + try + { + effect_num = 0; + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_select_conn(); + + unsigned int querysql_len = countsql.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(countsql); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + //std::vector field_array; + unsigned char action_setup = 0; + unsigned int column_num = 0; + unsigned int offset = 0; + + querysql_len = 0; + + for (; is_sql_item == false;) + { + n = conn->read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + column_num--; + if (column_num == 0) + { + action_setup = 2; + } + } + else if (action_setup == 2) + { + unsigned int tempnum = 0; + + unsigned int name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + querysql_len = 0; + for (unsigned int ik = 0; ik < name_length; ik++) + { + if (temp_pack_data.data[tempnum] >= '0' && temp_pack_data.data[tempnum] <= '9') + { + querysql_len = querysql_len * 10 + (temp_pack_data.data[tempnum] - '0'); + } + tempnum++; + } + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + + conn_obj->back_select_conn(conn); + + if (iscache) + { + if (exptime > 0) + { + save_cache(exptime); + exptime = 0; + iscache = false; + } + } + return querysql_len; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + return 0; + } + + return 0; + } + std::tuple + page(unsigned int page, unsigned int per_page = 10, unsigned int list_num = 5) + { + unsigned int total_page = count(); + if (per_page == 0) + { + per_page = 10; + } + if (list_num < 1) + { + list_num = 1; + } + total_page = std::ceil((float)total_page / per_page); + + if (total_page < 1) + { + total_page = 1; + } + if (page > total_page) + { + page = total_page; + } + if (page < 1) + { + page = 1; + } + unsigned int mid_num = std::floor(list_num / 2); + unsigned int last_num = list_num - 1; + + int temp_num = page - mid_num; + + unsigned int minpage = temp_num < 1 ? 1 : temp_num; + unsigned int maxpage = minpage + last_num; + + if (maxpage > total_page) + { + maxpage = total_page; + temp_num = (maxpage - last_num); + if (temp_num < 1) + { + minpage = 1; + } + else + { + minpage = temp_num; + } + } + limit((page - 1) * per_page, per_page); + return std::make_tuple(minpage, maxpage, page, total_page); + } + asio::awaitable async_count() + { + std::string countsql; + countsql = "SELECT count(*) as total_countnum FROM "; + countsql.append(B_BASE::tablename); + countsql.append(" WHERE "); + if (wheresql.empty()) + { + countsql.append(" 1 "); + } + else + { + countsql.append(wheresql); + } + if (!groupsql.empty()) + { + countsql.append(groupsql); + } + if (!limitsql.empty()) + { + countsql.append(limitsql); + } + + if (iserror) + { + co_return 0; + } + + try + { + effect_num = 0; + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_select_conn(); + + unsigned int querysql_len = countsql.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(countsql); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + //std::vector field_array; + unsigned char action_setup = 0; + unsigned int column_num = 0; + unsigned int offset = 0; + + querysql_len = 0; + + for (; is_sql_item == false;) + { + n = co_await conn->async_read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + column_num--; + if (column_num == 0) + { + action_setup = 2; + } + } + else if (action_setup == 2) + { + unsigned int tempnum = 0; + + unsigned int name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + querysql_len = 0; + for (unsigned int ik = 0; ik < name_length; ik++) + { + if (temp_pack_data.data[tempnum] >= '0' && temp_pack_data.data[tempnum] <= '9') + { + querysql_len = querysql_len * 10 + (temp_pack_data.data[tempnum] - '0'); + } + tempnum++; + } + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + + conn_obj->back_select_conn(conn); + + if (iscache) + { + if (exptime > 0) + { + save_cache(exptime); + exptime = 0; + iscache = false; + } + } + co_return querysql_len; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + co_return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + co_return 0; + } + co_return 0; + } + + asio::awaitable> + async_page(unsigned int page, unsigned int per_page = 10, unsigned int list_num = 5) + { + unsigned int total_page = async_count(); + if (per_page == 0) + { + per_page = 10; + } + if (list_num < 1) + { + list_num = 1; + } + total_page = std::ceil((float)total_page / per_page); + + if (total_page < 1) + { + total_page = 1; + } + if (page > total_page) + { + page = total_page; + } + if (page < 1) + { + page = 1; + } + unsigned int mid_num = std::floor(list_num / 2); + unsigned int last_num = list_num - 1; + + int temp_num = page - mid_num; + + unsigned int minpage = temp_num < 1 ? 1 : temp_num; + unsigned int maxpage = minpage + last_num; + + if (maxpage > total_page) + { + maxpage = total_page; + temp_num = (maxpage - last_num); + if (temp_num < 1) + { + minpage = 1; + } + else + { + minpage = temp_num; + } + } + limit((page - 1) * per_page, per_page); + co_return std::make_tuple(minpage, maxpage, page, total_page); + } + + unsigned int update_col(std::string colname, int num, char symbol = '+') + { + effect_num = 0; + std::string countsql; + countsql = "UPDATE "; + countsql.append(B_BASE::tablename); + countsql.append(" SET "); + countsql.append(colname); + if (num > 0) + { + countsql.append(" = "); + countsql.append(colname); + countsql.push_back(' '); + countsql.push_back(symbol); + countsql.append(std::to_string(num)); + } + else + { + countsql.append(" = "); + countsql.append(colname); + countsql.push_back(' '); + countsql.push_back(symbol); + countsql.push_back('('); + countsql.push_back('-'); + countsql.append(std::to_string(std::abs(num))); + countsql.push_back(')'); + } + countsql.append(" where "); + if (wheresql.empty()) + { + if (B_BASE::getPK() > 0) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + countsql.append(tempsql.str()); + } + else + { + return 0; + } + } + else + { + countsql.append(wheresql); + } + if (!groupsql.empty()) + { + countsql.append(groupsql); + } + if (!limitsql.empty()) + { + countsql.append(limitsql); + } + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = countsql.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(countsql); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + //insertid = pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + return effect_num; + } + + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + return 0; + } + + asio::awaitable async_update_col(std::string colname, int num, char symbol = '+') + { + effect_num = 0; + std::string countsql; + countsql = "UPDATE "; + countsql.append(B_BASE::tablename); + countsql.append(" SET "); + countsql.append(colname); + if (num > 0) + { + countsql.append(" = "); + countsql.append(colname); + countsql.push_back(' '); + countsql.push_back(symbol); + countsql.append(std::to_string(num)); + } + else + { + countsql.append(" = "); + countsql.append(colname); + countsql.push_back(' '); + countsql.push_back(symbol); + countsql.push_back('('); + countsql.push_back('-'); + countsql.append(std::to_string(std::abs(num))); + countsql.push_back(')'); + } + countsql.append(" where "); + if (wheresql.empty()) + { + if (B_BASE::getPK() > 0) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + countsql.append(tempsql.str()); + } + else + { + co_return 0; + } + } + else + { + countsql.append(wheresql); + } + if (!groupsql.empty()) + { + countsql.append(groupsql); + } + if (!limitsql.empty()) + { + countsql.append(limitsql); + } + if (iscommit) + { + iscommit = false; + co_return 0; + } + + if (iserror) + { + co_return 0; + } + + try + { + + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_edit_conn(); + + unsigned int querysql_len = countsql.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(countsql); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + unsigned int offset = 0; + n = co_await conn->async_read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + //insertid = pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + co_return effect_num; + } + + co_return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + co_return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + co_return 0; + } + + int replace_col(std::string colname, const std::string &old_string, const std::string &new_string) + { + effect_num = 0; + std::string countsql; + countsql = "UPDATE "; + countsql.append(B_BASE::tablename); + countsql.append(" SET "); + countsql.append(colname); + + countsql.append(" = REPLACE("); + countsql.append(colname); + countsql.append(",'"); + countsql.append(old_string); + countsql.append("','"); + countsql.append(new_string); + countsql.append("') "); + + countsql.append(" where "); + if (wheresql.empty()) + { + if (B_BASE::getPK() > 0) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + countsql.append(tempsql.str()); + } + else + { + return 0; + } + } + else + { + countsql.append(wheresql); + } + if (!groupsql.empty()) + { + countsql.append(groupsql); + } + if (!limitsql.empty()) + { + countsql.append(limitsql); + } + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = countsql.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(countsql); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + //insertid = pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + return effect_num; + } + + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + return 0; + } + + void assign_field_value(unsigned char index_pos, unsigned char *result_temp_data, unsigned int value_size, typename B_BASE::meta &data_temp) + { + switch(index_pos) + { + case 0: + data_temp.id=0; + + for(unsigned int i=0; i< value_size; i++) + { + if(result_temp_data[i]>='0'&&result_temp_data[i]<='9') + { + + data_temp.id= data_temp.id * 10 + (result_temp_data[i]-'0'); + } + if(i>32) + { + break; + } + } + break; + case 1: + data_temp.message.clear(); + data_temp.message.resize(value_size); + + std::memcpy(data_temp.message.data(), result_temp_data, value_size); + break; + + } + } + + +M_MODEL& eqId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id = "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& nqId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id != "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& inId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id IN("); + + wheresql.append(val); + wheresql.push_back(')'); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& inId(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + wheresql.append(std::to_string(val[i])); + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& inId(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + + try + { + wheresql.append(std::to_string(std::stoll(val[i]))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& ninId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id NOT IN("); + + wheresql.append(val); + wheresql.push_back(')'); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& ninId(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id NOT IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + wheresql.append(std::to_string(val[i])); + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& ninId(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id NOT IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + + try + { + wheresql.append(std::to_string(std::stoll(val[i]))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& btId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id > "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& beId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id >= "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& ltId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id < "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& leId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id <= "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& or_eqId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id = "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& or_nqId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id != "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& or_inId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id IN("); + + wheresql.append(val); + wheresql.push_back(')'); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_inId(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + wheresql.append(std::to_string(val[i])); + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& or_inId(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + + try + { + wheresql.append(std::to_string(std::stoll(val[i]))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& or_ninId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id NOT IN("); + + wheresql.append(val); + wheresql.push_back(')'); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_ninId(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id NOT IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + wheresql.append(std::to_string(val[i])); + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& or_ninId(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id NOT IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + + try + { + wheresql.append(std::to_string(std::stoll(val[i]))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& or_btId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id > "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& or_beId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id >= "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& or_ltId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id < "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& or_leId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id <= "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& eqId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id = "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& nqId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id != "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& btId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id > "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& beId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id >= "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& ltId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id < "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& leId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id <= "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_eqId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id = "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_nqId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id != "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_btId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id > "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_beId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id >= "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_ltId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id < "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_leId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id <= "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +M_MODEL& nullMessage() + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message = NULL "); + + return *mod; + } + + +M_MODEL& nnullMessage() + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message != NULL "); + + return *mod; + } + + +M_MODEL& eqMessage(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message = '"); + wheresql.append(B_BASE::stringaddslash(val)); + wheresql.push_back('\''); + + return *mod; + } + + +M_MODEL& nqMessage(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message != '"); + wheresql.append(B_BASE::stringaddslash(val)); + wheresql.push_back('\''); + + return *mod; + } + + +M_MODEL& inMessage(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message IN("); + wheresql.append(val); + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& inMessage(const std::vector &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message IN("); + + for(unsigned int i=0;i0) + { + wheresql.push_back(','); + } + wheresql.push_back('\''); + wheresql.append(B_BASE::stringaddslash(val[i])); + wheresql.push_back('\''); + } + + + + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& inMessage(const std::vector &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message IN("); + + for(unsigned int i=0;i0) + { + wheresql.push_back(','); + } + wheresql.push_back('\''); + wheresql.append(std::to_string(val[i])); + wheresql.push_back('\''); + } + + + + return *mod; + } + + +M_MODEL& ninMessage(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message NOT IN("); + wheresql.append(val); + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& ninMessage(const std::vector &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message NOT IN("); + + for(unsigned int i=0;i0) + { + wheresql.push_back(','); + } + wheresql.push_back('\''); + wheresql.append(B_BASE::stringaddslash(val[i])); + wheresql.push_back('\''); + } + + + + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& ninMessage(const std::vector &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message NOT IN("); + + for(unsigned int i=0;i0) + { + wheresql.push_back(','); + } + wheresql.push_back('\''); + wheresql.append(std::to_string(val[i])); + wheresql.push_back('\''); + } + + + + return *mod; + } + + +M_MODEL& likeMessage(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message LIKE '%"); + wheresql.append(B_BASE::stringaddslash(val)); + wheresql.append("%'"); + + return *mod; + } + + +M_MODEL& l_likeMessage(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message LIKE '%"); + wheresql.append(B_BASE::stringaddslash(val)); + wheresql.append("'"); + + return *mod; + } + + +M_MODEL& r_likeMessage(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message LIKE '"); + wheresql.append(B_BASE::stringaddslash(val)); + wheresql.append("%'"); + + return *mod; + } + + +M_MODEL& btMessage(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message > '"); + wheresql.append(B_BASE::stringaddslash(val)); + wheresql.push_back('\''); + + return *mod; + } + + +M_MODEL& beMessage(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message >= '"); + wheresql.append(B_BASE::stringaddslash(val)); + wheresql.push_back('\''); + + return *mod; + } + + +M_MODEL& ltMessage(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message < '"); + wheresql.append(B_BASE::stringaddslash(val)); + wheresql.push_back('\''); + + return *mod; + } + + +M_MODEL& leMessage(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message <= '"); + wheresql.append(B_BASE::stringaddslash(val)); + wheresql.push_back('\''); + + return *mod; + } + + +M_MODEL& or_nullMessage() + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message = NULL "); + + return *mod; + } + + +M_MODEL& or_nnullMessage() + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message != NULL "); + + return *mod; + } + + +M_MODEL& or_eqMessage(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message = '"); + wheresql.append(B_BASE::stringaddslash(val)); + wheresql.push_back('\''); + + return *mod; + } + + +M_MODEL& or_nqMessage(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message != '"); + wheresql.append(B_BASE::stringaddslash(val)); + wheresql.push_back('\''); + + return *mod; + } + + +M_MODEL& or_inMessage(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message IN("); + wheresql.append(val); + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& or_inMessage(const std::vector &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message IN("); + + for(unsigned int i=0;i0) + { + wheresql.push_back(','); + } + wheresql.push_back('\''); + wheresql.append(B_BASE::stringaddslash(val[i])); + wheresql.push_back('\''); + } + + + + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_inMessage(const std::vector &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message IN("); + + for(unsigned int i=0;i0) + { + wheresql.push_back(','); + } + wheresql.push_back('\''); + wheresql.append(std::to_string(val[i])); + wheresql.push_back('\''); + } + + + + return *mod; + } + + +M_MODEL& or_ninMessage(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message NOT IN("); + wheresql.append(val); + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& or_ninMessage(const std::vector &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message NOT IN("); + + for(unsigned int i=0;i0) + { + wheresql.push_back(','); + } + wheresql.push_back('\''); + wheresql.append(B_BASE::stringaddslash(val[i])); + wheresql.push_back('\''); + } + + + + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_ninMessage(const std::vector &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message NOT IN("); + + for(unsigned int i=0;i0) + { + wheresql.push_back(','); + } + wheresql.push_back('\''); + wheresql.append(std::to_string(val[i])); + wheresql.push_back('\''); + } + + + + return *mod; + } + + +M_MODEL& or_likeMessage(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message LIKE '%"); + wheresql.append(B_BASE::stringaddslash(val)); + wheresql.append("%'"); + + return *mod; + } + + +M_MODEL& orl_likeMessage(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message LIKE '%"); + wheresql.append(B_BASE::stringaddslash(val)); + wheresql.append("'"); + + return *mod; + } + + +M_MODEL& orr_likeMessage(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message LIKE '"); + wheresql.append(B_BASE::stringaddslash(val)); + wheresql.append("%'"); + + return *mod; + } + + +M_MODEL& or_btMessage(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message > '"); + wheresql.append(B_BASE::stringaddslash(val)); + wheresql.push_back('\''); + + return *mod; + } + + +M_MODEL& or_beMessage(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message >= '"); + wheresql.append(B_BASE::stringaddslash(val)); + wheresql.push_back('\''); + + return *mod; + } + + +M_MODEL& or_ltMessage(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message < '"); + wheresql.append(B_BASE::stringaddslash(val)); + wheresql.push_back('\''); + + return *mod; + } + + +M_MODEL& or_leMessage(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message <= '"); + wheresql.append(B_BASE::stringaddslash(val)); + wheresql.push_back('\''); + + return *mod; + } + + +template + requires std::is_floating_point_v||std::is_integral_v +M_MODEL& eqMessage(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message = '"); + wheresql.append(std::to_string(val)); + wheresql.push_back('\''); + + return *mod; + } + + +template + requires std::is_floating_point_v||std::is_integral_v +M_MODEL& nqMessage(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message != '"); + wheresql.append(std::to_string(val)); + wheresql.push_back('\''); + + return *mod; + } + + +template + requires std::is_floating_point_v||std::is_integral_v +M_MODEL& btMessage(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message > '"); + wheresql.append(std::to_string(val)); + wheresql.push_back('\''); + + return *mod; + } + + +template + requires std::is_floating_point_v||std::is_integral_v +M_MODEL& beMessage(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message >= '"); + wheresql.append(std::to_string(val)); + wheresql.push_back('\''); + + return *mod; + } + + +template + requires std::is_floating_point_v||std::is_integral_v +M_MODEL& ltMessage(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message < '"); + wheresql.append(std::to_string(val)); + wheresql.push_back('\''); + + return *mod; + } + + +template + requires std::is_floating_point_v||std::is_integral_v +M_MODEL& leMessage(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message <= '"); + wheresql.append(std::to_string(val)); + wheresql.push_back('\''); + + return *mod; + } + + +template + requires std::is_floating_point_v||std::is_integral_v +M_MODEL& or_eqMessage(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message = '"); + wheresql.append(std::to_string(val)); + wheresql.push_back('\''); + + return *mod; + } + + +template + requires std::is_floating_point_v||std::is_integral_v +M_MODEL& or_nqMessage(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message != '"); + wheresql.append(std::to_string(val)); + wheresql.push_back('\''); + + return *mod; + } + + +template + requires std::is_floating_point_v||std::is_integral_v +M_MODEL& or_btMessage(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message > '"); + wheresql.append(std::to_string(val)); + wheresql.push_back('\''); + + return *mod; + } + + +template + requires std::is_floating_point_v||std::is_integral_v +M_MODEL& or_beMessage(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message >= '"); + wheresql.append(std::to_string(val)); + wheresql.push_back('\''); + + return *mod; + } + + +template + requires std::is_floating_point_v||std::is_integral_v +M_MODEL& or_ltMessage(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message < '"); + wheresql.append(std::to_string(val)); + wheresql.push_back('\''); + + return *mod; + } + + +template + requires std::is_floating_point_v||std::is_integral_v +M_MODEL& or_leMessage(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" message <= '"); + wheresql.append(std::to_string(val)); + wheresql.push_back('\''); + + return *mod; + } + + + M_MODEL &select(const std::string &fieldname) + { + if (selectsql.size() > 0) + { + selectsql.push_back(','); + } + selectsql.append(fieldname); + return *mod; + } + + M_MODEL &where(const std::string &wq) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + + wheresql.append(wq); + return *mod; + } + template + requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value> + M_MODEL &where(const std::string &wq, _SQL_Value val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + char bi = wq.back(); + if (bi == '=' || bi == '>' || bi == '<') + { + } + else + { + wheresql.push_back('='); + } + + std::stringstream _stream; + _stream << val; + wheresql.append(_stream.str()); + return *mod; + } + + M_MODEL &where(const std::string &wq, char bi, http::OBJ_VALUE &obj) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + wheresql.push_back(bi); + if (obj.is_string()) + { + wheresql.push_back('\''); + wheresql.append(obj.as_string()); + wheresql.push_back('\''); + } + else + { + + wheresql.append(obj.to_string()); + } + return *mod; + } + M_MODEL &where(const std::string &wq, http::OBJ_VALUE &obj) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + char bi = wq.back(); + if (bi == '=' || bi == '>' || bi == '<') + { + } + else + { + wheresql.push_back('='); + } + + if (obj.is_string()) + { + wheresql.push_back('\''); + wheresql.append(obj.as_string()); + wheresql.push_back('\''); + } + else + { + + wheresql.append(obj.to_string()); + } + return *mod; + } + template + requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value> + M_MODEL &where(const std::string &wq, char bi, _SQL_Value val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + wheresql.push_back(bi); + std::stringstream _stream; + _stream << val; + wheresql.append(_stream.str()); + return *mod; + } + + M_MODEL &where(const std::string &wq, char bi, const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + wheresql.push_back(bi); + wheresql.push_back('\''); + + wheresql.append(val); + wheresql.push_back('\''); + return *mod; + } + M_MODEL &where(const std::string &wq, const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + char bi = wq.back(); + if (bi == '=' || bi == '>' || bi == '<') + { + } + else + { + wheresql.push_back('='); + } + + wheresql.push_back('\''); + wheresql.append(val); + wheresql.push_back('\''); + return *mod; + } + + M_MODEL &between(const std::string &wq, const std::string &a, const std::string &b) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" ("); + wheresql.append(wq); + wheresql.append(" BETWEEN '"); + std::stringstream _stream; + _stream << a; + _stream << "' AND '"; + _stream << b; + _stream << "' ) "; + wheresql.append(_stream.str()); + return *mod; + } + template + requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value> + M_MODEL &between(const std::string &wq, _SQL_Value a, _SQL_Value b) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" ("); + wheresql.append(wq); + wheresql.append(" BETWEEN "); + std::stringstream _stream; + _stream << a; + _stream << " AND "; + _stream << b; + _stream << " ) "; + wheresql.append(_stream.str()); + return *mod; + } + template + requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value> + M_MODEL &orBetween(const std::string &wq, _SQL_Value a, _SQL_Value b) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" ("); + wheresql.append(wq); + wheresql.append(" BETWEEN "); + std::stringstream _stream; + _stream << a; + _stream << " AND "; + _stream << b; + _stream << " ) "; + wheresql.append(_stream.str()); + return *mod; + } + M_MODEL &whereLike(const std::string &wq, const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + wheresql.append(" like '"); + if (val.size() > 0 && (val[0] == '%' || val.back() == '%')) + { + wheresql.append(val); + wheresql.append("' "); + } + else + { + wheresql.push_back('%'); + wheresql.append(val); + wheresql.append("%' "); + } + return *mod; + } + M_MODEL &whereLikeLeft(const std::string &wq, const std::string &val) + { + + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + wheresql.append(" like '"); + wheresql.push_back('%'); + wheresql.append(val); + wheresql.append("' "); + return *mod; + } + M_MODEL &whereLikeRight(const std::string &wq, const std::string &val) + { + + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + wheresql.append(" like '"); + wheresql.append(val); + wheresql.append("%' "); + return *mod; + } + M_MODEL &whereOrLike(const std::string &wq, const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + wheresql.append(" like '"); + if (val[0] == '%' || val.back() == '%') + { + wheresql.append(val); + wheresql.append("' "); + } + else + { + wheresql.push_back('%'); + wheresql.append(val); + wheresql.append("%' "); + } + return *mod; + } + M_MODEL &whereAnd(const std::string &wq) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + return *mod; + } + template + requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value> + M_MODEL &whereAnd(const std::string &wq, _SQL_Value val) + { + + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + char bi = wq.back(); + if (bi == '=' || bi == '>' || bi == '<') + { + } + else + { + wheresql.push_back('='); + } + std::stringstream _stream; + _stream << val; + wheresql.append(_stream.str()); + return *mod; + } + M_MODEL &whereAnd(const std::string &wq, const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + char bi = wq.back(); + if (bi == '=' || bi == '>' || bi == '<') + { + } + else + { + wheresql.push_back('='); + } + + wheresql.push_back('\''); + wheresql.append(val); + wheresql.push_back('\''); + + return *mod; + } + M_MODEL &whereOr(const std::string &wq) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + return *mod; + } + template + requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value> + M_MODEL &whereOr(const std::string &wq, _SQL_Value val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + char bi = wq.back(); + if (bi == '=' || bi == '>' || bi == '<') + { + } + else + { + wheresql.push_back('='); + } + std::stringstream _stream; + _stream << val; + wheresql.append(_stream.str()); + return *mod; + } + M_MODEL &whereOr(const std::string &wq, const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + char bi = wq.back(); + if (bi == '=' || bi == '>' || bi == '<') + { + } + else + { + wheresql.push_back('='); + } + + wheresql.push_back('\''); + wheresql.append(val); + wheresql.push_back('\''); + return *mod; + } + M_MODEL &whereIn(const std::string &k) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(k); + return *mod; + } + M_MODEL &whereIn(const std::string &k, const std::string &a) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + + wheresql.append(k); + wheresql.append(" IN("); + wheresql.append(a); + wheresql.append(") "); + return *mod; + } + + M_MODEL &whereIn(const std::string &k, const std::vector &a) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(k); + wheresql.append(" in("); + int i = 0; + for (auto &key : a) + { + if (i > 0) + { + wheresql.append(",\'"); + } + else + { + wheresql.append("\'"); + } + wheresql.append(key); + wheresql.append("\'"); + i++; + } + wheresql.append(") "); + return *mod; + } + M_MODEL &whereNotIn(const std::string &k, const std::vector &a) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + + wheresql.append(k); + wheresql.append(" NOT IN("); + int i = 0; + for (auto &key : a) + { + if (i > 0) + { + wheresql.append(",\'"); + } + else + { + wheresql.append("\'"); + } + wheresql.append(key); + wheresql.append("\'"); + i++; + } + wheresql.append(") "); + return *mod; + } + template + requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value> + M_MODEL &whereIn(const std::string &k, const std::list<_SQL_Value> &a) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + + wheresql.append(k); + wheresql.append(" in("); + int i = 0; + std::stringstream _stream; + for (auto &key : a) + { + if (i > 0) + { + wheresql.append(","); + } + _stream << key; + wheresql.append(_stream.str()); + i++; + _stream.str(""); + } + wheresql.append(") "); + return *mod; + } + + template + requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value> + M_MODEL &whereIn(const std::string &k, const std::vector<_SQL_Value> &a) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + + wheresql.append(k); + wheresql.append(" IN("); + int i = 0; + std::stringstream _stream; + for (auto &key : a) + { + if (i > 0) + { + wheresql.append(","); + } + _stream << key; + wheresql.append(_stream.str()); + i++; + _stream.str(""); + } + wheresql.append(") "); + return *mod; + } + template + requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value> + M_MODEL &whereNotIn(const std::string &k, const std::vector<_SQL_Value> &a) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + + wheresql.append(k); + wheresql.append(" NOT IN("); + int i = 0; + std::stringstream _stream; + for (auto &key : a) + { + if (i > 0) + { + wheresql.append(","); + } + _stream << key; + wheresql.append(_stream.str()); + i++; + _stream.str(""); + } + wheresql.append(") "); + return *mod; + } + + M_MODEL &order(const std::string &wq) + { + ordersql.append(" ORDER by "); + ordersql.append(wq); + return *mod; + } + M_MODEL &asc(const std::string &wq) + { + + ordersql.append(" ORDER by "); + ordersql.append(wq); + ordersql.append(" ASC "); + return *mod; + } + + M_MODEL &desc(const std::string &wq) + { + + ordersql.append(" ORDER by "); + ordersql.append(wq); + ordersql.append(" DESC "); + return *mod; + } + + M_MODEL &having(const std::string &wq) + { + + groupsql.append(" HAVING by "); + groupsql.append(wq); + return *mod; + } + + M_MODEL &group(const std::string &wq) + { + + groupsql.append(" GROUP BY "); + groupsql.append(wq); + return *mod; + } + + M_MODEL &orsub() + { + + if (iskuohao == true) + { + iskuohao = false; + ishascontent = false; + wheresql.append(" )"); + } + else + { + wheresql.append(" OR ("); + iskuohao = true; + ishascontent = false; + } + return *mod; + } + M_MODEL &andsub() + { + + if (iskuohao == true) + { + iskuohao = false; + wheresql.append(" )"); + ishascontent = false; + } + else + { + wheresql.append(" AND ("); + iskuohao = true; + ishascontent = false; + } + + return *mod; + } + + M_MODEL &endsub() + { + if (iskuohao == true) + { + iskuohao = false; + ishascontent = false; + wheresql.append(" )"); + } + return *mod; + } + + M_MODEL &or_b() + { + + if (iskuohao == true) + { + iskuohao = false; + ishascontent = false; + wheresql.append(" )"); + } + else + { + wheresql.append(" OR ("); + iskuohao = true; + ishascontent = false; + } + return *mod; + } + M_MODEL &and_b() + { + + if (iskuohao == true) + { + iskuohao = false; + wheresql.append(" )"); + ishascontent = false; + } + else + { + wheresql.append(" AND ("); + iskuohao = true; + ishascontent = false; + } + + return *mod; + } + + M_MODEL &or_e() + { + if (iskuohao == true) + { + iskuohao = false; + ishascontent = false; + wheresql.append(" )"); + } + return *mod; + } + + M_MODEL &and_e() + { + if (iskuohao == true) + { + iskuohao = false; + ishascontent = false; + wheresql.append(" )"); + } + return *mod; + } + + M_MODEL &limit(unsigned int num) + { + limitsql.clear(); + limitsql.append(" limit "); + limitsql.append(std::to_string(num)); + return *mod; + } + M_MODEL &limit(unsigned int num, unsigned int endnum) + { + limitsql.clear(); + limitsql.append(" limit "); + limitsql.append(std::to_string(num)); + limitsql.push_back(','); + limitsql.append(std::to_string(endnum)); + return *mod; + } + + std::vector> fetch_obj() + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + sqlstring.append(" 1 "); + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + std::vector> temprecord; + + if (iserror) + { + return temprecord; + } + + try + { + effect_num = 0; + if (conn_empty()) + { + return temprecord; + } + auto conn = conn_obj->get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return temprecord; + } + + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + unsigned char action_setup = 0; + unsigned int column_num = 0; + unsigned int offset = 0; + + std::vector field_pos; + + for (; is_sql_item == false;) + { + n = conn->read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + std::map data_temp; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + std::string temp_str; + temp_str.resize(name_length); + std::memcpy(temp_str.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length); + if (field_array[ij].name.size() > 0) + { + data_temp.insert({field_array[ij].name, std::move(temp_str)}); + } + else if (field_array[ij].org_name.size() > 0) + { + data_temp.insert({field_array[ij].org_name, std::move(temp_str)}); + } + + tempnum = tempnum + name_length; + } + temprecord.emplace_back(std::move(data_temp)); + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + + conn_obj->back_select_conn(conn); + + if (iscache) + { + if (exptime > 0) + { + save_cache(exptime); + exptime = 0; + iscache = false; + } + } + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + return temprecord; + } + std::tuple, std::map, std::vector>> + fetch_row() + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + sqlstring.append(" 1 "); + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + std::vector> temprecord; + std::vector table_fieldname; + std::map table_fieldmap; + + if (iscache) + { + std::size_t sqlhashid = std::hash{}(sqlstring); + + model_meta_cache> &temp_cache = + model_meta_cache>::getinstance(); + temprecord = temp_cache.get(sqlhashid); + if (temprecord.size() > 0) + { + iscache = false; + model_meta_cache &table_cache = model_meta_cache::getinstance(); + table_fieldname = table_cache.get(sqlhashid); + + model_meta_cache> &tablemap_cache = + model_meta_cache>::getinstance(); + table_fieldmap = tablemap_cache.get_obj(sqlhashid); + + return std::make_tuple(table_fieldname, table_fieldmap, temprecord); + } + } + + if (iserror) + { + return std::make_tuple(table_fieldname, table_fieldmap, temprecord); + } + + try + { + if (conn_empty()) + { + return std::make_tuple(table_fieldname, table_fieldmap, temprecord); + } + auto conn = conn_obj->get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return std::make_tuple(table_fieldname, table_fieldmap, temprecord); + } + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + // std::vector> field_value; + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + std::vector field_pos; + + for (; is_sql_item == false;) + { + n = conn->read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + table_fieldmap.insert({field_array[ii].org_name,table_fieldname.size()}); + table_fieldname.push_back(field_array[ii].org_name); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + std::vector temp_v_record; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + std::string tempstr; + tempstr.resize(name_length); + std::memcpy(tempstr.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length); + temp_v_record.push_back(std::move(tempstr)); + tempnum = tempnum + name_length; + } + temprecord.push_back(temp_v_record); + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + conn_obj->back_select_conn(conn); + + + + if (iscache) + { + if (exptime > 0) + { + if (temprecord.size() > 0) + { + std::size_t sqlhashid = std::hash{}(sqlstring); + + model_meta_cache> &temp_cache = + model_meta_cache>::getinstance(); + temp_cache.save(sqlhashid, temprecord, exptime); + + exptime += 1; + model_meta_cache &table_cache = model_meta_cache::getinstance(); + table_cache.save(sqlhashid, table_fieldname, exptime); + + model_meta_cache> &tablemap_cache = + model_meta_cache>::getinstance(); + tablemap_cache.save(sqlhashid, table_fieldmap, exptime); + exptime = 0; + iscache = false; + } + } + } + + return std::make_tuple(std::move(table_fieldname), std::move(table_fieldmap), std::move(temprecord)); + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + return std::make_tuple(table_fieldname, table_fieldmap, temprecord); + } + M_MODEL &fetch() + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + sqlstring.append(" 1 "); + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscache) + { + std::size_t sqlhashid = std::hash{}(sqlstring); + if (get_cacherecord(sqlhashid)) + { + iscache = false; + return *mod; + } + } + + B_BASE::record_reset(); + if (iserror) + { + return *mod; + } + + try + { + if (conn_empty()) + { + return *mod; + } + auto conn = conn_obj->get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return *mod; + } + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + std::vector field_pos; + + for (; is_sql_item == false;) + { + n = conn->read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + typename B_BASE::meta data_temp; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp); + tempnum = tempnum + name_length; + } + B_BASE::record.emplace_back(std::move(data_temp)); + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + conn_obj->back_select_conn(conn); + + if (iscache) + { + if (exptime > 0) + { + save_cache(exptime); + exptime = 0; + iscache = false; + } + } + return *mod; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return *mod; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + return *mod; + } + + asio::awaitable async_fetch() + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + sqlstring.append(" 1 "); + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscache) + { + std::size_t sqlhashid = std::hash{}(sqlstring); + if (get_cacherecord(sqlhashid)) + { + iscache = false; + co_return 0; + } + } + + B_BASE::record_reset(); + if (iserror) + { + co_return 0; + } + + try + { + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + std::vector field_pos; + + for (; is_sql_item == false;) + { + n = co_await conn->async_read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + typename B_BASE::meta data_temp; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp); + tempnum = tempnum + name_length; + } + B_BASE::record.emplace_back(std::move(data_temp)); + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + conn_obj->back_select_conn(conn); + + if (iscache) + { + if (exptime > 0) + { + save_cache(exptime); + exptime = 0; + iscache = false; + } + } + co_return effect_num; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + co_return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + co_return 0; + } + M_MODEL &fetch_append() + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + sqlstring.append(" 1 "); + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscache) + { + std::size_t sqlhashid = std::hash{}(sqlstring); + if (get_cacherecord(sqlhashid)) + { + iscache = false; + return *mod; + } + } + + if (iserror) + { + return *mod; + } + + try + { + + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + std::vector field_pos; + + for (; is_sql_item == false;) + { + n = conn->read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + typename B_BASE::meta data_temp; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp); + tempnum = tempnum + name_length; + } + B_BASE::record.emplace_back(std::move(data_temp)); + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + conn_obj->back_select_conn(conn); + + if (iscache) + { + if (exptime > 0) + { + save_cache(exptime); + exptime = 0; + iscache = false; + } + } + return *mod; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return *mod; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + return *mod; + } + + asio::awaitable async_fetch_append() + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + sqlstring.append(" 1 "); + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscache) + { + std::size_t sqlhashid = std::hash{}(sqlstring); + if (get_cacherecord(sqlhashid)) + { + iscache = false; + co_return 1; + } + } + + if (iserror) + { + co_return 0; + } + + try + { + effect_num = 0; + + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + // asio::error_code ec; + + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + // std::vector> field_value; + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + std::vector field_pos; + // std::map other_col; + + for (; is_sql_item == false;) + { + // std::memset(result_data, 0x00, 4096); + // n = co_await conn->socket->async_read_some(asio::buffer(result_data), asio::use_awaitable); + n = co_await conn->async_read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + typename B_BASE::meta data_temp; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp); + tempnum = tempnum + name_length; + } + effect_num++; + B_BASE::record.emplace_back(std::move(data_temp)); + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + conn_obj->back_select_conn(conn); + + if (iscache) + { + if (exptime > 0) + { + save_cache(exptime); + exptime = 0; + iscache = false; + } + } + co_return effect_num; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + co_return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + co_return 0; + } + unsigned int fetch_one(bool isappend = false) + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + sqlstring.append(" 1 "); + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + + sqlstring.append(" limit 1"); + + if (iscache) + { + std::size_t sqlhashid = std::hash{}(sqlstring); + if (get_cacherecord(sqlhashid)) + { + iscache = false; + return 0; + } + } + + B_BASE::data_reset(); + if (iserror) + { + return 0; + } + + try + { + effect_num = 0; + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + unsigned char action_setup = 0; + unsigned int column_num = 0; + unsigned int offset = 0; + + std::vector field_pos; + + for (; is_sql_item == false;) + { + n = conn->read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + if (isappend) + { + typename B_BASE::meta data_temp; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp); + tempnum = tempnum + name_length; + } + B_BASE::record.emplace_back(std::move(data_temp)); + effect_num++; + } + else + { + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, B_BASE::data); + tempnum = tempnum + name_length; + } + effect_num++; + } + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + + conn_obj->back_select_conn(conn); + + if (iscache) + { + if (exptime > 0) + { + save_cache(exptime); + exptime = 0; + iscache = false; + } + } + return effect_num; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + return 0; + } + + asio::awaitable async_fetch_one(bool isappend = false) + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + sqlstring.append(" 1 "); + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + + sqlstring.append(" limit 1"); + + if (iscache) + { + std::size_t sqlhashid = std::hash{}(sqlstring); + if (get_cacherecord(sqlhashid)) + { + iscache = false; + co_return 0; + } + } + + B_BASE::data_reset(); + if (iserror) + { + co_return 0; + } + + try + { + effect_num = 0; + + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + // std::vector> field_value; + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + std::vector field_pos; + // std::map other_col; + + for (; is_sql_item == false;) + { + n = co_await conn->async_read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + if (isappend) + { + typename B_BASE::meta data_temp; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp); + tempnum = tempnum + name_length; + } + B_BASE::record.emplace_back(std::move(data_temp)); + effect_num++; + } + else + { + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, B_BASE::data); + tempnum = tempnum + name_length; + } + effect_num++; + } + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + + conn_obj->back_select_conn(conn); + + if (iscache) + { + if (exptime > 0) + { + save_cache(exptime); + exptime = 0; + iscache = false; + } + } + co_return effect_num; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + co_return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + co_return 0; + } + + M_MODEL &use_cache(int cache_time = 0) + { + iscache = true; + exptime = cache_time; + return *mod; + } + bool isuse_cache(bool iscachedate = false) + { + if (iscachedate) + { + return exptime == 0 && iscache == false; + } + return iscache; + } + void set_cache_state(bool isrestatus = false) { iscache = isrestatus; } + void remove_exptime_cache() + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + temp_cache.remove_exptime(); + } + void clear_cache() + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + temp_cache.clear(); + } + bool remove_cache() + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + std::size_t sqlhashid = std::hash{}(sqlstring); + return temp_cache.remove(sqlhashid); + } + bool remove_cache(std::size_t cache_key_name) + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + return temp_cache.remove(cache_key_name); + } + int check_cache(std::size_t cache_key_name) + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + return temp_cache.check(cache_key_name); + } + std::vector get_cache_data(std::size_t cache_key_name) + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + auto cache_data = temp_cache.get(cache_key_name); + return cache_data; + } + typename B_BASE::meta get_cache_obj(std::size_t cache_key_name) + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + auto cache_data = temp_cache.get_obj(cache_key_name); + return cache_data; + } + M_MODEL &get_cache(std::size_t cache_key_name) + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + B_BASE::record = temp_cache.get(cache_key_name); + if (B_BASE::record.size() == 0) + { + B_BASE::record_reset(); + } + else + { + B_BASE::data = B_BASE::record[0]; + } + return *mod; + } + int update_cache(int exp_time = 0) + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + std::size_t sqlhashid = std::hash{}(sqlstring); + return temp_cache.update(sqlhashid, exp_time); + } + int update_cache(std::size_t cache_key_name, int exp_time) + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + return temp_cache.update(cache_key_name, exp_time); + } + bool save_cache(int exp_time = 0) + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + std::size_t sqlhashid = std::hash{}(sqlstring); + temp_cache.save(sqlhashid, B_BASE::record, exp_time); + return true; + } + + bool save_cache(std::size_t cache_key_name, typename B_BASE::meta &cache_data, int exp_time = 0) + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + temp_cache.save(cache_key_name, cache_data, exp_time); + return true; + } + + bool save_cache(std::size_t cache_key_name, std::vector &cache_data, int exp_time = 0) + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + temp_cache.save(cache_key_name, cache_data, exp_time); + return true; + } + bool get_cacherecord(std::size_t cache_key_name) + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + B_BASE::record = temp_cache.get(cache_key_name); + if (B_BASE::record.size() == 0) + { + return false; + } + else + { + B_BASE::data = B_BASE::record[0]; + return true; + } + } + http::OBJ_VALUE fetch_json() + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + sqlstring.append(" 1 "); + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + http::OBJ_VALUE valuetemp; + valuetemp.set_array(); + + if (iserror) + { + return valuetemp; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + for (; is_sql_item == false;) + { + n = conn->read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + http::OBJ_VALUE json_temp_v; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + std::string temp_str; + temp_str.resize(name_length); + std::memcpy(temp_str.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length); + if(field_array[ij].name.size()>0) + { + //or alias name + json_temp_v[field_array[ij].name]=std::move(temp_str); + } + else if(field_array[ij].org_name.size()>0) + { + json_temp_v[field_array[ij].org_name]=std::move(temp_str); + } + tempnum = tempnum + name_length; + } + valuetemp.push(json_temp_v); + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + conn_obj->back_select_conn(conn); + + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + return valuetemp; + } + + asio::awaitable async_fetch_json() + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + sqlstring.append(" 1 "); + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + http::OBJ_VALUE valuetemp; + valuetemp.set_array(); + + if (iserror) + { + co_return valuetemp; + } + + try + { + if (conn_empty()) + { + co_return valuetemp; + } + auto conn = co_await conn_obj->async_get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + conn->send_data.clear(); + + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + for (; is_sql_item == false;) + { + n = co_await conn->async_read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + http::OBJ_VALUE json_temp_v; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + std::string temp_str; + temp_str.resize(name_length); + std::memcpy(temp_str.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length); + if(field_array[ij].name.size()>0) + { + //or alias name + json_temp_v[field_array[ij].name]=std::move(temp_str); + } + else if(field_array[ij].org_name.size()>0) + { + json_temp_v[field_array[ij].org_name]=std::move(temp_str); + } + tempnum = tempnum + name_length; + } + valuetemp.push(json_temp_v); + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + conn_obj->back_select_conn(conn); + + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + co_return valuetemp; + } + + long long get_one(long long id) + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + sqlstring.append(B_BASE::getPKname()); + sqlstring.append("="); + sqlstring.append(std::to_string(id)); + sqlstring.append(" limit 1"); + if (iscache) + { + std::size_t sqlhashid = std::hash{}(sqlstring); + if (get_cacherecord(sqlhashid)) + { + iscache = false; + return 0; + } + } + + B_BASE::data_reset(); + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + std::vector field_pos; + + for (; is_sql_item == false;) + { + n = conn->read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, B_BASE::data); + tempnum = tempnum + name_length; + } + + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + conn_obj->back_select_conn(conn); + + if (iscache) + { + if (exptime > 0) + { + save_cache(exptime); + exptime = 0; + iscache = false; + } + } + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + return 0; + } + + asio::awaitable async_get_one(long long id) + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + sqlstring.append(B_BASE::getPKname()); + sqlstring.append("="); + sqlstring.append(std::to_string(id)); + sqlstring.append(" limit 1"); + if (iscache) + { + std::size_t sqlhashid = std::hash{}(sqlstring); + if (get_cacherecord(sqlhashid)) + { + iscache = false; + co_return 0; + } + } + + B_BASE::data_reset(); + + if (iserror) + { + co_return 0; + } + + try + { + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + std::vector field_pos; + + for (; is_sql_item == false;) + { + n = co_await conn->async_read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, B_BASE::data); + tempnum = tempnum + name_length; + } + + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + conn_obj->back_select_conn(conn); + + if (iscache) + { + if (exptime > 0) + { + save_cache(exptime); + exptime = 0; + iscache = false; + } + } + co_return effect_num; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + co_return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + co_return 0; + } + + int update() + { + effect_num = 0; + if (wheresql.empty()) + { + if (B_BASE::getPK() > 0) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + wheresql = tempsql.str(); + } + else + { + return 0; + } + } + sqlstring = B_BASE::_makeupdatesql(""); + sqlstring.append(" where "); + if (wheresql.empty()) + { + return 0; + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + return effect_num; + } + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + return 0; + } + int update(const std::string &fieldname) + { + effect_num = 0; + if (wheresql.empty()) + { + if (B_BASE::getPK() > 0) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + wheresql = tempsql.str(); + } + else + { + error_msg = "warning empty where sql!"; + return 0; + } + } + + sqlstring = B_BASE::_makeupdatesql(fieldname); + sqlstring.append(" where "); + if (wheresql.empty()) + { + return 0; + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + return effect_num; + } + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + return 0; + } + + asio::awaitable async_update(const std::string &fieldname) + { + effect_num = 0; + if (wheresql.empty()) + { + if (B_BASE::getPK() > 0) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + wheresql = tempsql.str(); + } + else + { + error_msg = "warning empty where sql!"; + co_return 0; + } + } + + sqlstring = B_BASE::_makeupdatesql(fieldname); + sqlstring.append(" where "); + if (wheresql.empty()) + { + co_return 0; + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscommit) + { + iscommit = false; + co_return 0; + } + + if (iserror) + { + co_return 0; + } + try + { + + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + unsigned int offset = 0; + n = co_await conn->async_read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + iserror = true; + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + + co_return effect_num; + } + co_return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + co_return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + co_return 0; + } + asio::awaitable async_update() + { + effect_num = 0; + if (wheresql.empty()) + { + if (B_BASE::getPK() > 0) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + wheresql = tempsql.str(); + } + else + { + error_msg = "warning empty where sql!"; + co_return 0; + } + } + + sqlstring = B_BASE::_makeupdatesql(""); + sqlstring.append(" where "); + if (wheresql.empty()) + { + co_return 0; + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscommit) + { + iscommit = false; + co_return 0; + } + + if (iserror) + { + co_return 0; + } + try + { + + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + unsigned int offset = 0; + n = co_await conn->async_read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + iserror = true; + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + + co_return effect_num; + } + co_return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + co_return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + co_return 0; + } + + int update_batch(const std::string &fieldname) + { + effect_num = 0; + if (B_BASE::record.size() == 0) + { + return 0; + } + if (fieldname.size() > 0) + { + sqlstring = B_BASE::_make_insert_into_sql(fieldname); + } + else + { + sqlstring = B_BASE::_make_replace_into_sql(); + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + return effect_num; + } + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + return 0; + } + int remove() + { + effect_num = 0; + if (wheresql.empty()) + { + if (B_BASE::getPK() > 0) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + wheresql = tempsql.str(); + } + else + { + return 0; + } + } + + sqlstring = "DELETE FROM "; + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + return 0; + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + return effect_num; + } + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + return 0; + } + + asio::awaitable async_remove() + { + effect_num = 0; + if (wheresql.empty()) + { + if (B_BASE::getPK() > 0) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + wheresql = tempsql.str(); + } + else + { + co_return 0; + } + } + + sqlstring = "DELETE FROM "; + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + co_return 0; + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscommit) + { + iscommit = false; + co_return 0; + } + + if (iserror) + { + co_return 0; + } + + try + { + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + unsigned int offset = 0; + n = co_await conn->async_read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + co_return effect_num; + } + co_return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + co_return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + co_return 0; + } + + int remove(long long id) + { + effect_num = 0; + sqlstring = "DELETE FROM "; + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + sqlstring.append(B_BASE::getPKname()); + sqlstring.append("="); + sqlstring.append(std::to_string(id)); + + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + return effect_num; + } + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + return 0; + } + + asio::awaitable async_remove(long long id) + { + effect_num = 0; + sqlstring = "DELETE FROM "; + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + sqlstring.append(B_BASE::getPKname()); + sqlstring.append("="); + sqlstring.append(std::to_string(id)); + + if (iscommit) + { + iscommit = false; + co_return 0; + } + + if (iserror) + { + co_return 0; + } + + try + { + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + unsigned int offset = 0; + n = co_await conn->async_read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + co_return effect_num; + } + co_return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + co_return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + co_return 0; + } + + int soft_remove(const std::string &fieldsql) + { + effect_num = 0; + if (wheresql.empty()) + { + if (B_BASE::getPK() > 0) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + wheresql = tempsql.str(); + } + else + { + return 0; + } + } + + sqlstring = B_BASE::soft_remove_sql(fieldsql); + if (sqlstring.empty()) + { + error_msg = "soft delete field empty."; + return 0; + } + sqlstring.append(" where "); + if (wheresql.empty()) + { + return 0; + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + return effect_num; + } + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + return 0; + } + int soft_remove() + { + effect_num = 0; + if (wheresql.empty()) + { + if (B_BASE::getPK() > 0) + { + std::ostringstream tempsql; + effect_num = 1; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + wheresql = tempsql.str(); + } + else + { + return 0; + } + } + if (effect_num == 1) + { + sqlstring = B_BASE::soft_remove_sql(" "); + } + else + { + sqlstring = B_BASE::soft_remove_sql(""); + } + effect_num = 0; + if (sqlstring.empty()) + { + error_msg = "soft delete field empty."; + return 0; + } + sqlstring.append(" where "); + if (wheresql.empty()) + { + return 0; + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + return effect_num; + } + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + return 0; + } + long long insert(typename B_BASE::meta &insert_data) + { + effect_num = 0; + sqlstring = B_BASE::_makerecordinsertsql(insert_data); + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + long long insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + + return insert_last_id; + } + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + return 0; + } + + asio::awaitable async_insert(typename B_BASE::meta &insert_data) + { + effect_num = 0; + sqlstring = B_BASE::_makerecordinsertsql(insert_data); + if (iscommit) + { + iscommit = false; + co_return 0; + } + + if (iserror) + { + co_return 0; + } + + try + { + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + unsigned int offset = 0; + n = co_await conn->async_read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + long long insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + + co_return insert_last_id; + } + co_return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + co_return 0; + } + + long long insert(std::vector &insert_data) + { + effect_num = 0; + sqlstring = B_BASE::_makerecordinsertsql(insert_data); + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + long long insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + + return insert_last_id; + } + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + return 0; + } + + asio::awaitable async_insert(std::vector &insert_data) + { + effect_num = 0; + sqlstring = B_BASE::_makerecordinsertsql(insert_data); + if (iscommit) + { + iscommit = false; + co_return 0; + } + + if (iserror) + { + co_return 0; + } + + try + { + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + unsigned int offset = 0; + n = co_await conn->async_read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + long long insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + + co_return insert_last_id; + } + co_return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + co_return 0; + } + + long long insert() + { + effect_num = 0; + sqlstring = B_BASE::_makeinsertsql(); + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + long long insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + + return insert_last_id; + } + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + return 0; + } + + asio::awaitable async_insert() + { + effect_num = 0; + sqlstring = B_BASE::_makeinsertsql(); + if (iscommit) + { + iscommit = false; + co_return 0; + } + + if (iserror) + { + co_return 0; + } + + try + { + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + unsigned int offset = 0; + n = co_await conn->async_read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + long long insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + + co_return insert_last_id; + } + co_return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + co_return 0; + } + + + long long save(bool isrealnew = false) + { + effect_num = 0; + if (B_BASE::getPK() > 0 && isrealnew == false) + { + if (wheresql.empty()) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + wheresql = tempsql.str(); + } + sqlstring = B_BASE::_makeupdatesql(""); + sqlstring.append(" where "); + if (wheresql.empty()) + { + return 0; + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + return effect_num; + } + return 0; + } + else + { + sqlstring = B_BASE::_makeinsertsql(); + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + long long insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + + return insert_last_id; + } + return 0; + } + return 0; + } + + asio::awaitable async_save(bool isrealnew = false) + { + effect_num = 0; + if (B_BASE::getPK() > 0 && isrealnew == false) + { + if (wheresql.empty()) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + wheresql = tempsql.str(); + } + sqlstring = B_BASE::_makeupdatesql(""); + sqlstring.append(" where "); + if (wheresql.empty()) + { + co_return 0; + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + if (iscommit) + { + iscommit = false; + co_return 0; + } + + if (iserror) + { + co_return 0; + } + + try + { + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + unsigned int offset = 0; + n = co_await conn->async_read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + iserror = true; + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + + co_return effect_num; + } + co_return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + co_return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + co_return 0; + } + co_return 0; + } + else + { + sqlstring = B_BASE::_makeinsertsql(); + try + { + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + unsigned int offset = 0; + n = co_await conn->async_read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + long long insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + + co_return insert_last_id; + } + co_return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + co_return 0; + } + co_return 0; + } + + std::tuple, std::map, std::vector>> + query(const std::string &rawsql) + { + + std::vector> temprecord; + std::vector table_fieldname; + std::map table_fieldmap; + + if(rawsql.size()>10) + { + unsigned int i=0; + for(;iget_select_conn(); + + unsigned int querysql_len = rawsql.length() + 1; + + conn->send_data.clear(); + + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(rawsql); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return std::make_tuple(table_fieldname, table_fieldmap, temprecord); + } + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + std::vector field_pos; + + for (; is_sql_item == false;) + { + n = conn->read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + table_fieldmap.insert({field_array[ii].org_name,table_fieldname.size()}); + table_fieldname.push_back(field_array[ii].org_name); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + std::vector temp_v_record; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + std::string tempstr; + tempstr.resize(name_length); + std::memcpy(tempstr.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length); + temp_v_record.push_back(std::move(tempstr)); + tempnum = tempnum + name_length; + } + temprecord.push_back(temp_v_record); + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + conn_obj->back_select_conn(conn); + + return std::make_tuple(std::move(table_fieldname), std::move(table_fieldmap), std::move(temprecord)); + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + return std::make_tuple(table_fieldname, table_fieldmap, temprecord); + } + + asio::awaitable, std::map, std::vector>>> + async_query(const std::string &rawsql) + { + + std::vector> temprecord; + std::vector table_fieldname; + std::map table_fieldmap; + + if(rawsql.size()>10) + { + unsigned int i=0; + for(;iasync_get_select_conn(); + + unsigned int querysql_len = rawsql.length() + 1; + + conn->send_data.clear(); + + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(rawsql); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + std::vector field_pos; + + for (; is_sql_item == false;) + { + n = co_await conn->async_read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + table_fieldmap.insert({field_array[ii].org_name,table_fieldname.size()}); + table_fieldname.push_back(field_array[ii].org_name); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + std::vector temp_v_record; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + std::string tempstr; + tempstr.resize(name_length); + std::memcpy(tempstr.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length); + temp_v_record.push_back(std::move(tempstr)); + tempnum = tempnum + name_length; + } + temprecord.push_back(temp_v_record); + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + conn_obj->back_select_conn(conn); + + co_return std::make_tuple(std::move(table_fieldname), std::move(table_fieldmap), std::move(temprecord)); + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + co_return std::make_tuple(table_fieldname, table_fieldmap, temprecord); + } + + // long long edit_query(const std::string &rawsql, bool isinsert = false) + // { + // if (iserror) + // { + // return 0; + // } + + // return 0; + // } + M_MODEL &clear(bool both = true) + { + selectsql.clear(); + wheresql.clear(); + ordersql.clear(); + groupsql.clear(); + limitsql.clear(); + sqlstring.clear(); + error_msg.clear(); + iskuohao = false; + ishascontent = false; + iscommit = false; + iscache = false; + effect_num = 0; + if (both) + { + B_BASE::record_reset(); + B_BASE::data_reset(); + } + return *mod; + } + M_MODEL &clearWhere() + { + selectsql.clear(); + wheresql.clear(); + ordersql.clear(); + groupsql.clear(); + limitsql.clear(); + sqlstring.clear(); + error_msg.clear(); + iskuohao = false; + ishascontent = false; + iscommit = false; + iscache = false; + effect_num = 0; + return *mod; + } + M_MODEL &set_data(typename B_BASE::meta indata) + { + B_BASE::data = indata; + return *mod; + } + M_MODEL &get() { return *mod; } + std::string get_query() { return sqlstring; } + M_MODEL &start_commit() + { + iscommit = true; + return *mod; + } + M_MODEL &end_commit() + { + iscommit = false; + return *mod; + } + + unsigned int effect() + { + return effect_num; + } + bool conn_empty() + { + if (conn_obj) + { + return false; + } + error_msg = "conn_obj is null"; + iserror = true; + return true; + } + + public: + std::string selectsql; + std::string wheresql; + std::string ordersql; + std::string groupsql; + std::string limitsql; + std::string sqlstring; + std::string dbtag; + std::string error_msg; + std::string original_tablename; + + // std::list commit_sqllist; + bool iskuohao = false; + bool iscommit = false; + bool ishascontent = false; + bool iscache = false; + bool iserror = false; + int exptime = 0; + unsigned int effect_num = 0; + + M_MODEL *mod; + + std::shared_ptr conn_obj; + }; +//} /*tagnamespace_replace*/ +}// namespace orm +#endif \ No newline at end of file diff --git a/frameworks/C++/paozhu/paozhu_benchmark/models/include/Fortune.h b/frameworks/C++/paozhu/paozhu_benchmark/models/include/Fortune.h old mode 100755 new mode 100644 index 548dbed843a..1f53aa1e51d --- a/frameworks/C++/paozhu/paozhu_benchmark/models/include/Fortune.h +++ b/frameworks/C++/paozhu/paozhu_benchmark/models/include/Fortune.h @@ -1,18 +1,16 @@ #ifndef ORM_DEFAULT_FORTUNE_H #define ORM_DEFAULT_FORTUNE_H -#include "mysqlorm.hpp" +#include "fortune_mysql.h" #include "fortunebase.h" /* 如果此文件存在不会自动覆盖，没有则会自动生成。 - *If this file exists, it will not be overwritten automatically. If not, it will be generated automatically. */ +*If this file exists, it will not be overwritten automatically. If not, it will be generated automatically. */ -namespace orm -{ -class Fortune : public mysql_orm -{ - public: - Fortune(std::string dbtag); - Fortune(); -}; -};// namespace orm + namespace orm { + class Fortune : public fortune_mysql{ + 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 old mode 100755 new mode 100644 index 15ae378052a..0967117ebb0 --- a/frameworks/C++/paozhu/paozhu_benchmark/models/include/World.h +++ b/frameworks/C++/paozhu/paozhu_benchmark/models/include/World.h @@ -1,18 +1,16 @@ #ifndef ORM_DEFAULT_WORLD_H #define ORM_DEFAULT_WORLD_H -#include "mysqlorm.hpp" +#include "world_mysql.h" #include "worldbase.h" /* 如果此文件存在不会自动覆盖，没有则会自动生成。 - *If this file exists, it will not be overwritten automatically. If not, it will be generated automatically. */ +*If this file exists, it will not be overwritten automatically. If not, it will be generated automatically. */ -namespace orm -{ -class World : public mysql_orm -{ - public: - World(std::string dbtag); - World(); -}; -};// namespace orm + namespace orm { + class World : public world_mysql{ + public: + World(std::string dbtag); + World(); + }; +} #endif diff --git a/frameworks/C++/paozhu/paozhu_benchmark/models/world_mysql.h b/frameworks/C++/paozhu/paozhu_benchmark/models/world_mysql.h new file mode 100644 index 00000000000..5fe029ad608 --- /dev/null +++ b/frameworks/C++/paozhu/paozhu_benchmark/models/world_mysql.h @@ -0,0 +1,9628 @@ +#ifndef _ORM_DEFAULT_WORLD_OPERATE_H +#define _ORM_DEFAULT_WORLD_OPERATE_H + +#include +#include +#include +#include +#include +#include +#include +#include "request.h" +#include "unicode.h" +#include "datetime.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "mysql_conn.h" +#include "mysql_conn_pool.h" +#include "orm_cache.hpp" +/*baseincludefile*/ +namespace orm +{ +// mysql Operational SQL middleware +/*tagnamespace*/ +//{ /*tagnamespace_replace*/ + template + class world_mysql : public B_BASE + { + public: + world_mysql(const std::string &tag) : dbtag(tag) + { + std::map> &conn_pool_obj = get_orm_conn_pool_obj(); + auto iter = conn_pool_obj.find(dbtag); + if (iter != conn_pool_obj.end()) + { + conn_obj = iter->second; + } + else + { + conn_obj = nullptr; + iserror = true; + error_msg = "conn_pool not found " + dbtag; + } + } + world_mysql() : dbtag(B_BASE::_rmstag) + { + std::map> &conn_pool_obj = get_orm_conn_pool_obj(); + auto iter = conn_pool_obj.find(dbtag); + if (iter != conn_pool_obj.end()) + { + conn_obj = iter->second; + } + else + { + conn_obj = nullptr; + iserror = true; + error_msg = "conn_pool not found " + dbtag; + } + } + M_MODEL &switchDB(const std::string &temptag) + { + std::map> &conn_pool_obj = get_orm_conn_pool_obj(); + auto iter = conn_pool_obj.find(temptag); + if (iter != conn_pool_obj.end()) + { + conn_obj = iter->second; + } + else + { + conn_obj = nullptr; + iserror = true; + error_msg = "conn_pool not found " + temptag; + } + } + M_MODEL &set_table(const std::string &table_name) + { + if (original_tablename.empty()) + { + original_tablename = B_BASE::tablename; + } + if (table_name.size() > 0) + { + B_BASE::tablename = table_name; + } + return *mod; + } + M_MODEL &reset_table() + { + if (original_tablename.empty()) + { + return *mod; + } + B_BASE::tablename = original_tablename; + return *mod; + } + unsigned int count() + { + std::string countsql; + countsql = "SELECT count(*) as total_countnum FROM "; + countsql.append(B_BASE::tablename); + countsql.append(" WHERE "); + if (wheresql.empty()) + { + countsql.append(" 1 "); + } + else + { + countsql.append(wheresql); + } + if (!groupsql.empty()) + { + countsql.append(groupsql); + } + if (!limitsql.empty()) + { + countsql.append(limitsql); + } + + if (iserror) + { + return 0; + } + + try + { + effect_num = 0; + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_select_conn(); + + unsigned int querysql_len = countsql.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(countsql); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + //std::vector field_array; + unsigned char action_setup = 0; + unsigned int column_num = 0; + unsigned int offset = 0; + + querysql_len = 0; + + for (; is_sql_item == false;) + { + n = conn->read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + column_num--; + if (column_num == 0) + { + action_setup = 2; + } + } + else if (action_setup == 2) + { + unsigned int tempnum = 0; + + unsigned int name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + querysql_len = 0; + for (unsigned int ik = 0; ik < name_length; ik++) + { + if (temp_pack_data.data[tempnum] >= '0' && temp_pack_data.data[tempnum] <= '9') + { + querysql_len = querysql_len * 10 + (temp_pack_data.data[tempnum] - '0'); + } + tempnum++; + } + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + + conn_obj->back_select_conn(conn); + + if (iscache) + { + if (exptime > 0) + { + save_cache(exptime); + exptime = 0; + iscache = false; + } + } + return querysql_len; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + return 0; + } + + return 0; + } + std::tuple + page(unsigned int page, unsigned int per_page = 10, unsigned int list_num = 5) + { + unsigned int total_page = count(); + if (per_page == 0) + { + per_page = 10; + } + if (list_num < 1) + { + list_num = 1; + } + total_page = std::ceil((float)total_page / per_page); + + if (total_page < 1) + { + total_page = 1; + } + if (page > total_page) + { + page = total_page; + } + if (page < 1) + { + page = 1; + } + unsigned int mid_num = std::floor(list_num / 2); + unsigned int last_num = list_num - 1; + + int temp_num = page - mid_num; + + unsigned int minpage = temp_num < 1 ? 1 : temp_num; + unsigned int maxpage = minpage + last_num; + + if (maxpage > total_page) + { + maxpage = total_page; + temp_num = (maxpage - last_num); + if (temp_num < 1) + { + minpage = 1; + } + else + { + minpage = temp_num; + } + } + limit((page - 1) * per_page, per_page); + return std::make_tuple(minpage, maxpage, page, total_page); + } + asio::awaitable async_count() + { + std::string countsql; + countsql = "SELECT count(*) as total_countnum FROM "; + countsql.append(B_BASE::tablename); + countsql.append(" WHERE "); + if (wheresql.empty()) + { + countsql.append(" 1 "); + } + else + { + countsql.append(wheresql); + } + if (!groupsql.empty()) + { + countsql.append(groupsql); + } + if (!limitsql.empty()) + { + countsql.append(limitsql); + } + + if (iserror) + { + co_return 0; + } + + try + { + effect_num = 0; + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_select_conn(); + + unsigned int querysql_len = countsql.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(countsql); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + //std::vector field_array; + unsigned char action_setup = 0; + unsigned int column_num = 0; + unsigned int offset = 0; + + querysql_len = 0; + + for (; is_sql_item == false;) + { + n = co_await conn->async_read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + column_num--; + if (column_num == 0) + { + action_setup = 2; + } + } + else if (action_setup == 2) + { + unsigned int tempnum = 0; + + unsigned int name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + querysql_len = 0; + for (unsigned int ik = 0; ik < name_length; ik++) + { + if (temp_pack_data.data[tempnum] >= '0' && temp_pack_data.data[tempnum] <= '9') + { + querysql_len = querysql_len * 10 + (temp_pack_data.data[tempnum] - '0'); + } + tempnum++; + } + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + + conn_obj->back_select_conn(conn); + + if (iscache) + { + if (exptime > 0) + { + save_cache(exptime); + exptime = 0; + iscache = false; + } + } + co_return querysql_len; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + co_return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + co_return 0; + } + co_return 0; + } + + asio::awaitable> + async_page(unsigned int page, unsigned int per_page = 10, unsigned int list_num = 5) + { + unsigned int total_page = async_count(); + if (per_page == 0) + { + per_page = 10; + } + if (list_num < 1) + { + list_num = 1; + } + total_page = std::ceil((float)total_page / per_page); + + if (total_page < 1) + { + total_page = 1; + } + if (page > total_page) + { + page = total_page; + } + if (page < 1) + { + page = 1; + } + unsigned int mid_num = std::floor(list_num / 2); + unsigned int last_num = list_num - 1; + + int temp_num = page - mid_num; + + unsigned int minpage = temp_num < 1 ? 1 : temp_num; + unsigned int maxpage = minpage + last_num; + + if (maxpage > total_page) + { + maxpage = total_page; + temp_num = (maxpage - last_num); + if (temp_num < 1) + { + minpage = 1; + } + else + { + minpage = temp_num; + } + } + limit((page - 1) * per_page, per_page); + co_return std::make_tuple(minpage, maxpage, page, total_page); + } + + unsigned int update_col(std::string colname, int num, char symbol = '+') + { + effect_num = 0; + std::string countsql; + countsql = "UPDATE "; + countsql.append(B_BASE::tablename); + countsql.append(" SET "); + countsql.append(colname); + if (num > 0) + { + countsql.append(" = "); + countsql.append(colname); + countsql.push_back(' '); + countsql.push_back(symbol); + countsql.append(std::to_string(num)); + } + else + { + countsql.append(" = "); + countsql.append(colname); + countsql.push_back(' '); + countsql.push_back(symbol); + countsql.push_back('('); + countsql.push_back('-'); + countsql.append(std::to_string(std::abs(num))); + countsql.push_back(')'); + } + countsql.append(" where "); + if (wheresql.empty()) + { + if (B_BASE::getPK() > 0) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + countsql.append(tempsql.str()); + } + else + { + return 0; + } + } + else + { + countsql.append(wheresql); + } + if (!groupsql.empty()) + { + countsql.append(groupsql); + } + if (!limitsql.empty()) + { + countsql.append(limitsql); + } + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = countsql.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(countsql); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + //insertid = pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + return effect_num; + } + + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + return 0; + } + + asio::awaitable async_update_col(std::string colname, int num, char symbol = '+') + { + effect_num = 0; + std::string countsql; + countsql = "UPDATE "; + countsql.append(B_BASE::tablename); + countsql.append(" SET "); + countsql.append(colname); + if (num > 0) + { + countsql.append(" = "); + countsql.append(colname); + countsql.push_back(' '); + countsql.push_back(symbol); + countsql.append(std::to_string(num)); + } + else + { + countsql.append(" = "); + countsql.append(colname); + countsql.push_back(' '); + countsql.push_back(symbol); + countsql.push_back('('); + countsql.push_back('-'); + countsql.append(std::to_string(std::abs(num))); + countsql.push_back(')'); + } + countsql.append(" where "); + if (wheresql.empty()) + { + if (B_BASE::getPK() > 0) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + countsql.append(tempsql.str()); + } + else + { + co_return 0; + } + } + else + { + countsql.append(wheresql); + } + if (!groupsql.empty()) + { + countsql.append(groupsql); + } + if (!limitsql.empty()) + { + countsql.append(limitsql); + } + if (iscommit) + { + iscommit = false; + co_return 0; + } + + if (iserror) + { + co_return 0; + } + + try + { + + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_edit_conn(); + + unsigned int querysql_len = countsql.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(countsql); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + unsigned int offset = 0; + n = co_await conn->async_read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + //insertid = pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + co_return effect_num; + } + + co_return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + co_return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + co_return 0; + } + + int replace_col(std::string colname, const std::string &old_string, const std::string &new_string) + { + effect_num = 0; + std::string countsql; + countsql = "UPDATE "; + countsql.append(B_BASE::tablename); + countsql.append(" SET "); + countsql.append(colname); + + countsql.append(" = REPLACE("); + countsql.append(colname); + countsql.append(",'"); + countsql.append(old_string); + countsql.append("','"); + countsql.append(new_string); + countsql.append("') "); + + countsql.append(" where "); + if (wheresql.empty()) + { + if (B_BASE::getPK() > 0) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + countsql.append(tempsql.str()); + } + else + { + return 0; + } + } + else + { + countsql.append(wheresql); + } + if (!groupsql.empty()) + { + countsql.append(groupsql); + } + if (!limitsql.empty()) + { + countsql.append(limitsql); + } + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = countsql.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(countsql); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + //insertid = pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + return effect_num; + } + + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + return 0; + } + + void assign_field_value(unsigned char index_pos, unsigned char *result_temp_data, unsigned int value_size, typename B_BASE::meta &data_temp) + { + switch(index_pos) + { + case 0: + data_temp.id=0; + + for(unsigned int i=0; i< value_size; i++) + { + if(result_temp_data[i]>='0'&&result_temp_data[i]<='9') + { + + data_temp.id= data_temp.id * 10 + (result_temp_data[i]-'0'); + } + if(i>32) + { + break; + } + } + break; + case 1: + data_temp.randomnumber=0; + + for(unsigned int i=0; i< value_size; i++) + { + if(result_temp_data[i]>='0'&&result_temp_data[i]<='9') + { + + data_temp.randomnumber= data_temp.randomnumber * 10 + (result_temp_data[i]-'0'); + } + if(i>32) + { + break; + } + } + break; + + } + } + + +M_MODEL& eqId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id = "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& nqId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id != "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& inId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id IN("); + + wheresql.append(val); + wheresql.push_back(')'); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& inId(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + wheresql.append(std::to_string(val[i])); + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& inId(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + + try + { + wheresql.append(std::to_string(std::stoll(val[i]))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& ninId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id NOT IN("); + + wheresql.append(val); + wheresql.push_back(')'); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& ninId(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id NOT IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + wheresql.append(std::to_string(val[i])); + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& ninId(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id NOT IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + + try + { + wheresql.append(std::to_string(std::stoll(val[i]))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& btId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id > "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& beId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id >= "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& ltId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id < "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& leId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id <= "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& or_eqId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id = "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& or_nqId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id != "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& or_inId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id IN("); + + wheresql.append(val); + wheresql.push_back(')'); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_inId(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + wheresql.append(std::to_string(val[i])); + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& or_inId(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + + try + { + wheresql.append(std::to_string(std::stoll(val[i]))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& or_ninId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id NOT IN("); + + wheresql.append(val); + wheresql.push_back(')'); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_ninId(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id NOT IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + wheresql.append(std::to_string(val[i])); + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& or_ninId(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id NOT IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + + try + { + wheresql.append(std::to_string(std::stoll(val[i]))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& or_btId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id > "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& or_beId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id >= "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& or_ltId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id < "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& or_leId(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id <= "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& eqId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id = "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& nqId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id != "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& btId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id > "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& beId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id >= "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& ltId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id < "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& leId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id <= "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_eqId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id = "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_nqId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id != "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_btId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id > "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_beId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id >= "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_ltId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id < "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_leId(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" id <= "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +M_MODEL& eqRandomnumber(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber = "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& nqRandomnumber(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber != "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& inRandomnumber(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber IN("); + + wheresql.append(val); + wheresql.push_back(')'); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& inRandomnumber(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + wheresql.append(std::to_string(val[i])); + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& inRandomnumber(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + + try + { + wheresql.append(std::to_string(std::stoll(val[i]))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& ninRandomnumber(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber NOT IN("); + + wheresql.append(val); + wheresql.push_back(')'); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& ninRandomnumber(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber NOT IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + wheresql.append(std::to_string(val[i])); + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& ninRandomnumber(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber NOT IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + + try + { + wheresql.append(std::to_string(std::stoll(val[i]))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& btRandomnumber(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber > "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& beRandomnumber(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber >= "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& ltRandomnumber(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber < "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& leRandomnumber(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber <= "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& or_eqRandomnumber(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber = "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& or_nqRandomnumber(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber != "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& or_inRandomnumber(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber IN("); + + wheresql.append(val); + wheresql.push_back(')'); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_inRandomnumber(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + wheresql.append(std::to_string(val[i])); + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& or_inRandomnumber(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + + try + { + wheresql.append(std::to_string(std::stoll(val[i]))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& or_ninRandomnumber(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber NOT IN("); + + wheresql.append(val); + wheresql.push_back(')'); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_ninRandomnumber(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber NOT IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + wheresql.append(std::to_string(val[i])); + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& or_ninRandomnumber(const std::vector& val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber NOT IN("); + + for(unsigned int i=0;i 0) + { + wheresql.push_back(','); + } + + try + { + wheresql.append(std::to_string(std::stoll(val[i]))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + } + wheresql.push_back(')'); + + return *mod; + } + + +M_MODEL& or_btRandomnumber(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber > "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& or_beRandomnumber(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber >= "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& or_ltRandomnumber(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber < "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +M_MODEL& or_leRandomnumber(const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber <= "); + + try + { + wheresql.append(std::to_string(std::stoll(val))); + } + catch (std::invalid_argument const& ex) + { + wheresql.push_back('0'); + } + catch (std::out_of_range const& ex) + { + wheresql.push_back('0'); + } + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& eqRandomnumber(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber = "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& nqRandomnumber(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber != "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& btRandomnumber(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber > "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& beRandomnumber(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber >= "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& ltRandomnumber(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber < "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& leRandomnumber(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber <= "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_eqRandomnumber(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber = "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_nqRandomnumber(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber != "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_btRandomnumber(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber > "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_beRandomnumber(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber >= "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_ltRandomnumber(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber < "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + +template + requires std::is_integral_v +M_MODEL& or_leRandomnumber(T val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" randomnumber <= "); + + wheresql.append(std::to_string(val)); + return *mod; + } + + + M_MODEL &select(const std::string &fieldname) + { + if (selectsql.size() > 0) + { + selectsql.push_back(','); + } + selectsql.append(fieldname); + return *mod; + } + + M_MODEL &where(const std::string &wq) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + + wheresql.append(wq); + return *mod; + } + template + requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value> + M_MODEL &where(const std::string &wq, _SQL_Value val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + char bi = wq.back(); + if (bi == '=' || bi == '>' || bi == '<') + { + } + else + { + wheresql.push_back('='); + } + + std::stringstream _stream; + _stream << val; + wheresql.append(_stream.str()); + return *mod; + } + + M_MODEL &where(const std::string &wq, char bi, http::OBJ_VALUE &obj) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + wheresql.push_back(bi); + if (obj.is_string()) + { + wheresql.push_back('\''); + wheresql.append(obj.as_string()); + wheresql.push_back('\''); + } + else + { + + wheresql.append(obj.to_string()); + } + return *mod; + } + M_MODEL &where(const std::string &wq, http::OBJ_VALUE &obj) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + char bi = wq.back(); + if (bi == '=' || bi == '>' || bi == '<') + { + } + else + { + wheresql.push_back('='); + } + + if (obj.is_string()) + { + wheresql.push_back('\''); + wheresql.append(obj.as_string()); + wheresql.push_back('\''); + } + else + { + + wheresql.append(obj.to_string()); + } + return *mod; + } + template + requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value> + M_MODEL &where(const std::string &wq, char bi, _SQL_Value val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + wheresql.push_back(bi); + std::stringstream _stream; + _stream << val; + wheresql.append(_stream.str()); + return *mod; + } + + M_MODEL &where(const std::string &wq, char bi, const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + wheresql.push_back(bi); + wheresql.push_back('\''); + + wheresql.append(val); + wheresql.push_back('\''); + return *mod; + } + M_MODEL &where(const std::string &wq, const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + char bi = wq.back(); + if (bi == '=' || bi == '>' || bi == '<') + { + } + else + { + wheresql.push_back('='); + } + + wheresql.push_back('\''); + wheresql.append(val); + wheresql.push_back('\''); + return *mod; + } + + M_MODEL &between(const std::string &wq, const std::string &a, const std::string &b) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" ("); + wheresql.append(wq); + wheresql.append(" BETWEEN '"); + std::stringstream _stream; + _stream << a; + _stream << "' AND '"; + _stream << b; + _stream << "' ) "; + wheresql.append(_stream.str()); + return *mod; + } + template + requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value> + M_MODEL &between(const std::string &wq, _SQL_Value a, _SQL_Value b) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" ("); + wheresql.append(wq); + wheresql.append(" BETWEEN "); + std::stringstream _stream; + _stream << a; + _stream << " AND "; + _stream << b; + _stream << " ) "; + wheresql.append(_stream.str()); + return *mod; + } + template + requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value> + M_MODEL &orBetween(const std::string &wq, _SQL_Value a, _SQL_Value b) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(" ("); + wheresql.append(wq); + wheresql.append(" BETWEEN "); + std::stringstream _stream; + _stream << a; + _stream << " AND "; + _stream << b; + _stream << " ) "; + wheresql.append(_stream.str()); + return *mod; + } + M_MODEL &whereLike(const std::string &wq, const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + wheresql.append(" like '"); + if (val.size() > 0 && (val[0] == '%' || val.back() == '%')) + { + wheresql.append(val); + wheresql.append("' "); + } + else + { + wheresql.push_back('%'); + wheresql.append(val); + wheresql.append("%' "); + } + return *mod; + } + M_MODEL &whereLikeLeft(const std::string &wq, const std::string &val) + { + + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + wheresql.append(" like '"); + wheresql.push_back('%'); + wheresql.append(val); + wheresql.append("' "); + return *mod; + } + M_MODEL &whereLikeRight(const std::string &wq, const std::string &val) + { + + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + wheresql.append(" like '"); + wheresql.append(val); + wheresql.append("%' "); + return *mod; + } + M_MODEL &whereOrLike(const std::string &wq, const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + wheresql.append(" like '"); + if (val[0] == '%' || val.back() == '%') + { + wheresql.append(val); + wheresql.append("' "); + } + else + { + wheresql.push_back('%'); + wheresql.append(val); + wheresql.append("%' "); + } + return *mod; + } + M_MODEL &whereAnd(const std::string &wq) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + return *mod; + } + template + requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value> + M_MODEL &whereAnd(const std::string &wq, _SQL_Value val) + { + + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + char bi = wq.back(); + if (bi == '=' || bi == '>' || bi == '<') + { + } + else + { + wheresql.push_back('='); + } + std::stringstream _stream; + _stream << val; + wheresql.append(_stream.str()); + return *mod; + } + M_MODEL &whereAnd(const std::string &wq, const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + char bi = wq.back(); + if (bi == '=' || bi == '>' || bi == '<') + { + } + else + { + wheresql.push_back('='); + } + + wheresql.push_back('\''); + wheresql.append(val); + wheresql.push_back('\''); + + return *mod; + } + M_MODEL &whereOr(const std::string &wq) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + return *mod; + } + template + requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value> + M_MODEL &whereOr(const std::string &wq, _SQL_Value val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + char bi = wq.back(); + if (bi == '=' || bi == '>' || bi == '<') + { + } + else + { + wheresql.push_back('='); + } + std::stringstream _stream; + _stream << val; + wheresql.append(_stream.str()); + return *mod; + } + M_MODEL &whereOr(const std::string &wq, const std::string &val) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" OR "); + } + else + { + if (!iskuohao) + { + wheresql.append(" OR "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(wq); + char bi = wq.back(); + if (bi == '=' || bi == '>' || bi == '<') + { + } + else + { + wheresql.push_back('='); + } + + wheresql.push_back('\''); + wheresql.append(val); + wheresql.push_back('\''); + return *mod; + } + M_MODEL &whereIn(const std::string &k) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(k); + return *mod; + } + M_MODEL &whereIn(const std::string &k, const std::string &a) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + + wheresql.append(k); + wheresql.append(" IN("); + wheresql.append(a); + wheresql.append(") "); + return *mod; + } + + M_MODEL &whereIn(const std::string &k, const std::vector &a) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + wheresql.append(k); + wheresql.append(" in("); + int i = 0; + for (auto &key : a) + { + if (i > 0) + { + wheresql.append(",\'"); + } + else + { + wheresql.append("\'"); + } + wheresql.append(key); + wheresql.append("\'"); + i++; + } + wheresql.append(") "); + return *mod; + } + M_MODEL &whereNotIn(const std::string &k, const std::vector &a) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + + wheresql.append(k); + wheresql.append(" NOT IN("); + int i = 0; + for (auto &key : a) + { + if (i > 0) + { + wheresql.append(",\'"); + } + else + { + wheresql.append("\'"); + } + wheresql.append(key); + wheresql.append("\'"); + i++; + } + wheresql.append(") "); + return *mod; + } + template + requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value> + M_MODEL &whereIn(const std::string &k, const std::list<_SQL_Value> &a) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + + wheresql.append(k); + wheresql.append(" in("); + int i = 0; + std::stringstream _stream; + for (auto &key : a) + { + if (i > 0) + { + wheresql.append(","); + } + _stream << key; + wheresql.append(_stream.str()); + i++; + _stream.str(""); + } + wheresql.append(") "); + return *mod; + } + + template + requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value> + M_MODEL &whereIn(const std::string &k, const std::vector<_SQL_Value> &a) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + + wheresql.append(k); + wheresql.append(" IN("); + int i = 0; + std::stringstream _stream; + for (auto &key : a) + { + if (i > 0) + { + wheresql.append(","); + } + _stream << key; + wheresql.append(_stream.str()); + i++; + _stream.str(""); + } + wheresql.append(") "); + return *mod; + } + template + requires std::is_integral_v<_SQL_Value> || std::is_floating_point_v<_SQL_Value> + M_MODEL &whereNotIn(const std::string &k, const std::vector<_SQL_Value> &a) + { + if (wheresql.empty()) + { + } + else + { + if (ishascontent) + { + wheresql.append(" AND "); + } + else + { + if (!iskuohao) + { + wheresql.append(" AND "); + } + } + } + if (iskuohao) + { + ishascontent = true; + } + + wheresql.append(k); + wheresql.append(" NOT IN("); + int i = 0; + std::stringstream _stream; + for (auto &key : a) + { + if (i > 0) + { + wheresql.append(","); + } + _stream << key; + wheresql.append(_stream.str()); + i++; + _stream.str(""); + } + wheresql.append(") "); + return *mod; + } + + M_MODEL &order(const std::string &wq) + { + ordersql.append(" ORDER by "); + ordersql.append(wq); + return *mod; + } + M_MODEL &asc(const std::string &wq) + { + + ordersql.append(" ORDER by "); + ordersql.append(wq); + ordersql.append(" ASC "); + return *mod; + } + + M_MODEL &desc(const std::string &wq) + { + + ordersql.append(" ORDER by "); + ordersql.append(wq); + ordersql.append(" DESC "); + return *mod; + } + + M_MODEL &having(const std::string &wq) + { + + groupsql.append(" HAVING by "); + groupsql.append(wq); + return *mod; + } + + M_MODEL &group(const std::string &wq) + { + + groupsql.append(" GROUP BY "); + groupsql.append(wq); + return *mod; + } + + M_MODEL &orsub() + { + + if (iskuohao == true) + { + iskuohao = false; + ishascontent = false; + wheresql.append(" )"); + } + else + { + wheresql.append(" OR ("); + iskuohao = true; + ishascontent = false; + } + return *mod; + } + M_MODEL &andsub() + { + + if (iskuohao == true) + { + iskuohao = false; + wheresql.append(" )"); + ishascontent = false; + } + else + { + wheresql.append(" AND ("); + iskuohao = true; + ishascontent = false; + } + + return *mod; + } + + M_MODEL &endsub() + { + if (iskuohao == true) + { + iskuohao = false; + ishascontent = false; + wheresql.append(" )"); + } + return *mod; + } + + M_MODEL &or_b() + { + + if (iskuohao == true) + { + iskuohao = false; + ishascontent = false; + wheresql.append(" )"); + } + else + { + wheresql.append(" OR ("); + iskuohao = true; + ishascontent = false; + } + return *mod; + } + M_MODEL &and_b() + { + + if (iskuohao == true) + { + iskuohao = false; + wheresql.append(" )"); + ishascontent = false; + } + else + { + wheresql.append(" AND ("); + iskuohao = true; + ishascontent = false; + } + + return *mod; + } + + M_MODEL &or_e() + { + if (iskuohao == true) + { + iskuohao = false; + ishascontent = false; + wheresql.append(" )"); + } + return *mod; + } + + M_MODEL &and_e() + { + if (iskuohao == true) + { + iskuohao = false; + ishascontent = false; + wheresql.append(" )"); + } + return *mod; + } + + M_MODEL &limit(unsigned int num) + { + limitsql.clear(); + limitsql.append(" limit "); + limitsql.append(std::to_string(num)); + return *mod; + } + M_MODEL &limit(unsigned int num, unsigned int endnum) + { + limitsql.clear(); + limitsql.append(" limit "); + limitsql.append(std::to_string(num)); + limitsql.push_back(','); + limitsql.append(std::to_string(endnum)); + return *mod; + } + + std::vector> fetch_obj() + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + sqlstring.append(" 1 "); + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + std::vector> temprecord; + + if (iserror) + { + return temprecord; + } + + try + { + effect_num = 0; + if (conn_empty()) + { + return temprecord; + } + auto conn = conn_obj->get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return temprecord; + } + + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + unsigned char action_setup = 0; + unsigned int column_num = 0; + unsigned int offset = 0; + + std::vector field_pos; + + for (; is_sql_item == false;) + { + n = conn->read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + std::map data_temp; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + std::string temp_str; + temp_str.resize(name_length); + std::memcpy(temp_str.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length); + if (field_array[ij].name.size() > 0) + { + data_temp.insert({field_array[ij].name, std::move(temp_str)}); + } + else if (field_array[ij].org_name.size() > 0) + { + data_temp.insert({field_array[ij].org_name, std::move(temp_str)}); + } + + tempnum = tempnum + name_length; + } + temprecord.emplace_back(std::move(data_temp)); + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + + conn_obj->back_select_conn(conn); + + if (iscache) + { + if (exptime > 0) + { + save_cache(exptime); + exptime = 0; + iscache = false; + } + } + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + return temprecord; + } + std::tuple, std::map, std::vector>> + fetch_row() + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + sqlstring.append(" 1 "); + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + std::vector> temprecord; + std::vector table_fieldname; + std::map table_fieldmap; + + if (iscache) + { + std::size_t sqlhashid = std::hash{}(sqlstring); + + model_meta_cache> &temp_cache = + model_meta_cache>::getinstance(); + temprecord = temp_cache.get(sqlhashid); + if (temprecord.size() > 0) + { + iscache = false; + model_meta_cache &table_cache = model_meta_cache::getinstance(); + table_fieldname = table_cache.get(sqlhashid); + + model_meta_cache> &tablemap_cache = + model_meta_cache>::getinstance(); + table_fieldmap = tablemap_cache.get_obj(sqlhashid); + + return std::make_tuple(table_fieldname, table_fieldmap, temprecord); + } + } + + if (iserror) + { + return std::make_tuple(table_fieldname, table_fieldmap, temprecord); + } + + try + { + if (conn_empty()) + { + return std::make_tuple(table_fieldname, table_fieldmap, temprecord); + } + auto conn = conn_obj->get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return std::make_tuple(table_fieldname, table_fieldmap, temprecord); + } + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + // std::vector> field_value; + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + std::vector field_pos; + + for (; is_sql_item == false;) + { + n = conn->read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + table_fieldmap.insert({field_array[ii].org_name,table_fieldname.size()}); + table_fieldname.push_back(field_array[ii].org_name); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + std::vector temp_v_record; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + std::string tempstr; + tempstr.resize(name_length); + std::memcpy(tempstr.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length); + temp_v_record.push_back(std::move(tempstr)); + tempnum = tempnum + name_length; + } + temprecord.push_back(temp_v_record); + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + conn_obj->back_select_conn(conn); + + + + if (iscache) + { + if (exptime > 0) + { + if (temprecord.size() > 0) + { + std::size_t sqlhashid = std::hash{}(sqlstring); + + model_meta_cache> &temp_cache = + model_meta_cache>::getinstance(); + temp_cache.save(sqlhashid, temprecord, exptime); + + exptime += 1; + model_meta_cache &table_cache = model_meta_cache::getinstance(); + table_cache.save(sqlhashid, table_fieldname, exptime); + + model_meta_cache> &tablemap_cache = + model_meta_cache>::getinstance(); + tablemap_cache.save(sqlhashid, table_fieldmap, exptime); + exptime = 0; + iscache = false; + } + } + } + + return std::make_tuple(std::move(table_fieldname), std::move(table_fieldmap), std::move(temprecord)); + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + return std::make_tuple(table_fieldname, table_fieldmap, temprecord); + } + M_MODEL &fetch() + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + sqlstring.append(" 1 "); + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscache) + { + std::size_t sqlhashid = std::hash{}(sqlstring); + if (get_cacherecord(sqlhashid)) + { + iscache = false; + return *mod; + } + } + + B_BASE::record_reset(); + if (iserror) + { + return *mod; + } + + try + { + if (conn_empty()) + { + return *mod; + } + auto conn = conn_obj->get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return *mod; + } + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + std::vector field_pos; + + for (; is_sql_item == false;) + { + n = conn->read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + typename B_BASE::meta data_temp; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp); + tempnum = tempnum + name_length; + } + B_BASE::record.emplace_back(std::move(data_temp)); + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + conn_obj->back_select_conn(conn); + + if (iscache) + { + if (exptime > 0) + { + save_cache(exptime); + exptime = 0; + iscache = false; + } + } + return *mod; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return *mod; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + return *mod; + } + + asio::awaitable async_fetch() + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + sqlstring.append(" 1 "); + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscache) + { + std::size_t sqlhashid = std::hash{}(sqlstring); + if (get_cacherecord(sqlhashid)) + { + iscache = false; + co_return 0; + } + } + + B_BASE::record_reset(); + if (iserror) + { + co_return 0; + } + + try + { + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + std::vector field_pos; + + for (; is_sql_item == false;) + { + n = co_await conn->async_read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + typename B_BASE::meta data_temp; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp); + tempnum = tempnum + name_length; + } + B_BASE::record.emplace_back(std::move(data_temp)); + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + conn_obj->back_select_conn(conn); + + if (iscache) + { + if (exptime > 0) + { + save_cache(exptime); + exptime = 0; + iscache = false; + } + } + co_return effect_num; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + co_return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + co_return 0; + } + M_MODEL &fetch_append() + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + sqlstring.append(" 1 "); + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscache) + { + std::size_t sqlhashid = std::hash{}(sqlstring); + if (get_cacherecord(sqlhashid)) + { + iscache = false; + return *mod; + } + } + + if (iserror) + { + return *mod; + } + + try + { + + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + std::vector field_pos; + + for (; is_sql_item == false;) + { + n = conn->read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + typename B_BASE::meta data_temp; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp); + tempnum = tempnum + name_length; + } + B_BASE::record.emplace_back(std::move(data_temp)); + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + conn_obj->back_select_conn(conn); + + if (iscache) + { + if (exptime > 0) + { + save_cache(exptime); + exptime = 0; + iscache = false; + } + } + return *mod; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return *mod; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + return *mod; + } + + asio::awaitable async_fetch_append() + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + sqlstring.append(" 1 "); + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscache) + { + std::size_t sqlhashid = std::hash{}(sqlstring); + if (get_cacherecord(sqlhashid)) + { + iscache = false; + co_return 1; + } + } + + if (iserror) + { + co_return 0; + } + + try + { + effect_num = 0; + + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + // asio::error_code ec; + + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + // std::vector> field_value; + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + std::vector field_pos; + // std::map other_col; + + for (; is_sql_item == false;) + { + // std::memset(result_data, 0x00, 4096); + // n = co_await conn->socket->async_read_some(asio::buffer(result_data), asio::use_awaitable); + n = co_await conn->async_read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + typename B_BASE::meta data_temp; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp); + tempnum = tempnum + name_length; + } + effect_num++; + B_BASE::record.emplace_back(std::move(data_temp)); + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + conn_obj->back_select_conn(conn); + + if (iscache) + { + if (exptime > 0) + { + save_cache(exptime); + exptime = 0; + iscache = false; + } + } + co_return effect_num; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + co_return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + co_return 0; + } + unsigned int fetch_one(bool isappend = false) + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + sqlstring.append(" 1 "); + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + + sqlstring.append(" limit 1"); + + if (iscache) + { + std::size_t sqlhashid = std::hash{}(sqlstring); + if (get_cacherecord(sqlhashid)) + { + iscache = false; + return 0; + } + } + + B_BASE::data_reset(); + if (iserror) + { + return 0; + } + + try + { + effect_num = 0; + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + unsigned char action_setup = 0; + unsigned int column_num = 0; + unsigned int offset = 0; + + std::vector field_pos; + + for (; is_sql_item == false;) + { + n = conn->read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + if (isappend) + { + typename B_BASE::meta data_temp; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp); + tempnum = tempnum + name_length; + } + B_BASE::record.emplace_back(std::move(data_temp)); + effect_num++; + } + else + { + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, B_BASE::data); + tempnum = tempnum + name_length; + } + effect_num++; + } + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + + conn_obj->back_select_conn(conn); + + if (iscache) + { + if (exptime > 0) + { + save_cache(exptime); + exptime = 0; + iscache = false; + } + } + return effect_num; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + return 0; + } + + asio::awaitable async_fetch_one(bool isappend = false) + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + sqlstring.append(" 1 "); + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + + sqlstring.append(" limit 1"); + + if (iscache) + { + std::size_t sqlhashid = std::hash{}(sqlstring); + if (get_cacherecord(sqlhashid)) + { + iscache = false; + co_return 0; + } + } + + B_BASE::data_reset(); + if (iserror) + { + co_return 0; + } + + try + { + effect_num = 0; + + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + // std::vector> field_value; + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + std::vector field_pos; + // std::map other_col; + + for (; is_sql_item == false;) + { + n = co_await conn->async_read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + if (isappend) + { + typename B_BASE::meta data_temp; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, data_temp); + tempnum = tempnum + name_length; + } + B_BASE::record.emplace_back(std::move(data_temp)); + effect_num++; + } + else + { + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, B_BASE::data); + tempnum = tempnum + name_length; + } + effect_num++; + } + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + + conn_obj->back_select_conn(conn); + + if (iscache) + { + if (exptime > 0) + { + save_cache(exptime); + exptime = 0; + iscache = false; + } + } + co_return effect_num; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + co_return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + co_return 0; + } + + M_MODEL &use_cache(int cache_time = 0) + { + iscache = true; + exptime = cache_time; + return *mod; + } + bool isuse_cache(bool iscachedate = false) + { + if (iscachedate) + { + return exptime == 0 && iscache == false; + } + return iscache; + } + void set_cache_state(bool isrestatus = false) { iscache = isrestatus; } + void remove_exptime_cache() + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + temp_cache.remove_exptime(); + } + void clear_cache() + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + temp_cache.clear(); + } + bool remove_cache() + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + std::size_t sqlhashid = std::hash{}(sqlstring); + return temp_cache.remove(sqlhashid); + } + bool remove_cache(std::size_t cache_key_name) + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + return temp_cache.remove(cache_key_name); + } + int check_cache(std::size_t cache_key_name) + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + return temp_cache.check(cache_key_name); + } + std::vector get_cache_data(std::size_t cache_key_name) + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + auto cache_data = temp_cache.get(cache_key_name); + return cache_data; + } + typename B_BASE::meta get_cache_obj(std::size_t cache_key_name) + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + auto cache_data = temp_cache.get_obj(cache_key_name); + return cache_data; + } + M_MODEL &get_cache(std::size_t cache_key_name) + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + B_BASE::record = temp_cache.get(cache_key_name); + if (B_BASE::record.size() == 0) + { + B_BASE::record_reset(); + } + else + { + B_BASE::data = B_BASE::record[0]; + } + return *mod; + } + int update_cache(int exp_time = 0) + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + std::size_t sqlhashid = std::hash{}(sqlstring); + return temp_cache.update(sqlhashid, exp_time); + } + int update_cache(std::size_t cache_key_name, int exp_time) + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + return temp_cache.update(cache_key_name, exp_time); + } + bool save_cache(int exp_time = 0) + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + std::size_t sqlhashid = std::hash{}(sqlstring); + temp_cache.save(sqlhashid, B_BASE::record, exp_time); + return true; + } + + bool save_cache(std::size_t cache_key_name, typename B_BASE::meta &cache_data, int exp_time = 0) + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + temp_cache.save(cache_key_name, cache_data, exp_time); + return true; + } + + bool save_cache(std::size_t cache_key_name, std::vector &cache_data, int exp_time = 0) + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + temp_cache.save(cache_key_name, cache_data, exp_time); + return true; + } + bool get_cacherecord(std::size_t cache_key_name) + { + model_meta_cache &temp_cache = model_meta_cache::getinstance(); + B_BASE::record = temp_cache.get(cache_key_name); + if (B_BASE::record.size() == 0) + { + return false; + } + else + { + B_BASE::data = B_BASE::record[0]; + return true; + } + } + http::OBJ_VALUE fetch_json() + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + sqlstring.append(" 1 "); + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + http::OBJ_VALUE valuetemp; + valuetemp.set_array(); + + if (iserror) + { + return valuetemp; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + for (; is_sql_item == false;) + { + n = conn->read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + http::OBJ_VALUE json_temp_v; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + std::string temp_str; + temp_str.resize(name_length); + std::memcpy(temp_str.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length); + if(field_array[ij].name.size()>0) + { + //or alias name + json_temp_v[field_array[ij].name]=std::move(temp_str); + } + else if(field_array[ij].org_name.size()>0) + { + json_temp_v[field_array[ij].org_name]=std::move(temp_str); + } + tempnum = tempnum + name_length; + } + valuetemp.push(json_temp_v); + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + conn_obj->back_select_conn(conn); + + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + return valuetemp; + } + + asio::awaitable async_fetch_json() + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + sqlstring.append(" 1 "); + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + http::OBJ_VALUE valuetemp; + valuetemp.set_array(); + + if (iserror) + { + co_return valuetemp; + } + + try + { + if (conn_empty()) + { + co_return valuetemp; + } + auto conn = co_await conn_obj->async_get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + conn->send_data.clear(); + + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + for (; is_sql_item == false;) + { + n = co_await conn->async_read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + http::OBJ_VALUE json_temp_v; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + std::string temp_str; + temp_str.resize(name_length); + std::memcpy(temp_str.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length); + if(field_array[ij].name.size()>0) + { + //or alias name + json_temp_v[field_array[ij].name]=std::move(temp_str); + } + else if(field_array[ij].org_name.size()>0) + { + json_temp_v[field_array[ij].org_name]=std::move(temp_str); + } + tempnum = tempnum + name_length; + } + valuetemp.push(json_temp_v); + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + conn_obj->back_select_conn(conn); + + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + co_return valuetemp; + } + + long long get_one(long long id) + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + sqlstring.append(B_BASE::getPKname()); + sqlstring.append("="); + sqlstring.append(std::to_string(id)); + sqlstring.append(" limit 1"); + if (iscache) + { + std::size_t sqlhashid = std::hash{}(sqlstring); + if (get_cacherecord(sqlhashid)) + { + iscache = false; + return 0; + } + } + + B_BASE::data_reset(); + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + std::vector field_pos; + + for (; is_sql_item == false;) + { + n = conn->read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, B_BASE::data); + tempnum = tempnum + name_length; + } + + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + conn_obj->back_select_conn(conn); + + if (iscache) + { + if (exptime > 0) + { + save_cache(exptime); + exptime = 0; + iscache = false; + } + } + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + return 0; + } + + asio::awaitable async_get_one(long long id) + { + effect_num = 0; + if (selectsql.empty()) + { + sqlstring = "SELECT * FROM "; + } + else + { + sqlstring = "SELECT "; + sqlstring.append(selectsql); + sqlstring.append(" FROM "); + } + + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + sqlstring.append(B_BASE::getPKname()); + sqlstring.append("="); + sqlstring.append(std::to_string(id)); + sqlstring.append(" limit 1"); + if (iscache) + { + std::size_t sqlhashid = std::hash{}(sqlstring); + if (get_cacherecord(sqlhashid)) + { + iscache = false; + co_return 0; + } + } + + B_BASE::data_reset(); + + if (iserror) + { + co_return 0; + } + + try + { + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_select_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + std::vector field_pos; + + for (; is_sql_item == false;) + { + n = co_await conn->async_read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + + assign_field_value(field_pos[ij], (unsigned char *)&temp_pack_data.data[tempnum], name_length, B_BASE::data); + tempnum = tempnum + name_length; + } + + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + conn_obj->back_select_conn(conn); + + if (iscache) + { + if (exptime > 0) + { + save_cache(exptime); + exptime = 0; + iscache = false; + } + } + co_return effect_num; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + co_return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + co_return 0; + } + + int update() + { + effect_num = 0; + if (wheresql.empty()) + { + if (B_BASE::getPK() > 0) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + wheresql = tempsql.str(); + } + else + { + return 0; + } + } + sqlstring = B_BASE::_makeupdatesql(""); + sqlstring.append(" where "); + if (wheresql.empty()) + { + return 0; + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + return effect_num; + } + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + return 0; + } + int update(const std::string &fieldname) + { + effect_num = 0; + if (wheresql.empty()) + { + if (B_BASE::getPK() > 0) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + wheresql = tempsql.str(); + } + else + { + error_msg = "warning empty where sql!"; + return 0; + } + } + + sqlstring = B_BASE::_makeupdatesql(fieldname); + sqlstring.append(" where "); + if (wheresql.empty()) + { + return 0; + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + return effect_num; + } + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + return 0; + } + + asio::awaitable async_update(const std::string &fieldname) + { + effect_num = 0; + if (wheresql.empty()) + { + if (B_BASE::getPK() > 0) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + wheresql = tempsql.str(); + } + else + { + error_msg = "warning empty where sql!"; + co_return 0; + } + } + + sqlstring = B_BASE::_makeupdatesql(fieldname); + sqlstring.append(" where "); + if (wheresql.empty()) + { + co_return 0; + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscommit) + { + iscommit = false; + co_return 0; + } + + if (iserror) + { + co_return 0; + } + try + { + + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + unsigned int offset = 0; + n = co_await conn->async_read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + iserror = true; + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + + co_return effect_num; + } + co_return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + co_return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + co_return 0; + } + asio::awaitable async_update() + { + effect_num = 0; + if (wheresql.empty()) + { + if (B_BASE::getPK() > 0) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + wheresql = tempsql.str(); + } + else + { + error_msg = "warning empty where sql!"; + co_return 0; + } + } + + sqlstring = B_BASE::_makeupdatesql(""); + sqlstring.append(" where "); + if (wheresql.empty()) + { + co_return 0; + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscommit) + { + iscommit = false; + co_return 0; + } + + if (iserror) + { + co_return 0; + } + try + { + + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + unsigned int offset = 0; + n = co_await conn->async_read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + iserror = true; + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + + co_return effect_num; + } + co_return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + co_return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + co_return 0; + } + + int update_batch(const std::string &fieldname) + { + effect_num = 0; + if (B_BASE::record.size() == 0) + { + return 0; + } + if (fieldname.size() > 0) + { + sqlstring = B_BASE::_make_insert_into_sql(fieldname); + } + else + { + sqlstring = B_BASE::_make_replace_into_sql(); + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + return effect_num; + } + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + return 0; + } + int remove() + { + effect_num = 0; + if (wheresql.empty()) + { + if (B_BASE::getPK() > 0) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + wheresql = tempsql.str(); + } + else + { + return 0; + } + } + + sqlstring = "DELETE FROM "; + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + return 0; + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + return effect_num; + } + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + return 0; + } + + asio::awaitable async_remove() + { + effect_num = 0; + if (wheresql.empty()) + { + if (B_BASE::getPK() > 0) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + wheresql = tempsql.str(); + } + else + { + co_return 0; + } + } + + sqlstring = "DELETE FROM "; + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + if (wheresql.empty()) + { + co_return 0; + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscommit) + { + iscommit = false; + co_return 0; + } + + if (iserror) + { + co_return 0; + } + + try + { + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + unsigned int offset = 0; + n = co_await conn->async_read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + co_return effect_num; + } + co_return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + co_return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + co_return 0; + } + + int remove(long long id) + { + effect_num = 0; + sqlstring = "DELETE FROM "; + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + sqlstring.append(B_BASE::getPKname()); + sqlstring.append("="); + sqlstring.append(std::to_string(id)); + + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + return effect_num; + } + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + return 0; + } + + asio::awaitable async_remove(long long id) + { + effect_num = 0; + sqlstring = "DELETE FROM "; + sqlstring.append(B_BASE::tablename); + sqlstring.append(" WHERE "); + + sqlstring.append(B_BASE::getPKname()); + sqlstring.append("="); + sqlstring.append(std::to_string(id)); + + if (iscommit) + { + iscommit = false; + co_return 0; + } + + if (iserror) + { + co_return 0; + } + + try + { + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + unsigned int offset = 0; + n = co_await conn->async_read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + co_return effect_num; + } + co_return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + co_return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + co_return 0; + } + + int soft_remove(const std::string &fieldsql) + { + effect_num = 0; + if (wheresql.empty()) + { + if (B_BASE::getPK() > 0) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + wheresql = tempsql.str(); + } + else + { + return 0; + } + } + + sqlstring = B_BASE::soft_remove_sql(fieldsql); + if (sqlstring.empty()) + { + error_msg = "soft delete field empty."; + return 0; + } + sqlstring.append(" where "); + if (wheresql.empty()) + { + return 0; + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + return effect_num; + } + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + return 0; + } + int soft_remove() + { + effect_num = 0; + if (wheresql.empty()) + { + if (B_BASE::getPK() > 0) + { + std::ostringstream tempsql; + effect_num = 1; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + wheresql = tempsql.str(); + } + else + { + return 0; + } + } + if (effect_num == 1) + { + sqlstring = B_BASE::soft_remove_sql(" "); + } + else + { + sqlstring = B_BASE::soft_remove_sql(""); + } + effect_num = 0; + if (sqlstring.empty()) + { + error_msg = "soft delete field empty."; + return 0; + } + sqlstring.append(" where "); + if (wheresql.empty()) + { + return 0; + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + return effect_num; + } + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + + } + return 0; + } + long long insert(typename B_BASE::meta &insert_data) + { + effect_num = 0; + sqlstring = B_BASE::_makerecordinsertsql(insert_data); + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + long long insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + + return insert_last_id; + } + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + return 0; + } + + asio::awaitable async_insert(typename B_BASE::meta &insert_data) + { + effect_num = 0; + sqlstring = B_BASE::_makerecordinsertsql(insert_data); + if (iscommit) + { + iscommit = false; + co_return 0; + } + + if (iserror) + { + co_return 0; + } + + try + { + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + unsigned int offset = 0; + n = co_await conn->async_read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + long long insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + + co_return insert_last_id; + } + co_return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + co_return 0; + } + + long long insert(std::vector &insert_data) + { + effect_num = 0; + sqlstring = B_BASE::_makerecordinsertsql(insert_data); + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + long long insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + + return insert_last_id; + } + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + return 0; + } + + asio::awaitable async_insert(std::vector &insert_data) + { + effect_num = 0; + sqlstring = B_BASE::_makerecordinsertsql(insert_data); + if (iscommit) + { + iscommit = false; + co_return 0; + } + + if (iserror) + { + co_return 0; + } + + try + { + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + unsigned int offset = 0; + n = co_await conn->async_read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + long long insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + + co_return insert_last_id; + } + co_return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + co_return 0; + } + + long long insert() + { + effect_num = 0; + sqlstring = B_BASE::_makeinsertsql(); + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + + try + { + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + long long insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + + return insert_last_id; + } + return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + return 0; + } + + asio::awaitable async_insert() + { + effect_num = 0; + sqlstring = B_BASE::_makeinsertsql(); + if (iscommit) + { + iscommit = false; + co_return 0; + } + + if (iserror) + { + co_return 0; + } + + try + { + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + unsigned int offset = 0; + n = co_await conn->async_read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + long long insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + + co_return insert_last_id; + } + co_return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + co_return 0; + } + + + long long save(bool isrealnew = false) + { + effect_num = 0; + if (B_BASE::getPK() > 0 && isrealnew == false) + { + if (wheresql.empty()) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + wheresql = tempsql.str(); + } + sqlstring = B_BASE::_makeupdatesql(""); + sqlstring.append(" where "); + if (wheresql.empty()) + { + return 0; + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + if (iscommit) + { + iscommit = false; + return 0; + } + + if (iserror) + { + return 0; + } + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + return effect_num; + } + return 0; + } + else + { + sqlstring = B_BASE::_makeinsertsql(); + if (conn_empty()) + { + return 0; + } + auto conn = conn_obj->get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return 0; + } + + unsigned int offset = 0; + n = conn->read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + long long insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + + return insert_last_id; + } + return 0; + } + return 0; + } + + asio::awaitable async_save(bool isrealnew = false) + { + effect_num = 0; + if (B_BASE::getPK() > 0 && isrealnew == false) + { + if (wheresql.empty()) + { + std::ostringstream tempsql; + tempsql << " "; + tempsql << B_BASE::getPKname(); + tempsql << " = '"; + tempsql << B_BASE::getPK(); + tempsql << "' "; + wheresql = tempsql.str(); + } + sqlstring = B_BASE::_makeupdatesql(""); + sqlstring.append(" where "); + if (wheresql.empty()) + { + co_return 0; + } + else + { + sqlstring.append(wheresql); + } + if (!groupsql.empty()) + { + sqlstring.append(groupsql); + } + if (!ordersql.empty()) + { + sqlstring.append(ordersql); + } + if (!limitsql.empty()) + { + sqlstring.append(limitsql); + } + if (iscommit) + { + iscommit = false; + co_return 0; + } + + if (iserror) + { + co_return 0; + } + + try + { + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + unsigned int offset = 0; + n = co_await conn->async_read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + iserror = true; + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + + co_return effect_num; + } + co_return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + co_return 0; + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + co_return 0; + } + co_return 0; + } + else + { + sqlstring = B_BASE::_makeinsertsql(); + try + { + if (conn_empty()) + { + co_return 0; + } + auto conn = co_await conn_obj->async_get_edit_conn(); + + unsigned int querysql_len = sqlstring.length() + 1; + + conn->send_data.clear(); + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(sqlstring); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + unsigned int offset = 0; + n = co_await conn->async_read_loop(); + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + + conn_obj->back_edit_conn(conn); + + if ((unsigned char)temp_pack_data.data[0] == 0xFF) + { + error_msg = temp_pack_data.data.substr(3); + } + else if ((unsigned char)temp_pack_data.data[0] == 0x00) + { + + unsigned int d_offset = 1; + effect_num = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + long long insert_last_id= conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], d_offset); + + co_return insert_last_id; + } + co_return 0; + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + co_return 0; + } + co_return 0; + } + + std::tuple, std::map, std::vector>> + query(const std::string &rawsql) + { + + std::vector> temprecord; + std::vector table_fieldname; + std::map table_fieldmap; + + if(rawsql.size()>10) + { + unsigned int i=0; + for(;iget_select_conn(); + + unsigned int querysql_len = rawsql.length() + 1; + + conn->send_data.clear(); + + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(rawsql); + + std::size_t n = asio::write(*conn->socket, asio::buffer(conn->send_data), conn->ec); + + if(conn->ec) + { + error_msg = conn->ec.message(); + iserror = true; + return std::make_tuple(table_fieldname, table_fieldmap, temprecord); + } + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + std::vector field_pos; + + for (; is_sql_item == false;) + { + n = conn->read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + table_fieldmap.insert({field_array[ii].org_name,table_fieldname.size()}); + table_fieldname.push_back(field_array[ii].org_name); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + std::vector temp_v_record; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + std::string tempstr; + tempstr.resize(name_length); + std::memcpy(tempstr.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length); + temp_v_record.push_back(std::move(tempstr)); + tempnum = tempnum + name_length; + } + temprecord.push_back(temp_v_record); + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + conn_obj->back_select_conn(conn); + + return std::make_tuple(std::move(table_fieldname), std::move(table_fieldmap), std::move(temprecord)); + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + return std::make_tuple(table_fieldname, table_fieldmap, temprecord); + } + + asio::awaitable, std::map, std::vector>>> + async_query(const std::string &rawsql) + { + + std::vector> temprecord; + std::vector table_fieldname; + std::map table_fieldmap; + + if(rawsql.size()>10) + { + unsigned int i=0; + for(;iasync_get_select_conn(); + + unsigned int querysql_len = rawsql.length() + 1; + + conn->send_data.clear(); + + conn->send_data.push_back((querysql_len & 0xFF)); + conn->send_data.push_back((querysql_len >> 8 & 0xFF)); + conn->send_data.push_back((querysql_len >> 16 & 0xFF)); + conn->send_data.push_back(0x00); + conn->send_data.push_back(0x03); + conn->send_data.append(rawsql); + + std::size_t n = co_await asio::async_write(*conn->socket, asio::buffer(conn->send_data), asio::use_awaitable); + + + pack_info_t temp_pack_data; + temp_pack_data.seq_id = 1; + bool is_sql_item = false; + std::vector field_array; + + unsigned char action_setup = 0; + unsigned int column_num = 0; + + unsigned int offset = 0; + + std::vector field_pos; + + for (; is_sql_item == false;) + { + n = co_await conn->async_read_loop(); + offset = 0; + for (; offset < n;) + { + conn->read_field_pack(conn->_cache_data, n, offset, temp_pack_data); + if (temp_pack_data.length == temp_pack_data.current_length) + { + if (conn->pack_eof_check(temp_pack_data)) + { + is_sql_item = true; + break; + } + + if (action_setup == 0) + { + if (temp_pack_data.length == 2 && (unsigned char)temp_pack_data.data[0] < 251 && (unsigned char)temp_pack_data.data[0] > 0) + { + action_setup = 1; + column_num = (unsigned char)temp_pack_data.data[0]; + } + } + else if (action_setup == 1) + { + field_info_t temp_filed_col; + conn->read_col_info(temp_pack_data.data, temp_filed_col); + + field_array.emplace_back(std::move(temp_filed_col)); + column_num--; + if (column_num == 0) + { + action_setup = 2; + for (unsigned int ii = 0; ii < field_array.size(); ii++) + { + field_pos.push_back(B_BASE::findcolpos(field_array[ii].org_name)); + table_fieldmap.insert({field_array[ii].org_name,table_fieldname.size()}); + table_fieldname.push_back(field_array[ii].org_name); + } + } + } + else if (action_setup == 2) + { + unsigned int column_num = field_array.size(); + unsigned int tempnum = 0; + + std::vector temp_v_record; + for (unsigned int ij = 0; ij < column_num; ij++) + { + unsigned long long name_length = 0; + name_length = conn->pack_real_num((unsigned char *)&temp_pack_data.data[0], tempnum); + std::string tempstr; + tempstr.resize(name_length); + std::memcpy(tempstr.data(), (unsigned char *)&temp_pack_data.data[tempnum], name_length); + temp_v_record.push_back(std::move(tempstr)); + tempnum = tempnum + name_length; + } + temprecord.push_back(temp_v_record); + effect_num++; + } + } + else + { + if (offset >= n) + { + break; + } + is_sql_item = true; + break; + } + } + } + conn_obj->back_select_conn(conn); + + co_return std::make_tuple(std::move(table_fieldname), std::move(table_fieldmap), std::move(temprecord)); + } + catch (const std::exception &e) + { + error_msg = std::string(e.what()); + } + catch (const std::string &e) + { + error_msg = e; + } + catch (...) + { + } + co_return std::make_tuple(table_fieldname, table_fieldmap, temprecord); + } + + // long long edit_query(const std::string &rawsql, bool isinsert = false) + // { + // if (iserror) + // { + // return 0; + // } + + // return 0; + // } + M_MODEL &clear(bool both = true) + { + selectsql.clear(); + wheresql.clear(); + ordersql.clear(); + groupsql.clear(); + limitsql.clear(); + sqlstring.clear(); + error_msg.clear(); + iskuohao = false; + ishascontent = false; + iscommit = false; + iscache = false; + effect_num = 0; + if (both) + { + B_BASE::record_reset(); + B_BASE::data_reset(); + } + return *mod; + } + M_MODEL &clearWhere() + { + selectsql.clear(); + wheresql.clear(); + ordersql.clear(); + groupsql.clear(); + limitsql.clear(); + sqlstring.clear(); + error_msg.clear(); + iskuohao = false; + ishascontent = false; + iscommit = false; + iscache = false; + effect_num = 0; + return *mod; + } + M_MODEL &set_data(typename B_BASE::meta indata) + { + B_BASE::data = indata; + return *mod; + } + M_MODEL &get() { return *mod; } + std::string get_query() { return sqlstring; } + M_MODEL &start_commit() + { + iscommit = true; + return *mod; + } + M_MODEL &end_commit() + { + iscommit = false; + return *mod; + } + + unsigned int effect() + { + return effect_num; + } + bool conn_empty() + { + if (conn_obj) + { + return false; + } + error_msg = "conn_obj is null"; + iserror = true; + return true; + } + + public: + std::string selectsql; + std::string wheresql; + std::string ordersql; + std::string groupsql; + std::string limitsql; + std::string sqlstring; + std::string dbtag; + std::string error_msg; + std::string original_tablename; + + // std::list commit_sqllist; + bool iskuohao = false; + bool iscommit = false; + bool ishascontent = false; + bool iscache = false; + bool iserror = false; + int exptime = 0; + unsigned int effect_num = 0; + + M_MODEL *mod; + + std::shared_ptr conn_obj; + }; +//} /*tagnamespace_replace*/ +}// namespace orm +#endif \ No newline at end of file diff --git a/frameworks/C++/paozhu/paozhu_benchmark/orm/include/fortunebase.h b/frameworks/C++/paozhu/paozhu_benchmark/orm/include/fortunebase.h old mode 100755 new mode 100644 index 544034baf9d..6576c16d41e --- a/frameworks/C++/paozhu/paozhu_benchmark/orm/include/fortunebase.h +++ b/frameworks/C++/paozhu/paozhu_benchmark/orm/include/fortunebase.h @@ -1,400 +1,313 @@ #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 - ***/ +*This file is auto create from cli +*本文件为自动生成 Sun, 02 Mar 2025 08:24:41 GMT +***/ #include #include #include #include -#include -#include -#include +#include +#include +#include #include #include #include +#include "unicode.h" -namespace orm -{ - +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}; - - 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(); } - - void assign_field_value(unsigned char index_pos, unsigned char *result_temp_data, unsigned int value_size, meta &data_temp) - { - /* - unsigned int id = 0; // - std::string message = "";// - */ - //bool is_minus = false; - switch (index_pos) - { - case 0: - data_temp.id = 0; - for (size_t i = 0; i < value_size; i++) - { - if (result_temp_data[i] >= '0' && result_temp_data[i] <= '9') - { - data_temp.id = data_temp.id * 10 + (result_temp_data[i] - '0'); - } - } - break; - case 1: - - data_temp.message.clear(); - data_temp.message.resize(value_size); - for (size_t i = 0; i < value_size; i++) - { - data_temp.message[i] = result_temp_data[i]; - } - break; - default: - break; - } - } - - std::string getPKname() - { - return "id"; - } - - void record_reset() - { - record.clear(); - } - void data_reset() - { - fortunebase::meta metatemp; - data = metatemp; - } - - std::string soft_remove_sql([[maybe_unused]] const std::string &fieldsql) - { - std::string temp; - - return temp; - } - - inline std::string stringaddslash(std::string &content) - { + 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 . +unsigned int _offset=0; +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(); } +static constexpr std::array col_names={"id","message"}; +static constexpr std::array col_types={3,253}; +static constexpr std::array col_length={0,0}; +static constexpr std::array col_decimals={0,0}; +std::string tablename="fortune"; +static constexpr std::string_view modelname="Fortune"; + + unsigned char findcolpos(const std::string &coln){ + if(coln.size()==0) + { + return 255; + } + unsigned char bi=coln[0]; + + + if(bi<91&&bi>64){ + bi+=32; + } + switch(coln[0]){ + + + case 'i': + return 0; +break; +case 'm': + return 1; +break; + + } + return 255; + } + + int size(){ return record.size(); } + + std::string getPKname(){ + return "id"; +} + + void record_reset() + { + record.clear(); + } + void data_reset(){ + fortunebase::meta metatemp; + data = metatemp; + } + + std::string soft_remove_sql([[maybe_unused]] const std::string &fieldsql){ + std::string temp; + + return temp; + } + + + inline std::string stringaddslash(const std::string &content){ std::string temp; - for (unsigned int i = 0; i < content.size(); i++) - { - if (content[i] == '\'') - { + for(unsigned int i=0;i 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; + tempsql<<"INSERT INTO "; + tempsql<0){ + tempsql<<"`,`"; + }else{ + tempsql<<"`"; + } + tempsql<0){ + tempsql<<"`"; + } + tempsql<<") VALUES ("; + + if(data.id==0){ +tempsql<<"null"; + }else{ + tempsql< 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 &insert_data) - { - unsigned int j = 0; + tempsql<<"INSERT INTO "; + 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 << tablename; - tempsql << " ("; - for (; j < colnames.size(); j++) - { - if (j > 0) - { - tempsql << "`,`"; - } - else - { - tempsql << "`"; - } - tempsql << colnames[j]; + tempsql<<"INSERT INTO "; + tempsql<0){ + tempsql<<"`,`"; + }else{ + tempsql<<"`"; + } + tempsql< 0) - { - tempsql << "`"; + if(j>0){ + tempsql<<"`"; } - tempsql << ") VALUES "; + tempsql<<") VALUES "; - for (unsigned int i = 0; i < insert_data.size(); i++) + for(unsigned int i=0;i 0) + if(i>0) { - tempsql << ","; + tempsql<<","; } - 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(); - } + if(insert_data[i].id==0){ + tempsql<<"null"; + }else{ + tempsql< keypos; - for (; jj < fileld.size(); jj++) - { - if (fileld[jj] == ',') - { - unsigned char bpos_i = findcolpos(keyname); - keypos.emplace_back(bpos_i); + tempsql<<"UPDATE "; + tempsql< keypos; + for(;jj 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]) - { + continue; + } + keyname.push_back(fileld[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) + } + if(keyname.size()>0){ + unsigned char bpos_i=findcolpos(keyname); + #ifdef DEBUG + if (bpos_i == 255) { - tempsql << ","; + std::cout << "\033[1m\033[31m-----------\n" + << keyname << " not in " << tablename << " table Field.\n-----------\033[0m" + << std::endl; } - tempsql << "`message`='" << stringaddslash(data.message) << "'"; - break; - - default:; - } - } - } +#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) { @@ -412,7 +325,7 @@ struct fortunebase { tempsql << "`"; } - tempsql << colnames[j]; + tempsql << col_names[j]; } if (j > 0) { @@ -427,19 +340,17 @@ struct fortunebase 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(); - } + if(record[i].id==0){ + tempsql<<"null"; + }else{ + tempsql< 0) { @@ -458,7 +369,7 @@ struct fortunebase { tempsql << "`"; } - tempsql << colnames[j]; + tempsql << col_names[j]; } if (j > 0) { @@ -473,2322 +384,2243 @@ struct fortunebase 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 "; - + if(record[i].id==0){ + tempsql<<"null"; + }else{ + tempsql< 0) - { - for (; jj < fileld.size(); jj++) - { - if (fileld[jj] == ',') + unsigned char jj=0; + j=0; + if(fileld.size()>0){ + for(;jj0) { - if (j > 0) - { - tempsql << ","; - } - tempsql << keyname; - tempsql << "=new."; - tempsql << keyname; + tempsql<<","; } - continue; - } - if (fileld[jj] == 0x20) - { - - continue; + tempsql< 0) + keyname.push_back(fileld[jj]); + + } + if(keyname.size()>0){ + if(findcolpos(keyname)<255) { - if (findcolpos(keyname) < 255) + if(j>0) { - if (j > 0) - { - tempsql << ","; - } - tempsql << keyname; - tempsql << "=new."; - tempsql << keyname; + tempsql<<","; } + tempsql< data_toarray(std::string fileld = "") - { + std::vector data_toarray(std::string fileld=""){ std::vector temparray; std::string keyname; - unsigned char jj = 0; + unsigned char jj=0; std::vector keypos; - if (fileld.size() > 1) - { - for (; jj < fileld.size(); jj++) - { - if (fileld[jj] == ',') - { - keypos.emplace_back(findcolpos(keyname)); + if(fileld.size()>1){ + for(;jj0){ + keypos.emplace_back(findcolpos(keyname)); + keyname.clear(); } - if (keyname.size() > 0) - { - keypos.emplace_back(findcolpos(keyname)); + }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_offset data_tomap(std::string fileld = "") - { - std::map tempsql; - std::string keyname; - unsigned char jj = 0; - std::vector 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 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 list_content; - for (; json_offset < json_content.size(); json_offset++) - { - if (json_content[json_offset] == '{') + if(json_content[json_offset]=='{') { break; } - if (json_content[json_offset] == '[') + if(json_content[json_offset]=='[') { - isarray = true; + isarray=true; break; } } - if (isarray) + if(isarray) { - json_offset += 1; - std::string json_key_name, json_value_name; - for (; json_offset < json_content.size(); json_offset++) + json_offset+=1; + std::string json_key_name,json_value_name; + for(;json_offset 0) + if(record.size()>0) { - data = metatemp; + data=metatemp; } - if (json_offset >= json_content.size()) + if(json_offset>=json_content.size()) { break; } - for (; json_offset < json_content.size(); json_offset++) + for(;json_offset= json_content.size()) - { - break; - } - json_value_name.clear(); - if (json_content[json_offset] == 0x22) + + if(json_content[json_offset]==0x20||json_content[json_offset]==0x0A||json_content[json_offset]==0x0D||json_content[json_offset]=='\t') { - - 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; - } + continue; } else { - if (json_content[json_offset] != '{' && json_content[json_offset] != ']') + if(json_content[json_offset]==0x22) { - for (; json_offset < json_content.size(); json_offset++) + 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()) + { + 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 1) + if(record.size()>1) { - data = record[0]; + data=record[0]; } } else { - if (json_content[json_offset] == '{') + if(json_content[json_offset]=='{') { - json_offset += 1; - std::string json_key_name, json_value_name; - - for (; json_offset < json_content.size(); json_offset++) + json_offset+=1; + std::string json_key_name,json_value_name; + + + for(;json_offset=json_content.size()) + { + break; } - 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_value_name.clear(); + if(json_content[json_offset]==0x22) { - json_offset += 1; + + 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] != ']') + else { - for (; json_offset < json_content.size(); json_offset++) + if(json_content[json_offset]!='{'&&json_content[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') + 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(); } - catch (...) - { - data.message.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; - void set_val(const std::string &set_key_name, const double set_value_name) - { - switch (findcolpos(set_key_name)) + } + } + + 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) { - 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 keypos; - if (fileld.size() > 0) - { - for (; jj < fileld.size(); jj++) + + unsigned char kpos; + kpos=findcolpos(keyname); + switch(kpos) { - if (fileld[jj] == ',') + 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) { - keypos.emplace_back(findcolpos(keyname)); - keyname.clear(); - continue; + + + } + + + 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) + { + } - if (fileld[jj] == 0x20) + + + + return 0.0; + } + + template::value,bool>::type = true > + std::string getVal(std::string keyname) + { + unsigned char kpos; + kpos=findcolpos(keyname); + + switch(kpos) { - continue; + case 1: + return data.message; + break; + } - 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++) + 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) { - if (n > 0) - { - tempsql << ",{"; - } - else + std::ostringstream a; + + unsigned char kpos; + kpos=findcolpos(keyname); + int j=0; + if(isyinhao&&record.size()>0) { - tempsql << "{"; + a<<'"'; } - - for (jj = 0; jj < keypos.size(); jj++) + for(auto &iter:record) { - switch (keypos[jj]) - { - case 0: - if (jj > 0) - { - tempsql << ","; - } - if (record[n].id == 0) - { - tempsql << "\"id\":0"; - } - else + if(j>0) { - tempsql << "\"id\":" << std::to_string(record[n].id); + if(isyinhao) + { + a<<"\",\""; + }else{ + a<<','; + } } - break; - case 1: - if (jj > 0) + switch(kpos) { - tempsql << ","; + + 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) + { - default:; - } - } - tempsql << "}"; - } - tempsql << "]"; - return tempsql.str(); - } + case 1: + ktemp=iter.message; + break; + } + switch(vpos){ + case 1: + vtemp=iter.message; + break; - std::string to_json(std::function func, std::string fileld = "") - { - std::ostringstream tempsql; - std::string keyname; - unsigned char jj = 0; - std::vector keypos; - if (fileld.size() > 0) - { - for (; jj < fileld.size(); jj++) - { - if (fileld[jj] == ',') + } + if(ktemp.size()>0) { - keypos.emplace_back(findcolpos(keyname)); - keyname.clear(); - continue; + a.emplace(ktemp,vtemp); } - if (fileld[jj] == 0x20) + } + + + 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){ - 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) + if(ktemp.size()>0) { - tempsql << ",{"; + a.emplace(ktemp,vtemp); } - else + } + + 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) { - tempsql << "{"; - } - tempsql << keyname; - } - else - { - continue; - } + switch(kpos) + { - for (jj = 0; jj < keypos.size(); jj++) - { + case 0: + ktemp=iter.id; + break; + } + switch(vpos){ + case 1: + vtemp=iter.message; + break; - 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) + if(ktemp.size()>0) { - tempsql << ","; + a.emplace(ktemp,vtemp); } - 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 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; - } + } + + 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) + { - template , bool>::type = true> - std::vector getCol([[maybe_unused]] std::string keyname) - { - std::vector a; + 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> - 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) - { + } + + 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) + { - unsigned char kpos; - kpos = findcolpos(keyname); - switch (kpos) - { - case 0: - return iter.id; - break; - } + case 0: + ktemp=iter.id; + break; + } + switch(vpos){ + case 0: + vtemp=iter.id; + break; - return 0; - } + } + 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) + { - template , bool>::type = true> - T getVal(std::string keyname) - { - unsigned char kpos; - kpos = findcolpos(keyname); + case 0: + a.emplace(iter.id,iter); + break; - switch (kpos) - { - } + } + } + + 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) + { - return 0.0; - } + case 1: + a.emplace(iter.message,iter); + break; - template , bool>::type = true> - T getVal([[maybe_unused]] fortunebase::meta &iter, std::string keyname) - { - unsigned char kpos; - kpos = findcolpos(keyname); - switch (kpos) - { - } + } + //a.emplace(ktemp,iter); + } + - return 0.0; + return a; } - - template ::value, bool>::type = true> - std::string getVal(std::string keyname) - { - unsigned char kpos; - kpos = findcolpos(keyname); - - switch (kpos) + + 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: - 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); + 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) + { - switch (kpos) - { + case 0: + ktemp=iter.id; + break; + } + switch(vpos){ - case 1: - return iter.message; - break; - } + } - return ""; - } + a.emplace_back(ktemp,vtemp); + } - 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) + 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) { - 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; + std::vector> 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 + + unsigned char kpos,vpos; + kpos=findcolpos(keyname); + vpos=findcolpos(valname); + T ktemp; + U vtemp; + for(auto &iter:record) { - a << ','; - } - } - switch (kpos) - { + switch(kpos) + { - case 0: - a << std::to_string(iter.id); - break; - case 1: - if (isyinhao) - { - a << jsonaddslash(iter.message); - } - else + 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) { - a << iter.message; - } - break; - } - j++; - } - if (isyinhao && j > 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) - { + + switch(kpos) + { - case 1: - ktemp = iter.message; - break; - } - switch (vpos) - { - case 1: - vtemp = iter.message; - break; - } - if (ktemp.size() > 0) - { - a.emplace(ktemp, vtemp); - } - } + 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) + { - return a; - } + 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) + { - 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; + 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) + { - 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; + case 0: + a.emplace_back(iter.id,iter); + break; - for (auto &iter : record) + } + } + + return a; + } + template::value,bool>::type = true > + std::vector> getvecRows([[maybe_unused]] std::string keyname) { - - switch (kpos) + std::vector> a; + + unsigned char kpos; + kpos=findcolpos(keyname); + for(auto &iter:record) { + switch(kpos) + { - case 1: - ktemp = iter.message; - break; - } - - switch (vpos) - { - case 0: - vtemp = iter.id; - break; - } + case 1: + a.emplace_back(iter.message,iter); + break; - switch (dpos) - { - case 1: - a[ktemp][vtemp].emplace_back(iter.message); - 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) + { - 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; + case 0: + ktemp=iter.id; + break; + } - unsigned char kpos, vpos, dpos; - kpos = findcolpos(keyname); - vpos = findcolpos(valname); - dpos = findcolpos(dataname); - T ktemp; - U vtemp; - // D dtemp; + switch(vpos){ + case 0: + vtemp=iter.id; + break; + } + + switch(dpos){ + + } + } - for (auto &iter : record) + + 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) { - switch (kpos) + 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; - } + case 0: + ktemp=iter.id; + break; + } - switch (vpos) - { - case 1: - vtemp = iter.message; - break; - } + switch(vpos){ + case 0: + vtemp=iter.id; + break; + } - switch (dpos) - { - } - } + 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, 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,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) + { - unsigned char kpos, vpos, dpos; - kpos = findcolpos(keyname); - vpos = findcolpos(valname); - dpos = findcolpos(dataname); - T ktemp; - U vtemp; - // D dtemp; + case 0: + ktemp=iter.id; + break; + } - for (auto &iter : record) - { + switch(vpos){ + case 0: + vtemp=iter.id; + break; + } - switch (kpos) - { + switch(dpos){ + case 1: + a[ktemp][vtemp].emplace_back(iter.message); + break; - case 1: - ktemp = 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) + { - switch (vpos) - { - case 1: - vtemp = iter.message; - break; - } + case 0: + ktemp=iter.id; + break; + } - switch (dpos) - { - case 0: - a[ktemp][vtemp].emplace_back(iter.id); - break; - } - } + switch(vpos){ + case 1: + vtemp=iter.message; + break; + } - return a; - } + switch(dpos){ - 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) + } + } + + 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; + std::map>> a; - unsigned char kpos, vpos, dpos; - kpos = findcolpos(keyname); - vpos = findcolpos(valname); - dpos = findcolpos(dataname); + + unsigned char kpos,vpos,dpos; + kpos=findcolpos(keyname); + vpos=findcolpos(valname); + dpos=findcolpos(dataname); T ktemp; U vtemp; - // D dtemp; + // D dtemp; - for (auto &iter : record) - { - switch (kpos) + for(auto &iter:record) + { + switch(kpos) { - case 1: - ktemp = iter.message; - break; - } + case 0: + ktemp=iter.id; + break; + } - switch (vpos) - { - case 1: - vtemp = iter.message; - break; - } + switch(vpos){ + case 1: + vtemp=iter.message; + break; + } - switch (dpos) - { - case 1: - a[ktemp][vtemp].emplace_back(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) + { - 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; + case 0: + ktemp=iter.id; + break; + } - unsigned char kpos, vpos; - kpos = findcolpos(keyname); - vpos = findcolpos(valname); - T ktemp; - //U vtemp; + switch(vpos){ + case 1: + vtemp=iter.message; + break; + } - for (auto &iter : record) - { - switch (kpos) - { + switch(dpos){ + case 1: + a[ktemp][vtemp].emplace_back(iter.message); + break; - case 1: - ktemp = 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) + { - switch (vpos) - { - case 1: - a[ktemp].emplace_back(iter.message); - break; - } - } + case 1: + ktemp=iter.message; + break; + } - return a; - } + switch(vpos){ + case 0: + vtemp=iter.id; + break; + } - 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; + switch(dpos){ - unsigned char kpos, vpos; - kpos = findcolpos(keyname); - vpos = findcolpos(valname); - T ktemp; - //U vtemp; + } + } + - for (auto &iter : record) + 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) { - switch (kpos) + 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; - } + case 1: + ktemp=iter.message; + break; + } - switch (vpos) - { - } - } + switch(vpos){ + case 0: + vtemp=iter.id; + break; + } - return a; - } + switch(dpos){ + case 0: + a[ktemp][vtemp].emplace_back(iter.id); + break; - 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) + } + } + + 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; + std::map>> a; - unsigned char kpos, vpos; - kpos = findcolpos(keyname); - vpos = findcolpos(valname); + + 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 1: - ktemp = iter.message; - break; - } + U vtemp; + // D dtemp; - switch (vpos) + for(auto &iter:record) + { + + switch(kpos) { - case 0: - a[ktemp].emplace_back(iter.id); - break; - } - } - return a; - } + case 1: + ktemp=iter.message; + break; + } - 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; + switch(vpos){ + case 0: + vtemp=iter.id; + break; + } - unsigned char kpos, vpos; - kpos = findcolpos(keyname); - vpos = findcolpos(valname); - T ktemp; - //U vtemp; + switch(dpos){ + case 1: + a[ktemp][vtemp].emplace_back(iter.message); + break; - for (auto &iter : record) + } + } + + 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; - switch (kpos) + for(auto &iter:record) { + switch(kpos) + { - case 0: - ktemp = iter.id; - break; - } - - switch (vpos) - { - case 1: - a[ktemp].emplace_back(iter.message); - break; - } - } + case 1: + ktemp=iter.message; + break; + } - return a; - } + switch(vpos){ + case 1: + vtemp=iter.message; + break; + } - 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; + switch(dpos){ - unsigned char kpos, vpos; - kpos = findcolpos(keyname); - vpos = findcolpos(valname); - T ktemp; - //U vtemp; + } + } - for (auto &iter : record) + + 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; - switch (kpos) + for(auto &iter:record) { + + switch(kpos) + { - case 0: - ktemp = iter.id; - break; - } - - switch (vpos) - { - } - } + case 1: + ktemp=iter.message; + break; + } - return a; - } + switch(vpos){ + case 1: + vtemp=iter.message; + break; + } - 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; + switch(dpos){ + case 0: + a[ktemp][vtemp].emplace_back(iter.id); + break; - unsigned char kpos, vpos; - kpos = findcolpos(keyname); - vpos = findcolpos(valname); - T ktemp; - //U vtemp; + } + } + + 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) + { - for (auto &iter : record) - { + case 1: + ktemp=iter.message; + break; + } - switch (kpos) - { + switch(vpos){ + case 1: + vtemp=iter.message; + break; + } - case 0: - ktemp = iter.id; - break; - } + switch(dpos){ + case 1: + a[ktemp][vtemp].emplace_back(iter.message); + break; - switch (vpos) - { - case 0: - a[ktemp].emplace_back(iter.id); - 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; - return a; - } + + unsigned char kpos,vpos; + kpos=findcolpos(keyname); + vpos=findcolpos(valname); + T ktemp; + //U vtemp; - template , bool>::type = true> - std::map> getgroupRows([[maybe_unused]] std::string keyname) - { - std::map> a; + for(auto &iter:record) + { + switch(kpos) + { - unsigned char kpos; - kpos = findcolpos(keyname); + case 1: + ktemp=iter.message; + break; + } - for (auto &iter : record) - { - switch (kpos) - { + switch(vpos){ + case 1: + a[ktemp].emplace_back(iter.message); + break; - case 0: - a[iter.id].emplace_back(iter); - 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; - return a; - } + for(auto &iter:record) + { + switch(kpos) + { - template ::value, bool>::type = true> - std::map> getgroupRows([[maybe_unused]] std::string keyname) - { - std::map> a; + case 1: + ktemp=iter.message; + break; + } + + switch(vpos){ - unsigned char kpos; - kpos = findcolpos(keyname); + } + } - for (auto &iter : record) + + 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; - switch (kpos) + for(auto &iter:record) { + + switch(kpos) + { - case 1: - a[iter.message].emplace_back(iter); - break; - } - } + case 1: + ktemp=iter.message; + break; + } - return a; - } + switch(vpos){ + case 0: + a[ktemp].emplace_back(iter.id); + break; - 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,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) + { - unsigned char kpos, vpos; - kpos = findcolpos(keyname); - vpos = findcolpos(valname); - T ktemp; + case 0: + ktemp=iter.id; + break; + } + + switch(vpos){ + case 1: + a[ktemp].emplace_back(iter.message); + break; + + } + } - for (auto &iter : record) + + 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; - switch (kpos) + for(auto &iter:record) { + + switch(kpos) + { - case 1: - ktemp = iter.message; - break; - } + case 0: + ktemp=iter.id; + break; + } - switch (vpos) - { - case 1: - a[ktemp][iter.message].emplace_back(iter); - break; - } - } + switch(vpos){ - return a; - } + } + } + + 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) + { - 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; + case 0: + ktemp=iter.id; + break; + } - unsigned char kpos, vpos; - kpos = findcolpos(keyname); - vpos = findcolpos(valname); - T ktemp; + switch(vpos){ + case 0: + a[ktemp].emplace_back(iter.id); + break; - for (auto &iter : record) + } + } + + return a; + } + + template,bool>::type = true> + std::map> getgroupRows([[maybe_unused]] std::string keyname) { + std::map> a; + + unsigned char kpos; + kpos=findcolpos(keyname); - switch (kpos) + for(auto &iter:record) { + switch(kpos) + { - case 1: - ktemp = iter.message; - break; - } + case 0: + a[iter.id].emplace_back(iter); + break; - switch (vpos) - { - case 0: - a[ktemp][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); - 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; + for(auto &iter:record) + { + + switch(kpos) + { - unsigned char kpos, vpos; - kpos = findcolpos(keyname); - vpos = findcolpos(valname); - T ktemp; + case 1: + a[iter.message].emplace_back(iter); + break; - for (auto &iter : record) + } + } + + 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; - switch (kpos) + for(auto &iter:record) { + + switch(kpos) + { - case 0: - ktemp = iter.id; - break; - } + case 1: + ktemp=iter.message; + break; + } - switch (vpos) - { - case 0: - a[ktemp][iter.id].emplace_back(iter); - break; - } - } + switch(vpos){ + case 1: + a[ktemp][iter.message].emplace_back(iter); + break; - return 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) + { - 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; + case 1: + ktemp=iter.message; + break; + } - unsigned char kpos, vpos; - kpos = findcolpos(keyname); - vpos = findcolpos(valname); - T ktemp; + switch(vpos){ + case 0: + a[ktemp][iter.id].emplace_back(iter); + break; - for (auto &iter : record) - { + } + } - switch (kpos) + + 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 0: + ktemp=iter.id; + break; + } - switch (vpos) - { - case 1: - a[ktemp][iter.message].emplace_back(iter); - break; - } - } + switch(vpos){ + case 0: + a[ktemp][iter.id].emplace_back(iter); + break; - return a; - } -}; + } + } + + 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; + } + + }; + -}// namespace orm +} #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 old mode 100755 new mode 100644 index dc44d63a6a0..35cae19e40f --- a/frameworks/C++/paozhu/paozhu_benchmark/orm/include/worldbase.h +++ b/frameworks/C++/paozhu/paozhu_benchmark/orm/include/worldbase.h @@ -1,450 +1,333 @@ #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 - ***/ +*This file is auto create from cli +*本文件为自动生成 Sun, 02 Mar 2025 08:24:41 GMT +***/ #include #include #include #include -#include -#include -#include +#include +#include +#include #include #include #include +#include "unicode.h" -namespace orm -{ - +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}; - - 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(); } - - void assign_field_value(unsigned char index_pos, unsigned char *result_temp_data, unsigned int value_size, meta &data_temp) - { - /* - unsigned int id = 0;// - int randomnumber = 0;// - */ - bool is_minus = false; - switch (index_pos) - { - case 0: - data_temp.id = 0; - for (size_t i = 0; i < value_size; i++) - { - if (result_temp_data[i] >= '0' && result_temp_data[i] <= '9') - { - data_temp.id = data_temp.id * 10 + (result_temp_data[i] - '0'); - } - } - break; - case 1: - - data_temp.randomnumber = 0; - - is_minus = false; - if (value_size > 0) - { - if (result_temp_data[0] == '-') - { - is_minus = true; - } - } - for (std::size_t i = 0; i < value_size; i++) - { - if (result_temp_data[i] >= '0' && result_temp_data[i] <= '9') - { - data_temp.randomnumber = data_temp.randomnumber * 10 + (result_temp_data[i] - '0'); - } - } - if (is_minus) - { - data_temp.randomnumber = ~(data_temp.randomnumber - 1); - } - break; - default: - break; - } - } - - std::string getPKname() - { - return "id"; - } - - void record_reset() - { - record.clear(); - } - void data_reset() - { - worldbase::meta metatemp; - data = metatemp; - } - - std::string soft_remove_sql([[maybe_unused]] const std::string &fieldsql) - { - std::string temp; - - return temp; - } - - inline std::string stringaddslash(std::string &content) - { + 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 . +unsigned int _offset=0; +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(); } +static constexpr std::array col_names={"id","randomnumber"}; +static constexpr std::array col_types={3,3}; +static constexpr std::array col_length={0,0}; +static constexpr std::array col_decimals={0,0}; +std::string tablename="world"; +static constexpr std::string_view modelname="World"; + + unsigned char findcolpos(const std::string &coln){ + if(coln.size()==0) + { + return 255; + } + unsigned char bi=coln[0]; + + + if(bi<91&&bi>64){ + bi+=32; + } + switch(coln[0]){ + + + case 'i': + return 0; +break; +case 'r': + return 1; +break; + + } + return 255; + } + + int size(){ return record.size(); } + + std::string getPKname(){ + return "id"; +} + + void record_reset() + { + record.clear(); + } + void data_reset(){ + worldbase::meta metatemp; + data = metatemp; + } + + std::string soft_remove_sql([[maybe_unused]] const std::string &fieldsql){ + std::string temp; + + return temp; + } + + + inline std::string stringaddslash(const std::string &content){ std::string temp; - for (unsigned int i = 0; i < content.size(); i++) - { - if (content[i] == '\'') - { + for(unsigned int i=0;i 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; + tempsql<<"INSERT INTO "; + tempsql<0){ + tempsql<<"`,`"; + }else{ + tempsql<<"`"; + } + tempsql<0){ + tempsql<<"`"; + } + tempsql<<") VALUES ("; + + if(data.id==0){ +tempsql<<"null"; + }else{ + tempsql< 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 &insert_data) - { - unsigned int j = 0; + tempsql<<"INSERT INTO "; + 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 << tablename; - tempsql << " ("; - for (; j < colnames.size(); j++) - { - if (j > 0) - { - tempsql << "`,`"; - } - else - { - tempsql << "`"; - } - tempsql << colnames[j]; + tempsql<<"INSERT INTO "; + tempsql<0){ + tempsql<<"`,`"; + }else{ + tempsql<<"`"; + } + tempsql< 0) - { - tempsql << "`"; + if(j>0){ + tempsql<<"`"; } - tempsql << ") VALUES "; + tempsql<<") VALUES "; - for (unsigned int i = 0; i < insert_data.size(); i++) + for(unsigned int i=0;i 0) + if(i>0) { - tempsql << ","; + tempsql<<","; } - 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(); - } + 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; jj < keypos.size(); jj++) - { - switch (keypos[jj]) - { + continue; + } + keyname.push_back(fileld[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 + } + if(keyname.size()>0){ + unsigned char bpos_i=findcolpos(keyname); + #ifdef DEBUG + if (bpos_i == 255) { - tempsql << "`randomnumber`=" << std::to_string(data.randomnumber); + std::cout << "\033[1m\033[31m-----------\n" + << keyname << " not in " << tablename << " table Field.\n-----------\033[0m" + << std::endl; } - break; - - default:; - } - } - } +#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) { @@ -462,7 +345,7 @@ struct worldbase { tempsql << "`"; } - tempsql << colnames[j]; + tempsql << col_names[j]; } if (j > 0) { @@ -477,26 +360,21 @@ struct worldbase 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(); - } + if(record[i].id==0){ + tempsql<<"null"; + }else{ + tempsql< 0) { @@ -515,7 +393,7 @@ struct worldbase { tempsql << "`"; } - tempsql << colnames[j]; + tempsql << col_names[j]; } if (j > 0) { @@ -530,2131 +408,2041 @@ struct worldbase tempsql << ",\n"; } tempsql << "("; - if (record[i].id == 0) - { - tempsql << "null"; + if(record[i].id==0){ + tempsql<<"null"; + }else{ + tempsql<0){ + for(;jj0) + { + tempsql<<","; + } + tempsql<0){ + if(findcolpos(keyname)<255) { - 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; - } + if(j>0) + { + tempsql<<","; + } + tempsql< data_toarray(std::string fileld = "") - { + std::vector data_toarray(std::string fileld=""){ std::vector temparray; std::string keyname; - unsigned char jj = 0; + unsigned char jj=0; std::vector keypos; - if (fileld.size() > 1) - { - for (; jj < fileld.size(); jj++) - { - if (fileld[jj] == ',') - { - keypos.emplace_back(findcolpos(keyname)); + if(fileld.size()>1){ + for(;jj 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:; + } + if(keyname.size()>0){ + keypos.emplace_back(findcolpos(keyname)); + keyname.clear(); } - } - - return temparray; - } - - std::map data_tomap(std::string fileld = "") - { - std::map tempsql; + }else{ + for(jj=0;jj data_tomap(std::string fileld=""){ + std::map tempsql; std::string keyname; - unsigned char jj = 0; + unsigned char jj=0; std::vector 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)); + if(fileld.size()>1){ + for(;jj0){ + keypos.emplace_back(findcolpos(keyname)); + keyname.clear(); } - tempsql << "}"; - - return tempsql.str(); - } - - std::string data_tojson(std::string fileld) - { + }else{ + for(jj=0;jj 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)); + if(fileld.size()>0){ + for(;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; + if(fileld[jj]==0x20){ - default:; + continue; } - } - tempsql << "}"; - return tempsql.str(); - } + keyname.push_back(fileld[jj]); + } + if(keyname.size()>0){ + 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_offset < json_content.size(); json_offset++) + for(;json_offset 0) + if(record.size()>0) { - data = metatemp; + data=metatemp; } - if (json_offset >= json_content.size()) + if(json_offset>=json_content.size()) { break; } - for (; json_offset < json_content.size(); json_offset++) + for(;json_offset= json_content.size()) - { - break; - } - json_value_name.clear(); - if (json_content[json_offset] == 0x22) + + if(json_content[json_offset]==0x20||json_content[json_offset]==0x0A||json_content[json_offset]==0x0D||json_content[json_offset]=='\t') { - - 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; - } + continue; } else { - if (json_content[json_offset] != '{' && json_content[json_offset] != ']') + if(json_content[json_offset]==0x22) { - for (; json_offset < json_content.size(); json_offset++) + 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()) + { + 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] == 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]!='{'&&json_content[json_offset]!=']') { - if (json_content[json_offset] == 0x7D) + for(;json_offset 1) + if(record.size()>1) { - data = record[0]; + data=record[0]; } } else { - if (json_content[json_offset] == '{') + if(json_content[json_offset]=='{') { - json_offset += 1; - std::string json_key_name, json_value_name; - - for (; json_offset < json_content.size(); json_offset++) + json_offset+=1; + std::string json_key_name,json_value_name; + + + for(;json_offset=json_content.size()) + { + break; } - 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_value_name.clear(); + if(json_content[json_offset]==0x22) { - json_offset += 1; + + 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] != ']') + else { - for (; json_offset < json_content.size(); json_offset++) + if(json_content[json_offset]!='{'&&json_content[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') + for(;json_offset keypos; + if(fileld.size()>0){ + for(;jj0){ + keypos.emplace_back(findcolpos(keyname)); + keyname.clear(); } - } - - std::string to_json(std::string fileld = "") - { - std::ostringstream tempsql; + }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; + unsigned char jj=0; std::vector keypos; - if (fileld.size() > 0) - { - for (; jj < fileld.size(); jj++) - { - if (fileld[jj] == ',') - { - keypos.emplace_back(findcolpos(keyname)); + if(fileld.size()>0){ + for(;jj 0) - { - keypos.emplace_back(findcolpos(keyname)); + + } + if(keyname.size()>0){ + keypos.emplace_back(findcolpos(keyname)); keyname.clear(); } - } - else - { - for (jj = 0; jj < colnames.size(); jj++) - { - keypos.emplace_back(jj); + }else{ + for(jj=0;jj 0) - { - tempsql << ",{"; - } - else - { - tempsql << "{"; - } - - for (jj = 0; jj < keypos.size(); jj++) - { - switch (keypos[jj]) + tempsql<<"["; + for(size_t n=0;n0){ + 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) { - 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) + switch(kpos) { - tempsql << "\"randomnumber\":0"; + case 0: + a.emplace_back(iter.id); + break; + case 1: + a.emplace_back(iter.randomnumber); + break; + } - else + } + + 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) { - tempsql << "\"randomnumber\":" << std::to_string(record[n].randomnumber); - } - break; - default:; - } - } - tempsql << "}"; - } - tempsql << "]"; - return tempsql.str(); - } + 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; + + } - std::string to_json(std::function func, std::string fileld = "") - { - std::ostringstream tempsql; - std::string keyname; - unsigned char jj = 0; - std::vector 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) + return 0; + } + + template,bool>::type = true > + T getVal(std::string keyname) + { + unsigned char kpos; + kpos=findcolpos(keyname); + + switch(kpos) { - 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) + + } + + + 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) { - tempsql << ",{"; + } - else + + + + return 0.0; + } + + template::value,bool>::type = true > + std::string getVal(std::string keyname) + { + unsigned char kpos; + kpos=findcolpos(keyname); + + switch(kpos) { - tempsql << "{"; - } - tempsql << keyname; - } - else - { - continue; - } - for (jj = 0; jj < keypos.size(); jj++) - { - - switch (keypos[jj]) + + } + 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) { - 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 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) + + + + return ""; + } + + template::value,bool>::type = true > + std::vector getCol([[maybe_unused]] std::string keyname) { - 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 ""; - } + std::vector a; - 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) + + std::string getstrCol(std::string keyname,[[maybe_unused]] bool isyinhao=false) { - if (j > 0) + std::ostringstream a; + + unsigned char kpos; + kpos=findcolpos(keyname); + int j=0; + if(isyinhao&&record.size()>0) { - if (isyinhao) - { - a << "\",\""; - } - else - { - a << ','; - } + a<<'"'; } - switch (kpos) + 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 ::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: + a< 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) - { - } - } + } + j++; + } + if(isyinhao&&j>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 ::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; + } + 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) + { - 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){ - 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::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 (dpos) - { - } - } + } + 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 ::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; + } + + 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) + { - unsigned char kpos, vpos, dpos; - kpos = findcolpos(keyname); - vpos = findcolpos(valname); - dpos = findcolpos(dataname); - T ktemp; - U vtemp; - //D vtemp; + 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; - for (auto &iter : record) - { + } + 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) + { - switch (kpos) - { - } + case 0: + a.emplace(iter.id,iter); + break; + case 1: + a.emplace(iter.randomnumber,iter); + break; - switch (vpos) - { - case 0: - vtemp = iter.id; - break; - case 1: - vtemp = iter.randomnumber; - break; - } + } + } + + return a; + } + + template::value,bool>::type = true > + std::map getmapRows([[maybe_unused]] std::string keyname) + { + std::map a; - 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> + 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) + { - 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; + 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) + { - for (auto &iter : record) - { + 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 (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) + { - switch (vpos) - { - case 0: - vtemp = iter.id; - break; - case 1: - vtemp = iter.randomnumber; - break; - } + 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) + { - switch (dpos) - { - } - } + 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, 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; + template::value,bool>::type = true > + std::vector> getvecRows([[maybe_unused]] std::string keyname) + { + std::vector> 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; + 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) + { - unsigned char kpos, vpos, dpos; - kpos = findcolpos(keyname); - vpos = findcolpos(valname); - dpos = findcolpos(dataname); - T ktemp; - U vtemp; - // D dtemp; + 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){ + + } + } - for (auto &iter : record) + + 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; - switch (kpos) + for(auto &iter:record) { - } + switch(kpos) + { - switch (vpos) - { - } + 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; - 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) + { - return a; - } + 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){ - 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,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) + { - return a; - } + case 0: + ktemp=iter.id; + break; + case 1: + ktemp=iter.randomnumber; + break; + } - 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; + switch(vpos){ + } - return a; - } + switch(dpos){ - 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) + } + } + + 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; + std::map>> a; - return a; - } + + unsigned char kpos,vpos,dpos; + kpos=findcolpos(keyname); + vpos=findcolpos(valname); + dpos=findcolpos(dataname); + T ktemp; + U vtemp; + // D dtemp; - 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; + for(auto &iter:record) + { + switch(kpos) + { - unsigned char kpos, vpos; - kpos = findcolpos(keyname); - vpos = findcolpos(valname); - T ktemp; - //U vtemp; + case 0: + ktemp=iter.id; + break; + case 1: + ktemp=iter.randomnumber; + break; + } - for (auto &iter : record) - { + switch(vpos){ + } - switch (kpos) - { - } + switch(dpos){ + case 0: + a[ktemp][vtemp].emplace_back(iter.id); + break; + case 1: + a[ktemp][vtemp].emplace_back(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, 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) + { - 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; + case 0: + ktemp=iter.id; + break; + case 1: + ktemp=iter.randomnumber; + break; + } - for (auto &iter : record) - { + switch(vpos){ + } - switch (kpos) - { + switch(dpos){ - case 0: - ktemp = iter.id; - break; - case 1: - ktemp = 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 vtemp; + for(auto &iter:record) + { + switch(kpos) + { - switch (vpos) - { - } - } + } - return a; - } + switch(vpos){ + case 0: + vtemp=iter.id; + break; + case 1: + vtemp=iter.randomnumber; + break; + } - 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; + switch(dpos){ - unsigned char kpos, vpos; - kpos = findcolpos(keyname); - vpos = findcolpos(valname); - T ktemp; - //U vtemp; + } + } + - for (auto &iter : record) + 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; - switch (kpos) + 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; - switch (vpos) - { - } + } + } + + return a; } - - 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) + + 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; + std::map>> a; - unsigned char kpos, vpos; - kpos = findcolpos(keyname); - vpos = findcolpos(valname); + + unsigned char kpos,vpos,dpos; + kpos=findcolpos(keyname); + vpos=findcolpos(valname); + dpos=findcolpos(dataname); T ktemp; - //U vtemp; - - for (auto &iter : record) - { + U vtemp; + // D dtemp; - switch (kpos) + 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){ - switch (vpos) - { - case 0: - a[ktemp].emplace_back(iter.id); - break; - case 1: - a[ktemp].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, 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; - return a; - } + for(auto &iter:record) + { + + switch(kpos) + { - template , bool>::type = true> - std::map> getgroupRows([[maybe_unused]] std::string keyname) - { - std::map> a; + } + + switch(vpos){ + } - unsigned char kpos; - kpos = findcolpos(keyname); + switch(dpos){ + case 0: + a[ktemp][vtemp].emplace_back(iter.id); + break; + case 1: + a[ktemp][vtemp].emplace_back(iter.randomnumber); + break; - for (auto &iter : record) + } + } + + 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) { - switch (kpos) - { + 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; - 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,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; - return a; - } + for(auto &iter:record) + { + + switch(kpos) + { - template ::value, bool>::type = true> - std::map> getgroupRows([[maybe_unused]] std::string keyname) - { - std::map> a; + } - return a; - } + switch(vpos){ + case 0: + a[ktemp].emplace_back(iter.id); + break; + case 1: + a[ktemp].emplace_back(iter.randomnumber); + break; - 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,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) + { - return a; - } + case 0: + ktemp=iter.id; + break; + case 1: + ktemp=iter.randomnumber; + break; + } - 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; + switch(vpos){ - unsigned char kpos, vpos; - kpos = findcolpos(keyname); - vpos = findcolpos(valname); - T ktemp; + } + } - for (auto &iter : record) + + 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; - switch (kpos) + 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; - } - } + case 0: + ktemp=iter.id; + break; + case 1: + ktemp=iter.randomnumber; + break; + } - return a; - } + switch(vpos){ - 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; + } + } + + 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) + { - unsigned char kpos, vpos; - kpos = findcolpos(keyname); - vpos = findcolpos(valname); - T ktemp; + 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; - for (auto &iter : record) + } + } + + return a; + } + + template,bool>::type = true> + std::map> getgroupRows([[maybe_unused]] std::string keyname) { + std::map> a; + + unsigned char kpos; + kpos=findcolpos(keyname); - switch (kpos) + for(auto &iter:record) { + switch(kpos) + { - case 0: - ktemp = iter.id; - break; - case 1: - ktemp = iter.randomnumber; - break; - } + case 0: + a[iter.id].emplace_back(iter); + break; + case 1: + a[iter.randomnumber].emplace_back(iter); + 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::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) + { - 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; + switch(vpos){ + case 0: + a[ktemp][iter.id].emplace_back(iter); + break; + case 1: + a[ktemp][iter.randomnumber].emplace_back(iter); + break; - unsigned char kpos, vpos; - kpos = findcolpos(keyname); - vpos = findcolpos(valname); - T ktemp; + } + } - for (auto &iter : record) + + 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) { - - switch (kpos) + 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; - } + 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; - switch (vpos) - { - } - } + } + } + + 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) + { - return a; - } -}; + case 0: + ktemp=iter.id; + break; + case 1: + ktemp=iter.randomnumber; + break; + } + + switch(vpos){ + + } + } + + return a; + } + + }; + -}// namespace orm +} #endif + \ No newline at end of file From 00647bcbce97458e1045f2fd1111ccb600030699 Mon Sep 17 00:00:00 2001 From: hzq Date: Sun, 2 Mar 2025 18:26:00 +0800 Subject: [PATCH 10/12] update paozhu --- .../C++/paozhu/paozhu_benchmark/{models => orm}/fortune_mysql.h | 0 .../C++/paozhu/paozhu_benchmark/{models => orm}/world_mysql.h | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename frameworks/C++/paozhu/paozhu_benchmark/{models => orm}/fortune_mysql.h (100%) rename frameworks/C++/paozhu/paozhu_benchmark/{models => orm}/world_mysql.h (100%) diff --git a/frameworks/C++/paozhu/paozhu_benchmark/models/fortune_mysql.h b/frameworks/C++/paozhu/paozhu_benchmark/orm/fortune_mysql.h similarity index 100% rename from frameworks/C++/paozhu/paozhu_benchmark/models/fortune_mysql.h rename to frameworks/C++/paozhu/paozhu_benchmark/orm/fortune_mysql.h diff --git a/frameworks/C++/paozhu/paozhu_benchmark/models/world_mysql.h b/frameworks/C++/paozhu/paozhu_benchmark/orm/world_mysql.h similarity index 100% rename from frameworks/C++/paozhu/paozhu_benchmark/models/world_mysql.h rename to frameworks/C++/paozhu/paozhu_benchmark/orm/world_mysql.h From 71c92c815a742ffd9450149ce354faeaa89042e4 Mon Sep 17 00:00:00 2001 From: hzq Date: Sun, 2 Mar 2025 18:39:15 +0800 Subject: [PATCH 11/12] update paozhu --- frameworks/C++/paozhu/paozhu.dockerfile | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/frameworks/C++/paozhu/paozhu.dockerfile b/frameworks/C++/paozhu/paozhu.dockerfile index af820de7002..d155b8f47ab 100644 --- a/frameworks/C++/paozhu/paozhu.dockerfile +++ b/frameworks/C++/paozhu/paozhu.dockerfile @@ -4,8 +4,8 @@ RUN apt-get install -yqq gcc g++ openssl libssl-dev zlib1g-dev build-essential l RUN apt-get -y install brotli libbrotli-dev RUN apt-get -y install libreadline-dev -RUN apt-get -y install mysql-client -RUN apt-get -y install libmysqlclient-dev +# RUN apt-get -y install mysql-client +# RUN apt-get -y install libmysqlclient-dev RUN locale-gen en_US.UTF-8 ENV LANG en_US.UTF-8 From 21e02d57c37f2f9e9e24fd36d45609d8030a752d Mon Sep 17 00:00:00 2001 From: hzq Date: Sun, 2 Mar 2025 19:00:37 +0800 Subject: [PATCH 12/12] update paozhu --- frameworks/C++/paozhu/paozhu.dockerfile | 2 ++ .../paozhu/paozhu_benchmark/orm/{ => include}/fortune_mysql.h | 0 .../C++/paozhu/paozhu_benchmark/orm/include/fortunebase.h | 2 +- .../C++/paozhu/paozhu_benchmark/orm/{ => include}/world_mysql.h | 0 frameworks/C++/paozhu/paozhu_benchmark/orm/include/worldbase.h | 2 +- 5 files changed, 4 insertions(+), 2 deletions(-) rename frameworks/C++/paozhu/paozhu_benchmark/orm/{ => include}/fortune_mysql.h (100%) rename frameworks/C++/paozhu/paozhu_benchmark/orm/{ => include}/world_mysql.h (100%) diff --git a/frameworks/C++/paozhu/paozhu.dockerfile b/frameworks/C++/paozhu/paozhu.dockerfile index d155b8f47ab..212773c8bea 100644 --- a/frameworks/C++/paozhu/paozhu.dockerfile +++ b/frameworks/C++/paozhu/paozhu.dockerfile @@ -92,6 +92,8 @@ RUN mkdir ./paozhu/orm/include COPY ./paozhu_benchmark/orm/orm.h ./paozhu/orm/ COPY ./paozhu_benchmark/orm/include/fortunebase.h ./paozhu/orm/include/ COPY ./paozhu_benchmark/orm/include/worldbase.h ./paozhu/orm/include/ +COPY ./paozhu_benchmark/orm/include/fortune_mysql.h ./paozhu/orm/include/ +COPY ./paozhu_benchmark/orm/include/world_mysql.h ./paozhu/orm/include/ RUN mkdir ./paozhu/models RUN mkdir ./paozhu/models/include diff --git a/frameworks/C++/paozhu/paozhu_benchmark/orm/fortune_mysql.h b/frameworks/C++/paozhu/paozhu_benchmark/orm/include/fortune_mysql.h similarity index 100% rename from frameworks/C++/paozhu/paozhu_benchmark/orm/fortune_mysql.h rename to frameworks/C++/paozhu/paozhu_benchmark/orm/include/fortune_mysql.h diff --git a/frameworks/C++/paozhu/paozhu_benchmark/orm/include/fortunebase.h b/frameworks/C++/paozhu/paozhu_benchmark/orm/include/fortunebase.h index 6576c16d41e..2d688b054ed 100644 --- a/frameworks/C++/paozhu/paozhu_benchmark/orm/include/fortunebase.h +++ b/frameworks/C++/paozhu/paozhu_benchmark/orm/include/fortunebase.h @@ -2,7 +2,7 @@ #define ORM_DEFAULT_FORTUNEBASEMATA_H /* *This file is auto create from cli -*本文件为自动生成 Sun, 02 Mar 2025 08:24:41 GMT +*本文件为自动生成 Sun, 02 Mar 2025 10:54:30 GMT ***/ #include #include diff --git a/frameworks/C++/paozhu/paozhu_benchmark/orm/world_mysql.h b/frameworks/C++/paozhu/paozhu_benchmark/orm/include/world_mysql.h similarity index 100% rename from frameworks/C++/paozhu/paozhu_benchmark/orm/world_mysql.h rename to frameworks/C++/paozhu/paozhu_benchmark/orm/include/world_mysql.h diff --git a/frameworks/C++/paozhu/paozhu_benchmark/orm/include/worldbase.h b/frameworks/C++/paozhu/paozhu_benchmark/orm/include/worldbase.h index 35cae19e40f..93f7c1f14b2 100644 --- a/frameworks/C++/paozhu/paozhu_benchmark/orm/include/worldbase.h +++ b/frameworks/C++/paozhu/paozhu_benchmark/orm/include/worldbase.h @@ -2,7 +2,7 @@ #define ORM_DEFAULT_WORLDBASEMATA_H /* *This file is auto create from cli -*本文件为自动生成 Sun, 02 Mar 2025 08:24:41 GMT +*本文件为自动生成 Sun, 02 Mar 2025 10:54:30 GMT ***/ #include #include