ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Private Member Functions | Private Attributes | List of all members
RDBVersionAccessor Class Reference

RDBVersionAccessor is a helper class navigating HVS tree and getting child node tag by the tag of one of its parents. More...

#include <RDBVersionAccessor.h>

Collaboration diagram for RDBVersionAccessor:

Public Member Functions

 RDBVersionAccessor (const std::string &childNode, const std::string &parentNode, const std::string &parentTag, coral::ISessionProxy *session, MsgStream &stream)
 Constructor.
void getChildTagData ()
 Constructs SQL query and retrieves child tag ID and Name from DB.
const std::string & getNodeName () const
const std::string & getTagName () const
const std::string & getTagID () const
bool isLeaf () const

Private Member Functions

 RDBVersionAccessor ()
 Default constructor.
std::string attribute2String (const coral::AttributeList &attList, const std::string &fieldName)

Private Attributes

coral::ISessionProxy * m_session
std::string m_childNode
std::string m_parentNode
std::string m_parentTag
std::string m_tagName
std::string m_tagID
bool m_isChildLeaf
MsgStream & m_msgStream

Detailed Description

RDBVersionAccessor is a helper class navigating HVS tree and getting child node tag by the tag of one of its parents.

Definition at line 36 of file RDBVersionAccessor.h.

Constructor & Destructor Documentation

◆ RDBVersionAccessor() [1/2]

RDBVersionAccessor::RDBVersionAccessor ( const std::string & childNode,
const std::string & parentNode,
const std::string & parentTag,
coral::ISessionProxy * session,
MsgStream & stream )

Constructor.

Parameters
childNode[IN] child node name
parentNode[IN] parent node name
parentTag[IN] parent tag name
session[IN] active relational session

Definition at line 34 of file RDBVersionAccessor.cxx.

39 : m_session(session)
40 , m_childNode(childNode)
41 , m_parentNode(parentNode)
42 , m_parentTag(parentTag)
43 , m_tagName("")
44 , m_tagID("")
45 , m_isChildLeaf(false)
46 , m_msgStream(msgStream)
47{
48}
RDBVersionAccessor::m_session
coral::ISessionProxy * m_session
Definition RDBVersionAccessor.h:74

◆ RDBVersionAccessor() [2/2]

RDBVersionAccessor::RDBVersionAccessor ( )
private

Default constructor.

Member Function Documentation

◆ attribute2String()

std::string RDBVersionAccessor::attribute2String ( const coral::AttributeList & attList,
const std::string & fieldName )
private

Definition at line 331 of file RDBVersionAccessor.cxx.

333{
334 std::ostringstream streamValue;
335 attList[fieldName].toOutputStream(streamValue);
336 std::string stringValue = streamValue.str();
337 unsigned int position = stringValue.find(") :");
338 return stringValue.substr(position+4);
339}

◆ getChildTagData()

void RDBVersionAccessor::getChildTagData ( )

Constructs SQL query and retrieves child tag ID and Name from DB.

Definition at line 50 of file RDBVersionAccessor.cxx.

