Public Member Functions
bool	build ()

void	executeAndLoad (void *address)

	QVQueryMaker (const edm::TypeWithDict &objectType, MappingElement &mapping, ContainerSchema &contSchema)

void	select (const std::vector< int > &fullId, const Selection &selection)

size_t	selectionCount (const std::vector< int > &fullId, const Selection &selection)

void	setQueryCondition (IRelationalData &queryData, const Selection &selection, MappingElement &mappingElement)

	~QVQueryMaker ()

Private Attributes
std::auto_ptr< IArrayHandler >	m_arrayHandler

std::auto_ptr< IRelationalReader >	m_dataReader

DataElement	m_localElement

MappingElement &	m_mappingElement

edm::TypeWithDict	m_objectType

int	m_oid

std::auto_ptr< SelectOperation >	m_query

std::vector< int >	m_recordId

ContainerSchema &	m_schema

Detailed Description

Definition at line 50 of file QueryableVectorStreamer.cc.

Constructor & Destructor Documentation

ora::QVQueryMaker::QVQueryMaker	(	const edm::TypeWithDict &	objectType,
		MappingElement &	mapping,
		ContainerSchema &	contSchema
	)

inline

Definition at line 52 of file QueryableVectorStreamer.cc.

                                                                                                              :
         m_objectType( objectType ),
         m_mappingElement( mapping ),
         m_schema( contSchema ),
         m_recordId(),
         m_localElement(),
         m_query(),
         m_arrayHandler(),
         m_oid(-1){
       }

ora::QVQueryMaker::~QVQueryMaker ( )

inline

Definition at line 63 of file QueryableVectorStreamer.cc.

63 {

64 }

Member Function Documentation

bool ora::QVQueryMaker::build ( )

inline

Definition at line 66 of file QueryableVectorStreamer.cc.

References ora::DataElement::clear(), ora::ClassUtils::containerSubType(), ora::ClassUtils::containerValueType(), edm::TypeWithDict::cppName(), ora::MappingElement::end(), ora::MappingElement::find(), i, m_arrayHandler, m_dataReader, m_localElement, m_mappingElement, m_objectType, m_query, m_recordId, m_schema, ora::ArrayHandlerFactory::newArrayHandler(), ora::RelationalStreamerFactory::newReader(), ora::MappingElement::pkColumn(), ora::MappingElement::recordIdColumns(), ora::ClassUtils::resolvedType(), ora::ContainerSchema::storageSchema(), ora::MappingElement::tableName(), and ora::throwException().

Referenced by ora::QueryableVectorLoader::loadSelection(), and psClasses.BuildThread::run().

                   {
         m_localElement.clear();
         m_recordId.clear();
         // allocate for the index...
         m_recordId.push_back(0);
 
         RelationalStreamerFactory streamerFactory( m_schema );
         // first open the insert on the extra table...
         m_query.reset( new SelectOperation( m_mappingElement.tableName(), m_schema.storageSchema() ));
 
         m_query->addWhereId( m_mappingElement.pkColumn() );
         std::vector<std::string> recIdCols = m_mappingElement.recordIdColumns();
         for( size_t i=0; i<recIdCols.size(); i++ ){
           m_query->addId( recIdCols[ i ] );
           m_query->addOrderId( recIdCols[ i ] );
         }
 
         edm::TypeWithDict storeBaseType = ClassUtils::containerSubType(m_objectType,"range_store_base_type");
         if( !storeBaseType ){
           throwException( "Missing dictionary information for the range store base type of the container \"" +
                           m_objectType.cppName() + "\"",
                           "QVQueryMaker::build" );          
         }
         
         m_arrayHandler.reset( ArrayHandlerFactory::newArrayHandler( storeBaseType ) );
 
         edm::TypeWithDict valueType = ClassUtils::containerValueType(m_objectType);
         edm::TypeWithDict valueResolvedType = ClassUtils::resolvedType(valueType);
         // Check the component type
         if ( ! valueType ||!valueResolvedType ) {
           throwException( "Missing dictionary information for the content type of the container \"" +
                           m_objectType.cppName() + "\"",
                           "QVQueryMaker::build" );
         }
         // Retrieve the relevant mapping element
         MappingElement::iterator iMe = m_mappingElement.find( "value_type" );
         if ( iMe == m_mappingElement.end() ) {
           throwException( "Item for \"value_type\" not found in the mapping element",
                           "QVQueryMaker::build" );
         }
 
         m_dataReader.reset( streamerFactory.newReader( valueResolvedType, iMe->second ) );
         m_dataReader->build( m_localElement, *m_query );
         return true;
       }

void ora::QVQueryMaker::executeAndLoad ( void * address )

