Logo ROOT  

Reference Guide
 
Loading...
Searching...
No Matches
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
14Implement 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
28ClassImp(TBufferSQL);
29
30////////////////////////////////////////////////////////////////////////////////
31/// Constructor.
32
33TBufferSQL::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
44TBufferSQL::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
55TBufferSQL::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
67TBufferSQL::TBufferSQL() : TBufferFile(), fColumnVec(0),fInsertQuery(0),fRowPtr(0)
68{
69}
70
71////////////////////////////////////////////////////////////////////////////////
72/// Destructor.
73
74TBufferSQL::~TBufferSQL()
75{
76 delete fColumnVec;
77}
78
79////////////////////////////////////////////////////////////////////////////////
80/// Operator>>
81
82void TBufferSQL::ReadBool(Bool_t &b)
83{
84 b = (Bool_t)atoi((*fRowPtr)->GetField(*fIter));
85
86 if (fIter != fColumnVec->end()) ++fIter;
87}
88
89////////////////////////////////////////////////////////////////////////////////
90/// Operator>>
91
92void TBufferSQL::ReadChar(Char_t &c)
93{
94 c = (Char_t)atoi((*fRowPtr)->GetField(*fIter));
95
96 if (fIter != fColumnVec->end()) ++fIter;
97}
98
99////////////////////////////////////////////////////////////////////////////////
100/// Operator>>
101
102void TBufferSQL::ReadShort(Short_t &h)
103{
104 h = (Short_t)atoi((*fRowPtr)->GetField(*fIter));
105
106 if (fIter != fColumnVec->end()) ++fIter;
107}
108
109////////////////////////////////////////////////////////////////////////////////
110/// Operator>>
111
112void TBufferSQL::ReadInt(Int_t &i)
113{
114 i = atoi((*fRowPtr)->GetField(*fIter));
115
116 if (fIter != fColumnVec->end()) ++fIter;
117}
118
119////////////////////////////////////////////////////////////////////////////////
120/// Operator>>
121
122void TBufferSQL::ReadFloat(Float_t &f)
123{
124 f = atof((*fRowPtr)->GetField(*fIter));
125
126 if (fIter != fColumnVec->end()) ++fIter;
127}
128
129////////////////////////////////////////////////////////////////////////////////
130/// Operator>>
131
132void TBufferSQL::ReadLong(Long_t &l)
133{
134 l = atol((*fRowPtr)->GetField(*fIter));
135
136 if (fIter != fColumnVec->end()) ++fIter;
137}
138
139////////////////////////////////////////////////////////////////////////////////
140/// Operator>>
141
142void TBufferSQL::ReadDouble(Double_t &d)
143{
144 d = atof((*fRowPtr)->GetField(*fIter));
145
146 if (fIter != fColumnVec->end()) ++fIter;
147}
148
149////////////////////////////////////////////////////////////////////////////////
150/// Operator<<
151
152void TBufferSQL::WriteBool(Bool_t b)
153{
154 (*fInsertQuery) += b;
155 (*fInsertQuery) += ",";
156 if (fIter != fColumnVec->end()) ++fIter;
157}
158
159////////////////////////////////////////////////////////////////////////////////
160/// Operator<<
161
162void TBufferSQL::WriteChar(Char_t c)
163{
164 (*fInsertQuery) += c;
165 (*fInsertQuery) += ",";
166 if (fIter != fColumnVec->end()) ++fIter;
167}
168
169////////////////////////////////////////////////////////////////////////////////
170/// Operator<<
171
172void TBufferSQL::WriteShort(Short_t h)
173{
174 (*fInsertQuery) += h;
175 (*fInsertQuery) += ",";
176 if (fIter != fColumnVec->end()) ++fIter;
177}
178
179////////////////////////////////////////////////////////////////////////////////
180/// Operator<<
181
182void TBufferSQL::WriteInt(Int_t i)
183{
184 (*fInsertQuery) += i;
185 (*fInsertQuery) += ",";
186 if (fIter != fColumnVec->end()) ++fIter;
187}
188
189////////////////////////////////////////////////////////////////////////////////
190/// Operator<<
191
192void TBufferSQL::WriteLong(Long_t l)
193{
194 (*fInsertQuery) += l;
195 (*fInsertQuery) += ",";
196 if (fIter != fColumnVec->end()) ++fIter;
197}
198
199////////////////////////////////////////////////////////////////////////////////
200/// Operator<<
201
202void TBufferSQL::WriteFloat(Float_t f)
203{
204 (*fInsertQuery) += f;
205 (*fInsertQuery) += ",";
206 if (fIter != fColumnVec->end()) ++fIter;
207}
208
209////////////////////////////////////////////////////////////////////////////////
210/// Operator<<
211
212void TBufferSQL::WriteDouble(Double_t d)
213{
214 (*fInsertQuery) += d;
215 (*fInsertQuery) += ",";
216 if (fIter != fColumnVec->end()) ++fIter;
217}
218
219////////////////////////////////////////////////////////////////////////////////
220/// Operator>>
221
222void TBufferSQL::ReadUChar(UChar_t& uc)
223{
224 uc = (UChar_t)atoi((*fRowPtr)->GetField(*fIter));
225
226 if (fIter != fColumnVec->end()) ++fIter;
227}
228
229////////////////////////////////////////////////////////////////////////////////
230/// Operator>>
231
232void TBufferSQL::ReadUShort(UShort_t& us)
233{
234 us = (UShort_t)atoi((*fRowPtr)->GetField(*fIter));
235
236 if (fIter != fColumnVec->end()) ++fIter;
237}
238
239////////////////////////////////////////////////////////////////////////////////
240/// Operator>>
241
242void TBufferSQL::ReadUInt(UInt_t& ui)
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
254void TBufferSQL::ReadULong(ULong_t& ul)
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
266void TBufferSQL::ReadLong64(Long64_t &ll)
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
278void TBufferSQL::ReadULong64(ULong64_t &ull)
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
290void TBufferSQL::ReadCharP(Char_t *str)
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
299void TBufferSQL::ReadTString(TString &s)
300{
301 s = (*fRowPtr)->GetField(*fIter);
302 if (fIter != fColumnVec->end()) ++fIter;
303}
304
305////////////////////////////////////////////////////////////////////////////////
306/// Write a TString
307
308void TBufferSQL::WriteTString(const TString &s)
309{
310 (*fInsertQuery) += s;
311 (*fInsertQuery) += ",";
312 if (fIter != fColumnVec->end()) ++fIter;
313}
314
315
316
317////////////////////////////////////////////////////////////////////////////////
318/// Read a std::string
319
320void TBufferSQL::ReadStdString(std::string *s)
321{
322 TBufferFile::ReadStdString(s);
323}
324
325////////////////////////////////////////////////////////////////////////////////
326/// Write a std::string
327
328void TBufferSQL::WriteStdString(const std::string *s)
329{
330 TBufferFile::WriteStdString(s);
331}
332
333////////////////////////////////////////////////////////////////////////////////
334/// Read a char* string
335
336void TBufferSQL::ReadCharStar(char* &s)
337{
338 TBufferFile::ReadCharStar(s);
339}
340
341////////////////////////////////////////////////////////////////////////////////
342/// Write a char* string
343
344void TBufferSQL::WriteCharStar(char *s)
345{
346 TBufferFile::WriteCharStar(s);
347}
348
349
350// Method to send to database.
351
352////////////////////////////////////////////////////////////////////////////////
353/// Operator<<
354
355void TBufferSQL::WriteUChar(UChar_t uc)
356{
357 (*fInsertQuery) += uc;
358 (*fInsertQuery) += ",";
359 ++fIter;
360}
361
362////////////////////////////////////////////////////////////////////////////////
363/// Operator<<
364
365void TBufferSQL::WriteUShort(UShort_t us)
366{
367 (*fInsertQuery) += us;
368 (*fInsertQuery) += ",";
369 ++fIter;
370}
371
372////////////////////////////////////////////////////////////////////////////////
373/// Operator<<
374
375void TBufferSQL::WriteUInt(UInt_t ui)
376{
377 (*fInsertQuery) += ui;
378 (*fInsertQuery) += ",";
379 ++fIter;
380}
381
382////////////////////////////////////////////////////////////////////////////////
383/// Operator<<
384
385void TBufferSQL::WriteULong(ULong_t ul)
386{
387 (*fInsertQuery) += ul;
388 (*fInsertQuery) += ",";
389 ++fIter;
390}
391
392////////////////////////////////////////////////////////////////////////////////
393/// Operator<<
394
395void TBufferSQL::WriteLong64(Long64_t ll)
396{
397 (*fInsertQuery) += ll;
398 (*fInsertQuery) += ",";
399 ++fIter;
400}
401
402////////////////////////////////////////////////////////////////////////////////
403/// Operator<<
404
405void TBufferSQL::WriteULong64(ULong64_t ull)
406{
407 (*fInsertQuery) += ull;
408 (*fInsertQuery) += ",";
409 ++fIter;
410}
411
412////////////////////////////////////////////////////////////////////////////////
413/// Operator<<
414
415void TBufferSQL::WriteCharP(const Char_t *str)
416{
417 (*fInsertQuery) += "\"";
418 (*fInsertQuery) += str;
419 (*fInsertQuery) += "\",";
420 ++fIter;
421}
422
423////////////////////////////////////////////////////////////////////////////////
424/// WriteFastArray SQL implementation.
425
426void TBufferSQL::WriteFastArray(const Bool_t *b, Int_t n)
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
438void TBufferSQL::WriteFastArray(const Char_t *c, Int_t n)
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
450void TBufferSQL::WriteFastArrayString(const Char_t *c, Int_t /* n */)
451{
452 (*fInsertQuery) += "\"";
453 (*fInsertQuery) += c;
454 (*fInsertQuery) += "\",";
455 ++fIter;
456}
457
458////////////////////////////////////////////////////////////////////////////////
459/// WriteFastArray SQL implementation.
460
461void TBufferSQL::WriteFastArray(const UChar_t *uc, Int_t n)
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
473void TBufferSQL::WriteFastArray(const Short_t *h, Int_t n)
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
485void TBufferSQL::WriteFastArray(const UShort_t *us, Int_t n)
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
497void TBufferSQL::WriteFastArray(const Int_t *ii, Int_t n)
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
510void TBufferSQL::WriteFastArray(const UInt_t *ui, Int_t n)
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
522void TBufferSQL::WriteFastArray(const Long_t *l, Int_t n)
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
534void TBufferSQL::WriteFastArray(const ULong_t *ul, Int_t n)
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
546void TBufferSQL::WriteFastArray(const Long64_t *l, Int_t n)
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
558void TBufferSQL::WriteFastArray(const ULong64_t *ul, Int_t n)
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
570void TBufferSQL::WriteFastArray(const Float_t *f, Int_t n)
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
582void TBufferSQL::WriteFastArray(const Double_t *d, Int_t n)
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
594void TBufferSQL::WriteFastArray(void*, const TClass*, Int_t, TMemberStreamer *)
595{
596 Fatal("WriteFastArray(void*, const TClass*, Int_t, TMemberStreamer *)","Not implemented yet");
597}
598
599////////////////////////////////////////////////////////////////////////////////
600/// WriteFastArray SQL implementation.
601
602Int_t TBufferSQL::WriteFastArray(void **, const TClass*, Int_t, Bool_t, TMemberStreamer*)
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
611void TBufferSQL::ReadFastArray(Bool_t *b, Int_t n)
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
622void TBufferSQL::ReadFastArray(Char_t *c, Int_t n)
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
633void TBufferSQL::ReadFastArrayString(Char_t *c, Int_t /* n */)
634{
635 strcpy(c,((*fRowPtr)->GetField(*fIter)));
636 ++fIter;
637}
638
639////////////////////////////////////////////////////////////////////////////////
640/// ReadFastArray SQL implementation.
641
642void TBufferSQL::ReadFastArray(UChar_t *uc, Int_t n)
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
653void TBufferSQL::ReadFastArray(Short_t *s, Int_t n)
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
664void TBufferSQL::ReadFastArray(UShort_t *us, Int_t n)
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
675void TBufferSQL::ReadFastArray(Int_t *in, Int_t n)
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
686void TBufferSQL::ReadFastArray(UInt_t *ui, Int_t n)
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
697void TBufferSQL::ReadFastArray(Long_t *l, Int_t n)
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
708void TBufferSQL::ReadFastArray(ULong_t *ul, Int_t n)
709{
710 for(int i=0; i<n; ++i) {
711 (*this) >> ul[i];
712 }
713}
714
715////////////////////////////////////////////////////////////////////////////////
716/// ReadFastArray SQL implementation.
717
718void TBufferSQL::ReadFastArray(Long64_t *ll, Int_t n)
719{
720 for(int i=0; i<n; ++i) {
721 (*this) >> ll[i];
722 }
723}
724
725////////////////////////////////////////////////////////////////////////////////
726/// ReadFastArray SQL implementation.
727
728void TBufferSQL::ReadFastArray(ULong64_t *ull, Int_t n)
729{
730 for(int i=0; i<n; ++i) {
731 (*this) >> ull[i];
732 }
733}
734
735////////////////////////////////////////////////////////////////////////////////
736/// ReadFastArray SQL implementation.
737
738void TBufferSQL::ReadFastArray(Float_t *f, Int_t n)
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
749void TBufferSQL::ReadFastArray(Double_t *d, Int_t n)
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
760void TBufferSQL::ReadFastArrayFloat16(Float_t *, Int_t , TStreamerElement *)
761{
762 Fatal("ReadFastArrayFloat16(Float_t *, Int_t , TStreamerElement *)","Not implemented yet");
763}
764
765////////////////////////////////////////////////////////////////////////////////
766/// Read array of Float16_t from buffer
767
768void 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
776void TBufferSQL::ReadFastArrayWithNbits(Float_t *, Int_t , Int_t /*nbits*/)
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
784void 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
792void TBufferSQL::ReadFastArrayWithNbits(Double_t *, Int_t , Int_t /*nbits*/)
793{
794 Fatal("ReadFastArrayWithNbits(Double_t *, Int_t , Int_t )","Not implemented yet");
795}
796
797////////////////////////////////////////////////////////////////////////////////
798/// ReadFastArray SQL implementation.
799
800void TBufferSQL::ReadFastArrayDouble32(Double_t *, Int_t , TStreamerElement *)
801{
802 Fatal("ReadFastArrayDouble32(Double_t *, Int_t , TStreamerElement *)","Not implemented yet");
803}
804
805////////////////////////////////////////////////////////////////////////////////
806/// ReadFastArray SQL implementation.
807
808void 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
816void TBufferSQL::ReadFastArray(void **, const TClass *, Int_t, Bool_t, TMemberStreamer *, const TClass *)
817{
818 Fatal("ReadFastArray(void **, const TClass *, Int_t, Bool_t, TMemberStreamer *, const TClass *)","Not implemented yet");
819}
820
821////////////////////////////////////////////////////////////////////////////////
822/// Reset Offset.
823
824void TBufferSQL::ResetOffset()
825{
826 fIter = fColumnVec->begin();
827}
828
829#if 0
830////////////////////////////////////////////////////////////////////////////////
831
832void 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
d
#define d(i)
Definition RSha256.hxx:102
b
#define b(i)
Definition RSha256.hxx:100
f
#define f(i)
Definition RSha256.hxx:104
c
#define c(i)
Definition RSha256.hxx:101
h
#define h(i)
Definition RSha256.hxx:106
Bool_t
bool Bool_t
Definition RtypesCore.h:63
UShort_t
unsigned short UShort_t
Definition RtypesCore.h:40
UChar_t
unsigned char UChar_t
Definition RtypesCore.h:38
Char_t
char Char_t
Definition RtypesCore.h:37
Long_t
long Long_t
Definition RtypesCore.h:54
Float_t
float Float_t
Definition RtypesCore.h:57
Short_t
short Short_t
Definition RtypesCore.h:39
Long64_t
long long Long64_t
Definition RtypesCore.h:80
ULong64_t
unsigned long long ULong64_t
Definition RtypesCore.h:81
ULong_t
unsigned long ULong_t
Definition RtypesCore.h:55
ClassImp
#define ClassImp(name)
Definition Rtypes.h:377
r
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t r
Definition TGWin32VirtualXProxy.cxx:168
mode
Option_t Option_t TPoint TPoint const char mode
Definition TGWin32VirtualXProxy.cxx:68
TBufferFile
The concrete implementation of TBuffer for writing/reading to/from a ROOT file or socket.
Definition TBufferFile.h:47
TBufferFile::ReadCharStar
void ReadCharStar(char *&s) override
Read char* from TBuffer.
Definition TBufferFile.cxx:284
TBufferFile::WriteCharStar
void WriteCharStar(char *s) override
Write char* into TBuffer.
Definition TBufferFile.cxx:301
TBufferFile::WriteStdString
void WriteStdString(const std::string *s) override
Write std::string to TBuffer.
Definition TBufferFile.cxx:260
TBufferFile::ReadStdString
void ReadStdString(std::string *s) override
Read std::string from TBuffer.
Definition TBufferFile.cxx:229
TBufferSQL
Implement TBuffer for a SQL backend.
Definition TBufferSQL.h:30
TBufferSQL::ReadLong
void ReadLong(Long_t &l) final
Operator>>
Definition TBufferSQL.cxx:132
TBufferSQL::WriteDouble
void WriteDouble(Double_t d) final
Operator<<.
Definition TBufferSQL.cxx:212
TBufferSQL::~TBufferSQL
~TBufferSQL()
Destructor.
Definition TBufferSQL.cxx:74
TBufferSQL::TBufferSQL
TBufferSQL()
Constructor.
Definition TBufferSQL.cxx:67
TBufferSQL::ReadFastArrayFloat16
void ReadFastArrayFloat16(Float_t *f, Int_t n, TStreamerElement *ele=nullptr) final
ReadFastArray SQL implementation.
Definition TBufferSQL.cxx:760
TBufferSQL::WriteFastArray
void WriteFastArray(const Bool_t *b, Int_t n) final
WriteFastArray SQL implementation.
Definition TBufferSQL.cxx:426
TBufferSQL::WriteULong
void WriteULong(ULong_t l) final
Operator<<.
Definition TBufferSQL.cxx:385
TBufferSQL::WriteUInt
void WriteUInt(UInt_t i) final
Operator<<.
Definition TBufferSQL.cxx:375
TBufferSQL::WriteFloat
void WriteFloat(Float_t f) final
Operator<<.
Definition TBufferSQL.cxx:202
TBufferSQL::ReadULong64
void ReadULong64(ULong64_t &l) final
Operator>>
Definition TBufferSQL.cxx:278
TBufferSQL::ReadCharStar
void ReadCharStar(char *&s) final
Read a char* string.
Definition TBufferSQL.cxx:336
TBufferSQL::ReadInt
void ReadInt(Int_t &i) final
Operator>>
Definition TBufferSQL.cxx:112
TBufferSQL::ReadTString
void ReadTString(TString &s) final
Read a TString.
Definition TBufferSQL.cxx:299
TBufferSQL::WriteUChar
void WriteUChar(UChar_t c) final
Operator<<.
Definition TBufferSQL.cxx:355
TBufferSQL::WriteShort
void WriteShort(Short_t s) final
Operator<<.
Definition TBufferSQL.cxx:172
TBufferSQL::WriteUShort
void WriteUShort(UShort_t s) final
Operator<<.
Definition TBufferSQL.cxx:365
TBufferSQL::ReadBool
void ReadBool(Bool_t &b) final
Operator>>
Definition TBufferSQL.cxx:82
TBufferSQL::ReadShort
void ReadShort(Short_t &s) final
Operator>>
Definition TBufferSQL.cxx:102
TBufferSQL::WriteLong
void WriteLong(Long_t l) final
Operator<<.
Definition TBufferSQL.cxx:192
TBufferSQL::ReadLong64
void ReadLong64(Long64_t &l) final
Operator>>
Definition TBufferSQL.cxx:266
TBufferSQL::ReadChar
void ReadChar(Char_t &c) final
Operator>>
Definition TBufferSQL.cxx:92
TBufferSQL::fColumnVec
std::vector< Int_t > * fColumnVec
Definition TBufferSQL.h:35
TBufferSQL::WriteFastArrayString
void WriteFastArrayString(const Char_t *c, Int_t n) final
WriteFastArray SQL implementation.
Definition TBufferSQL.cxx:450
TBufferSQL::ReadFastArrayString
void ReadFastArrayString(Char_t *, Int_t) final
ReadFastArray SQL implementation.
Definition TBufferSQL.cxx:633
TBufferSQL::WriteStdString
void WriteStdString(const std::string *s) final
Write a std::string.
Definition TBufferSQL.cxx:328
TBufferSQL::ReadStdString
void ReadStdString(std::string *s) final
Read a std::string.
Definition TBufferSQL.cxx:320
TBufferSQL::WriteInt
void WriteInt(Int_t i) final
Operator<<.
Definition TBufferSQL.cxx:182
TBufferSQL::ReadFastArray
void ReadFastArray(Bool_t *, Int_t) final
ReadFastArray SQL implementation.
Definition TBufferSQL.cxx:611
TBufferSQL::ReadUShort
void ReadUShort(UShort_t &s) final
Operator>>
Definition TBufferSQL.cxx:232
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
TBufferSQL::WriteTString
void WriteTString(const TString &s) final
Write a TString.
Definition TBufferSQL.cxx:308
TBufferSQL::ReadUInt
void ReadUInt(UInt_t &i) final
Operator>>
Definition TBufferSQL.cxx:242
TBufferSQL::WriteBool
void WriteBool(Bool_t b) final
Operator<<.
Definition TBufferSQL.cxx:152
TBufferSQL::WriteULong64
void WriteULong64(ULong64_t l) final
Operator<<.
Definition TBufferSQL.cxx:405
TBufferSQL::ReadCharP
void ReadCharP(Char_t *c) final
Operator>>
Definition TBufferSQL.cxx:290
TBufferSQL::WriteCharStar
void WriteCharStar(char *s) final
Write a char* string.
Definition TBufferSQL.cxx:344
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::fIter
std::vector< Int_t >::const_iterator fIter
Definition TBufferSQL.h:33
TBufferSQL::ResetOffset
void ResetOffset()
Reset Offset.
Definition TBufferSQL.cxx:824
TBufferSQL::WriteCharP
void WriteCharP(const Char_t *c) final
Operator<<.
Definition TBufferSQL.cxx:415
TBufferSQL::WriteLong64
void WriteLong64(Long64_t l) final
Operator<<.
Definition TBufferSQL.cxx:395
TBufferSQL::ReadDouble
void ReadDouble(Double_t &d) final
Operator>>
Definition TBufferSQL.cxx:142
TBufferSQL::ReadULong
void ReadULong(ULong_t &l) final
Operator>>
Definition TBufferSQL.cxx:254
TBufferSQL::ReadFastArrayDouble32
void ReadFastArrayDouble32(Double_t *d, Int_t n, TStreamerElement *ele=nullptr) final
ReadFastArray SQL implementation.
Definition TBufferSQL.cxx:800
TBufferSQL::ReadFloat
void ReadFloat(Float_t &f) final
Operator>>
Definition TBufferSQL.cxx:122
TBufferSQL::WriteChar
void WriteChar(Char_t c) final
Operator<<.
Definition TBufferSQL.cxx:162
TBufferSQL::ReadUChar
void ReadUChar(UChar_t &c) final
Operator>>
Definition TBufferSQL.cxx:222
TClass
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition TClass.h:81
TObject::Error
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition TObject.cxx:970
TObject::Fatal
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
Definition TObject.cxx:998
TString
Basic string class.
Definition TString.h:139
TString::Data
const char * Data() const
Definition TString.h:380
n
const Int_t n
Definition legend1.C:16
l
TLine l
Definition textangle.C:4
ptr1
static byte * ptr1
Definition gifdecode.c:16