update new test

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

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

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

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

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

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

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

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

@@ -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

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

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<Fortune,fortunebase>{
-		 public:
-		 Fortune(std::string dbtag);
-		 Fortune();
-		};
+namespace orm
+{
+class Fortune : public mysql_orm<Fortune, fortunebase>
+{
+  public:
+    Fortune(std::string dbtag);
+    Fortune();
 };
+};// namespace orm
 #endif

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<World,worldbase>{
-		 public:
-		 World(std::string dbtag);
-		 World();
-		};
+namespace orm
+{
+class World : public mysql_orm<World, worldbase>
+{
+  public:
+    World(std::string dbtag);
+    World();
 };
+};// namespace orm
 #endif

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

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