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