CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
RelationalOperation.cc
Go to the documentation of this file.
2 #include "RelationalOperation.h"
3 // externals
4 #include "CoralBase/Attribute.h"
5 #include "CoralBase/Blob.h"
6 #include "RelationalAccess/ISchema.h"
7 #include "RelationalAccess/ITable.h"
8 #include "RelationalAccess/ITableDataEditor.h"
9 #include "RelationalAccess/IBulkOperation.h"
10 #include "RelationalAccess/IQuery.h"
11 #include "RelationalAccess/ICursor.h"
12 
13 namespace ora {
14 
15  bool existAttribute(const std::string& attributeName,
16  const coral::AttributeList& data){
17  bool found = false;
18  for(coral::AttributeList::const_iterator iAttr = data.begin();
19  iAttr!=data.end() && !found; ++iAttr){
20  if( iAttr->specification().name() == attributeName ) found = true;
21  }
22  return found;
23  }
24 
25  char* conditionOfType( ConditionType condType ){
26  static char* cond[ 5 ] = { (char*)"=",(char*)">",(char*)"<",(char*)">=",(char*)"<=" };
27  return cond[ condType ];
28  }
29 
30 }
31 
33  m_data(),
34  m_setClause(""),
35  m_whereClause(""){
36 }
37 
39 }
40 
41 void ora::InputRelationalData::addId(const std::string& columnName){
42  if(!existAttribute( columnName, m_data )){
43  m_data.extend<int>( columnName );
44  if(!m_setClause.empty()) m_setClause += ", ";
45  m_setClause += ( columnName +"= :"+columnName );
46  }
47 }
48 
49 void ora::InputRelationalData::addData(const std::string& columnName,
50  const std::type_info& columnType ){
51  if(!existAttribute( columnName, m_data )){
52  m_data.extend( columnName, columnType );
53  if(!m_setClause.empty()) m_setClause += ", ";
54  m_setClause += ( columnName +"= :"+columnName );
55  }
56 }
57 
58 void ora::InputRelationalData::addBlobData(const std::string& columnName){
59  if(!existAttribute( columnName, m_data )){
60  m_data.extend<coral::Blob>( columnName );
61  if(!m_setClause.empty()) m_setClause += ", ";
62  m_setClause += ( columnName +"= :"+columnName );
63  }
64 }
65 
66 void ora::InputRelationalData::addWhereId( const std::string& columnName ){
67  if(!existAttribute( columnName, m_data )){
68  m_data.extend<int>( columnName );
69  }
70  if(!m_whereClause.empty()) m_whereClause += " AND ";
71  m_whereClause += ( columnName +"= :"+columnName );
72 }
73 
74 void ora::InputRelationalData::addWhereId( const std::string& columnName, ConditionType condType ){
75  if(!existAttribute( columnName, m_data )){
76  m_data.extend<int>( columnName );
77  if(!m_whereClause.empty()) m_whereClause += " AND ";
78  m_whereClause += ( columnName +conditionOfType(condType)+" :"+columnName );
79  }
80 }
81 
82 coral::AttributeList& ora::InputRelationalData::data(){
83  return m_data;
84 }
85 
86 coral::AttributeList& ora::InputRelationalData::whereData(){
87  // data and where data are hosted in the same buffer (as for update operation)
88  return m_data;
89 }
90 
92  return m_setClause;
93 }
94 
96  return m_whereClause;
97 }
98 
99 ora::InsertOperation::InsertOperation( const std::string& tableName,
100  coral::ISchema& schema ):
102  m_tableName( tableName ),
103  m_schema( schema ){
104 }
105 
107 }
108 
109 bool
111  return false;
112 }
113 
115  coral::ITable& table = m_schema.tableHandle( m_tableName );
116  table.dataEditor().insertRow( data() );
117  return true;
118 }
119 
121 }
122 
123 ora::BulkInsertOperation::BulkInsertOperation( const std::string& tableName,
124  coral::ISchema& schema ):
126  m_tableName( tableName ),
127  m_schema( schema ),
128  m_bulkOperations(){
129 }
130 
132  for( std::vector<coral::IBulkOperation*>::iterator iB = m_bulkOperations.begin();
133  iB != m_bulkOperations.end(); ++iB ){
134  delete *iB;
135  }
136 }
137 
138 coral::IBulkOperation& ora::BulkInsertOperation::setUp( int rowCacheSize ){
139  coral::ITable& table = m_schema.tableHandle( m_tableName );
140 
141  m_bulkOperations.push_back( table.dataEditor().bulkInsert( data(), rowCacheSize ) );
142  return *m_bulkOperations.back();
143 }
144 
145 bool
147  return false;
148 }
149 
151  for( std::vector<coral::IBulkOperation*>::iterator iB = m_bulkOperations.begin();
152  iB != m_bulkOperations.end(); ++iB ){
153  (*iB)->flush();
154  delete *iB;
155  }
156  m_bulkOperations.clear();
157  return true;
158 }
159 
161  for( std::vector<coral::IBulkOperation*>::iterator iB = m_bulkOperations.begin();
162  iB != m_bulkOperations.end(); ++iB ){
163  delete *iB;
164  }
165  m_bulkOperations.clear();
166 }
167 
168 ora::UpdateOperation::UpdateOperation( const std::string& tableName,
169  coral::ISchema& schema ):
171  m_tableName( tableName ),
172  m_schema( schema ){
173 }
174 
176 }
177 
178 bool
180  return true;
181 }
182 
184  bool ret = false;
185  if( updateClause().size() && whereClause().size() ){
186  coral::ITable& table = m_schema.tableHandle( m_tableName );
187  long nr = table.dataEditor().updateRows( updateClause(), whereClause(), data() );
188  ret = nr > 0;
189  }
190  return ret;
191 }
192 
194 }
195 
196 ora::DeleteOperation::DeleteOperation( const std::string& tableName,
197  coral::ISchema& schema ):
199  m_tableName( tableName ),
200  m_schema( schema ){
201 }
202 
204 }
205 
206 bool
208  return false;
209 }
210 
212  bool ret = false;
213  if( whereClause().size() ){
214  coral::ITable& table = m_schema.tableHandle( m_tableName );
215  long nr = table.dataEditor().deleteRows( whereClause(), whereData() );
216  ret = nr > 0;
217  }
218  return ret;
219 }
220 
222 }
223 
224 ora::SelectOperation::SelectOperation( const std::string& tableName,
225  coral::ISchema& schema ):
226  m_spec( new coral::AttributeListSpecification ),
227  m_whereData(),
228  m_whereClause(""),
229  m_orderByCols(),
230  m_query(),
231  m_cursor( 0 ),
232  m_tableName( tableName ),
233  m_schema( schema ){
234 }
235 
237  m_spec->release();
238 }
239 
240 void ora::SelectOperation::addOrderId(const std::string& columnName){
241  m_orderByCols.push_back( columnName );
242 }
243 
245  bool ret = false;
246  if( m_query.get() ){
247  ret = m_cursor->next();
248  if(!ret) clear();
249  }
250  return ret;
251 }
252 
254  m_query.reset();
255  m_cursor = 0;
256 }
257 
258 void ora::SelectOperation::addId(const std::string& columnName){
259  if(m_spec->index( columnName )==-1){
260  m_spec->extend< int >( columnName );
261  }
262 }
263 
264 void ora::SelectOperation::addData(const std::string& columnName,
265  const std::type_info& columnType ){
266  if(m_spec->index( columnName )==-1){
267  m_spec->extend( columnName, columnType );
268  }
269 }
270 
271 void ora::SelectOperation::addBlobData(const std::string& columnName ){
272  if(m_spec->index( columnName )==-1){
273  m_spec->extend<coral::Blob>( columnName );
274  }
275 }
276 
277 void ora::SelectOperation::addWhereId( const std::string& columnName ){
278  if(!existAttribute( columnName, m_whereData )){
279  m_whereData.extend<int>( columnName );
280  if(!m_whereClause.empty()) m_whereClause += " AND ";
281  m_whereClause += ( columnName +"= :"+columnName );
282  }
283 }
284 
285 coral::AttributeList& ora::SelectOperation::data(){
286  if(!m_cursor) throwException( "Query on table "+m_tableName+" has not been executed.",
287  "ora::ReadOperation::data" );
288  return const_cast<coral::AttributeList&>(m_cursor->currentRow());
289 }
290 
291 coral::AttributeList& ora::SelectOperation::whereData(){
292  return m_whereData;
293 }
294 
296  return m_whereClause;
297 }
298 
300  m_cursor = 0;
301  coral::ITable& table = m_schema.tableHandle( m_tableName );
302  m_query.reset( table.newQuery() );
303  for ( coral::AttributeListSpecification::const_iterator iSpec = m_spec->begin();
304  iSpec != m_spec->end(); ++iSpec ) {
305  m_query->addToOutputList( iSpec->name() );
306  m_query->defineOutputType( iSpec->name(),iSpec->typeName());
307  }
308  for(std::vector<std::string>::iterator iCol = m_orderByCols.begin();
309  iCol != m_orderByCols.end(); iCol++ ){
310  m_query->addToOrderList( *iCol );
311  }
312  m_query->setCondition( m_whereClause, m_whereData );
313  m_query->setRowCacheSize( 100 ); // We should better define this value !!!
314  m_cursor = &m_query->execute();
315 }
316 
317 coral::AttributeListSpecification& ora::SelectOperation::attributeListSpecification(){
318  return *m_spec;
319 }
320 
list table
Definition: asciidump.py:386
char * conditionOfType(ConditionType condType)
void addData(const std::string &columnName, const std::type_info &columnType)
coral::AttributeListSpecification & attributeListSpecification()
coral::AttributeList & whereData()
void addId(const std::string &columnName)
UpdateOperation(const std::string &tableName, coral::ISchema &schema)
BulkInsertOperation(const std::string &tableName, coral::ISchema &schema)
SelectOperation(const std::string &tableName, coral::ISchema &schema)
InsertOperation(const std::string &tableName, coral::ISchema &schema)
coral::IBulkOperation & setUp(int rowCacheSize)
void addBlobData(const std::string &columnName)
DeleteOperation(const std::string &tableName, coral::ISchema &schema)
void addId(const std::string &columnName)
coral::AttributeList & data()
void addOrderId(const std::string &columnName)
void addData(const std::string &columnName, const std::type_info &columnType)
coral::AttributeList & data()
coral::AttributeList & whereData()
void addWhereId(const std::string &columnName)
void addWhereId(const std::string &columnName)
void addBlobData(const std::string &columnName)
void throwException(const std::string &message, const std::string &methodName)
Definition: Exception.cc:10
tuple size
Write out results.
bool existAttribute(const std::string &attributeName, const coral::AttributeList &data)