51{
52 std::string parentNodeId, childNodeId, parentTagId;
53 int nRows{};
54
55 if(!m_session) {
56 m_msgStream << MSG::ERROR << "VersionAccessor: No connection to database!" << endmsg;
57 return;
58 }
59
60 try {
61 if(m_msgStream.level()==MSG::VERBOSE) {
62 m_msgStream << MSG::VERBOSE << "VersionAccessor: Version accessor for \n ChildNode = " << m_childNode
63 << " ParentNode = " << m_parentNode
64 << " ParentTag = " << m_parentTag << endmsg;
65 }
66
67 coral::ITable& tableTag2Node = m_session->nominalSchema().tableHandle("HVS_TAG2NODE");
68 coral::ITable& tableNode = m_session->nominalSchema().tableHandle("HVS_NODE");
69 coral::ITable& tableLtag2Ltag = m_session->nominalSchema().tableHandle("HVS_LTAG2LTAG");
70
71 //
72 // STEP 1. Get TagId for parentTag
73 //
74 // Query: "SELECT TAG_ID FROM HVS_TAG2NODE WHERE TAG_NAME='m_parentTag'"
75 //
76 coral::IQuery *queryTag2Node = tableTag2Node.newQuery();
77 queryTag2Node->addToOutputList("TAG_ID");
78 queryTag2Node->setMemoryCacheSize(1);
79 coral::AttributeList bindsTag2Node ATLAS_THREAD_SAFE;
80 bindsTag2Node.extend<std::string>("tagN");
81 queryTag2Node->setCondition("TAG_NAME=:tagN", bindsTag2Node);
82 bindsTag2Node[0].data<std::string>() = m_parentTag;
83
84 coral::ICursor& cursorTag2Node = queryTag2Node->execute();
85 nRows = 0;
86 while(cursorTag2Node.next()) {
87 if(++nRows>1) {
88 delete queryTag2Node;
89 throw std::runtime_error( "The tag " + m_parentTag + " is not unique in HVS_TAG2NODE table!");
90 }
91
92 const coral::AttributeList& row = cursorTag2Node.currentRow();
93 parentTagId = attribute2String(row,"TAG_ID");
94
95 }
96 if(nRows==0) {
97 delete queryTag2Node;
98 throw std::runtime_error( "The tag " + m_parentTag + " not found in HVS_TAG2NODE table!");
99 }
100
101 delete queryTag2Node;
102 if(m_msgStream.level()==MSG::VERBOSE) {
103 m_msgStream << MSG::VERBOSE << "VersionAccessor: Parent Tag Id = " << parentTagId << endmsg;
104 }
105
106 //
107 // STEP 2. Get NodeIDs for parentNode and child
108 //
109 // Query: "SELECT NODE_NAME, NODE_ID, BRANCH_FLAG FROM HVS_NODE
110 // WHERE NODE_NAME='m_parentNode' OR NODE_NAME='m_childNode'"
111 //
112
113 coral::IQuery* queryNodeIDs = tableNode.newQuery();
114
115 queryNodeIDs->addToOutputList("NODE_NAME");
116 queryNodeIDs->addToOutputList("NODE_ID");
117 queryNodeIDs->addToOutputList("BRANCH_FLAG");
118 queryNodeIDs->setMemoryCacheSize(2);
119
120 coral::AttributeList bindsNodeIDs ATLAS_THREAD_SAFE;
121 bindsNodeIDs.extend<std::string>("parentN");
122 bindsNodeIDs.extend<std::string>("childN");
123
124 queryNodeIDs->setCondition( "NODE_NAME=:parentN OR NODE_NAME=:childN", bindsNodeIDs);
125
126 bindsNodeIDs[0].data<std::string>() = m_parentNode;
127 bindsNodeIDs[1].data<std::string>() = m_childNode;
128
129 coral::ICursor& cursorNodeIDs = queryNodeIDs->execute();
130
131 nRows = 0;
132 while(cursorNodeIDs.next()) {
133 if(++nRows>2) {
134 break;
135 }
136 const coral::AttributeList& row = cursorNodeIDs.currentRow();
137
138 if(attribute2String(row,"NODE_NAME")==m_childNode) {
139 childNodeId = attribute2String(row,"NODE_ID");
140 m_isChildLeaf = (attribute2String(row,"BRANCH_FLAG")=="0");
141 }
142 else {
143 parentNodeId = attribute2String(row,"NODE_ID");
144 }
145 }
146 if(nRows!=2 && m_childNode!=m_parentNode) {
147 delete queryNodeIDs;
148 throw std::runtime_error("Error processing HVS_NODE, Number of fetched records !=2");
149 }
150
151 if(m_msgStream.level()==MSG::VERBOSE) {
152 m_msgStream << MSG::VERBOSE << "VersionAccessor: Child Node Id = " << childNodeId << endmsg;
153 m_msgStream << MSG::VERBOSE << "VersionAccessor: Parent Node Id = " << parentNodeId << endmsg;
154 }
155
156 delete queryNodeIDs;
157
158 if(m_childNode==m_parentNode) {
159 m_tagName = m_parentTag;
160 m_tagID = std::move(parentTagId);
161 return;
162 }
163
164 //
165 // STEP 3.
166 //
167 // *********************** THIS IS A TEMPORARY SOLUTION ************************
168 // *** ***
169 // *** 1. First we determine a path from childNode to parentNode querying ***
170 // *** HVS_NODE few times ***
171 // *** 2. Then we query HVS_LTAG2LTAG few times to get tag of childNode ***
172 // *** of childNode ***
173 // *** ***
174 // *********** ************ ********** ************* ************ **************
175
176 std::vector<std::string> path;
177 path.push_back(childNodeId);
178 std::string currentParrent = childNodeId;
179 std::string currentChild = std::move(childNodeId);
180
181 coral::AttributeList bindsNode ATLAS_THREAD_SAFE;
182 bindsNode.extend<std::string>("nodeId");
183
184 while(currentParrent != parentNodeId) {
185 //
186 // Query: "SELECT PARENT_ID FROM HVS_NODE WHERE NODE_ID='currentChild'"
187 //
188 coral::IQuery* queryNode(tableNode.newQuery());
189
190 queryNode->addToOutputList("PARENT_ID");
191 queryNode->setMemoryCacheSize(1);
192
193 queryNode->setCondition("NODE_ID=:nodeId", bindsNode);
194 bindsNode[0].data<std::string>()=currentChild;
195
196 coral::ICursor& cursorNode = queryNode->execute();
197
198 nRows = 0;
199
200 // Process Query results
201 while(cursorNode.next()) {
202 if(++nRows>1) {
203 delete queryNode;
204 throw std::runtime_error("The node " + currentChild + " has more than one parent!");
205 }
206
207 const coral::AttributeList& row = cursorNode.currentRow();
208
209 if(row[0].isNull()) {
210 delete queryNode;
211 throw std::runtime_error("The requested child and parent nodes are not on the same branch!");
212 }
213
214 currentParrent = attribute2String(row,"PARENT_ID");
215 currentChild = currentParrent;
216 path.push_back(currentParrent);
217 }
218 if(nRows==0) {
219 delete queryNode;
220 throw std::runtime_error("The node " + currentChild + " has no parent!");
221 }
222
223 delete queryNode;
224 if(m_msgStream.level()==MSG::VERBOSE) {
225 m_msgStream << MSG::VERBOSE << "VersionAccessor: Current Child = " << currentChild << endmsg;
226 m_msgStream << MSG::VERBOSE << "VersionAccessor: Current Parrent = " << currentParrent << endmsg;
227 }
228 }
229
230 coral::AttributeList bindsLtag2Ltag ATLAS_THREAD_SAFE;
231 bindsLtag2Ltag.extend<std::string>("childN");
232 bindsLtag2Ltag.extend<std::string>("parentT");
233 bindsLtag2Ltag.extend<std::string>("parentN");
234
235
236 for(unsigned int ind=1; ind<path.size(); ind++) {
237 // Query: "SELECT CHILD_TAG FROM HVS_LTAG2LTAG WHERE
238 // CHILD_NODE = 'path[path.size()-ind-1]' AND
239 // PARENT_TAG = 'parentTagId' AND
240 // PARENT_NODE = 'path[path.size()-ind]'
241 coral::IQuery* queryLtag2Ltag(tableLtag2Ltag.newQuery());
242
243 queryLtag2Ltag->addToOutputList("CHILD_TAG");
244 queryLtag2Ltag->setMemoryCacheSize(1);
245
246 std::string conditionString = "CHILD_NODE =:childN AND PARENT_TAG =:parentT AND PARENT_NODE =:parentN";
247 queryLtag2Ltag->setCondition(conditionString, bindsLtag2Ltag);
248
249 bindsLtag2Ltag[0].data<std::string>() = path[path.size()-ind-1];
250 bindsLtag2Ltag[1].data<std::string>() = parentTagId;
251 bindsLtag2Ltag[2].data<std::string>() = path[path.size()-ind];
252
253 coral::ICursor& cursorLtag2Ltag = queryLtag2Ltag->execute();
254
255 nRows = 0;
256 // Process Query results
257 while(cursorLtag2Ltag.next()) {
258 if(++nRows>1) {
259 delete queryLtag2Ltag;
260 throw std::runtime_error("Version " + parentTagId +
261 " has more than one child of type " + path[path.size()-ind-1] + "!");
262 }
263
264 const coral::AttributeList& row = cursorLtag2Ltag.currentRow();
265 parentTagId = attribute2String(row,"CHILD_TAG");
266 }
267 if(nRows==0) {
268 delete queryLtag2Ltag;
269 throw std::runtime_error("Version " + parentTagId + " has no child of type " + path[path.size()-ind-1] + "!");
270 }
271
272 delete queryLtag2Ltag;
273
274 if(m_msgStream.level()==MSG::VERBOSE) {
275 m_msgStream << MSG::VERBOSE << "VersionAccessor: Parent Tag Id = " << parentTagId << endmsg;
276 }
277 }
278
279 //
280 // STEP 4. Get tag name for obtained TAG_ID
281 //
282 // Query: "SELECT TAG_NAME from HVS_TAG2NODE WHERE TAG_ID='parentTagId'"
283 //
284 coral::IQuery* queryTagName(tableTag2Node.newQuery());
285
286 queryTagName->addToOutputList("TAG_NAME");
287 queryTagName->setMemoryCacheSize(1);
288
289 coral::AttributeList bindsTagName ATLAS_THREAD_SAFE;
290 bindsTagName.extend<std::string>("tagId");
291
292 queryTagName->setCondition("TAG_ID=:tagId", bindsTagName);
293 bindsTagName[0].data<std::string>() = parentTagId;
294
295 coral::ICursor& cursorTagName = queryTagName->execute();
296
297 nRows = 0;
298 while(cursorTagName.next()) {
299 if(++nRows>1) {
300 delete queryTagName;
301 throw std::runtime_error("More than one record retrieved when getting tag name for given ID");
302 }
303
304 const coral::AttributeList& row = cursorTagName.currentRow();
305
306 m_tagName =attribute2String(row,"TAG_NAME");
307 m_tagID = parentTagId;
308
309 if(m_msgStream.level()==MSG::VERBOSE) {
310 m_msgStream << MSG::VERBOSE << "VersionAccessor: Child Tag Name = " << m_tagName << endmsg;
311 }
312 }
313 delete queryTagName;
314
315 }
316 catch(coral::SchemaException& se)
317 {
318 m_msgStream << MSG::ERROR << "VersionAccessor: Schema Exception : " << se.what() << endmsg;
319 }
320 catch(std::exception& e)
321 {
322 if(m_msgStream.level()<=MSG::DEBUG)
323 m_msgStream << MSG::DEBUG << e.what() << endmsg;
324 }
325 catch(...)
326 {
327 m_msgStream << MSG::ERROR << "VersionAccessor: Exception caught(...)" << endmsg;
328 }
329}
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:63
ATLAS_THREAD_SAFE
#define ATLAS_THREAD_SAFE
Definition checker_macros.h:211
RDBVersionAccessor::attribute2String
std::string attribute2String(const coral::AttributeList &attList, const std::string &fieldName)
Definition RDBVersionAccessor.cxx:331
PrintTrkAnaSummary.row
row
Appending html table to final .html summary file.
Definition PrintTrkAnaSummary.py:356
RPDUtils::nRows
unsigned int constexpr nRows
Definition RPDUtils.h:24
athena.path
path
python interpreter configuration --------------------------------------—
Definition athena.py:128
keylayer_zslicemap.se
dict se
Definition keylayer_zslicemap.py:194

