Electroneum
ado_db_helper.h
Go to the documentation of this file.
1 // Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are met:
6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above copyright
9 // notice, this list of conditions and the following disclaimer in the
10 // documentation and/or other materials provided with the distribution.
11 // * Neither the name of the Andrey N. Sabelnikov nor the
12 // names of its contributors may be used to endorse or promote products
13 // derived from this software without specific prior written permission.
14 //
15 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
16 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER BE LIABLE FOR ANY
19 // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
20 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
21 // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
22 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
24 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 //
26 
27 
28 #ifndef _DB_ADO_HELPER_H_
29 #define _DB_ADO_HELPER_H_
30 
31 #include <vector>
32 #include <comutil.h>
33 #include "string_coding.h"
34 #include "math_helper.h"
35 #include "file_io_utils.h"
37 
38 
39 
40 #define BEGIN_TRY_SECTION() try {
41 
42 #define CATCH_TRY_SECTION(ret_val) CATCH_TRY_SECTION_MESS(ret_val, "")
43 
44 #define CATCH_TRY_SECTION_MESS(ret_val, mess_where) }\
45  catch(const std::exception&ex)\
46  {\
47  LOG_PRINT_J("DB_ERROR: " << ex.what(), LOG_LEVEL_0);\
48  return ret_val;\
49  }\
50  catch(const _com_error& comm_err)\
51  {\
52  const TCHAR* pstr = comm_err.Description();\
53  std::string descr = string_encoding::convert_to_ansii(pstr?pstr:TEXT(""));\
54  const TCHAR* pmessage = comm_err.ErrorMessage();\
55  pstr = comm_err.Source();\
56  std::string source = string_encoding::convert_to_ansii(pstr?pstr:TEXT(""));\
57  LOG_PRINT_J("COM_ERROR " << mess_where << ":\n\tDescriprion:" << descr << ", \n\t Message: " << string_encoding::convert_to_ansii(pmessage) << "\n\t Source: " << source, LOG_LEVEL_0);\
58  return ret_val;\
59  }\
60  catch(...)\
61  {\
62  LOG_PRINT_J("..._ERROR: Unknown error.", LOG_LEVEL_0);\
63  return ret_val;\
64  }\
65 
66 namespace epee
67 {
68 namespace ado_db_helper
69 {
70 
72  {
74  {}
75  //std::string m_sql;
77  size_t m_call_count;
78  DWORD m_max_time;
79  DWORD m_min_time;
80  };
81 
83  {
84  public:
85  typedef std::map<std::string, profile_entry> sqls_map;
87 
88  static bool sort_by_timing(const sqls_map::iterator& a, const sqls_map::iterator& b)
89  {
90  return a->second.m_avrg.get_avg() > b->second.m_avrg.get_avg();
91  }
92 
93  bool flush_log(const std::string& path)
94  {
95  CRITICAL_REGION_BEGIN(m_sqls_lock);
96  std::stringstream strm;
97  strm << "SQL PROFILE:\r\nStatements: " << m_sqls.size() << "\r\n";
98  std::list<sqls_map::iterator> m_sorted_by_time_sqls;
99  for(std::map<std::string, profile_entry>::iterator it = m_sqls.begin();it!=m_sqls.end();it++)
100  m_sorted_by_time_sqls.push_back(it);
101 
102  m_sorted_by_time_sqls.sort(sort_by_timing);
103 
104  for(std::list<sqls_map::iterator>::iterator it = m_sorted_by_time_sqls.begin();it!=m_sorted_by_time_sqls.end();it++)
105  {
106  strm << "---------------------------------------------------------------------------------------------------------\r\nSQL: " << (*it)->first << "\r\n";
107  strm << "\tavrg: " << (*it)->second.m_avrg.get_avg() << "\r\n\tmax: " << (*it)->second.m_max_time << "\r\n\tmin: " << (*it)->second.m_min_time << "\r\n\tcount: " << (*it)->second.m_call_count << "\r\n";
108  }
109 
110  return file_io_utils::save_string_to_file(path.c_str(), strm.str());
112  }
113 
114  bool push_entry(const std::string sql, DWORD time)
115  {
116  CRITICAL_REGION_BEGIN(m_sqls_lock);
117  profile_entry& entry_ref = m_sqls[sql];
118  entry_ref.m_avrg.push(time);
119  entry_ref.m_call_count++;
120  if(time > entry_ref.m_max_time) entry_ref.m_max_time = time;
121  if(time < entry_ref.m_min_time || entry_ref.m_min_time == 0) entry_ref.m_min_time = time;
123  return true;
124  }
125 
126  bool get_entry_avarege(const std::string sql, DWORD& time)
127  {
128  CRITICAL_REGION_BEGIN(m_sqls_lock);
129  sqls_map::iterator it = m_sqls.find(sql);
130  if(it==m_sqls.end())
131  return false;
132 
133  time = static_cast<DWORD>(it->second.m_avrg.get_avg());
135  return true;
136  }
137 
138  private:
139 
140  sqls_map m_sqls;
141  critical_section m_sqls_lock;
142  };
143 inline
144  profiler_manager* get_set_profiler(bool need_to_set = false, profiler_manager** pprofiler = NULL)
145  {
146  static profiler_manager* pmanager = NULL;
147  if(need_to_set)
148  pmanager = *pprofiler;
149  //else
150  // *pprofiler = pmanager;
151 
152  return pmanager;
153  }
154 inline
155  bool init() // INIT and DEINIT are NOT THREAD SAFE operations, CALL it BEFOR u start using this wrapper.
156  {
157  profiler_manager* pmanager = new profiler_manager();
158  get_set_profiler(true, &pmanager);
159  return true;
160  }
161 inline
162  bool deinit()
163  {
164  profiler_manager* pmanager = get_set_profiler();
165  //get_set_profiler(false, &pmanager);
166  if(pmanager)
167  delete pmanager;
168  return true;
169  }
170  inline bool push_timing(const std::string sql, DWORD time)
171  {
172  profiler_manager* pmanager = get_set_profiler();
173  //get_set_profiler(false, &pmanager);
174  if(pmanager)
175  return pmanager->push_entry(sql, time);
176  return true;
177  }
178 
179  inline bool flush_profiler(const std::string path)
180  {
181  profiler_manager* pmanager = get_set_profiler();
182  //get_set_profiler(false, &pmanager);
183  if(pmanager)
184  return pmanager->flush_log(path);
185  return true;
186  }
187 
189  {
190  DWORD m_start_time;
191  std::string m_sql;
192 
193  public:
195  {
196  m_start_time = ::GetTickCount();
197  m_sql = sql;
198  }
199 
201  {
202  DWORD timing = ::GetTickCount() - m_start_time;
203  push_timing(m_sql, timing);
204  }
205  };
206 #define PROFILE_SQL(sql) timing_guard local_timing(sql)
207 
208 
209  typedef std::vector<std::vector<_variant_t> > table;
210 
211  inline bool add_parametr(ADODB::_CommandPtr cmd, const std::string& parametr)
212  {
213  _variant_t param(parametr.c_str());
214  ADODB::ADO_LONGPTR size = sizeof(parametr);
215  ADODB::_ParameterPtr param_obj = cmd->CreateParameter("", ADODB::adVarChar, ADODB::adParamInput, static_cast<long>(parametr.size()+1), param);
216  cmd->Parameters->Append(param_obj);
217  return true;
218  }
219 
220  inline bool add_parametr(ADODB::_CommandPtr cmd, const std::wstring& parametr)
221  {
222  _variant_t param(parametr.c_str());
223  ADODB::ADO_LONGPTR size = sizeof(parametr);
224  ADODB::_ParameterPtr param_obj = cmd->CreateParameter("", ADODB::adVarWChar, ADODB::adParamInput, static_cast<long>(parametr.size()+2), param);
225  cmd->Parameters->Append(param_obj);
226  return true;
227  }
228 
229  inline bool add_parametr(ADODB::_CommandPtr cmd, const __int64 parametr)
230  {
231  _variant_t param(parametr);
232  ADODB::ADO_LONGPTR size = static_cast<long>(sizeof(parametr));
233  ADODB::_ParameterPtr param_obj = cmd->CreateParameter("parametr", ADODB::adBigInt, ADODB::adParamInput, static_cast<long>(size), param);
234  cmd->Parameters->Append(param_obj);
235  return true;
236  }
237 
238  inline bool add_parametr(ADODB::_CommandPtr cmd, const unsigned __int64 parametr)
239  {
240  _variant_t param(parametr);
241  ADODB::ADO_LONGPTR size = static_cast<long>(sizeof(parametr));
242  ADODB::_ParameterPtr param_obj = cmd->CreateParameter("parametr", ADODB::adUnsignedBigInt, ADODB::adParamInput, static_cast<long>(size), param);
243  cmd->Parameters->Append(param_obj);
244  return true;
245  }
246 
247 
248  inline bool add_parametr(ADODB::_CommandPtr cmd, const int parametr)
249  {
250  _variant_t param(parametr);
251  ADODB::ADO_LONGPTR size = static_cast<long>(sizeof(parametr));
252  ADODB::_ParameterPtr param_obj = cmd->CreateParameter("parametr", ADODB::adInteger, ADODB::adParamInput, static_cast<long>(size), param);
253  cmd->Parameters->Append(param_obj);
254  return true;
255  }
256 
257  inline bool add_parametr(ADODB::_CommandPtr cmd, const unsigned int parametr)
258  {
259  _variant_t param(parametr);
260  ADODB::ADO_LONGPTR size = static_cast<long>(sizeof(parametr));
261  ADODB::_ParameterPtr param_obj = cmd->CreateParameter("parametr", ADODB::adUnsignedInt, ADODB::adParamInput, static_cast<long>(size), param);
262  cmd->Parameters->Append(param_obj);
263  return true;
264  }
265 
266  inline bool add_parametr(ADODB::_CommandPtr cmd, float parametr)
267  {
268  _variant_t param;
269  param.ChangeType(VT_R4);
270  param.fltVal = parametr;
271  ADODB::_ParameterPtr param_obj = cmd->CreateParameter("parametr", ADODB::adSingle, ADODB::adParamInput, static_cast<long>(sizeof(float)), param);
272  cmd->Parameters->Append(param_obj);
273  return true;
274  }
275 
276  inline bool add_parametr(ADODB::_CommandPtr cmd, bool parametr)
277  {
278  _variant_t param;
279  param = parametr;
280  ADODB::_ParameterPtr param_obj = cmd->CreateParameter("parametr", ADODB::adBoolean, ADODB::adParamInput, sizeof(parametr), param);
281  cmd->Parameters->Append(param_obj);
282  return true;
283  }
284 
285 
286  inline bool add_parametr(ADODB::_CommandPtr cmd, _variant_t parametr)
287  {
288  ADODB::_ParameterPtr param_obj = cmd->CreateParameter("parametr", ADODB::adDBTimeStamp, ADODB::adParamInput, sizeof(parametr), parametr);
289  cmd->Parameters->Append(param_obj);
290  return true;
291  }
292 
293 
294  inline bool add_parametr_as_double(ADODB::_CommandPtr cmd, const DATE parametr)
295  {
296  _variant_t param;
297  param.ChangeType(VT_R8);
298  param.dblVal = parametr;
299  ADODB::_ParameterPtr param_obj = cmd->CreateParameter("parametr", ADODB::adDouble, ADODB::adParamInput, sizeof(float), param);
300  cmd->Parameters->Append(param_obj);
301  return true;
302  }
303 
304  template<typename TParam>
305  inline bool add_parametr(ADODB::_CommandPtr cmd, const std::list<TParam> params)
306  {
307  for(std::list<TParam>::const_iterator it = params.begin(); it!=params.end(); it++)
308  if(!add_parametr(cmd, *it))
309  return false;
310  return true;
311  }
312 
313  /*
314  inline bool add_parametr(ADODB::_CommandPtr cmd, const size_t parametr)
315  {
316  _variant_t param;
317  param.ChangeType(VT_I4);
318  param.intVal = parametr;
319  ADODB::_ParameterPtr param_obj = cmd->CreateParameter("parametr", ADODB::adInteger, ADODB::adParamInput, sizeof(parametr), param);
320  cmd->Parameters->Append(param_obj);
321  return true;
322  }*/
323 
324 
325  inline bool add_parametr(ADODB::_CommandPtr cmd, const DATE parametr)
326  {
327  /*_variant_t param;
328  param.ChangeType(VT_R8);
329  param.dblVal = parametr;
330  ADODB::_ParameterPtr param_obj = cmd->CreateParameter("parametr", ADODB::adDouble, ADODB::adParamInput, sizeof(float), param);
331  cmd->Parameters->Append(param_obj);*/
332 
333  _variant_t param;
334  param.ChangeType(VT_DATE);
335  param.date = parametr;
336  ADODB::_ParameterPtr param_obj = cmd->CreateParameter("parametr", ADODB::adDBDate, ADODB::adParamInput, sizeof(parametr), param);
337  cmd->Parameters->Append(param_obj);
338 
339  return true;
340  }
341 
342 
343  inline bool execute_helper(ADODB::_CommandPtr cmd, _variant_t* pcount_processed = NULL)
344  {
345  //BEGIN_TRY_SECTION();
346 
347  cmd->Execute(pcount_processed, NULL, ADODB::adExecuteNoRecords);
348 
349 
350  //CATCH_TRY_SECTION(false);
351 
352  return true;
353  }
354 
355 
356  inline bool select_helper(ADODB::_CommandPtr cmd, table& result_vector)
357  {
358  result_vector.clear();
359  //BEGIN_TRY_SECTION();
360 
361  ADODB::_RecordsetPtr precordset = cmd->Execute(NULL, NULL, NULL);
362  if(!precordset)
363  {
364  LOG_ERROR("DB_ERROR: cmd->Execute returned NULL!!!");
365  return false;
366  }
367 
368  //if(precordset->EndOfFile == EOF)
369  //{
370  // return true;
371  //}
372  /*try
373  {
374  if(precordset->MoveFirst()!= S_OK)
375  {
376  LOG_ERROR("DB_ERROR: Filed to move first!!!");
377  return false;
378  }
379  }
380  catch (...)
381  {
382  return true;
383  }*/
384 
385  size_t current_record_index = 0;
386  while(precordset->EndOfFile != EOF)
387  {
388  result_vector.push_back(table::value_type());
389  size_t fields_count = precordset->Fields->Count;
390  result_vector[current_record_index].resize(fields_count);
391  for(size_t current_field_index = 0; current_field_index < fields_count; current_field_index++)
392  {
393  _variant_t var;
394  var.ChangeType(VT_I2);
395  var.intVal = static_cast<INT>(current_field_index);
396  result_vector[current_record_index][current_field_index] = precordset->Fields->GetItem(var)->Value;
397  }
398  precordset->MoveNext();
399  current_record_index++;
400  }
401  //CATCH_TRY_SECTION(false);
402  return true;
403  }
404 
405 
406  template<typename TParam1>
408  {
409 
410  };
411 
412  template<typename TParam1>
414  {
415  TParam1 tparam1;
416  };
417  template<typename TParam1, typename TParam2>
419  {
420  TParam1 tparam1;
421  TParam2 tparam2;
422  };
423 
424 
425  template<typename TParam1, typename TParam2, typename TParam3>
427  {
428  TParam1 tparam1;
429  TParam2 tparam2;
430  TParam3 tparam3;
431  };
432 
433  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4>
435  {
436  TParam1 tparam1;
437  TParam2 tparam2;
438  TParam3 tparam3;
439  TParam4 tparam4;
440  };
441 
442  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4, typename TParam5>
444  {
445  TParam1 tparam1;
446  TParam2 tparam2;
447  TParam3 tparam3;
448  TParam4 tparam4;
449  TParam5 tparam5;
450  };
451 
452  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4, typename TParam5, typename TParam6>
454  {
455  TParam1 tparam1;
456  TParam2 tparam2;
457  TParam3 tparam3;
458  TParam4 tparam4;
459  TParam5 tparam5;
460  TParam6 tparam6;
461  };
462 
463  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4, typename TParam5, typename TParam6, typename TParam7>
465  {
466  TParam1 tparam1;
467  TParam2 tparam2;
468  TParam3 tparam3;
469  TParam4 tparam4;
470  TParam5 tparam5;
471  TParam6 tparam6;
472  TParam7 tparam7;
473  };
474 
475  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4, typename TParam5, typename TParam6, typename TParam7, typename TParam8, typename TParam9>
477  {
478  TParam1 tparam1;
479  TParam2 tparam2;
480  TParam3 tparam3;
481  TParam4 tparam4;
482  TParam5 tparam5;
483  TParam6 tparam6;
484  TParam7 tparam7;
485  TParam8 tparam8;
486  TParam9 tparam9;
487  };
488 
489  template<typename TParam1>
490  bool add_parametrs_multi(ADODB::_CommandPtr cmd, const adapter_zero<TParam1>& params)
491  {
492  return true;
493  }
494 
495  template<typename TParam1>
496  bool add_parametrs_multi(ADODB::_CommandPtr cmd, const adapter_single<TParam1>& params)
497  {
498  return add_parametr(cmd, params.tparam1);
499  }
500 
501  template<typename TParam1, typename TParam2>
502  bool add_parametrs_multi(ADODB::_CommandPtr cmd, const adapter_double<TParam1, TParam2>& params)
503  {
504  if(!add_parametr(cmd, params.tparam1)) return false;
505  return add_parametr(cmd, params.tparam2);
506  }
507 
508  template<typename TParam1, typename TParam2, typename TParam3>
509  bool add_parametrs_multi(ADODB::_CommandPtr cmd, const adapter_triple<TParam1, TParam2, TParam3>& params)
510  {
511  if(!add_parametr(cmd, params.tparam1)) return false;
512  if(!add_parametr(cmd, params.tparam2)) return false;
513  return add_parametr(cmd, params.tparam3);
514  }
515 
516  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4>
517  bool add_parametrs_multi(ADODB::_CommandPtr cmd, const adapter_quad<TParam1, TParam2, TParam3, TParam4>& params)
518  {
519  if(!add_parametr(cmd, params.tparam1)) return false;
520  if(!add_parametr(cmd, params.tparam2)) return false;
521  if(!add_parametr(cmd, params.tparam3)) return false;
522  return add_parametr(cmd, params.tparam4);
523  }
524 
525  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4, typename TParam5>
527  {
528  if(!add_parametr(cmd, params.tparam1)) return false;
529  if(!add_parametr(cmd, params.tparam2)) return false;
530  if(!add_parametr(cmd, params.tparam3)) return false;
531  if(!add_parametr(cmd, params.tparam4)) return false;
532  return add_parametr(cmd, params.tparam5);
533  }
534 
535  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4, typename TParam5, typename TParam6>
537  {
538  if(!add_parametr(cmd, params.tparam1)) return false;
539  if(!add_parametr(cmd, params.tparam2)) return false;
540  if(!add_parametr(cmd, params.tparam3)) return false;
541  if(!add_parametr(cmd, params.tparam4)) return false;
542  if(!add_parametr(cmd, params.tparam5)) return false;
543  return add_parametr(cmd, params.tparam6);
544  }
545 
546  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4, typename TParam5, typename TParam6, typename TParam7>
548  {
549  if(!add_parametr(cmd, params.tparam1)) return false;
550  if(!add_parametr(cmd, params.tparam2)) return false;
551  if(!add_parametr(cmd, params.tparam3)) return false;
552  if(!add_parametr(cmd, params.tparam4)) return false;
553  if(!add_parametr(cmd, params.tparam5)) return false;
554  if(!add_parametr(cmd, params.tparam6)) return false;
555  return add_parametr(cmd, params.tparam7);
556  }
557 
558  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4, typename TParam5, typename TParam6, typename TParam7, typename TParam8, typename TParam9>
560  {
561  if(!add_parametr(cmd, params.tparam1)) return false;
562  if(!add_parametr(cmd, params.tparam2)) return false;
563  if(!add_parametr(cmd, params.tparam3)) return false;
564  if(!add_parametr(cmd, params.tparam4)) return false;
565  if(!add_parametr(cmd, params.tparam5)) return false;
566  if(!add_parametr(cmd, params.tparam6)) return false;
567  if(!add_parametr(cmd, params.tparam7)) return false;
568  if(!add_parametr(cmd, params.tparam8)) return false;
569  return add_parametr(cmd, params.tparam9);
570  }
571 
572  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4, typename TParam5, typename TParam6, typename TParam7>
574  {
575  std::stringstream strm;
576  strm << params.tparam1 << ", " << params.tparam2 << ", " << params.tparam3 << ", " << params.tparam4 << ", " << params.tparam5 << ", " << params.tparam6 << ", " << params.tparam7;
577  return strm.str();
578  }
579 
580  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4, typename TParam5, typename TParam6, typename TParam7, typename TParam8, typename TParam9>
582  {
583  std::stringstream strm;
584  strm << params.tparam1 << ", " << params.tparam2 << ", " << params.tparam3 << ", " << params.tparam4 << ", " << params.tparam5 << ", " << params.tparam6 << ", " << params.tparam7 << ", " << params.tparam8 << ", " << params.tparam9;
585  return strm.str();
586  }
587 
588  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4, typename TParam5, typename TParam6>
590  {
591  std::stringstream strm;
592  strm << params.tparam1 << ", " << params.tparam2 << ", " << params.tparam3 << ", " << params.tparam4 << ", " << params.tparam5 << ", " << params.tparam6;
593  return strm.str();
594  }
595 
596  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4, typename TParam5>
598  {
599  std::stringstream strm;
600  strm << params.tparam1 << ", " << params.tparam2 << ", " << params.tparam3 << ", " << params.tparam4 << ", " << params.tparam5;
601  return strm.str();
602  }
603 
604 
605  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4>
607  {
608  std::stringstream strm;
609  strm << params.tparam1 << ", " << params.tparam2 << ", " << params.tparam3 << ", " << params.tparam4;
610  return strm.str();
611  }
612 
613  template<typename TParam1, typename TParam2, typename TParam3>
615  {
616  std::stringstream strm;
617  strm << params.tparam1 << ", " << params.tparam2 << ", " << params.tparam3;
618  return strm.str();
619  }
620 
621  template<typename TParam>
622  std::string get_str_param(const TParam& prm)
623  {
624  std::stringstream strm;
625  strm << prm;
626  return strm.str();
627  }
628 
629  template<typename TParam>
630  std::string get_str_param(const std::list<TParam>& prm_lst)
631  {
632  std::stringstream strm;
633  for(std::list<TParam>::const_iterator it = prm_lst.begin();it!=prm_lst.end();it++)
634  strm << get_str_param(*it) << ", ";
635  return strm.str();
636  }
637 
638 
639  template<typename TParam1, typename TParam2>
641  {
642  std::stringstream strm;
643  strm << get_str_param(params.tparam1) << ", " << get_str_param(params.tparam2);
644  return strm.str();
645  }
646 
647  template<typename TParam1>
649  {
650  std::stringstream strm;
651  strm << get_str_param(params.tparam1);
652  return strm.str();
653  }
654 
655  template<typename TParam1>
657  {
658  std::stringstream strm;
659  strm << "(no parametrs)";
660  return strm.str();
661  }
662 
663 
664  template<typename TParams>
665  bool execute_helper_multiparam(ADODB::_ConnectionPtr pconnection, const std::string& sql_statment, const TParams& parametrs, _variant_t* pcount_processed = NULL)
666  {
667  PROFILE_SQL(sql_statment);
668  bool res = false;
670 
671  ADODB::_CommandPtr cmd;
672  cmd.CreateInstance(__uuidof(ADODB::Command));
673  cmd->CommandText = _bstr_t(sql_statment.c_str());
674 
675  if(!add_parametrs_multi(cmd, parametrs))
676  return false;
677 
678  cmd->ActiveConnection = pconnection;
679  res = execute_helper(cmd, pcount_processed);
680 
681  CATCH_TRY_SECTION_MESS(false, "while statment: " << sql_statment << " [params]: " << print_parameters_multi(parametrs));
682  return res;
683  }
684 
685 
686  template<typename TParams>
687  inline
688  bool select_helper_multiparam(ADODB::_ConnectionPtr pconnection, const std::string& sql_statment, const TParams& parametrs, table& result_vector)
689  {
690  PROFILE_SQL(sql_statment);
691  bool res = false;
693  ADODB::_CommandPtr cmd;
694  cmd.CreateInstance(__uuidof(ADODB::Command));
695  cmd->CommandText = _bstr_t(sql_statment.c_str());
696 
697 
698  if(!add_parametrs_multi(cmd, parametrs))
699  return false;
700 
701  cmd->ActiveConnection = pconnection;
702  res = select_helper(cmd, result_vector);
703  CATCH_TRY_SECTION_MESS(false, "while statment: " << sql_statment << " [params]: " << print_parameters_multi(parametrs));
704  return res;
705  }
706 
707 
708  template<typename TParams>
709  inline
710  bool select_helper_param_container(ADODB::_ConnectionPtr pconnection, const std::string& sql_statment, const TParams& parametrs, table& result_vector)
711  {
712  PROFILE_SQL(sql_statment);
713  bool res = false;
715  ADODB::_CommandPtr cmd;
716  cmd.CreateInstance(__uuidof(ADODB::Command));
717  cmd->CommandText = _bstr_t(sql_statment.c_str());
718 
719 
720  for(TParams::const_iterator it = parametrs.begin(); it!=parametrs.end(); it++)
721  {
722  add_parametr(cmd, *it);
723  }
724 
725  cmd->ActiveConnection = pconnection;
726  res = select_helper(cmd, result_vector);
727 
728  CATCH_TRY_SECTION(false);
729  return res;
730  }
731 
732 
733  inline
734  bool execute_helper(ADODB::_ConnectionPtr pconnection, const std::string& sql_statment, _variant_t* pvt = NULL)
735  {
736  adapter_zero<int> params;
737  return execute_helper_multiparam(pconnection, sql_statment, params, pvt);
738  }
739 
740  template<typename TParam>
741  bool execute_helper(ADODB::_ConnectionPtr pconnection, const std::string& sql_statment, const TParam& parametr)
742  {
743  adapter_single<TParam> params;
744  params.tparam1 = parametr;
745  return execute_helper_multiparam(pconnection, sql_statment, params);
746  }
747 
748 
749  template<typename TParam1, typename TParam2>
750  bool execute_helper(ADODB::_ConnectionPtr pconnection, const std::string& sql_statment, const TParam1& parametr1, const TParam2& parametr2)
751  {
753  params.tparam1 = parametr1;
754  params.tparam2 = parametr2;
755  return execute_helper_multiparam(pconnection, sql_statment, params);
756 
757  }
758 
759  template<typename TParam1, typename TParam2, typename TParam3>
760  bool execute_helper(ADODB::_ConnectionPtr pconnection, const std::string& sql_statment, const TParam1& parametr1, const TParam2& parametr2, const TParam3& parametr3)
761  {
763  params.tparam1 = parametr1;
764  params.tparam2 = parametr2;
765  params.tparam3 = parametr3;
766  return execute_helper_multiparam(pconnection, sql_statment, params);
767  }
768 
769  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4>
770  bool execute_helper(ADODB::_ConnectionPtr pconnection, const std::string& sql_statment, const TParam1& parametr1, const TParam2& parametr2, const TParam3& parametr3, const TParam4& parametr4)
771  {
773  params.tparam1 = parametr1;
774  params.tparam2 = parametr2;
775  params.tparam3 = parametr3;
776  params.tparam4 = parametr4;
777  return execute_helper_multiparam(pconnection, sql_statment, params);
778  }
779 
780  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4, typename TParam5>
781  bool execute_helper(ADODB::_ConnectionPtr pconnection, const std::string& sql_statment, const TParam1& parametr1, const TParam2& parametr2, const TParam3& parametr3, const TParam4& parametr4, const TParam5& parametr5)
782  {
784  params.tparam1 = parametr1;
785  params.tparam2 = parametr2;
786  params.tparam3 = parametr3;
787  params.tparam4 = parametr4;
788  params.tparam5 = parametr5;
789  return execute_helper_multiparam(pconnection, sql_statment, params);
790  }
791 
792  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4, typename TParam5, typename TParam6>
793  bool execute_helper(ADODB::_ConnectionPtr pconnection, const std::string& sql_statment, const TParam1& parametr1, const TParam2& parametr2, const TParam3& parametr3, const TParam4& parametr4, const TParam5& parametr5, const TParam6& parametr6)
794  {
796  params.tparam1 = parametr1;
797  params.tparam2 = parametr2;
798  params.tparam3 = parametr3;
799  params.tparam4 = parametr4;
800  params.tparam5 = parametr5;
801  params.tparam6 = parametr6;
802  return execute_helper_multiparam(pconnection, sql_statment, params);
803  }
804 
805 
806  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4, typename TParam5, typename TParam6, typename TParam7>
807  bool execute_helper(ADODB::_ConnectionPtr pconnection, const std::string& sql_statment, const TParam1& parametr1, const TParam2& parametr2, const TParam3& parametr3, const TParam4& parametr4, const TParam5& parametr5, const TParam6& parametr6, const TParam7& parametr7)
808  {
810  params.tparam1 = parametr1;
811  params.tparam2 = parametr2;
812  params.tparam3 = parametr3;
813  params.tparam4 = parametr4;
814  params.tparam5 = parametr5;
815  params.tparam6 = parametr6;
816  params.tparam7 = parametr7;
817  return execute_helper_multiparam(pconnection, sql_statment, params);
818  }
819 
820  inline
821  bool select_helper(ADODB::_ConnectionPtr pconnection, const std::string& sql_statment, table& result_vector)
822  {
823  adapter_zero<int> params;
824  return select_helper_multiparam(pconnection, sql_statment, params, result_vector);
825  }
826 
827 
828  template<typename TParam>
829  bool select_helper(ADODB::_ConnectionPtr pconnection, const std::string& sql_statment, const TParam& parametr, table& result_vector)
830  {
831  adapter_single<TParam> params;
832  params.tparam1 = parametr;
833  return select_helper_multiparam(pconnection, sql_statment, params, result_vector);
834  }
835 
836  template<typename TParam1, typename TParam2>
837  bool select_helper(ADODB::_ConnectionPtr pconnection, const std::string& sql_statment, const TParam1 parametr1, const TParam2 parametr2, table& result_vector)
838  {
840  params.tparam1 = parametr1;
841  params.tparam2 = parametr2;
842  return select_helper_multiparam(pconnection, sql_statment, params, result_vector);
843 
844  }
845 
846  template<typename TParam1, typename TParam2, typename TParam3>
847  bool select_helper(ADODB::_ConnectionPtr pconnection, const std::string& sql_statment, const TParam1 parametr1, const TParam2 parametr2, const TParam3 parametr3, table& result_vector)
848  {
850  params.tparam1 = parametr1;
851  params.tparam2 = parametr2;
852  params.tparam3 = parametr3;
853  return select_helper_multiparam(pconnection, sql_statment, params, result_vector);
854 
855  }
856 
857  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4>
858  bool select_helper(ADODB::_ConnectionPtr pconnection, const std::string& sql_statment, const TParam1 parametr1, const TParam2 parametr2, const TParam3 parametr3, const TParam4 parametr4, table& result_vector)
859  {
861  params.tparam1 = parametr1;
862  params.tparam2 = parametr2;
863  params.tparam3 = parametr3;
864  params.tparam4 = parametr4;
865  return select_helper_multiparam(pconnection, sql_statment, params, result_vector);
866  }
867 
868  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4, typename TParam5>
869  bool select_helper(ADODB::_ConnectionPtr pconnection, const std::string& sql_statment, const TParam1 parametr1, const TParam2 parametr2, const TParam3 parametr3, const TParam4 parametr4, const TParam5 parametr5, table& result_vector)
870  {
872  params.tparam1 = parametr1;
873  params.tparam2 = parametr2;
874  params.tparam3 = parametr3;
875  params.tparam4 = parametr4;
876  params.tparam5 = parametr5;
877  return select_helper_multiparam(pconnection, sql_statment, params, result_vector);
878  }
879 
880 
881  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4, typename TParam5, typename TParam6>
882  bool select_helper(ADODB::_ConnectionPtr pconnection, const std::string& sql_statment, const TParam1 parametr1, const TParam2 parametr2, const TParam3 parametr3, const TParam4 parametr4, const TParam5 parametr5, const TParam6 parametr6, table& result_vector)
883  {
885  params.tparam1 = parametr1;
886  params.tparam2 = parametr2;
887  params.tparam3 = parametr3;
888  params.tparam4 = parametr4;
889  params.tparam5 = parametr5;
890  params.tparam6 = parametr6;
891  return select_helper_multiparam(pconnection, sql_statment, params, result_vector);
892  }
893 
894  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4, typename TParam5, typename TParam6, typename TParam7>
895  bool select_helper(ADODB::_ConnectionPtr pconnection, const std::string& sql_statment, const TParam1 parametr1, const TParam2 parametr2, const TParam3 parametr3, const TParam4 parametr4, const TParam5 parametr5, const TParam6 parametr6, const TParam7 parametr7, table& result_vector)
896  {
898  params.tparam1 = parametr1;
899  params.tparam2 = parametr2;
900  params.tparam3 = parametr3;
901  params.tparam4 = parametr4;
902  params.tparam5 = parametr5;
903  params.tparam6 = parametr6;
904  params.tparam7 = parametr7;
905  return select_helper_multiparam(pconnection, sql_statment, params, result_vector);
906  }
907 
908  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4, typename TParam5, typename TParam6, typename TParam7, typename TParam8, typename TParam9>
909  bool select_helper(ADODB::_ConnectionPtr pconnection, const std::string& sql_statment, const TParam1 parametr1, const TParam2 parametr2, const TParam3 parametr3, const TParam4 parametr4, const TParam5 parametr5, const TParam6 parametr6, const TParam7 parametr7,const TParam8 parametr8,const TParam9 parametr9, table& result_vector)
910  {
912  params.tparam1 = parametr1;
913  params.tparam2 = parametr2;
914  params.tparam3 = parametr3;
915  params.tparam4 = parametr4;
916  params.tparam5 = parametr5;
917  params.tparam6 = parametr6;
918  params.tparam7 = parametr7;
919  params.tparam8 = parametr8;
920  params.tparam9 = parametr9;
921  return select_helper_multiparam(pconnection, sql_statment, params, result_vector);
922  }
923 
924 
925 
926 
927  /************************************************************************/
928  /* */
929  /************************************************************************/
930 
932  {
933  public:
934  bool init(const std::string& connection_string, const std::string& login, const std::string& pass)
935  {
936  m_connection_string = connection_string;
937  m_login = login;
938  m_password = pass;
939  if(!get_db_connection().GetInterfacePtr())
940  return false;
941 
942  return true;
943  }
944 
945  ADODB::_ConnectionPtr& get_db_connection()
946  {
947 
948  //soci::session
949 
950  m_db_connections_lock.lock();
951  boost::shared_ptr<ADODB::_ConnectionPtr>& conn_ptr = m_db_connections[::GetCurrentThreadId()];
952  m_db_connections_lock.unlock();
953  if(!conn_ptr.get())
954  {
955  conn_ptr.reset(new ADODB::_ConnectionPtr());
956  ADODB::_ConnectionPtr& conn = *conn_ptr.get();
957  //init new connection
958 
960  //_bstr_t str = _bstr_t("Provider=SQLOLEDB;Data Source=SRV1;Integrated Security=SSPI;Initial Catalog=dispatcher;");
961 
962  if(S_OK != conn.CreateInstance(__uuidof(ADODB::Connection)))
963  {
964  LOG_ERROR("Failed to Create, instance, was CoInitialize called ???!");
965  return conn;
966  }
967 
968  HRESULT res = conn->Open(_bstr_t(m_connection_string.c_str()), _bstr_t(m_login.c_str()), _bstr_t(m_password.c_str()), NULL);
969  if(res != S_OK)
970  {
971  LOG_ERROR("Failed to connect do DB, connection str:" << m_connection_string);
972  return conn;
973  }
974  CATCH_TRY_SECTION_MESS(conn, "while creating another connection");
975  LOG_PRINT("New DB Connection added for threadid=" << ::GetCurrentThreadId(), LOG_LEVEL_0);
976  ado_db_helper::execute_helper(conn, "set enable_seqscan=false;");
977  return conn;
978  }
979 
980  return *conn_ptr.get();
981  }
982 
983  //----------------------------------------------------------------------------------------------
985  {
986  ADODB::_ConnectionPtr& rconn = get_db_connection();
987  if(!ado_db_helper::execute_helper(rconn, "SET CLIENT_ENCODING TO 'SQL_ASCII'"))
988  {
989 
990  try{
991  HRESULT res = rconn->Close();
992  }
993  catch(...)
994  {
995 
996  };
998 
999  HRESULT res = rconn->Open(_bstr_t(m_connection_string.c_str()), _bstr_t(m_login.c_str()), _bstr_t(m_password.c_str()), NULL);
1000  if(res != S_OK)
1001  {
1002  LOG_PRINT("Failed to restore connection to local AI DB", LOG_LEVEL_1);
1003  return false;
1004  }
1005  CATCH_TRY_SECTION(false);
1006  }
1007 
1008  return true;
1009  }
1010 
1011  protected:
1012  private:
1013  std::map<DWORD, boost::shared_ptr<ADODB::_ConnectionPtr> > m_db_connections;
1014  critical_section m_db_connections_lock;
1015  std::string m_connection_string;
1016  std::string m_login;
1017  std::string m_password;
1018  };
1019 
1020 
1021  template<typename TParam1, typename default_id_type, typename t_conn>
1022  bool find_or_add_t(const std::string& sql_select_statment, const std::string& sql_insert_statment, OUT default_id_type& id, OUT bool& new_object_added, TParam1 parametr_1, t_conn& c)
1023  {
1025  params.tparam1 = parametr_1;
1026  return find_or_add_t_multiparametred(sql_select_statment, sql_insert_statment, id, new_object_added, params, c);
1027  }
1028 
1029 
1030  template<typename TParam1, typename TParam2, typename default_id_type, typename t_conn>
1031  bool find_or_add_t(const std::string& sql_select_statment, const std::string& sql_insert_statment, OUT default_id_type& id, OUT bool& new_object_added, TParam1 parametr_1, TParam2 parametr_2, t_conn& c)
1032  {
1034  params.tparam1 = parametr_1;
1035  params.tparam2 = parametr_2;
1036  return find_or_add_t_multiparametred(sql_select_statment, sql_insert_statment, id, new_object_added, params, c);
1037  }
1038 
1039 
1040  template<typename TParam1, typename TParam2, typename TParam3, typename default_id_type, typename t_conn>
1041  bool find_or_add_t(const std::string& sql_select_statment, const std::string& sql_insert_statment, OUT default_id_type& id, OUT bool& new_object_added, TParam1 parametr_1, TParam2 parametr_2, TParam3 parametr_3, t_conn& c)
1042  {
1044  params.tparam1 = parametr_1;
1045  params.tparam2 = parametr_2;
1046  params.tparam3 = parametr_3;
1047  return find_or_add_t_multiparametred(sql_select_statment, sql_insert_statment, id, new_object_added, params, c);
1048  }
1049 
1050  template<typename TParam1, typename TParam2, typename TParam3, typename TParam4, typename default_id_type, typename t_conn>
1051  bool find_or_add_t(const std::string& sql_select_statment, const std::string& sql_insert_statment, OUT default_id_type& id, OUT bool& new_object_added, TParam1 parametr_1, TParam2 parametr_2, TParam3 parametr_3, TParam4 parametr_4, t_conn& c)
1052  {
1054  params.tparam1 = parametr_1;
1055  params.tparam2 = parametr_2;
1056  params.tparam3 = parametr_3;
1057  params.tparam4 = parametr_4;
1058  return find_or_add_t_multiparametred(sql_select_statment, sql_insert_statment, id, new_object_added, params, c);
1059  }
1060 
1061  template<typename TParams, typename default_id_type, typename t_conn>
1062  bool find_or_add_t_multiparametred(const std::string& sql_select_statment, const std::string& sql_insert_statment, OUT default_id_type& id, OUT bool& new_object_added, TParams params, t_conn& c)
1063  {
1064 
1065  //CHECK_CONNECTION(false);
1066 
1067  new_object_added = false;
1068  ado_db_helper::table result_table;
1069 
1070  bool res = select_helper_multiparam(c.get_db_connection(), sql_select_statment, params, result_table);
1071  if(!result_table.size())
1072  {
1073  res = select_helper_multiparam(c.get_db_connection(), sql_insert_statment, params, result_table);
1074  if(!res || !result_table.size())
1075  {
1076  //last time try to select
1077  res = select_helper_multiparam(c.get_db_connection(), sql_select_statment, params, result_table);
1078  CHECK_AND_ASSERT_MES(res, false, "Failed to execute statment: " << sql_select_statment);
1079  CHECK_AND_ASSERT_MES(result_table.size(), false, "No records returned from statment: " << sql_select_statment);
1080  }else
1081  {
1082  new_object_added = true;
1083  }
1084  }
1085 
1087  id = result_table[0][0];
1088  CATCH_TRY_SECTION_MESS(false, "while converting returned value [find_or_add_t_multiparametred()]");
1089 
1090  return true;
1091  }
1092 
1093 }
1094 }
1095 #endif
const char * res
Definition: hmac_keccak.cpp:41
std::vector< std::vector< _variant_t > > table
DWORD m_max_time
Definition: ado_db_helper.h:78
static bool sort_by_timing(const sqls_map::iterator &a, const sqls_map::iterator &b)
Definition: ado_db_helper.h:88
bool execute_helper(ADODB::_CommandPtr cmd, _variant_t *pcount_processed=NULL)
::std::string string
Definition: gtest-port.h:1097
Definition: ado_db_helper.h:71
timing_guard(const std::string &sql)
#define CHECK_AND_ASSERT_MES(expr, fail_ret_val, message)
Definition: misc_log_ex.h:181
#define BEGIN_TRY_SECTION()
Definition: ado_db_helper.h:40
std::map< std::string, profile_entry > sqls_map
Definition: ado_db_helper.h:85
std::string get_str_param(const TParam &prm)
bool get_entry_avarege(const std::string sql, DWORD &time)
bool select_helper(ADODB::_CommandPtr cmd, table &result_vector)
std::string print_parameters_multi(const adapter_sevento< TParam1, TParam2, TParam3, TParam4, TParam5, TParam6, TParam7 > &params)
void push(const value_type &vl)
Definition: math_helper.h:71
#define CRITICAL_REGION_END()
Definition: syncobj.h:233
#define OUT
Definition: string_tools.h:55
profiler_manager * get_set_profiler(bool need_to_set=false, profiler_manager **pprofiler=NULL)
profile_entry()
Definition: ado_db_helper.h:73
bool add_parametrs_multi(ADODB::_CommandPtr cmd, const adapter_zero< TParam1 > &params)
DWORD m_min_time
Definition: ado_db_helper.h:79
bool init(const std::string &connection_string, const std::string &login, const std::string &pass)
time_t time
Definition: blockchain.cpp:93
#define CATCH_TRY_SECTION_MESS(ret_val, mess_where)
Definition: ado_db_helper.h:44
bool select_helper_param_container(ADODB::_ConnectionPtr pconnection, const std::string &sql_statment, const TParams &parametrs, table &result_vector)
bool add_parametr_as_double(ADODB::_CommandPtr cmd, const DATE parametr)
::std::wstring wstring
Definition: gtest-port.h:1103
#define CRITICAL_REGION_BEGIN(x)
Definition: syncobj.h:229
#define PROFILE_SQL(sql)
bool flush_profiler(const std::string path)
bool flush_log(const std::string &path)
Definition: ado_db_helper.h:93
bool save_string_to_file(const std::string &path_to_file, const std::string &str)
Definition: file_io_utils.h:73
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition: pointer.h:1124
#define LOG_ERROR(x)
Definition: misc_log_ex.h:98
math_helper::average< DWORD, 10 > m_avrg
Definition: ado_db_helper.h:76
bool find_or_add_t_multiparametred(const std::string &sql_select_statment, const std::string &sql_insert_statment, OUT default_id_type &id, OUT bool &new_object_added, TParams params, t_conn &c)
bool push_entry(const std::string sql, DWORD time)
#define CATCH_TRY_SECTION(ret_val)
Definition: ado_db_helper.h:42
bool push_timing(const std::string sql, DWORD time)
size_t m_call_count
Definition: ado_db_helper.h:77
bool execute_helper_multiparam(ADODB::_ConnectionPtr pconnection, const std::string &sql_statment, const TParams &parametrs, _variant_t *pcount_processed=NULL)
bool add_parametr(ADODB::_CommandPtr cmd, const std::string &parametr)
bool select_helper_multiparam(ADODB::_ConnectionPtr pconnection, const std::string &sql_statment, const TParams &parametrs, table &result_vector)
bool find_or_add_t(const std::string &sql_select_statment, const std::string &sql_insert_statment, OUT default_id_type &id, OUT bool &new_object_added, TParam1 parametr_1, t_conn &c)