Add benchmark files

frameworks/C++/paozhu/paozhu_benchmark/orm/_rawsqlfile/default_Fortune.sql

@@ -0,0 +1,5 @@
+CREATE TABLE `fortune` (
+  `id` int unsigned NOT NULL AUTO_INCREMENT,
+  `message` varchar(2048) CHARACTER SET utf8mb3 COLLATE utf8mb3_general_ci NOT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB AUTO_INCREMENT=13 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

frameworks/C++/paozhu/paozhu_benchmark/orm/_rawsqlfile/default_World.sql

@@ -0,0 +1,5 @@
+CREATE TABLE `world` (
+  `id` int unsigned NOT NULL AUTO_INCREMENT,
+  `randomNumber` int NOT NULL DEFAULT '0',
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB AUTO_INCREMENT=10001 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

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

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

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

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

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

@@ -0,0 +1,4 @@
+/*build this file time Tue, 20 Dec 2022 11:40:56 GMT*/
+
+#include "Fortune.h"
+#include "World.h"