◆ getNodeName()

const std::string & RDBVersionAccessor::getNodeName ( ) const
inline
Returns
node name

Definition at line 54 of file RDBVersionAccessor.h.

54{return m_childNode;}

◆ getTagID()

const std::string & RDBVersionAccessor::getTagID ( ) const
inline
Returns
stringified tag ID

Definition at line 61 of file RDBVersionAccessor.h.

61{return m_tagID;}

◆ getTagName()

const std::string & RDBVersionAccessor::getTagName ( ) const
inline
Returns
tag name for the child node

Definition at line 58 of file RDBVersionAccessor.h.

58{return m_tagName;}

◆ isLeaf()

bool RDBVersionAccessor::isLeaf ( ) const
inline
Returns
branch flag for the child node returns false if the data has not been fetched yet

Definition at line 65 of file RDBVersionAccessor.h.

65{return m_isChildLeaf;}

Member Data Documentation

◆ m_childNode

std::string RDBVersionAccessor::m_childNode
private

Definition at line 76 of file RDBVersionAccessor.h.

◆ m_isChildLeaf

bool RDBVersionAccessor::m_isChildLeaf
private

Definition at line 82 of file RDBVersionAccessor.h.

◆ m_msgStream

MsgStream& RDBVersionAccessor::m_msgStream
private

Definition at line 84 of file RDBVersionAccessor.h.

◆ m_parentNode

std::string RDBVersionAccessor::m_parentNode
private

Definition at line 77 of file RDBVersionAccessor.h.

◆ m_parentTag

std::string RDBVersionAccessor::m_parentTag
private

Definition at line 78 of file RDBVersionAccessor.h.

◆ m_session

coral::ISessionProxy* RDBVersionAccessor::m_session
private

Definition at line 74 of file RDBVersionAccessor.h.

◆ m_tagID

std::string RDBVersionAccessor::m_tagID
private

Definition at line 81 of file RDBVersionAccessor.h.

◆ m_tagName

std::string RDBVersionAccessor::m_tagName
private

Definition at line 80 of file RDBVersionAccessor.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0