inline

Definition at line 218 of file QueryableVectorStreamer.cc.

References edm::ObjectWithDict::address(), edm::TypeWithDict::construct(), edm::TypeWithDict::cppName(), edm::TypeWithDict::dataMemberByName(), edm::TypeWithDict::destruct(), i, m_arrayHandler, m_dataReader, m_mappingElement, m_objectType, m_oid, m_query, m_recordId, edm::MemberWithDict::offset(), ora::MappingElement::posColumn(), and ora::throwException().

Referenced by ora::QueryableVectorLoader::loadSelection().

                                         {
 
         if(!m_query.get()){
           throwException("The reader has not been built.",
                          "QVReader::read");
         }
         edm::TypeWithDict iteratorDereferenceReturnType = m_arrayHandler->iteratorReturnType();
         edm::MemberWithDict firstMember = iteratorDereferenceReturnType.dataMemberByName( "first" );
         if ( ! firstMember ) {
           throwException( "Could not retrieve the data member \"first\" of the class \"" +
                           iteratorDereferenceReturnType.cppName() + "\"",
                           "QVQueryMakerAndLoad::read" );
         }
         edm::MemberWithDict secondMember = iteratorDereferenceReturnType.dataMemberByName( "second" );
         if ( ! secondMember ) {
           throwException( "Could not retrieve the data member \"second\" of the class \"" +
                           iteratorDereferenceReturnType.cppName() + "\"",
                           "QVQueryMakerAndLoad::read" );
         }
 
         m_arrayHandler->clear( address );
 
         unsigned int i=0;
         while ( m_query->nextCursorRow() ){
 
           // Create a new element for the array
           void* objectData = iteratorDereferenceReturnType.construct().address();
           void* positionData  = static_cast< char* >( objectData ) + firstMember.offset();
           void* containerData = static_cast< char* >( objectData ) + secondMember.offset();
 
           m_recordId[m_recordId.size()-1] = (int)i;
           coral::AttributeList& row = m_query->data();
 
           *(size_t*)positionData = (size_t)(row[m_mappingElement.posColumn()].data<int>());
     
           m_dataReader->setRecordId( m_recordId );
           m_dataReader->select( m_oid );
           m_dataReader->read( containerData );
 
           size_t prevSize = m_arrayHandler->size( address );
           m_arrayHandler->appendNewElement( address, objectData );
           bool inserted = m_arrayHandler->size( address )>prevSize;
           
           iteratorDereferenceReturnType.destruct( objectData );
           if ( !inserted ) {
             throwException( "Could not insert a new element in the array type \"" +
                             m_objectType.cppName() + "\"",
                             "QVQueryMakerAndLoad::executeAndLoad" );
           }
           ++i;
         }
 
         m_arrayHandler->finalize( address );
     m_query->clear();
       }

void ora::QVQueryMaker::select	(	const std::vector< int > &	fullId,
		const Selection &	selection
	)

inline

Definition at line 168 of file QueryableVectorStreamer.cc.

References i, m_mappingElement, m_oid, m_query, m_recordId, ora::MappingElement::pkColumn(), setQueryCondition(), and ora::throwException().

Referenced by Vispa.Views.LineDecayView.LineDecayContainer::createObject(), Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::find(), ora::QueryableVectorLoader::loadSelection(), Vispa.Views.LineDecayView.LineDecayContainer::mousePressEvent(), Vispa.Gui.PortConnection.PointToPointConnection::mousePressEvent(), Vispa.Gui.VispaWidget.VispaWidget::mousePressEvent(), and Vispa.Views.AbstractView.AbstractView::restoreSelection().

                                                                              {
         if(!m_query.get()){
           throwException("The reader has not been built.",
                          "QVReader::select");
         }
         
         m_oid = fullId[0];
         m_recordId.clear();
         for(size_t i=1;i<fullId.size();i++) {
           m_recordId.push_back( fullId[i] );
         }
         // allocate the element for the index...
         m_recordId.push_back( 0 );
 
         coral::AttributeList& whereData = m_query->whereData();
         whereData[ m_mappingElement.pkColumn() ].data<int>() = fullId[0];
 
         setQueryCondition( *m_query, selection, m_mappingElement );
         
         m_query->execute();
       }

size_t ora::QVQueryMaker::selectionCount	(	const std::vector< int > &	fullId,
		const Selection &	selection
	)

inline

Definition at line 190 of file QueryableVectorStreamer.cc.

References i, m_mappingElement, m_schema, ora::MappingElement::pkColumn(), ora::MappingElement::recordIdColumns(), mps_fire::result, setQueryCondition(), ora::ContainerSchema::storageSchema(), AlCaHLTBitMon_QueryRunRegistry::string, and ora::MappingElement::tableName().

