├── LICENSE
├── pg_ormlite.hpp
├── pg_query_object.hpp
├── readme.md
├── reflection.hpp
├── test.cpp
└── traits_utils.hpp


/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2023 hanson.young
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/pg_ormlite.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef PG_ORMLITE_HPP
  2 | #define PG_ORMLITE_HPP
  3 | #include <set>
  4 | #include <iostream>
  5 | #include <cstring>
  6 | #include "reflection.hpp"
  7 | #include "traits_utils.hpp"
  8 | #include "pg_query_object.hpp"
  9 | 
 10 | namespace pg_ormlite
 11 | {
 12 | 
 13 | struct key_map
 14 | {
 15 |     std::string fields;
 16 | };
 17 | 
 18 | struct auto_key_map
 19 | {
 20 |     std::string fields;
 21 | };
 22 | 
 23 | struct not_null_map
 24 | {
 25 |     std::set<std::string> fields;
 26 | };
 27 | 
 28 | template<typename... Args>
 29 | constexpr auto sort_tuple(const std::tuple<Args...>& t)
 30 | {
 31 |     if constexpr (sizeof...(Args) == 2)
 32 |     {
 33 |         auto [a, b] = t;
 34 |         if constexpr (!std::is_same_v<decltype(a), key_map> && !std::is_same_v<decltype(a), auto_key_map>)
 35 |         {
 36 |             return std::make_tuple(b, a);
 37 |         }
 38 |     }
 39 |     return t;
 40 | }
 41 | 
 42 | 
 43 | class pg_connection
 44 | {
 45 | private:
 46 |     template<typename Tuple1, typename Tuple2, size_t... Idx>
 47 |     std::string generate_connect_sql(const Tuple1& t1, const Tuple2& t2,std::index_sequence<Idx...>)
 48 |     {
 49 |         std::stringstream os;
 50 |         auto serialize = [&os](const std::string& key, const auto& val)
 51 |         {
 52 |             os << key << "="<< val<< " ";
 53 |         };
 54 |         
 55 |         int unused[] = {0, (serialize(std::get<Idx>(t1), std::get<Idx>(t2)), 0)...};
 56 |         (void) unused;
 57 |         return os.str();
 58 |     }
 59 | 
 60 | public:
 61 |     template<typename... Args> 
 62 |     pg_connection(Args&&... args)
 63 |     {
 64 |         auto args_tp = std::make_tuple(std::forward<Args>(args)...);
 65 |         auto index =  std::make_index_sequence<sizeof...(Args)>();
 66 |         constexpr size_t size = std::tuple_size<decltype(args_tp)>::value;
 67 |         std::string sql;
 68 |         if constexpr(size == 5)
 69 |         {
 70 |             auto fields = std::make_tuple("host", "port", "user", "password", "dbname");
 71 |             sql = generate_connect_sql(fields, args_tp, index);
 72 |         }
 73 |         if constexpr(size == 6)
 74 |         {
 75 |             auto fields = std::make_tuple("host", "port", "user", "password", "dbname", "connect_timeout");
 76 |             sql = generate_connect_sql(fields, args_tp, index);
 77 |         }
 78 |         
 79 |         std::cout<<"connect:"<<sql<<std::endl;
 80 |         conn_ = PQconnectdb(sql.data());
 81 |         if (PQstatus(conn_) != CONNECTION_OK)
 82 |         {
 83 |             std::cout<< PQerrorMessage(conn_) <<std::endl;
 84 |         }
 85 |     }
 86 | 
 87 |     template<typename T>
 88 |     bool prepare(const std::string& sql)
 89 |     {
 90 |         res_ = PQprepare(conn_, "", sql.data(), (int)reflection::get_value<T>(), nullptr);
 91 |         if (PQresultStatus(res_) != PGRES_COMMAND_OK)
 92 |         {
 93 |             std::cout<< PQerrorMessage(conn_) <<std::endl;
 94 |             return false;
 95 |         }
 96 |         PQclear(res_);
 97 |         return true;
 98 |     }
 99 | 
100 |     template<typename T, typename... Args>
101 |     bool create_table(Args&&... args)
102 |     {
103 |         std::string sql = generate_create_table_sql<T>(std::forward<Args>(args)...);
104 |         std::cout<<"create:"<<sql<<std::endl;
105 |         res_ = PQexec(conn_, sql.data());
106 |         if (PQresultStatus(res_) != PGRES_COMMAND_OK)
107 |         {
108 |             std::cout<< PQerrorMessage(conn_) <<std::endl;
109 |             return false;
110 |         }
111 |         PQclear(res_);
112 |         return true;
113 |     }
114 | 
115 |     template<typename T>
116 |     constexpr auto generate_insert_sql(bool replace)
117 |     {
118 |         std::string sql = replace ? "replace into " : "insert into ";
119 |         std::string table_name = reflection::get_name<T>().data();
120 |         std::string field_name_pack = reflection::get_field<T>().data();
121 |         sql += table_name + "(" + field_name_pack + ") values(";
122 |         constexpr auto field_size = reflection::get_value<T>();
123 |         for (size_t i = 0; i < field_size; i++)
124 |         {
125 |             sql += "$";
126 |             sql += std::to_string(i + 1);
127 |             if (i != field_size - 1)
128 |             {
129 |                 sql += ", ";
130 |             }
131 |         }
132 |         sql += ");";
133 |         return sql;
134 |     }
135 | 
136 |     template<typename T>
137 |     constexpr void set_param_values(std::vector<std::vector<char>>& param_values, T&& value)
138 |     {
139 |         using U = std::remove_const_t<std::remove_reference_t<T>>;
140 |         if constexpr(std::is_same_v<U, int64_t> || std::is_same_v<U, uint64_t>)  
141 |         { 
142 |             std::vector<char> temp(65, 0);
143 |             auto v_str = std::to_string(value);
144 |             memcpy(temp.data(), v_str.data(), v_str.size());
145 |             param_values.push_back(temp); 
146 |         }
147 |         else if constexpr(std::is_integral_v<U> || std::is_floating_point_v<U>)
148 |         {
149 |             std::vector<char> temp(20, 0);
150 |             auto v_str = std::to_string(value);
151 |             memcpy(temp.data(), v_str.data(), v_str.size());
152 |             param_values.push_back(std::move(temp)); 
153 |         }
154 |         else if constexpr(std::is_enum_v<U>)
155 |         {
156 |             std::vector<char> temp(20, 0);
157 |             auto v_str = std::to_string(static_cast<std::underlying_type_t<U>>(value));
158 |             memcpy(temp.data(), v_str.data(), v_str.size());
159 |             param_values.push_back(std::move(temp)); 
160 |         }
161 |         else if constexpr(std::is_same_v<U, std::string>)
162 |         {
163 |             std::vector<char> temp = {};
164 |             std::copy(value.data(), value.data() + value.size() + 1, std::back_inserter(temp));
165 |             param_values.push_back(std::move(temp)); 
166 |         }
167 |         else if constexpr(std::is_array<U>::value)
168 |         {
169 |             std::vector<char> temp = {};
170 |             std::copy(value, value + traits_utils::array_size<U>::value, std::back_inserter(temp));
171 |             param_values.push_back(std::move(temp));
172 |         }
173 |     }
174 | 
175 |     template<typename T>
176 |     bool insert_impl(std::string& sql, T&& t)
177 |     {
178 |         std::vector<std::vector<char>> param_values;
179 |         reflection::for_each(t, [&](auto& item, auto field, auto j){
180 |             set_param_values(param_values, t.*item);
181 |         });
182 |         if (param_values.empty())
183 |         {
184 |             return false;
185 |         }
186 |         std::vector<const char *> param_values_buf;
187 |         for (auto &item : param_values) 
188 |         {
189 |             param_values_buf.push_back(item.data());
190 |         }
191 | 
192 |         std::cout<<"params:";
193 |         for (size_t i = 0; i < param_values_buf.size(); i++)
194 |         {
195 |             std::cout << i << "="<<*(param_values_buf.data() + i)<<", ";
196 |         }
197 |         std::cout<<std::endl;
198 |         res_ = PQexecPrepared(conn_, "", (int)param_values.size(),
199 |                             param_values_buf.data(), NULL, NULL, 0);
200 | 
201 |         if (PQresultStatus(res_) != PGRES_COMMAND_OK) 
202 |         {
203 |             std::cout << PQresultErrorMessage(res_) << std::endl;
204 |             PQclear(res_);
205 |             return false;
206 |         }
207 | 
208 |         PQclear(res_);
209 |         return true;
210 |     }
211 | 
212 |     template<typename T>
213 |     int insert(T&& t)
214 |     {
215 |         std::string sql = generate_insert_sql<T>(false);
216 |         std::cout<<"insert prepare:"<<sql<<std::endl;
217 |         if (!prepare<T>(sql))
218 |             return false;
219 |         return insert_impl(sql, std::forward<T>(t));
220 |     }
221 | 
222 |     template<typename T>
223 |     int insert(std::vector<T>& t)
224 |     {
225 |         std::string sql = generate_insert_sql<T>(false);
226 |         std::cout<<"insert prepare:"<<sql<<std::endl;
227 |         if (!prepare<T>(sql))
228 |             return 0;
229 | 
230 |         for (auto& item : t)
231 |         {
232 |             if(!insert_impl(sql, item))
233 |             {
234 |                 execute("rollback;");
235 |                 return 0;
236 |             }
237 |         }
238 |         if (!execute("commit;"))
239 |             return 0;
240 |         return t.size();
241 |     }
242 | 
243 |     template <typename T>
244 |     constexpr auto get_type_names()
245 |     {
246 |         constexpr auto field_size = reflection::get_value<T>();
247 |         std::array<std::string, field_size> field_types;
248 |         reflection::for_each(T{}, [&](auto& item, auto field, auto j){
249 |             constexpr auto Idx = decltype(j)::value;
250 |             using U = std::remove_reference_t<decltype(reflection::get<Idx>(std::declval<T>()))>;
251 |             if constexpr(std::is_same_v<U, bool> || 
252 |                          std::is_same_v<U, int> || 
253 |                          std::is_same_v<U, int32_t> || 
254 |                          std::is_same_v<U, uint32_t> ||
255 |                          std::is_enum_v<U>)
256 |                 { field_types[Idx] = "integer"; return; }
257 |             if constexpr(std::is_same_v<U, int8_t> || std::is_same_v<U, uint8_t> || 
258 |                          std::is_same_v<U, int16_t> || std::is_same_v<U, uint16_t>)  
259 |                 { field_types[Idx] = "smallint"; return; }
260 |             if constexpr(std::is_same_v<U, int64_t> || std::is_same_v<U, uint64_t>)  
261 |                 { field_types[Idx] = "bigint"; return; }
262 |             if constexpr(std::is_same_v<U, float>)  
263 |                 { field_types[Idx] = "real"; return; }
264 |             if constexpr(std::is_same_v<U, double>)
265 |                 { field_types[Idx] = "double precision"; return; }
266 |             if constexpr(std::is_same_v<U, std::string>)
267 |                 { field_types[Idx] = "text"; return; }
268 |             if constexpr(std::is_array<U>::value)
269 |                 { field_types[Idx] = "varchar(" + std::to_string(traits_utils::array_size<U>::value) + ")"; return; }
270 |         });
271 |         return field_types;
272 |     }
273 |     template<typename T, typename... Args>
274 |     std::string generate_create_table_sql(Args&&... args)
275 |     {
276 |         auto table_name = reflection::get_name<T>();
277 |         std::string sql = std::string("create table if not exists ") + table_name.data() + "(";
278 |         auto field_names = reflection::get_array<T>();
279 |         auto field_types = get_type_names<T>();
280 |         using TT = std::tuple<std::decay_t<Args>...>;
281 |         if constexpr (sizeof...(Args) > 0)
282 |         {
283 |             
284 |             static_assert(!(traits_utils::has_type<key_map, TT>::value && traits_utils::has_type<auto_key_map, TT>::value), 
285 |                         "key_map and auto_key_map cannot be used together");
286 | 
287 |         }
288 | 
289 |         auto tp = sort_tuple(std::make_tuple(std::forward<Args>(args)...));
290 |         constexpr auto field_size = reflection::get_value<T>();
291 |         static_assert(field_size == field_names.size(), "field_size != field_names.size");
292 |         for (size_t i = 0; i < field_size; i++)
293 |         {
294 |             std::string field_name = field_names[i].data();
295 |             std::string field_type = field_types[i].data();
296 |             bool has_add = false;
297 |             reflection::for_each(
298 |                 tp,
299 |                 [&](auto item, auto j){
300 |                     if constexpr (std::is_same_v<decltype(item), not_null_map>)
301 |                     {
302 |                         // 如果字段不存在在not_null_map里面，则直接返回，进行普通填充
303 |                         if(item.fields.find(field_name) == item.fields.end())
304 |                             return;
305 |                     }
306 |                     else
307 |                     {
308 |                         // 如果字段不是主键，则直接返回，进行普通填充
309 |                         if(item.fields != field_name)
310 |                             return;
311 |                     }
312 | 
313 |                     if constexpr (std::is_same_v<decltype(item), auto_key_map>)
314 |                     {
315 |                         if(!has_add)
316 |                         {
317 |                             sql += field_name + " " + field_type + " serial primary key";
318 |                             has_add = true;
319 |                         }
320 |                     }
321 |                     else if constexpr (std::is_same_v<decltype(item), key_map>)
322 |                     {
323 |                         if(!has_add)
324 |                         {
325 |                             sql += field_name + " " + field_type + " primary key";
326 |                             has_add = true;
327 |                         }
328 |                     }
329 |                     else if constexpr (std::is_same_v<decltype(item), not_null_map>)
330 |                     {
331 |                         if(!has_add)
332 |                         {
333 |                             if(item.fields.find(field_name) == item.fields.end())
334 |                                 return;
335 |                             sql += field_name + " " + field_type + " not null";
336 |                             has_add = true;
337 |                         }
338 |                     }
339 |                 }
340 |             );
341 | 
342 |             if(!has_add)
343 |             {
344 |                 sql += field_name + " " + field_type;
345 |                 has_add = true;
346 |             }
347 | 
348 |             if( i < field_size-1)
349 |                 sql += ", ";
350 |         }
351 |         sql += ");";
352 |         return sql;
353 |     }
354 | 
355 |     template<typename T>
356 |     constexpr typename std::enable_if<reflection::is_reflection<T>::value, pg_query_object::query_object<T>>::type query()
357 |     {
358 |         return pg_query_object::query_object<T>(conn_, reflection::get_name<T>());
359 |     }
360 | 
361 |     template<typename T>
362 |     constexpr typename std::enable_if<reflection::is_reflection<T>::value, pg_query_object::query_object<T>>::type del()
363 |     {
364 |         return pg_query_object::query_object<T>(conn_, reflection::get_name<T>(), "delete", "");
365 |     }
366 | 
367 |     template<typename T>
368 |     constexpr typename std::enable_if<reflection::is_reflection<T>::value, pg_query_object::query_object<T>>::type update()
369 |     {
370 |         return pg_query_object::query_object<T>(conn_, reflection::get_name<T>(), "", "update");
371 |     }
372 | 
373 |     ~pg_connection()
374 |     {
375 |         if(conn_ != nullptr)
376 |         {
377 |             std::cout<<"release pg conn"<<std::endl;
378 |             PQfinish(conn_);
379 |             conn_ = nullptr;
380 |         } 
381 |     }
382 | 
383 |     bool execute(const std::string& sql)
384 |     {
385 |         res_ = PQexec(conn_, sql.data());
386 |         return PQresultStatus(res_) == PGRES_COMMAND_OK;
387 |     }
388 | 
389 | private:
390 |     PGresult *res_ = nullptr;
391 |     PGconn *conn_ = nullptr;
392 | };
393 | 
394 | }
395 | 
396 | 
397 | 
398 | #endif


