Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TTreeSQL.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 TTreeSQL
13\ingroup tree
14
15 A TTree object is a list of TBranch.
16 To Create a TTree object one must:
17 - Create the TTree header via the TTree constructor
18 - Call the TBranch constructor for every branch.
19
20 To Fill this object, use member function Fill with no parameters.
21 The Fill function loops on all defined TBranch.
22
23TTreeSQL is the TTree implementation interfacing with an SQL
24database
25
26*/
27
28#include <vector>
29#include <map>
30#include <cstdlib>
31
32#include "TString.h"
33#include "TError.h"
34#include "TLeaf.h"
35#include "TBranch.h"
36#include "TList.h"
37
38#include "TSQLRow.h"
39#include "TSQLResult.h"
40#include "TSQLServer.h"
41#include "TSQLTableInfo.h"
42#include "TSQLColumnInfo.h"
43
44#include "TTreeSQL.h"
45#include "TBasketSQL.h"
46
48
49////////////////////////////////////////////////////////////////////////////////
50/// Constructor with an explicit TSQLServer
51
52TTreeSQL::TTreeSQL(TSQLServer *server, TString DB, const TString& table) :
53 TTree(table.Data(), "Database read from table: " + table, 0), fDB(DB),
54 fTable(table.Data()),
55 fResult(0), fRow(0),
56 fServer(server),
57 fBranchChecked(kFALSE),
58 fTableInfo(0)
59{
60 fCurrentEntry = -1;
61 fQuery = TString("Select * from " + fTable);
62 fEntries = 0;
63
64 if (fServer==0) {
65 Error("TTreeSQL","No TSQLServer specified");
66 return;
67 }
68 if (CheckTable(fTable.Data())) {
69 Init();
70 }
71}
72
73////////////////////////////////////////////////////////////////////////////////
74/// Not implemented yet
75
76TBranch* TTreeSQL::BranchImp(const char *, const char *,
77 TClass *, void *, Int_t ,
78 Int_t )
79{
80 Fatal("BranchImp","Not implemented yet");
81 return 0;
82}
83
84////////////////////////////////////////////////////////////////////////////////
85/// Not implemented yet
86
88 void *, Int_t , Int_t )
89{
90 Fatal("BranchImp","Not implemented yet");
91 return 0;
92}
93////////////////////////////////////////////////////////////////////////////////
94/// Not implemented yet
95
97 Int_t, const char *)
98{
99 Fatal("Branch","Not implemented yet");
100 return 0;
101}
102
103////////////////////////////////////////////////////////////////////////////////
104/// Not implemented yet
105
107{
108 Fatal("Branch","Not implemented yet");
109 return 0;
110}
111
112////////////////////////////////////////////////////////////////////////////////
113/// Not implemented yet
114
116 Int_t)
117{
118 Fatal("Branch","Not implemented yet");
119 return 0;
120}
121
122////////////////////////////////////////////////////////////////////////////////
123/// Not implemented yet
124
125TBranch* TTreeSQL::Bronch(const char *, const char *, void *,
126 Int_t, Int_t)
127{
128 Fatal("Bronch","Not implemented yet");
129 return 0;
130}
131
132////////////////////////////////////////////////////////////////////////////////
133/// Not implemented yet
134
135TBranch* TTreeSQL::BranchOld(const char *, const char *,
136 void *, Int_t, Int_t)
137{
138 Fatal("BranchOld","Not implemented yet");
139 return 0;
140}
141
142////////////////////////////////////////////////////////////////////////////////
143/// Not implemented yet
144
145TBranch *TTreeSQL::Branch(const char *, const char *, void *,
146 Int_t, Int_t)
147{
148 Fatal("Branch","Not implemented yet");
149 return 0;
150}
151
152///////////////////////////////////////////////////////////////////////////////
153/// Create a branch
154
155TBranch * TTreeSQL::Branch(const char *name, void *address,
156 const char *leaflist, Int_t bufsize)
157{
159 TBranch *branch;
160 TString brName;
161
162 for (int i=0;i<nb;i++) {
163 branch = (TBranch*)fBranches.UncheckedAt(i);
164 brName = branch->GetName();
165 if (brName.CompareTo(name) == 0) {
166 // Now if the branch exists in db, root gives a warning and exit
167 // Dealing with duplicate branch has been done, but not tested yet.
168 // So if you want to allow duplicate branch, just comment Fatal() line and uncomment commented
169 // below Fatal() line
170
171 Fatal("Branch()", "Duplicate branch!!!");
172
173 /* Commented. If uncommented, should comment Fatal line.
174 // this is a duplicate branch. So reset data structure memory address and return.
175 branch->SetAddress(address);
176 return branch;
177 */
178 }
179 }
180
181 return TTree::Branch(name, address, leaflist, bufsize);
182}
183
184////////////////////////////////////////////////////////////////////////////////
185/// Check if the basket is properly setup
186
188{
189 TBasketSQL* basket = (TBasketSQL *)branch->GetBasket(0);
190
191 if (basket==0) {
192 basket = (TBasketSQL*)CreateBasket(branch);
193 if (basket==0) return;
194 //++(branch->fNBaskets);
195 branch->GetListOfBaskets()->AddAtAndExpand(basket,0);
196 }
197 TBuffer * buffer = basket->GetBufferRef();
198
199 if(buffer == 0){
200 std::vector<Int_t> *columns = GetColumnIndice(branch);
201 if (columns) basket->CreateBuffer(branch->GetName(),"A", columns, branch, &fResult);
202 }
203
204 Int_t nb = branch->GetListOfBranches()->GetEntriesFast();
205 for (int i=0;i<nb;i++) {
206 TBranch * subbranch = (TBranch*)branch->GetListOfBranches()->UncheckedAt(i);
207 if(subbranch) CheckBasket(subbranch);
208 }
209}
210
211////////////////////////////////////////////////////////////////////////////////
212/// Check if the table has a column corresponding the branch
213/// and that the resultset are properly setup
214
216{
217 if (fServer==0) {
218 return kFALSE;
219 }
220 TString leafName;
221 TLeaf *leaf;
222 Int_t nl;
223 TString str = "";
224 TString typeName = "";
225
226 if (!tb) return kFALSE;
227
228 TBasketSQL *basket = (TBasketSQL *)tb->GetBasket(0);
229 if (!basket) return kFALSE;
230
231 TSQLResult *rs = basket->GetResultSet();
232 if (!rs) {
233 Error("CheckBranch","%s has basket but no resultset yet",tb->GetName());
234 return kFALSE;
235 }
236
237 nl = tb->GetNleaves();
238
239 for(int j=0;j<nl;j++) {
240 leaf = (TLeaf*)tb->GetListOfLeaves()->UncheckedAt(j);
241 typeName = leaf->GetTypeName();
242 typeName = ConvertTypeName(leaf->GetTypeName());
243 leafName = leaf->GetName();
244 str = "";
245 str = tb->GetName();
246 str += "__";
247 str += leafName;
248
249 for (int i=0; i< rs->GetFieldCount(); ++i) {
250 if (str.CompareTo(rs->GetFieldName(i),TString::kIgnoreCase) == 0) return kTRUE;
251 }
252 // We assume that if ONE of the leaf is in the table, then ALL the leaf are in
253 // the table.
254 // TODO: this assumption is harmful if user changes branch structure while keep its name
255 CreateBranch(str, typeName);
256 }
257 return kFALSE;
258}
259
260////////////////////////////////////////////////////////////////////////////////
261/// Check the table exist in the database
262
264{
265 if (fServer==0) return kFALSE;
266 TSQLResult * tables = fServer->GetTables(fDB.Data(),table);
267 if (!tables) return kFALSE;
268 TSQLRow * row = 0;
269 while( (row = tables->Next()) ) {
270 if(table.CompareTo(row->GetField(0),TString::kIgnoreCase)==0){
271 return kTRUE;
272 }
273 }
274 // The table is a not a permanent table, let's see if it is a 'temporary' table
275 Int_t before = gErrorIgnoreLevel;
277 TSQLResult *res = fServer->GetColumns(fDB.Data(),table);
278 if (res) {
279 delete res;
280 return kTRUE;
281 }
282 gErrorIgnoreLevel = before;
283
284 return kFALSE;
285}
286
287////////////////////////////////////////////////////////////////////////////////
288/// Convert from ROOT typename to SQL typename
289
291{
292 TString tn = "";
293
294 if(typeName == "Char_t"){
295 tn = "TEXT";
296 }
297 else if(typeName == "Int_t") {
298 tn = "INTEGER";
299 }
300 else if(typeName == "Short_t") {
301 tn = "SMALLINT";
302 }
303 else if( typeName == "UShort_t") {
304 tn = "SMALLINT UNSIGNED";
305 }
306 else if(typeName == "Float_t"){
307 tn = "FLOAT";
308 }
309 else if(typeName == "Float16_t"){
310 tn = "FLOAT";
311 }
312 else if(typeName == "Double_t"){
313 tn = "DOUBLE";
314 }
315 else if(typeName == "Double32_t"){
316 tn = "FLOAT";
317 }
318 else if(typeName == "UInt_t") {
319 tn = "INT UNSIGNED";
320 }
321 else if( typeName == "Long_t") {
322 tn = "INTEGER";
323 }
324 else if( typeName == "ULong_t") {
325 tn = "INTEGER UNSIGNED";
326 }
327 else if( typeName == "Long64_t") {
328 tn = "BIGINT";
329 }
330 else if( typeName == "ULong64_t") {
331 tn = "BIGINT UNSIGNED";
332 }
333 else if( typeName == "Bool_t") {
334 tn = "BOOL";
335 }
336 else if( typeName == "TString") {
337 tn = "TEXT";
338 }
339
340 else {
341 Error("ConvertTypeName","TypeName (%s) not found",typeName.Data());
342 return "";
343 }
344
345 return tn;
346}
347
348////////////////////////////////////////////////////////////////////////////////
349/// Create a TBasketSQL
350
352{
353 if (fServer==0) {
354 Error("CreateBasket","No TSQLServer specified");
355 return 0;
356 }
357 std::vector<Int_t> *columnVec = GetColumnIndice(tb);
358 if (columnVec) {
359 return new TBasketSQL(tb->GetName(), tb->GetName(), tb,
360 &fResult, &fInsertQuery, columnVec, &fRow);
361 } else {
362 return 0;
363 }
364}
365
366////////////////////////////////////////////////////////////////////////////////
367/// Create the column(s) in the database that correspond to the branch/
368
369void TTreeSQL::CreateBranch(const TString &branchName, const TString &typeName)
370{
371 if (fServer==0) {
372 Error("CreateBranch","No TSQLServer specified");
373 return;
374 }
375 TString alterSQL = "";
376 alterSQL = "";
377 alterSQL = "ALTER TABLE ";
378 alterSQL += fTable.Data();
379 alterSQL += " ADD ";
380 alterSQL += branchName.Data();;
381 alterSQL += " ";
382 alterSQL += typeName;
383 alterSQL += " ";
384
385 fServer->Query(alterSQL);
386}
387
388////////////////////////////////////////////////////////////////////////////////
389/// determine leaf description string
390
392{
393 TList * columns = fTableInfo->GetColumns();
394 if(!columns) return;
395
396 TIter next(columns);
397
398 TString branchName;
400 TString leafName;
401 TBranch * br = 0;
402 TSQLColumnInfo * info;
403 while ( (info = ((TSQLColumnInfo*) next()) ))
404 {
405 type = info->GetTypeName();
406 branchName = info->GetName();
407
408
409 Int_t pos;
410 if ((pos=branchName.Index("__"))!=kNPOS) {
411 leafName = branchName(pos+2,branchName.Length());
412 branchName.Remove(pos);
413 } else {
414 leafName = branchName;
415 }
416
417 TString str;
418 int i;
419 unsigned ui;
420 double d;
421 float f;
422
423 br = 0;
424
425 if(type.CompareTo("varchar",TString::kIgnoreCase)==0 ||
426 type.CompareTo("varchar2",TString::kIgnoreCase)==0 ||
427 type.CompareTo("char",TString::kIgnoreCase)==0 ||
428 type.CompareTo("longvarchar",TString::kIgnoreCase)==0 ||
429 type.CompareTo("longvarbinary",TString::kIgnoreCase)==0 ||
430 type.CompareTo("varbinary",TString::kIgnoreCase)==0 ||
431 type.CompareTo("text",TString::kIgnoreCase )==0 ) {
432 br = TTree::Branch(leafName,&str);
433
434 }
435 else if(type.CompareTo("int",TString::kIgnoreCase)==0 ){
436 br = TTree::Branch(leafName,&i);
437 }
438
439 //Somehow it should be possible to special-case the time classes
440 //but I think we'd need to create a new TSQLTime or something like that...
441 else if( type.CompareTo("date",TString::kIgnoreCase)==0 ||
442 type.CompareTo("time",TString::kIgnoreCase)==0 ||
443 type.CompareTo("timestamp",TString::kIgnoreCase)==0 ||
444 type.CompareTo("datetime",TString::kIgnoreCase)==0 ) {
445 br = TTree::Branch(leafName,&str);
446
447 }
448
449 else if(type.CompareTo("bit",TString::kIgnoreCase)==0 ||
450 type.CompareTo("tinyint",TString::kIgnoreCase)==0 ||
451 type.CompareTo("smallint",TString::kIgnoreCase)==0 ) {
452 br = TTree::Branch(leafName,&ui);
453 }
454
455 else if( type.CompareTo("decimal",TString::kIgnoreCase)==0 ||
456 type.CompareTo("numeric",TString::kIgnoreCase)==0 ||
457 type.CompareTo("double",TString::kIgnoreCase)==0 ||
458 type.CompareTo("float",TString::kIgnoreCase)==0 )
459 {
460 br = TTree::Branch(leafName,&f);
461 }
462 else if( type.CompareTo("bigint",TString::kIgnoreCase)==0 ||
463 type.CompareTo("real",TString::kIgnoreCase) == 0)
464 {
465 br = TTree::Branch(leafName,&d);
466 }
467
468 if (br == 0)
469 {
470 Error("CreateBranches", "Skipped %s", branchName.Data());
471 continue;
472 }
473
474 br->ResetAddress();
475
476 (br->GetBasketEntry())[0] = 0;
477 (br->GetBasketEntry())[1] = fEntries;
478 br->SetEntries(fEntries);
479
480 //++(br->fNBaskets);
482 }
483}
484
485////////////////////////////////////////////////////////////////////////////////
486/// Create the database table corresponding to this TTree.
487
489{
490 if (fServer==0) {
491 Error("CreateTable","No TSQLServer specified");
492 return false;
493 }
494 Int_t i, j;
495 TString branchName, leafName, typeName;
496 TString createSQL, alterSQL, str;
498 Int_t nl = 0;
499
500 TBranch *branch;
501 TLeaf *leaf;
502
503 for (i=0;i<nb;i++) {
504 branch = (TBranch*)fBranches.UncheckedAt(i);
505 branchName = branch->GetName();
506 nl = branch->GetNleaves();
507 for(j=0;j<nl;j++) {
508 leaf = (TLeaf*)branch->GetListOfLeaves()->UncheckedAt(j);
509 leafName = leaf->GetName();
510 typeName = ConvertTypeName(leaf->GetTypeName());
511 // length = leaf->GetLenStatic();
512
513 if(i == 0 && j == 0) {
514 createSQL = "";
515 createSQL += "CREATE TABLE ";
516 createSQL += table;
517 createSQL += " (";
518 createSQL += branchName;
519 createSQL += "__";
520 createSQL += leafName;
521 createSQL += " ";
522 createSQL += typeName;
523 createSQL += " ";
524 createSQL += ")";
525
526 TSQLResult *sres = fServer->Query(createSQL.Data());
527 if (!sres) {
528 Error("CreateTable","May have failed");
529 return false;
530 }
531 }
532 else {
533 str = "";
534 str = branchName;
535 str += "__";
536 str += leafName;
537 CreateBranch(str, typeName);
538 } //else
539 } // inner for loop
540 } // outer for loop
541 // retrieve table to initialize fResult
542 delete fResult;
544 return (fResult!=0);
545}
546
547////////////////////////////////////////////////////////////////////////////////
548/// Initialization routine
549
551{
552 fCurrentEntry = -1;
553
554 GetEntries();
555
556 delete fResult;
558 if(!fResult) return;
559
560 if (fDB != "") {
562 }
565}
566
567////////////////////////////////////////////////////////////////////////////////
568/// Copy the information from the user object to the TTree
569
571{
573 TString typeName;
574 TBranch *branch;
575
576 if (fServer==0) return 0;
577
578 if(!CheckTable(fTable.Data())) {
579 if (!CreateTable(fTable.Data())) {
580 return -1;
581 }
582 }
583
585
586 for (int i=0;i<nb;i++) {
587 branch = (TBranch*)fBranches.UncheckedAt(i);
588 CheckBasket(branch);
589 }
590
591 if (!fBranchChecked) {
592 for(int i=0;i<nb;i++) {
593 branch = (TBranch*)fBranches.UncheckedAt(i);
594 if (!CheckBranch(branch)) {
595 Error("Fill","CheckBranch for %s failed",branch->GetName());
596 }
597 }
599 }
600 ResetQuery();
601
602 TTree::Fill();
603
604 if (fInsertQuery[fInsertQuery.Length()-1]!='(') {
606 fInsertQuery += ")";
608
609 if (res) {
610 return res->GetRowCount();
611 }
612 }
613 return -1;
614}
615
616////////////////////////////////////////////////////////////////////////////////
617/// Return a vector of columns index corresponding to the
618/// current SQL table and the branch given as argument
619/// Returns 0 if no columns indices is found
620/// Otherwise returns a pointer to a vector to be deleted by the caller
621
622std::vector<Int_t> *TTreeSQL::GetColumnIndice(TBranch *branch)
623{
624 if (!CheckTable(fTable)) return 0;
625
626 std::vector<Int_t> *columns = new std::vector<Int_t>;
627
628 Int_t nl = branch->GetNleaves();
629
630 std::vector<TString> names;
631
632 TList *col_list = fTableInfo->GetColumns();
633 if (col_list==0) {
634 delete columns;
635 return 0;
636 }
637
638 std::pair<TString,Int_t> value;
639
640 TIter next(col_list);
641 TSQLColumnInfo * cinfo;
642 int rows = 0;
643 while ((cinfo = (TSQLColumnInfo*) next())) {
644 names.push_back( cinfo->GetName() );
645 rows++;
646 }
647
648 for(int j=0;j<nl;j++) {
649
650 Int_t col = -1;
651 TLeaf *leaf = (TLeaf*)branch->GetListOfLeaves()->UncheckedAt(j);
652 TString leafName = leaf->GetName();
653 TString str;
654
655 str = "";
656 str = branch->GetName();
657 str += "__";
658 str += leafName;
659 for (Int_t i=0;i<rows;++i) {
660 if (str.CompareTo(names[i],TString::kIgnoreCase)==0) {
661 col = i;
662 break;
663 }
664 }
665 if (col<0) {
666 str = leafName;
667 for (Int_t i=0;i<rows;++i) {
668 if (str.CompareTo(names[i],TString::kIgnoreCase)==0) {
669 col = i;
670 break;
671 }
672 }
673 }
674 if(col>=0){
675 columns->push_back(col);
676 } else Error("GetColumnIndice","Error finding column %d %s",j,str.Data());
677 }
678 if (columns->empty()) {
679 delete columns;
680 return 0;
681 } else
682 return columns;
683}
684
685////////////////////////////////////////////////////////////////////////////////
686/// Get the number of rows in the database
687
689{
690 if (fServer==0) return GetEntriesFast();
691 if (!CheckTable(fTable.Data())) return 0;
692
693 TTreeSQL* thisvar = const_cast<TTreeSQL*>(this);
694
695 // What if the user already started to call GetEntry
696 // What about the initial value of fEntries is it really 0?
697
698 TString counting = "select count(*) from " + fTable;
699 TSQLResult *count = fServer->Query(counting);
700
701 if (count==0) {
702 thisvar->fEntries = 0;
703 } else {
704 TSQLRow * row = count->Next();
705 if (row) {
706 TString val = row->GetField(0);
707 Long_t ret;
708 sscanf(val.Data(), "%ld",&(ret) );
709 thisvar->fEntries = ret;
710 } else {
711 thisvar->fEntries = 0;
712 }
713 }
714 return fEntries;
715}
716
717////////////////////////////////////////////////////////////////////////////////
718/// Return the number of entries as of the last check.
719/// Use GetEntries for a more accurate count.
720
722{
723 return fEntries;
724}
725
726////////////////////////////////////////////////////////////////////////////////
727/// Load the data for the entry from the database.
728
730{
731 if (PrepEntry(entry)>=0) return TTree::GetEntry(entry,getall);
732 else return -1;
733}
734
735////////////////////////////////////////////////////////////////////////////////
736/// Setup the tree to the load the specified entry.
737
739{
740 fReadEntry = entry;
741 return PrepEntry(entry);
742}
743
744////////////////////////////////////////////////////////////////////////////////
745/// Make sure the server and result set are setup for the requested entry
746
748{
749 if (entry < 0 || entry >= fEntries || fServer==0) return 0;
750 fReadEntry = entry;
751
752 if(entry == fCurrentEntry) return entry;
753
754 if(entry < fCurrentEntry || fResult==0){
755 delete fResult;
757 fCurrentEntry = -1;
758 }
759
760 Bool_t reset = false;
761 while ( fResult && fCurrentEntry < entry ) {
763 delete fRow;
764 fRow = fResult->Next();
765 if (fRow==0 && !reset) {
766 delete fResult;
768 fCurrentEntry = -1;
769 reset = true;
770 }
771 }
772 if (fRow==0) return -1;
773 return entry;
774}
775
776//______________________________________________________________________________
777// void TTreeSQL::LoadNumberEntries()
778// {
779// R__ASSERT(0);
780
781// fResult = fServer->Query(fQuery.Data());
782// fEntries=0;
783
784// while(fResult->Next()){
785// fEntries++;
786// }
787// fResult = fServer->Query(fQuery.Data());
788// }
789
790////////////////////////////////////////////////////////////////////////////////
791/// Refresh contents of this Tree and its branches from the current
792/// Tree status in the database
793/// One can call this function in case the Tree on its file is being
794/// updated by another process
795
797{
798 // Note : something to be done?
799 GetEntries(); // Re-load the number of entries
800 fCurrentEntry = -1;
801 delete fResult; fResult = 0;
802 delete fRow; fRow = 0;
803}
804
805////////////////////////////////////////////////////////////////////////////////
806/// Reset the internal query
807
809{
810 fInsertQuery = "INSERT INTO " + fTable + " VALUES (";
811}
812
813
814////////////////////////////////////////////////////////////////////////////////
815// Destructor
816
818{
819 delete fTableInfo;
820 delete fResult;
821 delete fRow;
822}
#define d(i)
Definition RSha256.hxx:102
#define f(i)
Definition RSha256.hxx:104
const Ssiz_t kNPOS
Definition RtypesCore.h:115
const Bool_t kFALSE
Definition RtypesCore.h:92
long Long_t
Definition RtypesCore.h:54
long long Long64_t
Definition RtypesCore.h:73
const Bool_t kTRUE
Definition RtypesCore.h:91
#define ClassImp(name)
Definition Rtypes.h:364
const Int_t kFatal
Definition TError.h:51
R__EXTERN Int_t gErrorIgnoreLevel
Definition TError.h:129
char name[80]
Definition TGX11.cxx:110
int type
Definition TGX11.cxx:121
Implement TBasket for a SQL backend.
Definition TBasketSQL.h:31
TSQLResult * GetResultSet()
Definition TBasketSQL.h:52
void CreateBuffer(const char *name, TString title, std::vector< Int_t > *vc, TBranch *branch, TSQLResult **rs)
Create a TSQLBuffer for this basket.
Manages buffers for branches of a Tree.
Definition TBasket.h:34
A TTree is a list of TBranches.
Definition TBranch.h:89
virtual void ResetAddress()
Reset the address of the branch.
Definition TBranch.cxx:2589
TObjArray * GetListOfBranches()
Definition TBranch.h:242
TBasket * GetBasket(Int_t basket)
Definition TBranch.h:209
Int_t GetNleaves() const
Definition TBranch.h:245
TObjArray * GetListOfBaskets()
Definition TBranch.h:241
TObjArray * GetListOfLeaves()
Definition TBranch.h:243
virtual void SetEntries(Long64_t entries)
Set the number of entries in this branch.
Definition TBranch.cxx:2776
Long64_t * GetBasketEntry() const
Definition TBranch.h:211
Buffer base class used for serializing objects.
Definition TBuffer.h:43
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition TClass.h:80
Collection abstract base class.
Definition TCollection.h:63
TBuffer * GetBufferRef() const
Definition TKey.h:80
A TLeaf describes individual elements of a TBranch See TBranch structure in TTree.
Definition TLeaf.h:57
virtual const char * GetTypeName() const
Definition TLeaf.h:139
A doubly linked list.
Definition TList.h:44
virtual const char * GetName() const
Returns name of object.
Definition TNamed.h:47
Int_t GetEntriesFast() const
Definition TObjArray.h:64
virtual void AddAtAndExpand(TObject *obj, Int_t idx)
Add object at position idx.
TObject * UncheckedAt(Int_t i) const
Definition TObjArray.h:90
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition TObject.cxx:893
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
Definition TObject.cxx:921
const char * GetTypeName() const
virtual const char * GetFieldName(Int_t field)=0
virtual Int_t GetRowCount() const
Definition TSQLResult.h:45
virtual TSQLRow * Next()=0
virtual Int_t GetFieldCount()=0
virtual const char * GetField(Int_t field)=0
virtual Int_t SelectDataBase(const char *dbname)=0
virtual TSQLTableInfo * GetTableInfo(const char *tablename)
Produce TSQLTableInfo object, which contain info about table itself and each table column Object must...
virtual TSQLResult * GetColumns(const char *dbname, const char *table, const char *wild=nullptr)=0
virtual TSQLResult * Query(const char *sql)=0
virtual TSQLResult * GetTables(const char *dbname, const char *wild=nullptr)=0
TList * GetColumns() const
Basic string class.
Definition TString.h:136
Ssiz_t Length() const
Definition TString.h:410
int CompareTo(const char *cs, ECaseCompare cmp=kExact) const
Compare a string to char *cs2.
Definition TString.cxx:438
const char * Data() const
Definition TString.h:369
@ kIgnoreCase
Definition TString.h:268
TString & Remove(Ssiz_t pos)
Definition TString.h:673
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition TString.h:639
A TTree object is a list of TBranch.
Definition TTreeSQL.h:42
TString fDB
Definition TTreeSQL.h:46
TString ConvertTypeName(const TString &typeName)
Convert from ROOT typename to SQL typename.
Definition TTreeSQL.cxx:290
virtual Long64_t GetEntries() const
Get the number of rows in the database.
Definition TTreeSQL.cxx:688
virtual Long64_t GetEntriesFast() const
Return the number of entries as of the last check.
Definition TTreeSQL.cxx:721
Bool_t CheckTable(const TString &table) const
Check the table exist in the database.
Definition TTreeSQL.cxx:263
virtual Int_t GetEntry(Long64_t entry=0, Int_t getall=0)
Load the data for the entry from the database.
Definition TTreeSQL.cxx:729
void CreateBranches()
determine leaf description string
Definition TTreeSQL.cxx:391
virtual Int_t Fill()
Copy the information from the user object to the TTree.
Definition TTreeSQL.cxx:570
TSQLTableInfo * fTableInfo
Definition TTreeSQL.h:54
void Init()
Initialization routine.
Definition TTreeSQL.cxx:550
Bool_t fBranchChecked
Definition TTreeSQL.h:53
TSQLServer * fServer
Definition TTreeSQL.h:52
std::vector< Int_t > * GetColumnIndice(TBranch *branch)
Return a vector of columns index corresponding to the current SQL table and the branch given as argum...
Definition TTreeSQL.cxx:622
TSQLResult * fResult
Definition TTreeSQL.h:50
Bool_t CheckBranch(TBranch *tb)
Check if the table has a column corresponding the branch and that the resultset are properly setup.
Definition TTreeSQL.cxx:215
virtual TBranch * Bronch(const char *name, const char *classname, void *addobj, Int_t bufsize=32000, Int_t splitlevel=99)
Not implemented yet.
Definition TTreeSQL.cxx:125
virtual Long64_t PrepEntry(Long64_t entry)
Make sure the server and result set are setup for the requested entry.
Definition TTreeSQL.cxx:747
TString fQuery
Definition TTreeSQL.h:48
virtual Long64_t LoadTree(Long64_t entry)
Setup the tree to the load the specified entry.
Definition TTreeSQL.cxx:738
virtual Int_t Branch(TCollection *list, Int_t bufsize=32000, Int_t splitlevel=99, const char *name="")
Not implemented yet.
Definition TTreeSQL.cxx:96
TString fTable
Definition TTreeSQL.h:49
virtual TBranch * BranchOld(const char *name, const char *classname, void *addobj, Int_t bufsize=32000, Int_t splitlevel=1)
Not implemented yet.
Definition TTreeSQL.cxx:135
virtual void CreateBranch(const TString &branchName, const TString &typeName)
Create the column(s) in the database that correspond to the branch/.
Definition TTreeSQL.cxx:369
void Refresh()
Refresh contents of this Tree and its branches from the current Tree status in the database One can c...
Definition TTreeSQL.cxx:796
virtual ~TTreeSQL()
Definition TTreeSQL.cxx:817
Int_t fCurrentEntry
Definition TTreeSQL.h:45
TString fInsertQuery
Definition TTreeSQL.h:47
TSQLRow * fRow
Definition TTreeSQL.h:51
void ResetQuery()
Reset the internal query.
Definition TTreeSQL.cxx:808
TTreeSQL(TSQLServer *server, TString DB, const TString &table)
Constructor with an explicit TSQLServer.
Definition TTreeSQL.cxx:52
virtual TBasket * CreateBasket(TBranch *br)
Create a TBasketSQL.
Definition TTreeSQL.cxx:351
Bool_t CreateTable(const TString &table)
Create the database table corresponding to this TTree.
Definition TTreeSQL.cxx:488
virtual TBranch * BranchImp(const char *branchname, const char *classname, TClass *ptrClass, void *addobj, Int_t bufsize, Int_t splitlevel)
Not implemented yet.
Definition TTreeSQL.cxx:76
void CheckBasket(TBranch *tb)
Check if the basket is properly setup.
Definition TTreeSQL.cxx:187
A TTree represents a columnar dataset.
Definition TTree.h:79
virtual Int_t Fill()
Fill all branches.
Definition TTree.cxx:4590
TObjArray fBranches
List of Branches.
Definition TTree.h:119
Long64_t fEntries
Number of entries.
Definition TTree.h:84
TBranch * Branch(const char *name, T *obj, Int_t bufsize=32000, Int_t splitlevel=99)
Add a new branch, and infer the data type from the type of obj being passed.
Definition TTree.h:350
virtual Int_t GetEntry(Long64_t entry=0, Int_t getall=0)
Read all branches of entry and return total number of bytes read.
Definition TTree.cxx:5618
Long64_t fReadEntry
! Number of the entry being processed
Definition TTree.h:107