Logo ROOT   6.08/07
Reference Guide
TMySQLStatement.cxx
Go to the documentation of this file.
1 // @(#)root/mysql:$Id$
2 // Author: Sergey Linev 6/02/2006
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2006, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 //////////////////////////////////////////////////////////////////////////
13 // //
14 // SQL statement class for MySQL //
15 // //
16 // See TSQLStatement class documentation for more details. //
17 // //
18 //////////////////////////////////////////////////////////////////////////
19 
20 #include "TMySQLStatement.h"
21 #include "TMySQLServer.h"
22 #include "TDataType.h"
23 #include "TDatime.h"
24 #include <stdlib.h>
25 
27 
28 ULong64_t TMySQLStatement::fgAllocSizeLimit = 0x8000000; // 128 Mb
29 
30 #if MYSQL_VERSION_ID >= 40100
31 
32 ////////////////////////////////////////////////////////////////////////////////
33 /// Normal constructor.
34 /// Checks if statement contains parameters tags.
35 
37  TSQLStatement(errout),
38  fStmt(stmt),
39  fNumBuffers(0),
40  fBind(0),
41  fBuffer(0),
42  fWorkingMode(0),
43  fIterationCount(-1),
44  fNeedParBind(kFALSE)
45 {
46  ULong_t paramcount = mysql_stmt_param_count(fStmt);
47 
48  if (paramcount>0) {
49  fWorkingMode = 1;
50  SetBuffersNumber(paramcount);
51  fNeedParBind = kTRUE;
52  fIterationCount = -1;
53  }
54 }
55 
56 ////////////////////////////////////////////////////////////////////////////////
57 /// Destructor.
58 
60 {
61  Close();
62 }
63 
64 ////////////////////////////////////////////////////////////////////////////////
65 /// Close statement.
66 
68 {
69  if (fStmt)
70  mysql_stmt_close(fStmt);
71 
72  fStmt = 0;
73 
74  FreeBuffers();
75 }
76 
77 
78 // Reset error and check that statement exists
79 #define CheckStmt(method, res) \
80  { \
81  ClearError(); \
82  if (fStmt==0) { \
83  SetError(-1,"Statement handle is 0",method); \
84  return res; \
85  } \
86  }
87 
88 // check last mysql statement error code
89 #define CheckErrNo(method, force, res) \
90  { \
91  unsigned int stmterrno = mysql_stmt_errno(fStmt); \
92  if ((stmterrno!=0) || force) { \
93  const char* stmterrmsg = mysql_stmt_error(fStmt); \
94  if (stmterrno==0) { stmterrno = 11111; stmterrmsg = "MySQL statement error"; } \
95  SetError(stmterrno, stmterrmsg, method); \
96  return res; \
97  } \
98  }
99 
100 
101 // check last mysql statement error code
102 #define CheckGetField(method, res) \
103  { \
104  ClearError(); \
105  if (!IsResultSetMode()) { \
106  SetError(-1,"Cannot get statement parameters",method); \
107  return res; \
108  } \
109  if ((npar<0) || (npar>=fNumBuffers)) { \
110  SetError(-1,Form("Invalid parameter number %d", npar),method); \
111  return res; \
112  } \
113  }
114 
115 ////////////////////////////////////////////////////////////////////////////////
116 /// Process statement.
117 
119 {
120  CheckStmt("Process",kFALSE);
121 
122  // if parameters was set, processing just means of closing parameters and variables
123  if (IsSetParsMode()) {
124  if (fIterationCount>=0)
125  if (!NextIteration()) return kFALSE;
126  fWorkingMode = 0;
127  fIterationCount = -1;
128  FreeBuffers();
129  return kTRUE;
130  }
131 
132  if (mysql_stmt_execute(fStmt))
133  CheckErrNo("Process",kTRUE, kFALSE);
134 
135  return kTRUE;
136 }
137 
138 ////////////////////////////////////////////////////////////////////////////////
139 /// Return number of affected rows after statement is processed.
140 
142 {
143  CheckStmt("Process", -1);
144 
145  my_ulonglong res = mysql_stmt_affected_rows(fStmt);
146 
147  if (res == (my_ulonglong) -1)
148  CheckErrNo("GetNumAffectedRows", kTRUE, -1);
149 
150  return (Int_t) res;
151 }
152 
153 ////////////////////////////////////////////////////////////////////////////////
154 /// Return number of statement parameters.
155 
157 {
158  CheckStmt("GetNumParameters", -1);
159 
160  Int_t res = mysql_stmt_param_count(fStmt);
161 
162  CheckErrNo("GetNumParameters", kFALSE, -1);
163 
164  return res;
165 }
166 
167 ////////////////////////////////////////////////////////////////////////////////
168 /// Store result of statement processing to access them
169 /// via GetInt(), GetDouble() and so on methods.
170 
172 {
173  CheckStmt("StoreResult", kFALSE);
174  if (fWorkingMode!=0) {
175  SetError(-1,"Cannot store result for that statement","StoreResult");
176  return kFALSE;
177  }
178 
179  if (mysql_stmt_store_result(fStmt))
180  CheckErrNo("StoreResult",kTRUE, kFALSE);
181 
182  // allocate memeory for data reading from query
183  MYSQL_RES* meta = mysql_stmt_result_metadata(fStmt);
184  if (meta) {
185  int count = mysql_num_fields(meta);
186 
187  SetBuffersNumber(count);
188 
189  MYSQL_FIELD *fields = mysql_fetch_fields(meta);
190 
191  for (int n=0;n<count;n++) {
192  SetSQLParamType(n, fields[n].type, (fields[n].flags & UNSIGNED_FLAG) == 0, fields[n].length);
193  if (fields[n].name!=0) {
194  fBuffer[n].fFieldName = new char[strlen(fields[n].name)+1];
195  strcpy(fBuffer[n].fFieldName, fields[n].name);
196  }
197  }
198 
199  mysql_free_result(meta);
200  }
201 
202  if (fBind==0) return kFALSE;
203 
204  /* Bind the buffers */
205  if (mysql_stmt_bind_result(fStmt, fBind))
206  CheckErrNo("StoreResult",kTRUE, kFALSE);
207 
208  fWorkingMode = 2;
209 
210  return kTRUE;
211 }
212 
213 ////////////////////////////////////////////////////////////////////////////////
214 /// Return number of fields in result set.
215 
217 {
218  return IsResultSetMode() ? fNumBuffers : -1;
219 }
220 
221 ////////////////////////////////////////////////////////////////////////////////
222 /// Returns field name in result set.
223 
224 const char* TMySQLStatement::GetFieldName(Int_t nfield)
225 {
226  if (!IsResultSetMode() || (nfield<0) || (nfield>=fNumBuffers)) return 0;
227 
228  return fBuffer[nfield].fFieldName;
229 }
230 
231 ////////////////////////////////////////////////////////////////////////////////
232 /// Shift cursor to nect row in result set.
233 
235 {
236  if ((fStmt==0) || !IsResultSetMode()) return kFALSE;
237 
238  Bool_t res = !mysql_stmt_fetch(fStmt);
239 
240  if (!res) {
241  fWorkingMode = 0;
242  FreeBuffers();
243  }
244 
245  return res;
246 }
247 
248 ////////////////////////////////////////////////////////////////////////////////
249 /// Increment iteration counter for statement, where parameter can be set.
250 /// Statement with parameters of previous iteration
251 /// automatically will be applied to database.
252 
254 {
255  ClearError();
256 
257  if (!IsSetParsMode() || (fBind==0)) {
258  SetError(-1,"Cannot call for that statement","NextIteration");
259  return kFALSE;
260  }
261 
262  fIterationCount++;
263 
264  if (fIterationCount==0) return kTRUE;
265 
266  if (fNeedParBind) {
267  fNeedParBind = kFALSE;
268  if (mysql_stmt_bind_param(fStmt, fBind))
269  CheckErrNo("NextIteration",kTRUE, kFALSE);
270  }
271 
272  if (mysql_stmt_execute(fStmt))
273  CheckErrNo("NextIteration", kTRUE, kFALSE);
274 
275  return kTRUE;
276 }
277 
278 ////////////////////////////////////////////////////////////////////////////////
279 /// Release all buffers, used by statement.
280 
282 {
283  if (fBuffer) {
284  for (Int_t n=0; n<fNumBuffers;n++) {
285  free(fBuffer[n].fMem);
286  if (fBuffer[n].fStrBuffer)
287  delete[] fBuffer[n].fStrBuffer;
288  if (fBuffer[n].fFieldName)
289  delete[] fBuffer[n].fFieldName;
290  }
291  delete[] fBuffer;
292  }
293 
294  if (fBind)
295  delete[] fBind;
296 
297  fBuffer = 0;
298  fBind = 0;
299  fNumBuffers = 0;
300 }
301 
302 ////////////////////////////////////////////////////////////////////////////////
303 /// Allocate buffers for statement parameters/ result fields.
304 
306 {
307  FreeBuffers();
308  if (numpars<=0) return;
309 
310  fNumBuffers = numpars;
311 
312  fBind = new MYSQL_BIND[fNumBuffers];
313  memset(fBind, 0, sizeof(MYSQL_BIND)*fNumBuffers);
314 
315  fBuffer = new TParamData[fNumBuffers];
316  memset(fBuffer, 0, sizeof(TParamData)*fNumBuffers);
317 }
318 
319 ////////////////////////////////////////////////////////////////////////////////
320 /// Convert field value to string.
321 
322 const char* TMySQLStatement::ConvertToString(Int_t npar)
323 {
324  if (fBuffer[npar].fResNull) return 0;
325 
326  void* addr = fBuffer[npar].fMem;
327  Bool_t sig = fBuffer[npar].fSign;
328 
329  if (addr==0) return 0;
330 
331  if ((fBind[npar].buffer_type==MYSQL_TYPE_STRING) ||
332  (fBind[npar].buffer_type==MYSQL_TYPE_VAR_STRING))
333  return (const char*) addr;
334 
335  if (fBuffer[npar].fStrBuffer==0)
336  fBuffer[npar].fStrBuffer = new char[100];
337 
338  char* buf = fBuffer[npar].fStrBuffer;
339 
340  switch(fBind[npar].buffer_type) {
341  case MYSQL_TYPE_LONG:
342  if (sig) snprintf(buf,100,"%d",*((int*) addr));
343  else snprintf(buf,100,"%u",*((unsigned int*) addr));
344  break;
345  case MYSQL_TYPE_LONGLONG:
346  if (sig) snprintf(buf,100,"%lld",*((Long64_t*) addr)); else
347  snprintf(buf,100,"%llu",*((ULong64_t*) addr));
348  break;
349  case MYSQL_TYPE_SHORT:
350  if (sig) snprintf(buf,100,"%hd",*((short*) addr)); else
351  snprintf(buf,100,"%hu",*((unsigned short*) addr));
352  break;
353  case MYSQL_TYPE_TINY:
354  if (sig) snprintf(buf,100,"%d",*((char*) addr)); else
355  snprintf(buf,100,"%u",*((unsigned char*) addr));
356  break;
357  case MYSQL_TYPE_FLOAT:
358  snprintf(buf, 100, TSQLServer::GetFloatFormat(), *((float*) addr));
359  break;
360  case MYSQL_TYPE_DOUBLE:
361  snprintf(buf, 100, TSQLServer::GetFloatFormat(), *((double*) addr));
362  break;
363  case MYSQL_TYPE_DATETIME:
364  case MYSQL_TYPE_TIMESTAMP: {
365  MYSQL_TIME* tm = (MYSQL_TIME*) addr;
366  snprintf(buf,100,"%4.4d-%2.2d-%2.2d %2.2d:%2.2d:%2.2d",
367  tm->year, tm->month, tm->day,
368  tm->hour, tm->minute, tm->second);
369  break;
370  }
371  case MYSQL_TYPE_TIME: {
372  MYSQL_TIME* tm = (MYSQL_TIME*) addr;
373  snprintf(buf,100,"%2.2d:%2.2d:%2.2d",
374  tm->hour, tm->minute, tm->second);
375  break;
376  }
377  case MYSQL_TYPE_DATE: {
378  MYSQL_TIME* tm = (MYSQL_TIME*) addr;
379  snprintf(buf,100,"%4.4d-%2.2d-%2.2d",
380  tm->year, tm->month, tm->day);
381  break;
382  }
383  default:
384  return 0;
385  }
386  return buf;
387 }
388 
389 ////////////////////////////////////////////////////////////////////////////////
390 /// Convert field to numeric value.
391 
393 {
394  if (fBuffer[npar].fResNull) return 0;
395 
396  void* addr = fBuffer[npar].fMem;
397  Bool_t sig = fBuffer[npar].fSign;
398 
399  if (addr==0) return 0;
400 
401  switch(fBind[npar].buffer_type) {
402  case MYSQL_TYPE_LONG:
403  if (sig) return *((int*) addr); else
404  return *((unsigned int*) addr);
405  break;
406  case MYSQL_TYPE_LONGLONG:
407  if (sig) return *((Long64_t*) addr); else
408  return *((ULong64_t*) addr);
409  break;
410  case MYSQL_TYPE_SHORT:
411  if (sig) return *((short*) addr); else
412  return *((unsigned short*) addr);
413  break;
414  case MYSQL_TYPE_TINY:
415  if (sig) return *((char*) addr); else
416  return *((unsigned char*) addr);
417  break;
418  case MYSQL_TYPE_FLOAT:
419  return *((float*) addr);
420  break;
421  case MYSQL_TYPE_DOUBLE:
422  return *((double*) addr);
423  break;
424 #if MYSQL_VERSION_ID >= 50022
425  case MYSQL_TYPE_NEWDECIMAL /* new MYSQL_TYPE fixed precision decimal */:
426 #endif
427  case MYSQL_TYPE_STRING:
428  case MYSQL_TYPE_VAR_STRING:
429  case MYSQL_TYPE_BLOB: {
430  char* str = (char*) addr;
431  ULong_t len = fBuffer[npar].fResLength;
432  if ((str==0) || (*str==0) || (len==0)) return 0;
433  Int_t size = fBuffer[npar].fSize;
434  if (1.*len<size)
435  str[len] = 0;
436  else
437  str[size-1] = 0;
438  long double buf = 0;
439  sscanf(str,"%Lf",&buf);
440  return buf;
441  break;
442  }
443  case MYSQL_TYPE_DATETIME:
444  case MYSQL_TYPE_TIMESTAMP: {
445  MYSQL_TIME* tm = (MYSQL_TIME*) addr;
446  TDatime rtm(tm->year, tm->month, tm->day,
447  tm->hour, tm->minute, tm->second);
448  return rtm.Get();
449  break;
450  }
451  case MYSQL_TYPE_DATE: {
452  MYSQL_TIME* tm = (MYSQL_TIME*) addr;
453  TDatime rtm(tm->year, tm->month, tm->day, 0, 0, 0);
454  return rtm.GetDate();
455  break;
456  }
457  case MYSQL_TYPE_TIME: {
458  MYSQL_TIME* tm = (MYSQL_TIME*) addr;
459  TDatime rtm(2000, 1, 1, tm->hour, tm->minute, tm->second);
460  return rtm.GetTime();
461  break;
462  }
463 
464  default:
465  return 0;
466  }
467 
468  return 0;
469 }
470 
471 ////////////////////////////////////////////////////////////////////////////////
472 /// Checks if field value is null.
473 
475 {
476  CheckGetField("IsNull", kTRUE);
477 
478  return fBuffer[npar].fResNull;
479 }
480 
481 ////////////////////////////////////////////////////////////////////////////////
482 /// Return field value as integer.
483 
485 {
486  CheckGetField("GetInt", 0);
487 
488  if ((fBuffer[npar].fSqlType==MYSQL_TYPE_LONG) && fBuffer[npar].fSign)
489  return (Int_t) *((int*) fBuffer[npar].fMem);
490 
491  return (Int_t) ConvertToNumeric(npar);
492 }
493 
494 ////////////////////////////////////////////////////////////////////////////////
495 /// Return field value as unsigned integer.
496 
498 {
499  CheckGetField("GetUInt", 0);
500 
501  if ((fBuffer[npar].fSqlType==MYSQL_TYPE_LONG) && !fBuffer[npar].fSign)
502  return (UInt_t) *((unsigned int*) fBuffer[npar].fMem);
503 
504  return (UInt_t) ConvertToNumeric(npar);
505 }
506 
507 ////////////////////////////////////////////////////////////////////////////////
508 /// Return field value as long integer.
509 
511 {
512  CheckGetField("GetLong", 0);
513 
514  if ((fBuffer[npar].fSqlType==MYSQL_TYPE_LONG) && fBuffer[npar].fSign)
515  return (Long_t) *((int*) fBuffer[npar].fMem);
516 
517  return (Long_t) ConvertToNumeric(npar);
518 }
519 
520 ////////////////////////////////////////////////////////////////////////////////
521 /// Return field value as 64-bit integer.
522 
524 {
525  CheckGetField("GetLong64", 0);
526 
527  if ((fBuffer[npar].fSqlType==MYSQL_TYPE_LONGLONG) && fBuffer[npar].fSign)
528  return (Long64_t) *((Long64_t*) fBuffer[npar].fMem);
529 
530  return (Long64_t) ConvertToNumeric(npar);
531 }
532 
533 ////////////////////////////////////////////////////////////////////////////////
534 /// Return field value as unsigned 64-bit integer.
535 
537 {
538  CheckGetField("GetULong64", 0);
539 
540  if ((fBuffer[npar].fSqlType==MYSQL_TYPE_LONGLONG) && !fBuffer[npar].fSign)
541  return (ULong64_t) *((ULong64_t*) fBuffer[npar].fMem);
542 
543  return (ULong64_t) ConvertToNumeric(npar);
544 }
545 
546 ////////////////////////////////////////////////////////////////////////////////
547 /// Return field value as double.
548 
550 {
551  CheckGetField("GetDouble", 0);
552 
553  if (fBuffer[npar].fSqlType==MYSQL_TYPE_DOUBLE)
554  return (Double_t) *((double*) fBuffer[npar].fMem);
555 
556  return (Double_t) ConvertToNumeric(npar);
557 }
558 
559 ////////////////////////////////////////////////////////////////////////////////
560 /// Return field value as string.
561 
562 const char *TMySQLStatement::GetString(Int_t npar)
563 {
564  CheckGetField("GetString", 0);
565 
566  if ((fBind[npar].buffer_type==MYSQL_TYPE_STRING)
567  || (fBind[npar].buffer_type==MYSQL_TYPE_BLOB)
568  || (fBind[npar].buffer_type==MYSQL_TYPE_VAR_STRING)
569 #if MYSQL_VERSION_ID >= 50022
570  || (fBuffer[npar].fSqlType==MYSQL_TYPE_NEWDECIMAL)
571 #endif
572  ) {
573  if (fBuffer[npar].fResNull) return 0;
574  char* str = (char*) fBuffer[npar].fMem;
575  ULong_t len = fBuffer[npar].fResLength;
576  Int_t size = fBuffer[npar].fSize;
577  if (1.*len<size) str[len] = 0; else
578  str[size-1] = 0;
579  return str;
580  }
581 
582  return ConvertToString(npar);
583 }
584 
585 ////////////////////////////////////////////////////////////////////////////////
586 /// Return field value as binary array.
587 
588 Bool_t TMySQLStatement::GetBinary(Int_t npar, void* &mem, Long_t& size)
589 {
590  mem = 0;
591  size = 0;
592 
593  CheckGetField("GetBinary", kFALSE);
594 
595  if ((fBind[npar].buffer_type==MYSQL_TYPE_STRING) ||
596  (fBind[npar].buffer_type==MYSQL_TYPE_VAR_STRING) ||
597  (fBind[npar].buffer_type==MYSQL_TYPE_BLOB) ||
598  (fBind[npar].buffer_type==MYSQL_TYPE_TINY_BLOB) ||
599  (fBind[npar].buffer_type==MYSQL_TYPE_MEDIUM_BLOB) ||
600  (fBind[npar].buffer_type==MYSQL_TYPE_LONG_BLOB)) {
601  if (fBuffer[npar].fResNull) return kTRUE;
602  mem = fBuffer[npar].fMem;
603  size = fBuffer[npar].fResLength;
604  return kTRUE;
605  }
606 
607  return kFALSE;
608 }
609 
610 ////////////////////////////////////////////////////////////////////////////////
611 /// Return field value as date.
612 
613 Bool_t TMySQLStatement::GetDate(Int_t npar, Int_t& year, Int_t& month, Int_t& day)
614 {
615  CheckGetField("GetDate", kFALSE);
616 
617  if (fBuffer[npar].fResNull) return kFALSE;
618 
619  switch(fBind[npar].buffer_type) {
620  case MYSQL_TYPE_DATETIME:
621  case MYSQL_TYPE_TIMESTAMP:
622  case MYSQL_TYPE_DATE: {
623  MYSQL_TIME* tm = (MYSQL_TIME*) fBuffer[npar].fMem;
624  if (tm==0) return kFALSE;
625  year = tm->year;
626  month = tm->month;
627  day = tm->day;
628  break;
629  }
630  default:
631  return kFALSE;
632  }
633  return kTRUE;
634 }
635 
636 ////////////////////////////////////////////////////////////////////////////////
637 /// Return field value as time.
638 
639 Bool_t TMySQLStatement::GetTime(Int_t npar, Int_t& hour, Int_t& min, Int_t& sec)
640 {
641  CheckGetField("GetTime", kFALSE);
642 
643  if (fBuffer[npar].fResNull) return kFALSE;
644 
645  switch(fBind[npar].buffer_type) {
646  case MYSQL_TYPE_DATETIME:
647  case MYSQL_TYPE_TIMESTAMP:
648  case MYSQL_TYPE_TIME: {
649  MYSQL_TIME* tm = (MYSQL_TIME*) fBuffer[npar].fMem;
650  if (tm==0) return kFALSE;
651  hour = tm->hour;
652  min = tm->minute;
653  sec = tm->second;
654  break;
655  }
656  default:
657  return kFALSE;
658  }
659  return kTRUE;
660 }
661 
662 ////////////////////////////////////////////////////////////////////////////////
663 /// Return field value as date & time.
664 
665 Bool_t TMySQLStatement::GetDatime(Int_t npar, Int_t& year, Int_t& month, Int_t& day, Int_t& hour, Int_t& min, Int_t& sec)
666 {
667  CheckGetField("GetDatime", kFALSE);
668 
669  if (fBuffer[npar].fResNull) return kFALSE;
670 
671  switch(fBind[npar].buffer_type) {
672  case MYSQL_TYPE_DATETIME:
673  case MYSQL_TYPE_TIMESTAMP: {
674  MYSQL_TIME* tm = (MYSQL_TIME*) fBuffer[npar].fMem;
675  if (tm==0) return kFALSE;
676  year = tm->year;
677  month = tm->month;
678  day = tm->day;
679  hour = tm->hour;
680  min = tm->minute;
681  sec = tm->second;
682  break;
683  }
684  default:
685  return kFALSE;
686  }
687  return kTRUE;
688 }
689 
690 ////////////////////////////////////////////////////////////////////////////////
691 /// Return field value as time stamp.
692 
693 Bool_t TMySQLStatement::GetTimestamp(Int_t npar, Int_t& year, Int_t& month, Int_t& day, Int_t& hour, Int_t& min, Int_t& sec, Int_t& frac)
694 {
695  CheckGetField("GetTimstamp", kFALSE);
696 
697  if (fBuffer[npar].fResNull) return kFALSE;
698 
699  switch(fBind[npar].buffer_type) {
700  case MYSQL_TYPE_DATETIME:
701  case MYSQL_TYPE_TIMESTAMP: {
702  MYSQL_TIME* tm = (MYSQL_TIME*) fBuffer[npar].fMem;
703  if (tm==0) return kFALSE;
704  year = tm->year;
705  month = tm->month;
706  day = tm->day;
707  hour = tm->hour;
708  min = tm->minute;
709  sec = tm->second;
710  frac = 0;
711  break;
712  }
713  default:
714  return kFALSE;
715  }
716  return kTRUE;
717 }
718 
719 ////////////////////////////////////////////////////////////////////////////////
720 /// Set parameter type to be used as buffer.
721 /// Used in both setting data to database and retriving data from data base.
722 /// Initialize proper MYSQL_BIND structure and allocate required buffers.
723 
724 Bool_t TMySQLStatement::SetSQLParamType(Int_t npar, int sqltype, Bool_t sig, ULong_t sqlsize)
725 {
726  if ((npar<0) || (npar>=fNumBuffers)) return kFALSE;
727 
728  fBuffer[npar].fMem = 0;
729  fBuffer[npar].fSize = 0;
730  fBuffer[npar].fResLength = 0;
731  fBuffer[npar].fResNull = false;
732  fBuffer[npar].fStrBuffer = 0;
733 
734  ULong64_t allocsize = 0;
735 
736  Bool_t doreset = false;
737 
738  switch (sqltype) {
739  case MYSQL_TYPE_LONG: allocsize = sizeof(int); break;
740  case MYSQL_TYPE_LONGLONG: allocsize = sizeof(Long64_t); break;
741  case MYSQL_TYPE_SHORT: allocsize = sizeof(short); break;
742  case MYSQL_TYPE_TINY: allocsize = sizeof(char); break;
743  case MYSQL_TYPE_FLOAT: allocsize = sizeof(float); break;
744  case MYSQL_TYPE_DOUBLE: allocsize = sizeof(double); break;
745 #if MYSQL_VERSION_ID >= 50022
746  case MYSQL_TYPE_NEWDECIMAL /* new MYSQL_TYPE fixed precision decimal */:
747 #endif
748  case MYSQL_TYPE_STRING: allocsize = sqlsize > 256 ? sqlsize : 256; break;
749  case MYSQL_TYPE_VAR_STRING: allocsize = sqlsize > 256 ? sqlsize : 256; break;
750  case MYSQL_TYPE_MEDIUM_BLOB:
751  case MYSQL_TYPE_LONG_BLOB:
752  case MYSQL_TYPE_BLOB: allocsize = sqlsize >= 65525 ? sqlsize : 65535; break;
753  case MYSQL_TYPE_TINY_BLOB: allocsize = sqlsize > 255 ? sqlsize : 255; break;
754  case MYSQL_TYPE_TIME:
755  case MYSQL_TYPE_DATE:
756  case MYSQL_TYPE_TIMESTAMP:
757  case MYSQL_TYPE_DATETIME: allocsize = sizeof(MYSQL_TIME); doreset = true; break;
758  default: SetError(-1,"Nonsupported SQL type","SetSQLParamType"); return kFALSE;
759  }
760 
761  if (allocsize > fgAllocSizeLimit) allocsize = fgAllocSizeLimit;
762 
763  fBuffer[npar].fMem = malloc(allocsize);
764  fBuffer[npar].fSize = allocsize;
765  fBuffer[npar].fSqlType = sqltype;
766  fBuffer[npar].fSign = sig;
767 
768  if ((allocsize>0) && fBuffer[npar].fMem && doreset)
769  memset(fBuffer[npar].fMem, 0, allocsize);
770 
771  fBind[npar].buffer_type = enum_field_types(sqltype);
772  fBind[npar].buffer = fBuffer[npar].fMem;
773  fBind[npar].buffer_length = allocsize;
774  fBind[npar].is_null= &(fBuffer[npar].fResNull);
775  fBind[npar].length = &(fBuffer[npar].fResLength);
776  fBind[npar].is_unsigned = !sig;
777 
778  return kTRUE;
779 }
780 
781 ////////////////////////////////////////////////////////////////////////////////
782 /// Check boundary condition before setting value of parameter.
783 /// Return address of parameter buffer.
784 
785 void *TMySQLStatement::BeforeSet(const char* method, Int_t npar, Int_t sqltype, Bool_t sig, ULong_t size)
786 {
787  ClearError();
788 
789  if (!IsSetParsMode()) {
790  SetError(-1,"Cannot set parameter for statement", method);
791  return 0;
792  }
793 
794  if ((npar<0) || (npar>=fNumBuffers)) {
795  SetError(-1,Form("Invalid parameter number %d",npar), method);
796  return 0;
797  }
798 
799  if ((fIterationCount==0) && (fBuffer[npar].fSqlType==0))
800  if (!SetSQLParamType(npar, sqltype, sig, size)) {
801  SetError(-1,"Cannot initialize parameter buffer", method);
802  return 0;
803  }
804 
805  if ((fBuffer[npar].fSqlType!=sqltype) ||
806  (fBuffer[npar].fSign != sig)) return 0;
807 
808  fBuffer[npar].fResNull = false;
809 
810  return fBuffer[npar].fMem;
811 }
812 
813 ////////////////////////////////////////////////////////////////////////////////
814 /// Set NULL as parameter value.
815 /// If NULL should be set for statement parameter during first iteration,
816 /// one should call before proper Set... method to identify type of argument for
817 /// the future. For instance, if one suppose to have double as type of parameter,
818 /// code should look like:
819 /// stmt->SetDouble(2, 0.);
820 /// stmt->SetNull(2);
821 
823 {
824  void* addr = BeforeSet("SetNull", npar, MYSQL_TYPE_LONG);
825 
826  if (addr!=0)
827  *((int*) addr) = 0;
828 
829  if ((npar>=0) && (npar<fNumBuffers))
830  fBuffer[npar].fResNull = true;
831 
832  return kTRUE;
833 }
834 
835 ////////////////////////////////////////////////////////////////////////////////
836 /// Set parameter value as integer.
837 
839 {
840  void* addr = BeforeSet("SetInt", npar, MYSQL_TYPE_LONG);
841 
842  if (addr!=0)
843  *((int*) addr) = value;
844 
845  return (addr!=0);
846 }
847 
848 ////////////////////////////////////////////////////////////////////////////////
849 /// Set parameter value as unsigned integer.
850 
852 {
853  void* addr = BeforeSet("SetUInt", npar, MYSQL_TYPE_LONG, kFALSE);
854 
855  if (addr!=0)
856  *((unsigned int*) addr) = value;
857 
858  return (addr!=0);
859 }
860 
861 ////////////////////////////////////////////////////////////////////////////////
862 /// Set parameter value as long integer.
863 
865 {
866  void* addr = BeforeSet("SetLong", npar, MYSQL_TYPE_LONG);
867 
868  if (addr!=0)
869  *((int*) addr) = value;
870 
871  return (addr!=0);
872 }
873 
874 ////////////////////////////////////////////////////////////////////////////////
875 /// Set parameter value as 64-bit integer.
876 
878 {
879  void* addr = BeforeSet("SetLong64", npar, MYSQL_TYPE_LONGLONG);
880 
881  if (addr!=0)
882  *((Long64_t*) addr) = value;
883 
884  return (addr!=0);
885 }
886 
887 ////////////////////////////////////////////////////////////////////////////////
888 /// Set parameter value as unsigned 64-bit integer.
889 
891 {
892  void* addr = BeforeSet("SetULong64", npar, MYSQL_TYPE_LONGLONG, kFALSE);
893 
894  if (addr!=0)
895  *((ULong64_t*) addr) = value;
896 
897  return (addr!=0);
898 }
899 
900 ////////////////////////////////////////////////////////////////////////////////
901 /// Set parameter value as double.
902 
904 {
905  void* addr = BeforeSet("SetDouble", npar, MYSQL_TYPE_DOUBLE, kFALSE);
906 
907  if (addr!=0)
908  *((double*) addr) = value;
909 
910  return (addr!=0);
911 }
912 
913 ////////////////////////////////////////////////////////////////////////////////
914 /// Set parameter value as string.
915 
916 Bool_t TMySQLStatement::SetString(Int_t npar, const char* value, Int_t maxsize)
917 {
918  Int_t len = value ? strlen(value) : 0;
919 
920  void* addr = BeforeSet("SetString", npar, MYSQL_TYPE_STRING, true, maxsize);
921 
922  if (addr==0) return kFALSE;
923 
924  if (len >= fBuffer[npar].fSize) {
925  free(fBuffer[npar].fMem);
926 
927  fBuffer[npar].fMem = malloc(len+1);
928  fBuffer[npar].fSize = len + 1;
929 
930  fBind[npar].buffer = fBuffer[npar].fMem;
931  fBind[npar].buffer_length = fBuffer[npar].fSize;
932 
933  addr = fBuffer[npar].fMem;
934  fNeedParBind = kTRUE;
935  }
936 
937  if (value) strcpy((char*) addr, value);
938  else ((char*)addr)[0]='\0';
939 
940  fBuffer[npar].fResLength = len;
941 
942  return kTRUE;
943 }
944 
945 ////////////////////////////////////////////////////////////////////////////////
946 /// Set parameter value as binary data.
947 
948 Bool_t TMySQLStatement::SetBinary(Int_t npar, void* mem, Long_t size, Long_t maxsize)
949 {
950  if (size>=maxsize) maxsize = size + 1;
951 
952  int bin_type = MYSQL_TYPE_BLOB;
953  if (maxsize > 65525) bin_type = MYSQL_TYPE_MEDIUM_BLOB;
954  if (maxsize > 16777205) bin_type = MYSQL_TYPE_LONG_BLOB;
955 
956  void* addr = BeforeSet("SetBinary", npar, bin_type, true, maxsize);
957 
958  if (addr==0) return kFALSE;
959 
960  if (size >= fBuffer[npar].fSize) {
961  free(fBuffer[npar].fMem);
962 
963  fBuffer[npar].fMem = malloc(size+1);
964  fBuffer[npar].fSize = size + 1;
965 
966  fBind[npar].buffer = fBuffer[npar].fMem;
967  fBind[npar].buffer_length = fBuffer[npar].fSize;
968 
969  addr = fBuffer[npar].fMem;
970  fNeedParBind = kTRUE;
971  }
972 
973  memcpy(addr, mem, size);
974 
975  fBuffer[npar].fResLength = size;
976 
977  return kTRUE;
978 }
979 
980 ////////////////////////////////////////////////////////////////////////////////
981 /// Set parameter value as date.
982 
983 Bool_t TMySQLStatement::SetDate(Int_t npar, Int_t year, Int_t month, Int_t day)
984 {
985  MYSQL_TIME* addr = (MYSQL_TIME*) BeforeSet("SetDate", npar, MYSQL_TYPE_DATE);
986 
987  if (addr!=0) {
988  addr->year = year;
989  addr->month = month;
990  addr->day = day;
991  }
992 
993  return (addr!=0);
994 }
995 
996 ////////////////////////////////////////////////////////////////////////////////
997 /// Set parameter value as time.
998 
1000 {
1001  MYSQL_TIME* addr = (MYSQL_TIME*) BeforeSet("SetTime", npar, MYSQL_TYPE_TIME);
1002 
1003  if (addr!=0) {
1004  addr->hour = hour;
1005  addr->minute = min;
1006  addr->second = sec;
1007  }
1008 
1009  return (addr!=0);
1010 }
1011 
1012 ////////////////////////////////////////////////////////////////////////////////
1013 /// Set parameter value as date & time.
1014 
1015 Bool_t TMySQLStatement::SetDatime(Int_t npar, Int_t year, Int_t month, Int_t day, Int_t hour, Int_t min, Int_t sec)
1016 {
1017  MYSQL_TIME* addr = (MYSQL_TIME*) BeforeSet("SetDatime", npar, MYSQL_TYPE_DATETIME);
1018 
1019  if (addr!=0) {
1020  addr->year = year;
1021  addr->month = month;
1022  addr->day = day;
1023  addr->hour = hour;
1024  addr->minute = min;
1025  addr->second = sec;
1026  }
1027 
1028  return (addr!=0);
1029 }
1030 
1031 ////////////////////////////////////////////////////////////////////////////////
1032 /// Set parameter value as timestamp.
1033 
1034 Bool_t TMySQLStatement::SetTimestamp(Int_t npar, Int_t year, Int_t month, Int_t day, Int_t hour, Int_t min, Int_t sec, Int_t)
1035 {
1036  MYSQL_TIME* addr = (MYSQL_TIME*) BeforeSet("SetTimestamp", npar, MYSQL_TYPE_TIMESTAMP);
1037 
1038  if (addr!=0) {
1039  addr->year = year;
1040  addr->month = month;
1041  addr->day = day;
1042  addr->hour = hour;
1043  addr->minute = min;
1044  addr->second = sec;
1045  }
1046 
1047  return (addr!=0);
1048 }
1049 
1050 #else
1051 
1052 ////////////////////////////////////////////////////////////////////////////////
1053 /// Normal constructor.
1054 /// For MySQL version < 4.1 no statement is supported
1055 
1057 {
1058 }
1059 
1060 ////////////////////////////////////////////////////////////////////////////////
1061 /// Destructor.
1062 
1064 {
1065 }
1066 
1067 ////////////////////////////////////////////////////////////////////////////////
1068 /// Close statement
1069 
1071 {
1072 }
1073 
1074 ////////////////////////////////////////////////////////////////////////////////
1075 /// Process statement.
1076 
1078 {
1079  return kFALSE;
1080 }
1081 
1082 ////////////////////////////////////////////////////////////////////////////////
1083 /// Return number of affected rows after statement is processed.
1084 
1086 {
1087  return 0;
1088 }
1089 
1090 ////////////////////////////////////////////////////////////////////////////////
1091 /// Return number of statement parameters.
1092 
1094 {
1095  return 0;
1096 }
1097 
1098 ////////////////////////////////////////////////////////////////////////////////
1099 /// Store result of statement processing to access them
1100 /// via GetInt(), GetDouble() and so on methods.
1101 
1103 {
1104  return kFALSE;
1105 }
1106 
1107 ////////////////////////////////////////////////////////////////////////////////
1108 /// Return number of fields in result set.
1109 
1111 {
1112  return 0;
1113 }
1114 
1115 ////////////////////////////////////////////////////////////////////////////////
1116 /// Returns field name in result set.
1117 
1119 {
1120  return 0;
1121 }
1122 
1123 ////////////////////////////////////////////////////////////////////////////////
1124 /// Shift cursor to nect row in result set.
1125 
1127 {
1128  return kFALSE;
1129 }
1130 
1131 
1132 ////////////////////////////////////////////////////////////////////////////////
1133 /// Increment iteration counter for statement, where parameter can be set.
1134 /// Statement with parameters of previous iteration
1135 /// automatically will be applied to database.
1136 
1138 {
1139  return kFALSE;
1140 }
1141 
1142 ////////////////////////////////////////////////////////////////////////////////
1143 /// Release all buffers, used by statement.
1144 
1146 {
1147 }
1148 
1149 ////////////////////////////////////////////////////////////////////////////////
1150 /// Allocate buffers for statement parameters/ result fields.
1151 
1153 {
1154 }
1155 
1156 ////////////////////////////////////////////////////////////////////////////////
1157 /// Convert field value to string.
1158 
1160 {
1161  return 0;
1162 }
1163 
1164 ////////////////////////////////////////////////////////////////////////////////
1165 /// Convert field to numeric value.
1166 
1168 {
1169  return 0;
1170 }
1171 
1172 ////////////////////////////////////////////////////////////////////////////////
1173 /// Checks if field value is null.
1174 
1176 {
1177  return kTRUE;
1178 }
1179 
1180 ////////////////////////////////////////////////////////////////////////////////
1181 /// Return field value as integer.
1182 
1184 {
1185  return 0;
1186 }
1187 
1188 ////////////////////////////////////////////////////////////////////////////////
1189 /// Return field value as unsigned integer.
1190 
1192 {
1193  return 0;
1194 }
1195 
1196 ////////////////////////////////////////////////////////////////////////////////
1197 /// Return field value as long integer.
1198 
1200 {
1201  return 0;
1202 }
1203 
1204 ////////////////////////////////////////////////////////////////////////////////
1205 /// Return field value as 64-bit integer.
1206 
1208 {
1209  return 0;
1210 }
1211 
1212 ////////////////////////////////////////////////////////////////////////////////
1213 /// Return field value as unsigned 64-bit integer.
1214 
1216 {
1217  return 0;
1218 }
1219 
1220 ////////////////////////////////////////////////////////////////////////////////
1221 /// Return field value as double.
1222 
1224 {
1225  return 0.;
1226 }
1227 
1228 ////////////////////////////////////////////////////////////////////////////////
1229 /// Return field value as string.
1230 
1232 {
1233  return 0;
1234 }
1235 
1236 ////////////////////////////////////////////////////////////////////////////////
1237 /// Return field value as binary array.
1238 
1240 {
1241  return kFALSE;
1242 }
1243 
1244 
1245 ////////////////////////////////////////////////////////////////////////////////
1246 /// Return field value as date.
1247 
1249 {
1250  return kFALSE;
1251 }
1252 
1253 ////////////////////////////////////////////////////////////////////////////////
1254 /// Return field value as time.
1255 
1257 {
1258  return kFALSE;
1259 }
1260 
1261 ////////////////////////////////////////////////////////////////////////////////
1262 /// Return field value as date & time.
1263 
1265 {
1266  return kFALSE;
1267 }
1268 
1269 ////////////////////////////////////////////////////////////////////////////////
1270 /// Return field value as time stamp.
1271 
1273 {
1274  return kFALSE;
1275 }
1276 
1277 ////////////////////////////////////////////////////////////////////////////////
1278 /// Set parameter type to be used as buffer.
1279 /// Used in both setting data to database and retriving data from data base.
1280 /// Initialize proper MYSQL_BIND structure and allocate required buffers.
1281 
1283 {
1284  return kFALSE;
1285 }
1286 
1287 ////////////////////////////////////////////////////////////////////////////////
1288 /// Check boundary condition before setting value of parameter.
1289 /// Return address of parameter buffer.
1290 
1292 {
1293  return 0;
1294 }
1295 
1296 ////////////////////////////////////////////////////////////////////////////////
1297 /// Set NULL as parameter value.
1298 /// If NULL should be set for statement parameter during first iteration,
1299 /// one should call before proper Set... method to identify type of argument for
1300 /// the future. For instance, if one suppose to have double as type of parameter,
1301 /// code should look like:
1302 /// stmt->SetDouble(2, 0.);
1303 /// stmt->SetNull(2);
1304 
1306 {
1307  return kFALSE;
1308 }
1309 
1310 ////////////////////////////////////////////////////////////////////////////////
1311 /// Set parameter value as integer.
1312 
1314 {
1315  return kFALSE;
1316 }
1317 
1318 ////////////////////////////////////////////////////////////////////////////////
1319 /// Set parameter value as unsigned integer.
1320 
1322 {
1323  return kFALSE;
1324 }
1325 
1326 ////////////////////////////////////////////////////////////////////////////////
1327 /// Set parameter value as long integer.
1328 
1330 {
1331  return kFALSE;
1332 }
1333 
1334 ////////////////////////////////////////////////////////////////////////////////
1335 /// Set parameter value as 64-bit integer.
1336 
1338 {
1339  return kFALSE;
1340 }
1341 
1342 ////////////////////////////////////////////////////////////////////////////////
1343 /// Set parameter value as unsigned 64-bit integer.
1344 
1346 {
1347  return kFALSE;
1348 }
1349 
1350 ////////////////////////////////////////////////////////////////////////////////
1351 /// Set parameter value as double.
1352 
1354 {
1355  return kFALSE;
1356 }
1357 
1358 ////////////////////////////////////////////////////////////////////////////////
1359 /// Set parameter value as string.
1360 
1362 {
1363  return kFALSE;
1364 }
1365 
1366 ////////////////////////////////////////////////////////////////////////////////
1367 /// Set parameter value as binary data.
1368 
1370 {
1371  return kFALSE;
1372 }
1373 
1374 ////////////////////////////////////////////////////////////////////////////////
1375 /// Set parameter value as date.
1376 
1378 {
1379  return kFALSE;
1380 }
1381 
1382 ////////////////////////////////////////////////////////////////////////////////
1383 /// Set parameter value as time.
1384 
1386 {
1387  return kFALSE;
1388 }
1389 
1390 ////////////////////////////////////////////////////////////////////////////////
1391 /// Set parameter value as date & time.
1392 
1394 {
1395  return kFALSE;
1396 }
1397 
1398 ////////////////////////////////////////////////////////////////////////////////
1399 /// Set parameter value as timestamp.
1400 
1402 {
1403  return kFALSE;
1404 }
1405 
1406 #endif // MYSQL_VERSION_ID > 40100
virtual Bool_t SetLong64(Int_t npar, Long64_t value)
Set parameter value as 64-bit integer.
virtual Int_t GetNumParameters()
Return number of statement parameters.
virtual Bool_t SetBinary(Int_t npar, void *mem, Long_t size, Long_t maxsize=0x1000)
Set parameter value as binary data.
long long Long64_t
Definition: RtypesCore.h:69
const char * ConvertToString(Int_t npar)
Convert field value to string.
#define CheckStmt(method, res)
const char Option_t
Definition: RtypesCore.h:62
virtual ULong64_t GetULong64(Int_t npar)
Return field value as unsigned 64-bit integer.
virtual Int_t GetNumAffectedRows()
Return number of affected rows after statement is processed.
virtual Bool_t SetNull(Int_t npar)
Set NULL as parameter value.
virtual Bool_t SetLong(Int_t npar, Long_t value)
Set parameter value as long integer.
virtual Bool_t NextResultRow()
Shift cursor to nect row in result set.
virtual Bool_t SetTime(Int_t npar, Int_t hour, Int_t min, Int_t sec)
Set parameter value as time.
void Close(Option_t *opt="")
Close connection to MySQL DB server.
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
const Bool_t kFALSE
Definition: Rtypes.h:92
#define malloc
Definition: civetweb.c:818
static const char * GetFloatFormat()
return current printf format for float/double members, default "%e"
Definition: TSQLServer.cxx:269
void FreeBuffers()
Release all buffers, used by statement.
virtual Bool_t SetULong64(Int_t npar, ULong64_t value)
Set parameter value as unsigned 64-bit integer.
void ClearError()
reset error fields
Definition: TSQLServer.cxx:119
virtual void Close(Option_t *="")
Close statement.
virtual Bool_t SetDatime(Int_t npar, Int_t year, Int_t month, Int_t day, Int_t hour, Int_t min, Int_t sec)
Set parameter value as date & time.
const int maxsize
void SetBuffersNumber(Int_t n)
Allocate buffers for statement parameters/ result fields.
virtual Int_t GetInt(Int_t npar)
Return field value as integer.
virtual Bool_t GetDate(Int_t npar, Int_t &year, Int_t &month, Int_t &day)
Return field value as date.
virtual Bool_t SetString(Int_t npar, const char *value, Int_t maxsize=256)
Set parameter value as string.
#define CheckErrNo(method, force, res)
virtual Int_t GetNumFields()
Return number of fields in result set.
virtual Bool_t SetDouble(Int_t npar, Double_t value)
Set parameter value as double.
virtual Long64_t GetLong64(Int_t npar)
Return field value as 64-bit integer.
virtual Bool_t GetTimestamp(Int_t npar, Int_t &year, Int_t &month, Int_t &day, Int_t &hour, Int_t &min, Int_t &sec, Int_t &)
Return field value as time stamp.
unsigned int UInt_t
Definition: RtypesCore.h:42
char * Form(const char *fmt,...)
virtual Double_t GetDouble(Int_t npar)
Return field value as double.
TMySQLStatement(const TMySQLStatement &)
virtual Bool_t GetTime(Int_t npar, Int_t &hour, Int_t &min, Int_t &sec)
Return field value as time.
long Long_t
Definition: RtypesCore.h:50
#define ClassImp(name)
Definition: Rtypes.h:279
long double ConvertToNumeric(Int_t npar)
Convert field to numeric value.
double Double_t
Definition: RtypesCore.h:55
virtual Bool_t SetUInt(Int_t npar, UInt_t value)
Set parameter value as unsigned integer.
int type
Definition: TGX11.cxx:120
unsigned long long ULong64_t
Definition: RtypesCore.h:70
#define free
Definition: civetweb.c:821
virtual Bool_t SetInt(Int_t npar, Int_t value)
Set parameter value as integer.
unsigned long ULong_t
Definition: RtypesCore.h:51
virtual Bool_t Process()
Process statement.
virtual Bool_t GetBinary(Int_t npar, void *&mem, Long_t &size)
Return field value as binary array.
virtual const char * GetFieldName(Int_t nfield)
Returns field name in result set.
void SetError(Int_t code, const char *msg, const char *method=0)
set new values for error fields if method is specified, displays error message
Definition: TSQLServer.cxx:129
virtual Bool_t GetDatime(Int_t npar, Int_t &year, Int_t &month, Int_t &day, Int_t &hour, Int_t &min, Int_t &sec)
Return field value as date & time.
virtual Bool_t SetTimestamp(Int_t npar, Int_t year, Int_t month, Int_t day, Int_t hour, Int_t min, Int_t sec, Int_t frac=0)
Set parameter value as timestamp.
virtual Long_t GetLong(Int_t npar)
Return field value as long integer.
#define CheckGetField(method, defres)
virtual Bool_t SetDate(Int_t npar, Int_t year, Int_t month, Int_t day)
Set parameter value as date.
virtual const char * GetString(Int_t npar)
Return field value as string.
virtual Bool_t IsNull(Int_t npar)
Checks if field value is null.
#define snprintf
Definition: civetweb.c:822
virtual UInt_t GetUInt(Int_t npar)
Return field value as unsigned integer.
virtual Bool_t NextIteration()
Increment iteration counter for statement, where parameter can be set.
const Bool_t kTRUE
Definition: Rtypes.h:91
static ULong64_t fgAllocSizeLimit
void * BeforeSet(const char *method, Int_t npar, Int_t sqltype, Bool_t sig=kTRUE, ULong_t size=0)
Check boundary condition before setting value of parameter.
const Int_t n
Definition: legend1.C:16
char name[80]
Definition: TGX11.cxx:109
Bool_t SetSQLParamType(Int_t npar, int sqltype, Bool_t sig, ULong_t sqlsize=0)
Set parameter type to be used as buffer.
virtual Bool_t StoreResult()
Store result of statement processing to access them via GetInt(), GetDouble() and so on methods...
This class stores the date and time with a precision of one second in an unsigned 32 bit word (950130...
Definition: TDatime.h:39
virtual ~TMySQLStatement()
Destructor.