Logo ROOT   6.14/05
Reference Guide
TBufferSQL.cxx
Go to the documentation of this file.
1 // @(#)root/tree:$Id$
2 // Author: Philippe Canal and al. 08/2004
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2000, 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 /** \class TBufferSQL
13 \ingroup tree
14 Implement TBuffer for a SQL backend.
15 */
16 
17 #include <stdio.h>
18 #include "Riostream.h"
19 #include "TError.h"
20 
21 #include "TBasketSQL.h"
22 #include "TBufferSQL.h"
23 #include "TSQLResult.h"
24 #include "TSQLRow.h"
25 #include <stdlib.h>
26 
28 
29 ////////////////////////////////////////////////////////////////////////////////
30 /// Constructor.
31 
32 TBufferSQL::TBufferSQL(TBuffer::EMode mode, std::vector<Int_t> *vc,
33  TString *insert_query, TSQLRow ** r) :
34  TBufferFile(mode),
35  fColumnVec(vc), fInsertQuery(insert_query), fRowPtr(r)
36 {
37  fIter = fColumnVec->begin();
38 }
39 
40 ////////////////////////////////////////////////////////////////////////////////
41 /// Constructor.
42 
43 TBufferSQL::TBufferSQL(TBuffer::EMode mode, Int_t bufsiz, std::vector<Int_t> *vc,
44  TString *insert_query, TSQLRow ** r) :
45  TBufferFile(mode,bufsiz),
46  fColumnVec(vc), fInsertQuery(insert_query), fRowPtr(r)
47 {
48  fIter = fColumnVec->begin();
49 }
50 
51 ////////////////////////////////////////////////////////////////////////////////
52 /// Constructor.
53 
54 TBufferSQL::TBufferSQL(TBuffer::EMode mode, Int_t bufsiz, std::vector<Int_t> *vc,
55  TString *insert_query, TSQLRow ** r,
56  void *buf, Bool_t adopt) :
57  TBufferFile(mode,bufsiz,buf,adopt),
58  fColumnVec(vc), fInsertQuery(insert_query), fRowPtr(r)
59 {
60  fIter = fColumnVec->begin();
61 }
62 
63 ////////////////////////////////////////////////////////////////////////////////
64 /// Constructor.
65 
67 {
68 }
69 
70 ////////////////////////////////////////////////////////////////////////////////
71 /// Destructor.
72 
74 {
75  delete fColumnVec;
76 }
77 
78 ////////////////////////////////////////////////////////////////////////////////
79 /// Operator>>
80 
82 {
83  b = (Bool_t)atoi((*fRowPtr)->GetField(*fIter));
84 
85  if (fIter != fColumnVec->end()) ++fIter;
86 }
87 
88 ////////////////////////////////////////////////////////////////////////////////
89 /// Operator>>
90 
92 {
93  c = (Char_t)atoi((*fRowPtr)->GetField(*fIter));
94 
95  if (fIter != fColumnVec->end()) ++fIter;
96 }
97 
98 ////////////////////////////////////////////////////////////////////////////////
99 /// Operator>>
100 
102 {
103  h = (Short_t)atoi((*fRowPtr)->GetField(*fIter));
104 
105  if (fIter != fColumnVec->end()) ++fIter;
106 }
107 
108 ////////////////////////////////////////////////////////////////////////////////
109 /// Operator>>
110 
112 {
113  i = atoi((*fRowPtr)->GetField(*fIter));
114 
115  if (fIter != fColumnVec->end()) ++fIter;
116 }
117 
118 ////////////////////////////////////////////////////////////////////////////////
119 /// Operator>>
120 
122 {
123  f = atof((*fRowPtr)->GetField(*fIter));
124 
125  if (fIter != fColumnVec->end()) ++fIter;
126 }
127 
128 ////////////////////////////////////////////////////////////////////////////////
129 /// Operator>>
130 
132 {
133  l = atol((*fRowPtr)->GetField(*fIter));
134 
135  if (fIter != fColumnVec->end()) ++fIter;
136 }
137 
138 ////////////////////////////////////////////////////////////////////////////////
139 /// Operator>>
140 
142 {
143  d = atof((*fRowPtr)->GetField(*fIter));
144 
145  if (fIter != fColumnVec->end()) ++fIter;
146 }
147 
148 ////////////////////////////////////////////////////////////////////////////////
149 /// Operator<<
150 
152 {
153  (*fInsertQuery) += b;
154  (*fInsertQuery) += ",";
155  if (fIter != fColumnVec->end()) ++fIter;
156 }
157 
158 ////////////////////////////////////////////////////////////////////////////////
159 /// Operator<<
160 
162 {
163  (*fInsertQuery) += c;
164  (*fInsertQuery) += ",";
165  if (fIter != fColumnVec->end()) ++fIter;
166 }
167 
168 ////////////////////////////////////////////////////////////////////////////////
169 /// Operator<<
170 
172 {
173  (*fInsertQuery) += h;
174  (*fInsertQuery) += ",";
175  if (fIter != fColumnVec->end()) ++fIter;
176 }
177 
178 ////////////////////////////////////////////////////////////////////////////////
179 /// Operator<<
180 
182 {
183  (*fInsertQuery) += i;
184  (*fInsertQuery) += ",";
185  if (fIter != fColumnVec->end()) ++fIter;
186 }
187 
188 ////////////////////////////////////////////////////////////////////////////////
189 /// Operator<<
190 
192 {
193  (*fInsertQuery) += l;
194  (*fInsertQuery) += ",";
195  if (fIter != fColumnVec->end()) ++fIter;
196 }
197 
198 ////////////////////////////////////////////////////////////////////////////////
199 /// Operator<<
200 
202 {
203  (*fInsertQuery) += f;
204  (*fInsertQuery) += ",";
205  if (fIter != fColumnVec->end()) ++fIter;
206 }
207 
208 ////////////////////////////////////////////////////////////////////////////////
209 /// Operator<<
210 
212 {
213  (*fInsertQuery) += d;
214  (*fInsertQuery) += ",";
215  if (fIter != fColumnVec->end()) ++fIter;
216 }
217 
218 ////////////////////////////////////////////////////////////////////////////////
219 /// Operator>>
220 
222 {
223  uc = (UChar_t)atoi((*fRowPtr)->GetField(*fIter));
224 
225  if (fIter != fColumnVec->end()) ++fIter;
226 }
227 
228 ////////////////////////////////////////////////////////////////////////////////
229 /// Operator>>
230 
232 {
233  us = (UShort_t)atoi((*fRowPtr)->GetField(*fIter));
234 
235  if (fIter != fColumnVec->end()) ++fIter;
236 }
237 
238 ////////////////////////////////////////////////////////////////////////////////
239 /// Operator>>
240 
242 {
243  TString val = (*fRowPtr)->GetField(*fIter);
244  Int_t code = sscanf(val.Data(), "%u",&ui);
245  if(code == 0) Error("operator>>(UInt_t&)","Error reading UInt_t");
246 
247  if (fIter != fColumnVec->end()) ++fIter;
248 }
249 
250 ////////////////////////////////////////////////////////////////////////////////
251 /// Operator>>
252 
254 {
255  TString val = (*fRowPtr)->GetField(*fIter);
256  Int_t code = sscanf(val.Data(), "%lu",&ul);
257  if(code == 0) Error("operator>>(ULong_t&)","Error reading ULong_t");
258 
259  if (fIter != fColumnVec->end()) ++fIter;
260 }
261 
262 ////////////////////////////////////////////////////////////////////////////////
263 /// Operator>>
264 
266 {
267  TString val = (*fRowPtr)->GetField(*fIter);
268  Int_t code = sscanf(val.Data(), "%lld",&ll);
269  if(code == 0) Error("operator>>(ULong_t&)","Error reading Long64_t");
270 
271  if (fIter != fColumnVec->end()) ++fIter;
272 }
273 
274 ////////////////////////////////////////////////////////////////////////////////
275 /// Operator>>
276 
278 {
279  TString val = (*fRowPtr)->GetField(*fIter);
280  Int_t code = sscanf(val.Data(), "%llu",&ull);
281  if(code == 0) Error("operator>>(ULong_t&)","Error reading ULong64_t");
282 
283  if (fIter != fColumnVec->end()) ++fIter;
284 }
285 
286 ////////////////////////////////////////////////////////////////////////////////
287 /// Operator>>
288 
290 {
291  strcpy(str,(*fRowPtr)->GetField(*fIter)); // Legacy interface, we have no way to know the user's buffer size ....
292  if (fIter != fColumnVec->end()) ++fIter;
293 }
294 
295 ////////////////////////////////////////////////////////////////////////////////
296 /// Read a TString
297 
299 {
301 }
302 
303 ////////////////////////////////////////////////////////////////////////////////
304 /// Write a TString
305 
307 {
309 }
310 
311 ////////////////////////////////////////////////////////////////////////////////
312 /// Read a std::string
313 
314 void TBufferSQL::ReadStdString(std::string *s)
315 {
317 }
318 
319 ////////////////////////////////////////////////////////////////////////////////
320 /// Write a std::string
321 
322 void TBufferSQL::WriteStdString(const std::string *s)
323 {
325 }
326 
327 ////////////////////////////////////////////////////////////////////////////////
328 /// Read a char* string
329 
331 {
333 }
334 
335 ////////////////////////////////////////////////////////////////////////////////
336 /// Write a char* string
337 
339 {
341 }
342 
343 
344 // Method to send to database.
345 
346 ////////////////////////////////////////////////////////////////////////////////
347 /// Operator<<
348 
350 {
351  (*fInsertQuery) += uc;
352  (*fInsertQuery) += ",";
353  ++fIter;
354 }
355 
356 ////////////////////////////////////////////////////////////////////////////////
357 /// Operator<<
358 
360 {
361  (*fInsertQuery) += us;
362  (*fInsertQuery) += ",";
363  ++fIter;
364 }
365 
366 ////////////////////////////////////////////////////////////////////////////////
367 /// Operator<<
368 
370 {
371  (*fInsertQuery) += ui;
372  (*fInsertQuery) += ",";
373  ++fIter;
374 }
375 
376 ////////////////////////////////////////////////////////////////////////////////
377 /// Operator<<
378 
380 {
381  (*fInsertQuery) += ul;
382  (*fInsertQuery) += ",";
383  ++fIter;
384 }
385 
386 ////////////////////////////////////////////////////////////////////////////////
387 /// Operator<<
388 
390 {
391  (*fInsertQuery) += ll;
392  (*fInsertQuery) += ",";
393  ++fIter;
394 }
395 
396 ////////////////////////////////////////////////////////////////////////////////
397 /// Operator<<
398 
400 {
401  (*fInsertQuery) += ull;
402  (*fInsertQuery) += ",";
403  ++fIter;
404 }
405 
406 ////////////////////////////////////////////////////////////////////////////////
407 /// Operator<<
408 
410 {
411  (*fInsertQuery) += "\"";
412  (*fInsertQuery) += str;
413  (*fInsertQuery) += "\",";
414  ++fIter;
415 }
416 
417 ////////////////////////////////////////////////////////////////////////////////
418 /// WriteFastArray SQL implementation.
419 
421 {
422  for(int i=0; i<n; ++i) {
423  (*fInsertQuery) += b[i];
424  (*fInsertQuery) += ",";
425  ++fIter;
426  }
427 }
428 
429 ////////////////////////////////////////////////////////////////////////////////
430 /// WriteFastArray SQL implementation.
431 
433 {
434  for(int i=0; i<n; ++i) {
435  (*fInsertQuery) += (Short_t)c[i];
436  (*fInsertQuery) += ",";
437  ++fIter;
438  }
439 }
440 
441 ////////////////////////////////////////////////////////////////////////////////
442 /// WriteFastArray SQL implementation.
443 
445 {
446  (*fInsertQuery) += "\"";
447  (*fInsertQuery) += c;
448  (*fInsertQuery) += "\",";
449  ++fIter;
450 }
451 
452 ////////////////////////////////////////////////////////////////////////////////
453 /// WriteFastArray SQL implementation.
454 
456 {
457  for(int i=0; i<n; ++i) {
458  (*fInsertQuery) += uc[i];
459  (*fInsertQuery) += ",";
460  ++fIter;
461  }
462 }
463 
464 ////////////////////////////////////////////////////////////////////////////////
465 /// WriteFastArray SQL implementation.
466 
468 {
469  for(int i=0; i<n; ++i) {
470  (*fInsertQuery) += h[i];
471  (*fInsertQuery) += ",";
472  ++fIter;
473  }
474 }
475 
476 ////////////////////////////////////////////////////////////////////////////////
477 /// WriteFastArray SQL implementation.
478 
480 {
481  for(int i=0; i<n; ++i) {
482  (*fInsertQuery) += us[i];
483  (*fInsertQuery) += ",";
484  ++fIter;
485  }
486 }
487 
488 ////////////////////////////////////////////////////////////////////////////////
489 /// WriteFastArray SQL implementation.
490 
492 {
493  // std::cerr << "Column: " <<*fIter << " i:" << *ii << std::endl;
494  for(int i=0; i<n; ++i) {
495  (*fInsertQuery) += ii[i];
496  (*fInsertQuery) += ",";
497  ++fIter;
498  }
499 }
500 
501 ////////////////////////////////////////////////////////////////////////////////
502 /// WriteFastArray SQL implementation.
503 
505 {
506  for(int i=0; i<n; ++i) {
507  (*fInsertQuery) += ui[i];
508  (*fInsertQuery) += ",";
509  ++fIter;
510  }
511 }
512 
513 ////////////////////////////////////////////////////////////////////////////////
514 /// WriteFastArray SQL implementation.
515 
517 {
518  for(int i=0; i<n; ++i) {
519  (*fInsertQuery)+= l[i];
520  (*fInsertQuery)+= ",";
521  ++fIter;
522  }
523 }
524 
525 ////////////////////////////////////////////////////////////////////////////////
526 /// WriteFastArray SQL implementation.
527 
529 {
530  for(int i=0; i<n; ++i) {
531  (*fInsertQuery) += ul[i];
532  (*fInsertQuery) += ",";
533  ++fIter;
534  }
535 }
536 
537 ////////////////////////////////////////////////////////////////////////////////
538 /// WriteFastArray SQL implementation.
539 
541 {
542  for(int i=0; i<n; ++i) {
543  (*fInsertQuery) += l[i];
544  (*fInsertQuery) += ",";
545  ++fIter;
546  }
547 }
548 
549 ////////////////////////////////////////////////////////////////////////////////
550 /// WriteFastArray SQL implementation.
551 
553 {
554  for(int i=0; i<n; ++i) {
555  (*fInsertQuery) += ul[i];
556  (*fInsertQuery) += ",";
557  ++fIter;
558  }
559 }
560 
561 ////////////////////////////////////////////////////////////////////////////////
562 /// WriteFastArray SQL implementation.
563 
565 {
566  for(int i=0; i<n; ++i) {
567  (*fInsertQuery) += f[i];
568  (*fInsertQuery) += ",";
569  ++fIter;
570  }
571 }
572 
573 ////////////////////////////////////////////////////////////////////////////////
574 /// WriteFastArray SQL implementation.
575 
577 {
578  for(int i=0; i<n; ++i) {
579  (*fInsertQuery) += d[i];
580  (*fInsertQuery )+= ",";
581  ++fIter;
582  }
583 }
584 
585 ////////////////////////////////////////////////////////////////////////////////
586 /// WriteFastArray SQL implementation.
587 
589 {
590  Fatal("riteFastArray(void*, const TClass*, Int_t, TMemberStreamer *)","Not implemented yet");
591 }
592 
593 ////////////////////////////////////////////////////////////////////////////////
594 /// WriteFastArray SQL implementation.
595 
597 {
598  Fatal("WriteFastArray(void **, const TClass*, Int_t, Bool_t, TMemberStreamer*)","Not implemented yet");
599  return 0;
600 }
601 
602 ////////////////////////////////////////////////////////////////////////////////
603 /// ReadFastArray SQL implementation.
604 
606 {
607  for(int i=0; i<n; ++i) {
608  b[i] = (Bool_t)atoi((*fRowPtr)->GetField(*fIter));
609  ++fIter;
610  }
611 }
612 
613 ////////////////////////////////////////////////////////////////////////////////
614 /// ReadFastArray SQL implementation.
615 
617 {
618  for(int i=0; i<n; ++i) {
619  c[i] = (Char_t)atoi((*fRowPtr)->GetField(*fIter));
620  ++fIter;
621  }
622 }
623 
624 ////////////////////////////////////////////////////////////////////////////////
625 /// ReadFastArray SQL implementation.
626 
628 {
629  strcpy(c,((*fRowPtr)->GetField(*fIter)));
630  ++fIter;
631 }
632 
633 ////////////////////////////////////////////////////////////////////////////////
634 /// ReadFastArray SQL implementation.
635 
637 {
638  for(int i=0; i<n; ++i) {
639  uc[i] = (UChar_t)atoi((*fRowPtr)->GetField(*fIter));
640  ++fIter;
641  }
642 }
643 
644 ////////////////////////////////////////////////////////////////////////////////
645 /// ReadFastArray SQL implementation.
646 
648 {
649  for(int i=0; i<n; ++i) {
650  s[i] = (Short_t)atoi((*fRowPtr)->GetField(*fIter));
651  ++fIter;
652  }
653 }
654 
655 ////////////////////////////////////////////////////////////////////////////////
656 /// ReadFastArray SQL implementation.
657 
659 {
660  for(int i=0; i<n; ++i) {
661  us[i] = (UShort_t)atoi((*fRowPtr)->GetField(*fIter));
662  ++fIter;
663  }
664 }
665 
666 ////////////////////////////////////////////////////////////////////////////////
667 /// ReadFastArray SQL implementation.
668 
670 {
671  for(int i=0; i<n; ++i) {
672  in[i] = atoi((*fRowPtr)->GetField(*fIter));
673  ++fIter;
674  }
675 }
676 
677 ////////////////////////////////////////////////////////////////////////////////
678 /// ReadFastArray SQL implementation.
679 
681 {
682  for(int i=0; i<n; ++i) {
683  ui[i] = atoi((*fRowPtr)->GetField(*fIter));
684  ++fIter;
685  }
686 }
687 
688 ////////////////////////////////////////////////////////////////////////////////
689 /// ReadFastArray SQL implementation.
690 
692 {
693  for(int i=0; i<n; ++i) {
694  l[i] = atol((*fRowPtr)->GetField(*fIter));
695  ++fIter;
696  }
697 }
698 
699 ////////////////////////////////////////////////////////////////////////////////
700 /// ReadFastArray SQL implementation.
701 
703 {
704  for(int i=0; i<n; ++i) {
705  (*this) >> ul[i];
706  }
707 }
708 
709 ////////////////////////////////////////////////////////////////////////////////
710 /// ReadFastArray SQL implementation.
711 
713 {
714  for(int i=0; i<n; ++i) {
715  (*this) >> ll[i];
716  }
717 }
718 
719 ////////////////////////////////////////////////////////////////////////////////
720 /// ReadFastArray SQL implementation.
721 
723 {
724  for(int i=0; i<n; ++i) {
725  (*this) >> ull[i];
726  }
727 }
728 
729 ////////////////////////////////////////////////////////////////////////////////
730 /// ReadFastArray SQL implementation.
731 
733 {
734  for(int i=0; i<n; ++i) {
735  f[i] = atof((*fRowPtr)->GetField(*fIter));
736  ++fIter;
737  }
738 }
739 
740 ////////////////////////////////////////////////////////////////////////////////
741 /// ReadFastArray SQL implementation.
742 
744 {
745  for(int i=0; i<n; ++i) {
746  d[i] = atof((*fRowPtr)->GetField(*fIter));
747  ++fIter;
748  }
749 }
750 
751 ////////////////////////////////////////////////////////////////////////////////
752 /// ReadFastArray SQL implementation.
753 
755 {
756  Fatal("ReadFastArrayFloat16(Float_t *, Int_t , TStreamerElement *)","Not implemented yet");
757 }
758 
759 ////////////////////////////////////////////////////////////////////////////////
760 /// Read array of Float16_t from buffer
761 
762 void TBufferSQL::ReadFastArrayWithFactor(Float_t *, Int_t , Double_t /* factor */, Double_t /* minvalue */)
763 {
764  Fatal("ReadFastArrayWithFactor(Float_t *, Int_t, Double_t, Double_t)","Not implemented yet");
765 }
766 
767 ////////////////////////////////////////////////////////////////////////////////
768 /// Read array of Float16_t from buffer
769 
771 {
772  Fatal("ReadFastArrayWithNbits(Float_t *, Int_t , Int_t )","Not implemented yet");
773 }
774 
775 ////////////////////////////////////////////////////////////////////////////////
776 /// Read array of Double32_t from buffer
777 
778 void TBufferSQL::ReadFastArrayWithFactor(Double_t *, Int_t , Double_t /* factor */, Double_t /* minvalue */)
779 {
780  Fatal("ReadFastArrayWithFactor(Double_t *, Int_t, Double_t, Double_t)","Not implemented yet");
781 }
782 
783 ////////////////////////////////////////////////////////////////////////////////
784 /// Read array of Double32_t from buffer
785 
787 {
788  Fatal("ReadFastArrayWithNbits(Double_t *, Int_t , Int_t )","Not implemented yet");
789 }
790 
791 ////////////////////////////////////////////////////////////////////////////////
792 /// ReadFastArray SQL implementation.
793 
795 {
796  Fatal("ReadFastArrayDouble32(Double_t *, Int_t , TStreamerElement *)","Not implemented yet");
797 }
798 
799 ////////////////////////////////////////////////////////////////////////////////
800 /// ReadFastArray SQL implementation.
801 
802 void TBufferSQL::ReadFastArray(void *, const TClass *, Int_t, TMemberStreamer *, const TClass *)
803 {
804  Fatal("ReadFastArray(void *, const TClass *, Int_t, TMemberStreamer *, const TClass *)","Not implemented yet");
805 }
806 
807 ////////////////////////////////////////////////////////////////////////////////
808 /// ReadFastArray SQL implementation.
809 
811 {
812  Fatal("ReadFastArray(void **, const TClass *, Int_t, Bool_t, TMemberStreamer *, const TClass *)","Not implemented yet");
813 }
814 
815 ////////////////////////////////////////////////////////////////////////////////
816 /// Reset Offset.
817 
819 {
820  fIter = fColumnVec->begin();
821 }
822 
823 #if 0
824 ////////////////////////////////////////////////////////////////////////////////
825 
826 void TBufferSQL::insert_test(const char* dsn, const char* usr,
827  const char* pwd, const TString& tblname)
828 {
829  TString str;
830  TString select = "select * from ";
831  TString sql;
832  TSQLStatement* stmt;
833  sql = select + "ins";
834 
835  con = gSQLDriverManager->GetConnection(dsn,usr,pwd);
836 
837  if(!con)
838  printf("\n\n\nConnection NOT Successful\n\n\n");
839  else
840  printf("\n\n\nConnection Sucessful\n\n\n");
841 
842  stmt = con->CreateStatement(0, odbc::ResultSet::CONCUR_READ_ONLY);
843 
844  ptr = stmt->ExecuteQuery(sql.Data());
845  if(!ptr) printf("No recorSet found!");
846 
847  ptr->Next();
848  ptr->MoveToInsertRow();
849  std::cerr << "IsAfterLast(): " << ptr->IsAfterLast() << std::endl;
850  ptr->UpdateInt(1, 5555);
851  ptr->InsertRow();
852  con->Commit();
853 
854  ptr1 = stmt->ExecuteQuery(sql.Data());
855 
856 }
857 #endif
virtual void ReadLong64(Long64_t &l)
Operator>>
Definition: TBufferSQL.cxx:265
virtual void WriteUShort(UShort_t s)
Operator<<.
Definition: TBufferSQL.cxx:359
The concrete implementation of TBuffer for writing/reading to/from a ROOT file or socket...
Definition: TBufferFile.h:46
virtual void WriteUChar(UChar_t c)
Operator<<.
Definition: TBufferSQL.cxx:349
virtual void ReadStdString(std::string *s)
Read a std::string.
Definition: TBufferSQL.cxx:314
long long Long64_t
Definition: RtypesCore.h:69
Implement TBuffer for a SQL backend.
Definition: TBufferSQL.h:30
float Float_t
Definition: RtypesCore.h:53
static constexpr double us
static byte * ptr1
Definition: gifdecode.c:16
virtual void ReadTString(TString &s)
Read TString from TBuffer.
virtual void WriteChar(Char_t c)
Operator<<.
Definition: TBufferSQL.cxx:161
unsigned short UShort_t
Definition: RtypesCore.h:36
virtual void WriteCharP(const Char_t *c)
Operator<<.
Definition: TBufferSQL.cxx:409
Basic string class.
Definition: TString.h:131
TString * fInsertQuery
Definition: TBufferSQL.h:36
virtual void WriteCharStar(char *s)
Write char* into TBuffer.
#define f(i)
Definition: RSha256.hxx:104
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
void ResetOffset()
Reset Offset.
Definition: TBufferSQL.cxx:818
virtual void ReadFastArrayWithFactor(Float_t *ptr, Int_t n, Double_t factor, Double_t minvalue)
Read array of Float16_t from buffer.
Definition: TBufferSQL.cxx:762
virtual void WriteShort(Short_t s)
Operator<<.
Definition: TBufferSQL.cxx:171
virtual void ReadUChar(UChar_t &c)
Operator>>
Definition: TBufferSQL.cxx:221
std::vector< Int_t >::const_iterator fIter
Definition: TBufferSQL.h:33
virtual void ReadLong(Long_t &l)
Operator>>
Definition: TBufferSQL.cxx:131
virtual void ReadCharStar(char *&s)
Read char* from TBuffer.
virtual void ReadChar(Char_t &c)
Operator>>
Definition: TBufferSQL.cxx:91
virtual void ReadCharP(Char_t *c)
Operator>>
Definition: TBufferSQL.cxx:289
virtual void ReadInt(Int_t &i)
Operator>>
Definition: TBufferSQL.cxx:111
virtual void ReadUShort(UShort_t &s)
Operator>>
Definition: TBufferSQL.cxx:231
virtual void WriteStdString(const std::string *s)
Write std::string to TBuffer.
virtual void ReadFloat(Float_t &f)
Operator>>
Definition: TBufferSQL.cxx:121
virtual void WriteFastArray(const Bool_t *b, Int_t n)
WriteFastArray SQL implementation.
Definition: TBufferSQL.cxx:420
virtual void WriteFastArrayString(const Char_t *c, Int_t n)
WriteFastArray SQL implementation.
Definition: TBufferSQL.cxx:444
virtual void ReadStdString(std::string *s)
Read std::string from TBuffer.
virtual void ReadTString(TString &s)
Read a TString.
Definition: TBufferSQL.cxx:298
virtual void WriteTString(const TString &s)
Write TString to TBuffer.
virtual void WriteFloat(Float_t f)
Operator<<.
Definition: TBufferSQL.cxx:201
ROOT::R::TRInterface & r
Definition: Object.C:4
virtual void ReadShort(Short_t &s)
Operator>>
Definition: TBufferSQL.cxx:101
TBufferSQL()
Constructor.
Definition: TBufferSQL.cxx:66
virtual void WriteInt(Int_t i)
Operator<<.
Definition: TBufferSQL.cxx:181
unsigned int UInt_t
Definition: RtypesCore.h:42
virtual void WriteLong(Long_t l)
Operator<<.
Definition: TBufferSQL.cxx:191
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:880
std::vector< Int_t > * fColumnVec
Definition: TBufferSQL.h:35
short Short_t
Definition: RtypesCore.h:35
virtual void WriteLong64(Long64_t l)
Operator<<.
Definition: TBufferSQL.cxx:389
The ROOT global object gROOT contains a list of all defined classes.
Definition: TClass.h:75
virtual void WriteCharStar(char *s)
Write a char* string.
Definition: TBufferSQL.cxx:338
virtual void ReadFastArray(Bool_t *, Int_t)
ReadFastArray SQL implementation.
Definition: TBufferSQL.cxx:605
#define h(i)
Definition: RSha256.hxx:106
virtual void WriteStdString(const std::string *s)
Write a std::string.
Definition: TBufferSQL.cxx:322
long Long_t
Definition: RtypesCore.h:50
#define d(i)
Definition: RSha256.hxx:102
virtual void ReadULong(ULong_t &l)
Operator>>
Definition: TBufferSQL.cxx:253
virtual void ReadFastArrayFloat16(Float_t *f, Int_t n, TStreamerElement *ele=0)
ReadFastArray SQL implementation.
Definition: TBufferSQL.cxx:754
#define ClassImp(name)
Definition: Rtypes.h:359
virtual void ReadCharStar(char *&s)
Read a char* string.
Definition: TBufferSQL.cxx:330
virtual void WriteBool(Bool_t b)
Operator<<.
Definition: TBufferSQL.cxx:151
double Double_t
Definition: RtypesCore.h:55
virtual void ReadUInt(UInt_t &i)
Operator>>
Definition: TBufferSQL.cxx:241
unsigned long long ULong64_t
Definition: RtypesCore.h:70
unsigned long ULong_t
Definition: RtypesCore.h:51
virtual void ReadFastArrayString(Char_t *, Int_t)
ReadFastArray SQL implementation.
Definition: TBufferSQL.cxx:627
virtual void WriteUInt(UInt_t i)
Operator<<.
Definition: TBufferSQL.cxx:369
static constexpr double s
~TBufferSQL()
Destructor.
Definition: TBufferSQL.cxx:73
char Char_t
Definition: RtypesCore.h:29
virtual void WriteULong(ULong_t l)
Operator<<.
Definition: TBufferSQL.cxx:379
virtual void ReadDouble(Double_t &d)
Operator>>
Definition: TBufferSQL.cxx:141
virtual void WriteDouble(Double_t d)
Operator<<.
Definition: TBufferSQL.cxx:211
auto * l
Definition: textangle.C:4
virtual void WriteULong64(ULong64_t l)
Operator<<.
Definition: TBufferSQL.cxx:399
you should not use this method at all Int_t Int_t Double_t Double_t Double_t Int_t Double_t Double_t Double_t Double_t b
Definition: TRolke.cxx:630
#define c(i)
Definition: RSha256.hxx:101
virtual void WriteTString(const TString &s)
Write a TString.
Definition: TBufferSQL.cxx:306
virtual void ReadFastArrayWithNbits(Float_t *ptr, Int_t n, Int_t nbits)
Read array of Float16_t from buffer.
Definition: TBufferSQL.cxx:770
virtual void ReadBool(Bool_t &b)
Operator>>
Definition: TBufferSQL.cxx:81
unsigned char UChar_t
Definition: RtypesCore.h:34
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
Definition: TObject.cxx:908
TSQLRow ** fRowPtr
Definition: TBufferSQL.h:37
virtual void ReadULong64(ULong64_t &l)
Operator>>
Definition: TBufferSQL.cxx:277
const Int_t n
Definition: legend1.C:16
virtual void ReadFastArrayDouble32(Double_t *d, Int_t n, TStreamerElement *ele=0)
ReadFastArray SQL implementation.
Definition: TBufferSQL.cxx:794
const char * Data() const
Definition: TString.h:364