--------------------------------------------------------------------------------
/pg_query_object.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef PG_QUERY_OBJECT_HPP
  2 | #define PG_QUERY_OBJECT_HPP
  3 | #include <cassert>
  4 | #include <iostream>
  5 | #include <cstring>
  6 | #include <libpq-fe.h>
  7 | #include "reflection.hpp"
  8 | 
  9 | namespace pg_query_object
 10 | {
 11 | 
 12 | template<typename RNT_TYPE>
 13 | struct selectable
 14 | {
 15 |     selectable(std::string_view&& field, std::string_view&& tbl_name, std::string_view&& op) 
 16 |     : expr_(std::string(op) + "(" + std::string(field) + ")"), tbl_name_(tbl_name){};
 17 | 
 18 |     inline std::string to_string() const
 19 |     {
 20 |         return expr_;
 21 |     }
 22 | 
 23 |     inline std::string table_name() const
 24 |     {
 25 |         return tbl_name_;
 26 |     }
 27 | 
 28 |     RNT_TYPE return_type;
 29 | 
 30 | private:
 31 |     std::string expr_;
 32 |     std::string tbl_name_;
 33 |     
 34 | };
 35 | 
 36 | class expr
 37 | {
 38 | public:
 39 |     expr(std::string_view&& field, std::string_view&& tbl_name) : expr_(field), tbl_name_(tbl_name) {};
 40 | 
 41 |     template <typename T>
 42 |     expr make_expr(std::string&& op, T value)
 43 |     {
 44 |         using U = std::decay_t<T>;
 45 |         if constexpr (std::is_array<U>::value || std::is_same_v<U, std::string> || std::is_same_v<U, const char*>)
 46 |             return expr (expr_ + " " + op + " " + "'" + value + "'", tbl_name_);
 47 |         else if constexpr (std::is_same_v<T, expr>)
 48 |             return expr (expr_ + " " + op + " " + value.expr_, tbl_name_);
 49 |         else
 50 |             return expr (expr_ + " " + op + " " + std::to_string(value), tbl_name_);
 51 |     }
 52 | 
 53 |     template <typename T>
 54 |     inline expr operator == (T value)
 55 |     {
 56 |         return expr(make_expr("=", value));
 57 |     }
 58 | 
 59 |     template <typename T>
 60 |     inline expr operator = (T value)
 61 |     {
 62 |         return expr(make_expr("=", value));
 63 |     }
 64 | 
 65 |     template <typename T>
 66 |     inline expr operator | (T value)
 67 |     {
 68 |         return expr(make_expr(",", value));
 69 |     }
 70 | 
 71 |     template <typename T>
 72 |     inline expr operator != (T value)
 73 |     {
 74 |         return expr(make_expr("!=", value));
 75 |     }
 76 | 
 77 |     template <typename T>
 78 |     inline expr operator < (T value)
 79 |     {
 80 |         return expr(make_expr("<", value));
 81 |     }
 82 | 
 83 |     template <typename T>
 84 |     inline expr operator > (T value)
 85 |     {
 86 |         return expr(make_expr(">", value));
 87 |     }
 88 | 
 89 |     template <typename T>
 90 |     inline expr operator <= (T value)
 91 |     {
 92 |         return expr(make_expr("<=", value));
 93 |     }
 94 | 
 95 |     template <typename T>
 96 |     inline expr operator >= (T value)
 97 |     {
 98 | 
 99 |         return expr(make_expr(">=", value));
100 |     }
101 | 
102 |     inline expr operator % (std::string&& value)
103 |     {
104 |         return expr(make_expr("like", value));
105 |     }
106 | 
107 |     inline expr operator ^ (std::string&& value)
108 |     {
109 |         return expr(make_expr("not like", value));
110 |     }
111 | 
112 |     inline expr operator && (expr&& value)
113 |     {
114 |         return expr(make_expr("and", value));
115 |     }
116 | 
117 |     inline expr operator || (expr&& value)
118 |     {
119 |         return expr(make_expr("or", value));
120 |     }
121 | 
122 |     inline std::string to_string() const
123 |     {
124 |         return expr_;
125 |     }
126 | 
127 |     inline std::string table_name() const
128 |     {
129 |         return tbl_name_;
130 |     }
131 | 
132 |     inline std::string print() const
133 |     {
134 |         return tbl_name_ + ", "+ expr_;
135 |     }
136 | 
137 | private:
138 |     std::string expr_;
139 |     std::string tbl_name_;
140 | };
141 | 
142 | template <typename QueryResult>
143 | class query_object
144 | {
145 | private:
146 |     std::string select_sql_;
147 |     std::string where_sql_;
148 |     std::string group_by_sql_;
149 |     std::string having_sql_;
150 |     std::string order_by_sql_;
151 |     std::string limit_sql_;
152 |     std::string offset_sql_;
153 |     std::string delete_sql_;
154 |     std::string update_sql_;
155 |     std::string set_sql_;
156 | 
157 |     std::string table_name_;
158 |     QueryResult query_result_;
159 |     PGconn* conn_;
160 |     PGresult* res_;
161 |     
162 | public:
163 | 
164 |     query_object(PGconn* conn, std::string_view table_name) : conn_(conn), table_name_(table_name)
165 |     {
166 | 
167 |     }
168 | 
169 |     query_object(PGconn* conn, std::string_view table_name, const std::string& delete_sql, const std::string& update_sql) 
170 |     : conn_(conn), 
171 |       table_name_(table_name), 
172 |       delete_sql_(update_sql.empty() ? delete_sql + " from " + std::string(table_name): ""),
173 |       update_sql_(delete_sql.empty() ? update_sql + " " + std::string(table_name): "")
174 |     {
175 | 
176 |     }
177 | 
178 |     query_object(PGconn* conn, std::string_view table_name, QueryResult& query_result, 
179 |                  const std::string& select_sql, const std::string& where_sql, const std::string& group_by_sql, 
180 |                  const std::string& having_sql, const std::string& order_by_sql, const std::string& limit_sql, 
181 |                  const std::string& offset_sql, const std::string& delete_sql, const std::string& update_sql, const std::string& set_sql) 
182 |     : conn_(conn), 
183 |       table_name_(table_name),
184 |       query_result_(query_result),
185 |       select_sql_(select_sql),
186 |       where_sql_(where_sql),
187 |       group_by_sql_(group_by_sql),
188 |       having_sql_(having_sql),
189 |       order_by_sql_(order_by_sql),
190 |       limit_sql_(limit_sql),
191 |       offset_sql_(offset_sql),
192 |       delete_sql_(delete_sql),
193 |       update_sql_(update_sql),
194 |       set_sql_(set_sql)
195 |     {
196 | 
197 |     }
198 | 
199 |     template<typename... Args>
200 |     inline void select_impl(std::string& sql, Args&&... args)
201 |     {
202 |         constexpr auto size = sizeof...(Args);
203 |         auto tp = std::make_tuple(std::forward<Args>(args)...);
204 |         reflection::for_each(tp, [&](auto arg, auto i) {
205 |             if constexpr (std::is_same_v<decltype(arg), selectable<decltype(arg.return_type)>>)
206 |             {
207 |                 bool same_table = arg.table_name() == table_name_;
208 |                 assert(same_table);
209 |                 table_name_ = arg.table_name();
210 |                 sql += arg.to_string();
211 |                 if(i != size - 1)
212 |                     sql += ", "; 
213 |             }
214 |         });
215 |     }
216 | 
217 |     template<typename... Args>
218 |     inline query_object<std::tuple<Args...>> new_query(std::tuple<Args...>&& query_result)
219 |     {
220 |         return query_object<std::tuple<Args...>>(conn_, table_name_, query_result,  
221 |                                                 select_sql_, where_sql_, group_by_sql_, 
222 |                                                 having_sql_, order_by_sql_, limit_sql_, 
223 |                                                 offset_sql_, delete_sql_, update_sql_, set_sql_);
224 |     }
225 | 
226 |     
227 |     template<typename... Args>
228 |     inline auto select(Args&&... args)
229 |     {
230 |         std::string sql = "select ";
231 |         if constexpr (sizeof...(Args) > 0)
232 |             select_impl(sql, std::forward<Args>(args)...);
233 |         else
234 |             sql += " * ";
235 |         sql += " from " + table_name_;
236 |         (*this).select_sql_ = sql;
237 |         return new_query(std::tuple<decltype(args.return_type)...>{});
238 |     }
239 | 
240 |     inline query_object&& set(const expr& expression)
241 |     {
242 |         table_name_ = expression.table_name();
243 |         (*this).set_sql_ = " set " + expression.to_string();
244 |         return std::move(*this);
245 |     }
246 | 
247 |     inline query_object&& where(const expr& expression)
248 |     {
249 |         table_name_ = expression.table_name();
250 |         (*this).where_sql_ = " where (" + expression.to_string() + ")";
251 |         return std::move(*this);
252 |     }
253 | 
254 |     inline query_object&& group_by(const expr& expression)
255 |     {
256 |         (*this).group_by_sql_ = " group by (" + expression.to_string() + ")";
257 |         return std::move(*this);
258 |     }
259 | 
260 |     inline query_object&& having(const expr& expression)
261 |     {
262 |         (*this).having_sql_ = " having (" + expression.to_string() + ")";
263 |         return std::move(*this);
264 |     }
265 | 
266 |     inline query_object&& order_by(const expr& expression)
267 |     {
268 |         (*this).order_by_sql_ = " order by " + expression.to_string() + " asc";
269 |         return std::move(*this);
270 |     }
271 | 
272 |     inline query_object&& order_by_desc(const expr& expression)
273 |     {
274 |         (*this).order_by_sql_ = " order by " + expression.to_string() + " desc";
275 |         return std::move(*this);
276 |     }
277 | 
278 |     inline query_object&& limit(std::size_t n)
279 |     {
280 |         (*this).limit_sql_ = " limit " + std::to_string(n);
281 |         return std::move(*this);
282 |     }
283 | 
284 |     inline query_object&& offset(std::size_t n)
285 |     {
286 |         (*this).offset_sql_ = " offset " + std::to_string(n);
287 |         return std::move(*this);
288 |     }
289 |     
290 |     std::string to_string()
291 |     {
292 |         if (select_sql_.empty() && delete_sql_.empty() && update_sql_.empty())
293 |         {
294 |             select_sql_ = "select * from " + table_name_;
295 |         }
296 |         return update_sql_ + delete_sql_ + select_sql_ + set_sql_ + where_sql_ + group_by_sql_ + 
297 |                having_sql_ + order_by_sql_ + limit_sql_ + offset_sql_ + ";";
298 |     }
299 | 
300 |     template<typename T>
301 |     constexpr void assign_value(T&& value, int row, int col)
302 |     {
303 |         using U = std::remove_const_t<std::remove_reference_t<T>>;
304 |         if constexpr(std::is_integral<U>::value && !(std::is_same<U, int64_t>::value || std::is_same<U, uint64_t>::value))
305 |         {
306 |             // std::cout<<"smallint:"<<row<<","<<col<<std::endl;
307 |             value = atoi(PQgetvalue(res_, row, col));
308 |         }
309 |         else if constexpr(std::is_enum_v<U>)
310 |         {
311 |             value = static_cast<U>(atoi(PQgetvalue(res_, row, col)));
312 |         }
313 |         else if constexpr(std::is_floating_point<U>::value)
314 |         {
315 |             // std::cout<<"float:"<<row<<","<<col<<std::endl;
316 |             value = atof(PQgetvalue(res_, row, col));
317 |         }
318 |         else if constexpr(std::is_same<U, int64_t>::value || std::is_same<U, uint64_t>::value)
319 |         {
320 |             // std::cout<<"bigint:"<<row<<","<<col<<std::endl;
321 |             value = atoll(PQgetvalue(res_, row, col));
322 |         }
323 |         else if constexpr(std::is_same<U, std::string>::value)
324 |         {
325 |             // std::cout<<"string:"<<row<<","<<col<<std::endl;
326 |             value = PQgetvalue(res_, row, col);
327 |         }
328 |         else if constexpr(std::is_array<U>::value && std::is_same<char, std::remove_pointer_t<std::decay_t<U>>>::value)
329 |         {
330 |             // std::cout<<"array:"<<row<<","<<col<<std::endl;
331 |             auto ptr = PQgetvalue(res_, row, col);
332 |             memcpy(value, ptr, sizeof(U));
333 |         }
334 |         else
335 |         {
336 |             std::cout<<"unsupported type:" << std::is_array<U>::value<<std::endl;
337 |         }
338 |     }
339 | 
340 |     template<typename T>
341 |     constexpr std::enable_if_t<reflection::is_reflection<T>::value, std::vector<T>> query(const std::string& sql)
342 |     {
343 |         std::vector<T> ret_vector;
344 |         std::cout<<"query:"<<sql<<std::endl;
345 |         res_ = PQexec(conn_, sql.c_str());
346 |         if (PQresultStatus(res_) != PGRES_TUPLES_OK) 
347 |         {
348 |             std::cout << PQresultErrorMessage(res_) << std::endl;
349 |             PQclear(res_);
350 |             return ret_vector;
351 |         }
352 |         // std::cout<<"num:"<<PQntuples(res_)<<std::endl;
353 |         auto ntuples = PQntuples(res_);
354 |         for (size_t i = 0; i < ntuples; i++)
355 |         {
356 |             T tp = {};
357 |             reflection::for_each(tp, [this, &tp, &i](auto item, auto field, auto j){
358 |                 assign_value(tp.*item, i, (int)decltype(j)::value);
359 |             });
360 |             ret_vector.push_back(std::move(tp));
361 |         }
362 |         PQclear(res_);
363 |         return ret_vector;
364 |     }
365 |     
366 |     template<typename T>
367 |     constexpr std::enable_if_t<!reflection::is_reflection<T>::value, std::vector<T>> query(const std::string& sql)
368 |     {
369 |         std::vector<T> ret_vector;
370 |         std::cout<<"query:"<<sql<<std::endl;
371 |         res_ = PQexec(conn_, sql.c_str());
372 |         if (PQresultStatus(res_) != PGRES_TUPLES_OK) 
373 |         {
374 |             std::cout << PQresultErrorMessage(res_) << std::endl;
375 |             PQclear(res_);
376 |             return ret_vector;
377 |         }
378 |         // std::cout<<"num:"<<PQntuples(res_)<<std::endl;
379 |         auto ntuples = PQntuples(res_);
380 |         for (size_t i = 0; i < ntuples; i++)
381 |         {
382 |             T tp = {};
383 |             int index = 0;
384 |             reflection::for_each(tp, [this, &i, &index](auto& item, auto j){
385 |                 if constexpr(reflection::is_reflection_v<std::decay_t<decltype(item)>>)
386 |                 {
387 |                     std::decay_t<decltype(item)> t = {};
388 |                     reflection::for_each(t, [this, &index, &t](auto ele, auto field, auto j){
389 |                         assign_value(t.*ele, j, index++);
390 |                     });
391 |                     item = std::move(t);
392 |                 }
393 |                 else
394 |                 {
395 |                     assign_value(item, (int)i, index++);
396 |                 }
397 |             });
398 |             ret_vector.push_back(tp);
399 |         }
400 |         PQclear(res_);
401 |         return ret_vector;
402 |     }
403 | 
404 |     std::vector<QueryResult> to_vector()
405 |     {
406 |         return query<QueryResult>(to_string());
407 |     }
408 | 
409 |     bool execute()
410 |     {
411 |         auto sql = to_string();
412 |         std::cout<<"exec:"<<sql<<std::endl;
413 |         res_ = PQexec(conn_, sql.data());
414 |         return PQresultStatus(res_) == PGRES_COMMAND_OK;
415 |         // return true;
416 |     }
417 | 
418 | 
419 | };
420 | 
421 | 
422 | 
423 | template <typename T>
424 | struct field_attribute;
425 | 
426 | template <typename T, typename U>
427 | struct field_attribute<U T::*> {
428 |   using type = T;
429 |   using return_type = U;
430 | };
431 | 
432 | template <typename U>
433 | constexpr std::string_view get_field_name(std::string_view full_name) 
434 | {
435 |   using T = typename field_attribute<U>::type;
436 |   return full_name.substr(reflection::get_name<T>().length() + 2,
437 |                           full_name.length());
438 | }
439 | 
440 | template <typename U>
441 | constexpr std::string_view get_table_name(std::string_view full_name) 
442 | {
443 |   using T = typename field_attribute<U>::type;
444 |   return reflection::get_name<T>();
445 | }
446 | 
447 | }
448 | 
449 | #define FD(field)                                                                 \
450 | pg_query_object::expr(                                                            \
451 |     pg_query_object::get_field_name<decltype(&field)>(std::string_view(#field)),  \
452 |     pg_query_object::get_table_name<decltype(&field)>(std::string_view(#field)))  \
453 | 
454 | #define ORM_AGG(field, op, type)                                                  \
455 | pg_query_object::selectable<type>(                                                \
456 |     pg_query_object::get_field_name<decltype(&field)>(std::string_view(#field)),  \
457 |     pg_query_object::get_table_name<decltype(&field)>(std::string_view(#field)),  \
458 |     op)                                                                           \
459 | 
460 | #define RNT(field) ORM_AGG(field, "", pg_query_object::field_attribute<decltype(&field)>::return_type)
461 | #define ORM_COUNT(field) ORM_AGG(field, "count", std::size_t)
462 | #define ORM_SUM(field) ORM_AGG(field, "sum", pg_query_object::field_attribute<decltype(&field)>::return_type)
463 | #define ORM_AVG(field) ORM_AGG(field, "avg", pg_query_object::field_attribute<decltype(&field)>::return_type)
464 | #define ORM_MAX(field) ORM_AGG(field, "max", pg_query_object::field_attribute<decltype(&field)>::return_type)
465 | #define ORM_MIN(field) ORM_AGG(field, "min", pg_query_object::field_attribute<decltype(&field)>::return_type)
466 | 
467 | 
468 | #endif


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
  1 | 
  2 | # 🌟 ORM-CPP: A Header-only Library for Modern C++17
  3 | 
  4 | ORM-CPP is a header-only library for modern C++17 that supports PostgreSQL CURD operations. It allows you to use LINQ syntax without the need to write any SQL queries.
  5 | 
  6 | ## Features
  7 | - Header-only library
  8 | - Supports PostgreSQL database, will support TDengine/CK/sqlite.
  9 | - LINQ syntax for SQL queries
 10 | - No need to write raw SQL code
 11 | - Compile-time reflection can reduce runtime overhead.
 12 | 
 13 | ## 🚀 Getting Started
 14 | 
 15 | ### Installing
 16 | 
 17 | To use ORM-CPP, simply add the `*.hpp` header file to your project.Make sure you have installed the PostgreSQL client and server.  
 18 | Ubuntu/Debian: `sudo apt install libpq-dev`  
 19 | You can use the command `g++ -o test test.cpp --std=c++17 -lpq -I /usr/include/postgresql` to compile the example program.
 20 | 
 21 | ### Usage
 22 | 
 23 | Include the header file `pg_ormlite.hpp` and Create a struct and decorate the struct name and members with the REFLECTION_TEMPLATE macro.
 24 | ```cpp
 25 | #include "pg_ormlite.hpp"
 26 | enum Gender: int
 27 | {
 28 |     Mail,
 29 |     Femail,
 30 | };
 31 | 
 32 | struct person {
 33 |     short id;
 34 |     char name[10];
 35 |     Gender gender;
 36 |     int age;
 37 |     float score;
 38 | }__attribute__((packed));
 39 | REFLECTION_TEMPLATE(person, id, name, gender, age, score)
 40 | ```
 41 | #### Connect
 42 | To use ORM-CPP, you need to first create a connection object to your PostgreSQL database, like so:
 43 | 
 44 | ```cpp
 45 | pg_ormlite::pg_connection conn("xx.xx.xx.xx", "1234", "user", "password", "dbname");
 46 | ```
 47 | #### Create
 48 | Once you have a connection object, you can create a table using the following statement
 49 | ```cpp
 50 | pg_ormlite::key_map key_map_{"id"};
 51 | pg_ormlite::not_null_map not_null_map_;
 52 | not_null_map_.fields = {"id", "age"};
 53 | conn.create_table<person>(key_map_, not_null_map_);
 54 | // create:create table if not exists person(id smallint primary key, name varchar(10), gender integer, age integer not null, score real);
 55 | ```
 56 | #### Insert
 57 | You can use the insert method to insert a single person object or insert multiple objects in batches into the database table.
 58 | ``` cpp
 59 | // insert single object one by one
 60 | person p1{1, "hxf1", Gender::Femail, 30, 101.1f};
 61 | person p2{2, "hxf2", Gender::Femail, 28, 102.2f};
 62 | person p3{3, "hxf3", Gender::Mail, 27, 103.3f};
 63 | person p4{4, "hxf4", Gender::Femail, 26, 104.4f};
 64 | person p5{5, "hxf1", Gender::Mail, 30, 108.1f};
 65 | person p6{6, "hxf3", Gender::Femail, 30, 109.1f};
 66 | 
 67 | conn.insert(p1);
 68 | // insert prepare:insert into person(id, name, gender, age, score) values($1, $2, $3, $4, $5);
 69 | conn.insert(p2);
 70 | conn.insert(p3);
 71 | conn.insert(p4);
 72 | conn.insert(p5);
 73 | conn.insert(p6);
 74 | 
 75 | // insert multiple objects in batches
 76 | std::vector<person> persons;
 77 | for (size_t i = 6; i < 10; i++)
 78 | {
 79 |     person p;
 80 |     p.id = i + 1;
 81 |     std::string name = "hxf" + std::to_string(i + 1);
 82 |     strcpy(p.name, name.c_str());
 83 |     p.gender = Gender::Mail;
 84 |     p.age = 30 + i;
 85 |     p.score = 101.1f + i;
 86 |     persons.push_back(p);
 87 | }
 88 | conn.insert(persons);
 89 | ```
 90 | #### Query 
 91 | Use ORM-CPP's LINQ syntax to query database. Directly return an array of structs.
 92 | ``` cpp
 93 | auto pn1 = 
 94 | conn.query<person>()
 95 |     .where(FD(person::age) > 27 && FD(person::id) < 3)
 96 |     .limit(2)
 97 |     .to_vector();
 98 | 
 99 | for(auto it: pn1)
100 | {
101 |         std::cout<<it.id<<" "<<it.name<< " "<<it.gender<<" "<<it.age<<" "<<it.score<<std::endl;
102 | }
103 | // select * from person where (age > 27 and id < 3) limit 2;
104 | // 1 hxf1 1 30 101.1
105 | // 2 hxf2 1 28 102.2
106 | ```
107 | If you only want to query certain fields, you can use the select method to filter them. In the end, it will return an array of `tuple` objects.
108 | 
109 | ```cpp
110 | auto pn2 = 
111 | conn.query<person>()
112 |     .select(RNT(person::id), RNT(person::name), RNT(person::gender), RNT(person::age))
113 |     .where(FD(person::age) >= 28 && FD(person::id) < 5)
114 |     .to_vector();
115 | 
116 | for(auto it: pn2)
117 | {
118 |     std::apply([](auto&&... args) {
119 |         ((std::cout << args << ' '), ...);
120 |     }, it);
121 |     std::cout<<std::endl;
122 | }
123 | // select (id), (name), (gender), (age) from person where (age >= 28 and id < 5);
124 | // 1 hxf1 1 30 
125 | // 2 hxf2 1 28 
126 | ```
127 | To use the calculation engine of the database itself, you can use more complex operations such as group_by, order_by, etc. You can also add some aggregate functions to perform data statistics. The aggregate functions currently provided include count, sum, avg, max, and min.
128 | ```cpp
129 | auto pn3 = 
130 | conn.query<person>()
131 |     .select(RNT(person::age), ORM_SUM(person::score), ORM_COUNT(person::name))
132 |     .where(FD(person::age) > 24 && FD(person::id) < 7)
133 |     .limit(3)
134 |     .group_by(FD(person::age))
135 |     .order_by_desc(FD(person::age))
136 |     .to_vector();
137 | 
138 | for(auto it: pn3)
139 | {
140 |     std::apply([](auto&&... args) {
141 |         ((std::cout << args << ' '), ...);
142 |     }, it);
143 |     std::cout<<std::endl;
144 | }
145 | // select (age), sum(score), count(name) from person where (age > 24 and id < 7) group by (age) order by age desc limit 3;
146 | // 30 318.3 3 
147 | // 28 102.2 1 
148 | // 27 103.3 1 
149 | ```
150 | #### Update 
151 | The syntax for updating data is similar to that of querying data, you can do:
152 | 
153 | ```cpp
154 | auto res2 =
155 | conn.update<person>()
156 |     .set((FD(person::age) = 50) | (FD(person::name) = "hxf100"))
157 |     .where(FD(person::age) > 29)
158 |     .execute();
159 | // update person set age = 50 , name = 'hxf100' where (age > 29);
160 | ```
161 | 
162 | #### Delete 
163 | To delete data, you can use the del method.
164 | ```cpp
165 | auto res = 
166 | conn.del<person>()
167 |     .where(FD(person::age) > 29)
168 |     .execute();
169 | // delete from person where (age > 29);
170 | ```
171 | 
172 | ## 📖 Documentation
173 | 
174 | For more information on how to implement ORM-CPP, check out the [post](https://zhuanlan.zhihu.com/p/629445959).
175 | 
176 | ## 🤝 Contributing
177 | 
178 | Contributions are welcome! If you find a bug or have a feature request, please open an issue on the [issue tracker](https://github.com/hanson-young/orm-cpp/issues). If you want to contribute code, please fork the repository and submit a pull request.
179 | 
180 | ## 📃 License
181 | 
182 | ORM-CPP is licensed under the [MIT License](https://github.com/hanson-young/orm-cpp/blob/main/LICENSE).
183 | 


--------------------------------------------------------------------------------
/reflection.hpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | Author: YangJian
  3 | Date: 2023-05-11
  4 | */
  5 | #ifndef REFLECTION_HPP
  6 | #define REFLECTION_HPP
  7 | #include <type_traits>
  8 | #include <vector>
  9 | #include <tuple>
 10 | #include <string>
 11 | #include <string_view>
 12 | #include <array>
 13 | #include <algorithm>
 14 | #include <sstream>
 15 | 
 16 | namespace reflection {
 17 | 
 18 | #define MARCO_EXPAND(...) __VA_ARGS__
 19 | #define ADD_VIEW(str) std::string_view(#str, sizeof(#str) - 1)
 20 | #define SEPERATOR ,
 21 | #define CON_STR_1(element, ...) ADD_VIEW(element)
 22 | #define CON_STR_2(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_1(__VA_ARGS__))
 23 | #define CON_STR_3(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_2(__VA_ARGS__))
 24 | #define CON_STR_4(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_3(__VA_ARGS__))
 25 | #define CON_STR_5(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_4(__VA_ARGS__))
 26 | #define CON_STR_6(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_5(__VA_ARGS__))
 27 | #define CON_STR_7(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_6(__VA_ARGS__))
 28 | #define CON_STR_8(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_7(__VA_ARGS__))
 29 | #define CON_STR_9(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_8(__VA_ARGS__))
 30 | #define CON_STR_10(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_9(__VA_ARGS__))
 31 | #define CON_STR_11(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_10(__VA_ARGS__))
 32 | #define CON_STR_12(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_11(__VA_ARGS__))
 33 | #define CON_STR_13(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_12(__VA_ARGS__))
 34 | #define CON_STR_14(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_13(__VA_ARGS__))
 35 | #define CON_STR_15(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_14(__VA_ARGS__))
 36 | #define CON_STR_16(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_15(__VA_ARGS__))
 37 | #define CON_STR_17(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_16(__VA_ARGS__))
 38 | #define CON_STR_18(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_17(__VA_ARGS__))
 39 | #define CON_STR_19(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_18(__VA_ARGS__))
 40 | #define CON_STR_20(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_19(__VA_ARGS__))
 41 | #define CON_STR_21(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_20(__VA_ARGS__))
 42 | #define CON_STR_22(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_21(__VA_ARGS__))
 43 | #define CON_STR_23(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_22(__VA_ARGS__))
 44 | #define CON_STR_24(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_23(__VA_ARGS__))
 45 | #define CON_STR_25(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_24(__VA_ARGS__))
 46 | #define CON_STR_26(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_25(__VA_ARGS__))
 47 | #define CON_STR_27(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_26(__VA_ARGS__))
 48 | #define CON_STR_28(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_27(__VA_ARGS__))
 49 | #define CON_STR_29(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_28(__VA_ARGS__))
 50 | #define CON_STR_30(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_29(__VA_ARGS__))
 51 | #define CON_STR_31(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_30(__VA_ARGS__))
 52 | #define CON_STR_32(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_31(__VA_ARGS__))
 53 | #define CON_STR_33(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_32(__VA_ARGS__))
 54 | #define CON_STR_34(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_33(__VA_ARGS__))
 55 | #define CON_STR_35(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_34(__VA_ARGS__))
 56 | #define CON_STR_36(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_35(__VA_ARGS__))
 57 | #define CON_STR_37(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_36(__VA_ARGS__))
 58 | #define CON_STR_38(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_37(__VA_ARGS__))
 59 | #define CON_STR_39(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_38(__VA_ARGS__))
 60 | #define CON_STR_40(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_39(__VA_ARGS__))
 61 | #define CON_STR_41(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_40(__VA_ARGS__))
 62 | #define CON_STR_42(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_41(__VA_ARGS__))
 63 | #define CON_STR_43(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_42(__VA_ARGS__))
 64 | #define CON_STR_44(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_43(__VA_ARGS__))
 65 | #define CON_STR_45(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_44(__VA_ARGS__))
 66 | #define CON_STR_46(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_45(__VA_ARGS__))
 67 | #define CON_STR_47(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_46(__VA_ARGS__))
 68 | #define CON_STR_48(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_47(__VA_ARGS__))
 69 | #define CON_STR_49(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_48(__VA_ARGS__))
 70 | #define CON_STR_50(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_49(__VA_ARGS__))
 71 | #define CON_STR_51(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_50(__VA_ARGS__))
 72 | #define CON_STR_52(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_51(__VA_ARGS__))
 73 | #define CON_STR_53(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_52(__VA_ARGS__))
 74 | #define CON_STR_54(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_53(__VA_ARGS__))
 75 | #define CON_STR_55(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_54(__VA_ARGS__))
 76 | #define CON_STR_56(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_55(__VA_ARGS__))
 77 | #define CON_STR_57(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_56(__VA_ARGS__))
 78 | #define CON_STR_58(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_57(__VA_ARGS__))
 79 | #define CON_STR_59(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_58(__VA_ARGS__))
 80 | #define CON_STR_60(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_59(__VA_ARGS__))
 81 | #define CON_STR_61(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_60(__VA_ARGS__))
 82 | #define CON_STR_62(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_61(__VA_ARGS__))
 83 | #define CON_STR_63(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_62(__VA_ARGS__))
 84 | #define CON_STR_64(element, ...) ADD_VIEW(element) SEPERATOR MARCO_EXPAND(CON_STR_63(__VA_ARGS__))
 85 | 
 86 | #define MACRO_ARGS_(exp)        exp
 87 | #define MACRO_FILTER(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _N, ...) _N
 88 | #define RNG_N() 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
 89 | #define MACRO_ARGS_INNER(...) MACRO_FILTER(__VA_ARGS__)
 90 | #define MACRO_ARGS_SIZE(...) MACRO_ARGS_(MACRO_ARGS_INNER(0, ##__VA_ARGS__, RNG_N()))
 91 | 
 92 | #define MACRO_CONCAT(a, b) a##_##b
 93 | #define FIELD(f) f
 94 | 
 95 | #define MAKE_ARG_LIST_1(op, arg, ...) op(arg)
 96 | #define MAKE_ARG_LIST_2(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_1(op, __VA_ARGS__))
 97 | #define MAKE_ARG_LIST_3(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_2(op, __VA_ARGS__))
 98 | #define MAKE_ARG_LIST_4(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_3(op, __VA_ARGS__))
 99 | #define MAKE_ARG_LIST_5(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_4(op, __VA_ARGS__))
100 | #define MAKE_ARG_LIST_6(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_5(op, __VA_ARGS__))
101 | #define MAKE_ARG_LIST_7(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_6(op, __VA_ARGS__))
102 | #define MAKE_ARG_LIST_8(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_7(op, __VA_ARGS__))
103 | #define MAKE_ARG_LIST_9(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_8(op, __VA_ARGS__))
104 | #define MAKE_ARG_LIST_10(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_9(op, __VA_ARGS__))
105 | #define MAKE_ARG_LIST_11(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_10(op, __VA_ARGS__))
106 | #define MAKE_ARG_LIST_12(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_11(op, __VA_ARGS__))
107 | #define MAKE_ARG_LIST_13(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_12(op, __VA_ARGS__))
108 | #define MAKE_ARG_LIST_14(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_13(op, __VA_ARGS__))
109 | #define MAKE_ARG_LIST_15(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_14(op, __VA_ARGS__))
110 | #define MAKE_ARG_LIST_16(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_15(op, __VA_ARGS__))
111 | #define MAKE_ARG_LIST_17(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_16(op, __VA_ARGS__))
112 | #define MAKE_ARG_LIST_18(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_17(op, __VA_ARGS__))
113 | #define MAKE_ARG_LIST_19(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_18(op, __VA_ARGS__))
114 | #define MAKE_ARG_LIST_20(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_19(op, __VA_ARGS__))
115 | #define MAKE_ARG_LIST_21(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_20(op, __VA_ARGS__))
116 | #define MAKE_ARG_LIST_22(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_21(op, __VA_ARGS__))
117 | #define MAKE_ARG_LIST_23(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_22(op, __VA_ARGS__))
118 | #define MAKE_ARG_LIST_24(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_23(op, __VA_ARGS__))
119 | #define MAKE_ARG_LIST_25(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_24(op, __VA_ARGS__))
120 | #define MAKE_ARG_LIST_26(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_25(op, __VA_ARGS__))
121 | #define MAKE_ARG_LIST_27(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_26(op, __VA_ARGS__))
122 | #define MAKE_ARG_LIST_28(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_27(op, __VA_ARGS__))
123 | #define MAKE_ARG_LIST_29(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_28(op, __VA_ARGS__))
124 | #define MAKE_ARG_LIST_30(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_29(op, __VA_ARGS__))
125 | #define MAKE_ARG_LIST_31(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_30(op, __VA_ARGS__))
126 | #define MAKE_ARG_LIST_32(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_31(op, __VA_ARGS__))
127 | #define MAKE_ARG_LIST_33(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_32(op, __VA_ARGS__))
128 | #define MAKE_ARG_LIST_34(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_33(op, __VA_ARGS__))
129 | #define MAKE_ARG_LIST_35(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_34(op, __VA_ARGS__))
130 | #define MAKE_ARG_LIST_36(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_35(op, __VA_ARGS__))
131 | #define MAKE_ARG_LIST_37(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_36(op, __VA_ARGS__))
132 | #define MAKE_ARG_LIST_38(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_37(op, __VA_ARGS__))
133 | #define MAKE_ARG_LIST_39(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_38(op, __VA_ARGS__))
134 | #define MAKE_ARG_LIST_40(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_39(op, __VA_ARGS__))
135 | #define MAKE_ARG_LIST_41(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_40(op, __VA_ARGS__))
136 | #define MAKE_ARG_LIST_42(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_41(op, __VA_ARGS__))
137 | #define MAKE_ARG_LIST_43(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_42(op, __VA_ARGS__))
138 | #define MAKE_ARG_LIST_44(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_43(op, __VA_ARGS__))
139 | #define MAKE_ARG_LIST_45(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_44(op, __VA_ARGS__))
140 | #define MAKE_ARG_LIST_46(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_45(op, __VA_ARGS__))
141 | #define MAKE_ARG_LIST_47(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_46(op, __VA_ARGS__))
142 | #define MAKE_ARG_LIST_48(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_47(op, __VA_ARGS__))
143 | #define MAKE_ARG_LIST_49(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_48(op, __VA_ARGS__))
144 | #define MAKE_ARG_LIST_50(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_49(op, __VA_ARGS__))
145 | #define MAKE_ARG_LIST_51(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_50(op, __VA_ARGS__))
146 | #define MAKE_ARG_LIST_52(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_51(op, __VA_ARGS__))
147 | #define MAKE_ARG_LIST_53(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_52(op, __VA_ARGS__))
148 | #define MAKE_ARG_LIST_54(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_53(op, __VA_ARGS__))
149 | #define MAKE_ARG_LIST_55(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_54(op, __VA_ARGS__))
150 | #define MAKE_ARG_LIST_56(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_55(op, __VA_ARGS__))
151 | #define MAKE_ARG_LIST_57(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_56(op, __VA_ARGS__))
152 | #define MAKE_ARG_LIST_58(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_57(op, __VA_ARGS__))
153 | #define MAKE_ARG_LIST_59(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_58(op, __VA_ARGS__))
154 | #define MAKE_ARG_LIST_60(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_59(op, __VA_ARGS__))
155 | #define MAKE_ARG_LIST_61(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_60(op, __VA_ARGS__))
156 | #define MAKE_ARG_LIST_62(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_61(op, __VA_ARGS__))
157 | #define MAKE_ARG_LIST_63(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_62(op, __VA_ARGS__))
158 | #define MAKE_ARG_LIST_64(op, arg, ...) op(arg), MARCO_EXPAND(MAKE_ARG_LIST_63(op, __VA_ARGS__))
159 | 
160 | #define MAKE_ARG_LIST(N, op, arg, ...) MACRO_CONCAT(MAKE_ARG_LIST, N)(op, arg, __VA_ARGS__)
161 | 
162 | #define MAKE_REFLECT_MEMBERS(class_name, ...)                                       \
163 | inline auto reflect_members_func(class_name const &){                               \
164 |   struct reflect_members                                                            \
165 |   {                                                                                 \
166 |     constexpr decltype(auto) static apply_impl()                                    \
167 |     {                                                                               \
168 |       return std::make_tuple(__VA_ARGS__);                                          \
169 |     }                                                                               \
170 |     using size_type = std::integral_constant<size_t, MACRO_ARGS_SIZE(__VA_ARGS__)>; \
171 |     constexpr static std::string_view name() { return name_##class_name; }          \
172 |     constexpr static std::string_view fields() {  return fields_##class_name; }     \
173 |     constexpr static size_t value() { return size_type::value; }                    \
174 |     constexpr static std::array<std::string_view, size_type::value> arr()           \
175 |     { return arr_##class_name; }                                                    \
176 |   };                                                                                \
177 |   return reflect_members{};                                                         \
178 | }
179 | 
180 | #define MAKE_META_DATA(class_name, table_name, N, ...)                  \
181 |   constexpr std::array<std::string_view, N> arr_##class_name = { \
182 |       MARCO_EXPAND(MACRO_CONCAT(CON_STR, N)(__VA_ARGS__)) };              \
183 |   constexpr std::string_view fields_##class_name = { #__VA_ARGS__ }; \
184 |   constexpr std::string_view name_##class_name = table_name; \
185 |   MAKE_REFLECT_MEMBERS(class_name, MAKE_ARG_LIST(N, &class_name::FIELD, __VA_ARGS__))\
186 | 
187 | 
188 | #define REFLECTION_TEMPLATE(class_name, ...) \
189 |     MAKE_META_DATA(class_name, #class_name, MACRO_ARGS_SIZE(__VA_ARGS__), __VA_ARGS__) \
190 | 
191 | #define REFLECTION_TEMPLATE_WITH_NAME(class_name, table_name, ...) \
192 |     MAKE_META_DATA(class_name, table_name, MACRO_ARGS_SIZE(__VA_ARGS__), __VA_ARGS__) \
193 | 
194 | 
195 | template <typename T>
196 | using Reflect_members = decltype(reflect_members_func(std::declval<T>()));
197 | 
198 | template <typename T, typename = void>
199 | struct is_reflection : std::false_type {};
200 | 
201 | template <typename T>
202 | struct is_reflection<T, std::void_t<decltype(Reflect_members<T>::arr())>>
203 |     : std::true_type {};
204 | 
205 | 
206 | template <template <typename...> class U, typename T>
207 | struct is_template_instant_of : std::false_type {};
208 | 
209 | template <template <typename...> class U, typename... args>
210 | struct is_template_instant_of<U, U<args...>> : std::true_type {};
211 | 
212 | template <typename T>
213 | struct is_stdstring : is_template_instant_of<std::basic_string, T> {};
214 | 
215 | template <typename T>
216 | struct is_tuple : is_template_instant_of<std::tuple, T> {};
217 | 
218 | 
219 | template <typename T>
220 | inline constexpr bool is_reflection_v = is_reflection<T>::value;
221 | 
222 | template <typename... Args, typename A, typename F, std::size_t... Idx>
223 | constexpr void for_each(const std::tuple<Args...>& t, const A& arr, F&& f,
224 |                         std::index_sequence<Idx...>) {
225 |   (std::forward<F>(f)(std::get<Idx>(t), arr[Idx], std::integral_constant<size_t, Idx>{}),
226 |    ...);
227 | }
228 | 
229 | template <typename...Args, typename F, std::size_t...Idx>
230 | constexpr void for_each(std::tuple<Args...>& t, F&& f, std::index_sequence<Idx...>) 
231 | {
232 |   (std::forward<F>(f)(std::get<Idx>(t), std::integral_constant<size_t, Idx>{}), ...);  
233 | }
234 | 
235 | template <typename T, typename F>
236 | constexpr std::enable_if_t<is_reflection<T>::value> for_each(T&& t, F&& f) {
237 |   using M = decltype(reflect_members_func(std::forward<T>(t)));
238 |   for_each(M::apply_impl(), M::arr(), std::forward<F>(f),
239 |            std::make_index_sequence<M::value()>{});
240 | }
241 | 
242 | template<typename T, typename F>
243 | constexpr std::enable_if_t<!is_reflection<T>::value && is_tuple<std::decay_t<T>>::value> for_each(T&& t, F&& f) {
244 |   for_each(std::forward<T>(t), 
245 |            std::forward<F>(f), 
246 |            std::make_index_sequence<std::tuple_size_v<std::decay_t<T>>>{}
247 |           );
248 | }
249 | 
250 | 
251 | template <typename T>
252 | constexpr void set_param_values(std::ostream& os, const std::string_view& field,
253 |                                 T &&value, size_t idx) 
254 | {
255 |   os << field<< ":"<< value <<" ";
256 | }
257 | 
258 | template <typename T>
259 | constexpr std::string serialize(T &t) 
260 | {
261 |   std::stringstream ss;
262 |   for_each(t,
263 |           [&t, &ss](auto item, auto field, auto i) {
264 |             set_param_values(ss, field, t.*item, i);
265 |           });
266 |   return ss.str();
267 | }
268 | 
269 | template<typename T>
270 | constexpr typename std::enable_if<!is_reflection<T>::value, std::size_t>::type get_value()
271 | {
272 |   return 0;
273 | }
274 | 
275 | template<typename T>
276 | constexpr typename std::enable_if<is_reflection<T>::value, std::size_t>::type get_value()
277 | {
278 |   using M = decltype(reflect_members_func(std::declval<T>()));
279 |   return M::value();
280 | }
281 | 
282 | template<typename T>
283 | constexpr std::size_t get_index(std::string_view field)
284 | {
285 |   using M = decltype(reflect_members_func(std::declval<T>()));
286 |   auto arr = M::arr();
287 |   auto it = std::find_if(arr.begin(), arr.end(), [&field](auto f) {
288 |     return std::string_view(f) == field;
289 |   });
290 |   return std::distance(arr.begin(), it);
291 | }
292 | 
293 | template<typename T>
294 | constexpr auto get_array()
295 | {
296 |   using M = decltype(reflect_members_func(std::declval<T>()));
297 |   return M::arr();
298 | }
299 | 
300 | template<typename T>
301 | constexpr std::string_view get_field()
302 | {
303 |   using M = decltype(reflect_members_func(std::declval<T>()));
304 |   return M::fields();
305 | }
306 | 
307 | template<typename T>
308 | constexpr auto get_name()
309 | {
310 |   using M = decltype(reflect_members_func(std::declval<T>()));
311 |   return M::name();
312 | }
313 | 
314 | template<typename T>
315 | constexpr auto get_name(size_t idx)
316 | {
317 |   using M = decltype(reflect_members_func(std::declval<T>()));
318 |   return M::arr()[idx];
319 | }
320 | 
321 | template<typename T, std::size_t I>
322 | constexpr auto get_name()
323 | {
324 |   using M = decltype(reflect_members_func(std::declval<T>()));
325 |   static_assert(I < M::value(), "index out of range");
326 |   return M::arr()[I];
327 | }
328 | 
329 | template<typename T>
330 | std::string_view get_name_impl(const T& t, std::size_t i)
331 | {
332 |     // get_name_impl(p, 2)
333 |     return get_name<T>(i);
334 | }
335 | 
336 | template <size_t I, typename T>
337 | constexpr decltype(auto) get(T&& t) {
338 |   using M = decltype(reflect_members_func(std::forward<T>(t)));
339 |   using U = decltype(std::forward<T>(t).*(std::get<I>(M::apply_impl())));
340 | 
341 |   if constexpr (std::is_array_v<U>) {
342 |     auto s = std::forward<T>(t).*(std::get<I>(M::apply_impl()));
343 |     std::array<char, sizeof(U)> arr;
344 |     memcpy(arr.data(), s, arr.size());
345 |     return arr;
346 |   }
347 |   else
348 |     return std::forward<T>(t).*(std::get<I>(M::apply_impl()));
349 | }
350 | 
351 | 
352 | }
353 | 
354 | #endif


--------------------------------------------------------------------------------
/test.cpp:
--------------------------------------------------------------------------------
  1 | // g++ -o test test.cpp --std=c++17 -lpq
  2 | 
  3 | #include <type_traits>
  4 | #include <string>
  5 | #include <iostream>
  6 | #include <tuple>
  7 | #include <vector>
  8 | #include "pg_ormlite.hpp"
  9 | 
 10 | enum Gender: int
 11 | {
 12 |     Mail,
 13 |     Femail,
 14 | };
 15 | 
 16 | struct person {
 17 |     short id;
 18 |     char name[10];
 19 |     Gender gender;
 20 |     int age;
 21 |     float score;
 22 | }__attribute__((packed));
 23 | REFLECTION_TEMPLATE(person, id, name, gender, age, score)
 24 | 
 25 | enum class Color: int16_t {RED, GREEN, BLUE};
 26 | 
 27 | int main() {
 28 | 
 29 |     std::cout << std::boolalpha;
 30 |     
 31 |     // connect database
 32 |     pg_ormlite::pg_connection conn("xx.xx.xx.xx", "1234", "user", "password", "dbname");
 33 |     // delete table
 34 |     conn.execute("drop table person;");
 35 |     // create table
 36 |     pg_ormlite::key_map key_map_{"id"};
 37 |     pg_ormlite::not_null_map not_null_map_;
 38 |     not_null_map_.fields = {"id", "age"};
 39 |     conn.create_table<person>(key_map_, not_null_map_);
 40 | 
 41 |     // insert data
 42 |     person p1{1, "hxf1", Gender::Femail, 30, 101.1f};
 43 |     person p2{2, "hxf2", Gender::Femail, 28, 102.2f};
 44 |     person p3{3, "hxf3", Gender::Mail, 27, 103.3f};
 45 |     person p4{4, "hxf4", Gender::Femail, 26, 104.4f};
 46 |     person p5{5, "hxf1", Gender::Mail, 30, 108.1f};
 47 |     person p6{6, "hxf3", Gender::Femail, 30, 109.1f};
 48 | 
 49 |     conn.insert(p1);
 50 |     conn.insert(p2);
 51 |     conn.insert(p3);
 52 |     conn.insert(p4);
 53 |     conn.insert(p5);
 54 |     conn.insert(p6);
 55 | 
 56 |     std::vector<person> persons;
 57 |     for (size_t i = 6; i < 10; i++)
 58 |     {
 59 |         person p;
 60 |         p.id = i + 1;
 61 |         std::string name = "hxf" + std::to_string(i + 1);
 62 |         strcpy(p.name, name.c_str());
 63 |         p.gender = Gender::Mail;
 64 |         p.age = 30 + i;
 65 |         p.score = 101.1f + i;
 66 |         persons.push_back(p);
 67 |     }
 68 |     conn.insert(persons);
 69 |     
 70 |     // query 1 return person struct
 71 |     auto pn1 = 
 72 |     conn.query<person>()
 73 |         .where(FD(person::age) > 27 && FD(person::id) < 3)
 74 |         .limit(2)
 75 |         .to_vector();
 76 | 
 77 |     for(auto it: pn1)
 78 |     {
 79 |         std::cout<<it.id<<" "<<it.name<< " "<<it.gender<<" "<<it.age<<" "<<it.score<<std::endl;
 80 |     }
 81 | 
 82 |     // query 2 return an array of tuple objects
 83 |     auto pn2 = 
 84 |     conn.query<person>()
 85 |         .select(RNT(person::id), RNT(person::name), RNT(person::gender), RNT(person::age))
 86 |         .where(FD(person::age) >= 28 && FD(person::id) < 5)
 87 |         .to_vector();
 88 | 
 89 |     for(auto it: pn2)
 90 |     {
 91 |         std::apply([](auto&&... args) {
 92 |             ((std::cout << args << ' '), ...);
 93 |         }, it);
 94 |         std::cout<<std::endl;
 95 |     }
 96 | 
 97 |     // query 3 return an array of tuple objects, use group by
 98 |     auto pn3 = 
 99 |     conn.query<person>()
100 |         .select(RNT(person::age), ORM_SUM(person::score), ORM_COUNT(person::name))
101 |         .where(FD(person::age) > 24 && FD(person::id) < 7)
102 |         .limit(3)
103 |         .group_by(FD(person::age))
104 |         .order_by_desc(FD(person::age))
105 |         .to_vector();
106 | 
107 |     for(auto it: pn3)
108 |     {
109 |         std::apply([](auto&&... args) {
110 |             ((std::cout << args << ' '), ...);
111 |         }, it);
112 |         std::cout<<std::endl;
113 |     }
114 | 
115 |     // update
116 |     auto res2 =
117 |     conn.update<person>()
118 |         .set((FD(person::age) = 50) | (FD(person::name) = "hxf100"))
119 |         .where(FD(person::age) > 29)
120 |         .execute();
121 | 
122 |     // query all 
123 |     auto pn4 = 
124 |     conn.query<person>()
125 |         .to_vector();
126 | 
127 |     for(auto it: pn4)
128 |     {
129 |         std::cout<<it.id<<" "<<it.name<< " "<<it.gender<<" "<<it.age<<" "<<it.score<<std::endl;
130 |     }
131 | 
132 |     // delete
133 |     auto res = 
134 |     conn.del<person>()
135 |         .where(FD(person::age) > 29)
136 |         .execute();
137 |     return 0;
138 | }
139 | 


--------------------------------------------------------------------------------
/traits_utils.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef TRAITS_UTILS_HPP
 2 | #define TRAITS_UTILS_HPP
 3 | #include <type_traits>
 4 | #include <tuple>
 5 | 
 6 | namespace traits_utils
 7 | {
 8 | 
 9 | template<typename T, typename Tuple>
10 | struct has_type{};
11 | 
12 | template<typename T, typename... Args>
13 | struct has_type<T, std::tuple<Args...>>
14 | : std::disjunction<std::is_same<T, Args>...>{};
15 | 
16 | template<typename T>
17 | struct identity{};
18 | 
19 | 
20 | template<typename T>
21 | struct array_size;
22 | 
23 | template<typename T, std::size_t N>
24 | struct array_size<std::array<T, N>>
25 | {
26 |     static constexpr size_t value = N;
27 | };
28 | 
29 | template<std::size_t N>
30 | struct array_size<char[N]>
31 | {
32 |     static constexpr std::size_t value = N;
33 | };
34 | 
35 | 
36 | }
37 | 
38 | #endif


--------------------------------------------------------------------------------