Referenced by ora::QueryableVectorLoader::getSelectionCount().

                                                                                        {
         SelectOperation countQuery( m_mappingElement.tableName(), m_schema.storageSchema() );
         std::string countColumn("COUNT(*)");
         countQuery.addData( countColumn ,typeid(int) );
         countQuery.addWhereId( m_mappingElement.pkColumn() );
         std::vector<std::string> recIdColumns = m_mappingElement.recordIdColumns();
         for( size_t i=0;i<recIdColumns.size();i++){
           countQuery.addWhereId( recIdColumns[i] );
         }
 
         coral::AttributeList& whereData = countQuery.whereData();
         // Fill-in the identities.
         whereData[ m_mappingElement.pkColumn() ].data<int>() = fullId[0];
         for ( size_t i=0;i<fullId.size();i++ ){
           whereData[ recIdColumns[i] ].data<int>() = fullId[i+1];
         }
         
         setQueryCondition( countQuery, selection, m_mappingElement );
         countQuery.execute();
 
         size_t result = 0;
         if( countQuery.nextCursorRow() ){
           coral::AttributeList& row = countQuery.data();
           result = row[countColumn].data<int>();
         }
         return result;
       }

void ora::QVQueryMaker::setQueryCondition	(	IRelationalData &	queryData,
		const Selection &	selection,
		MappingElement &	mappingElement
	)

inline

Definition at line 112 of file QueryableVectorStreamer.cc.

References ora::MappingElement::columnNames(), ora::Selection::data(), ora::MappingElement::elementType(), ora::MappingElement::elementTypeAsString(), ora::MappingElement::end(), ora::MappingElement::find(), i, ora::Selection::indexVariable(), ora::Selection::items(), ora::MappingElement::Object, ora::MappingElement::Primitive, AlCaHLTBitMon_QueryRunRegistry::string, ora::throwException(), ora::Selection::variableNameFromUniqueString(), ora::IRelationalData::whereClause(), and ora::IRelationalData::whereData().

Referenced by select(), and selectionCount().

                                                                                                                       {
         coral::AttributeList& whereData = queryData.whereData();
         // adding the selection conditions
         const std::vector<std::pair<std::string,std::string> >& theItems =  selection.items();
         std::stringstream cond;
         unsigned int i=0;
         for(std::vector<std::pair<std::string,std::string> >::const_iterator iItem = theItems.begin();
             iItem != theItems.end();
             ++iItem){
           cond << " AND ";
           std::string varName = Selection::variableNameFromUniqueString(iItem->first);
           std::stringstream selColumn;
           std::string colName("");
           if(varName == Selection::indexVariable()){
             colName = mappingElement.columnNames()[mappingElement.columnNames().size()-1]; // the position column is the last
             selColumn << colName<<"_"<<i;
             whereData.extend<int>(selColumn.str());
             whereData[selColumn.str()].data<int>() = selection.data()[iItem->first].data<int>();
           } else {
             MappingElement::iterator iElem = mappingElement.find("value_type");
             if ( iElem == mappingElement.end() ) {
               throwException( "Item for element \"value_type\" not found in the mapping element",
                               "QVQueryMaker::setQueryCondition" );
             }
             MappingElement& valueTypeElement = iElem->second;
             if( valueTypeElement.elementType()==MappingElement::Primitive ){
               if(varName!="value_type"){
                 throwException( "Item for element \"" + varName + "\" not found in the mapping element",
                                 "QVQueryMaker::setQueryCondition" );
               }
               colName = valueTypeElement.columnNames()[0];
             } else if( valueTypeElement.elementType()==MappingElement::Object ){
               MappingElement::iterator iInnerElem = valueTypeElement.find(varName);
               if ( iInnerElem == valueTypeElement.end() ) {
                 throwException( "Item for element \"" + varName + "\" not found in the mapping element",
                                 "QVQueryMaker::setQueryCondition" );
               }
               colName = iInnerElem->second.columnNames()[0];
             } else {
               throwException( "Queries cannot be executed on types mapped on "+
                               MappingElement::elementTypeAsString(valueTypeElement.elementType()),
                               "QVQueryMaker::setQueryCondition" );
             }
             selColumn << colName<<"_"<<i;
             whereData.extend(selColumn.str(),selection.data()[iItem->first].specification().type());
             whereData[selColumn.str()].setValueFromAddress(selection.data()[iItem->first].addressOfData());
           }
           cond << colName << " " << iItem->second << " :"<<selColumn.str();
           i++;
           selColumn.str("");
         }
 
         // add the resulting condition clause
         queryData.whereClause()+=cond.str();
       }