OMDSReader.h

Go to the documentation of this file.

#ifndef CondTools_L1Trigger_OMDSReader_h
#define CondTools_L1Trigger_OMDSReader_h
// -*- C++ -*-
//
// Package:     L1Trigger
// Class  :     OMDSReader
//
//
// Original Author:  Werner Sun
//         Created:  Sun Mar  2 01:36:06 CET 2008
// $Id: OMDSReader.h,v 1.14 2010/04/12 20:29:23 wsun Exp $
//

// system include files
#include <memory>

// user include files
#include "CondTools/L1Trigger/interface/DataManager.h"
#include "RelationalAccess/IQuery.h"
#include "CoralBase/AttributeList.h"
#include "CoralBase/AttributeSpecification.h"
#include "CoralBase/Attribute.h"

#include "RelationalAccess/ITable.h"
#include "RelationalAccess/IView.h"
#include "RelationalAccess/ISchema.h"
#include "RelationalAccess/ISessionProxy.h"
#include "RelationalAccess/ICursor.h"

// forward declarations

namespace l1t
{

  class OMDSReader : public DataManager
  {

  public:
    // std::vector< std::string > is the list of attribute names.
    // We need to store the column names because there is no way to ask
    // AttributeList for this information.  We have a vector of AttributeLists
    // because the query may return more than one row, each of which is
    // encapsulated in an AttributeList.
    class QueryResults
    {
    public:
      QueryResults() {}
      QueryResults( const std::vector< std::string >& columnNames,
            const std::vector< coral::AttributeList >& attLists )
        : m_columnNames( columnNames), m_attributeLists( attLists ) {}

      virtual ~QueryResults() {}

      const std::vector< std::string >& columnNames() const
        { return m_columnNames ; }
      const std::vector< coral::AttributeList >& attributeLists() const
        { return m_attributeLists ; }
      bool queryFailed() const { return m_attributeLists.empty() ; }
      int numberRows() const { return m_attributeLists.size() ; }

      // Return value is false if variable is null.
      template< class T >
        bool fillVariable( const std::string& columnName,
                   T& outputVariable ) const ;

      template< class T >
        bool fillVariableFromRow( const std::string& columnName,
                      int rowNumber,
                      T& outputVariable ) const ;

      // If there is only one column, no need to give column name
      template< class T >
        bool fillVariable( T& outputVariable ) const ;

      template< class T >
        bool fillVariableFromRow( int rowNumber,
                      T& outputVariable ) const ;

    private:
      std::vector< std::string > m_columnNames ;
      std::vector< coral::AttributeList > m_attributeLists ;
    } ;

    OMDSReader() ;

    OMDSReader( const std::string& connectString,
        const std::string& authenticationPath ) ;

    ~OMDSReader() override;

      // ---------- const member functions ---------------------

      // These functions encapsulate basic SQL queries of the form
      //
      // SELECT <columns> FROM <schema.table> WHERE <conditionLHS> = <conditionRHS>
      //
      // where
      //
      // <columns> can be one or many column names
      // <conditionRHS> can be a string or the result of another query

      // Assume data type of condition RHS is std::string
      const QueryResults basicQuery(
    const std::vector< std::string >& columnNames,
    const std::string& schemaName, // for nominal schema, use ""
    const std::string& tableName,
    const std::string& conditionLHS = "",
    const QueryResults conditionRHS = QueryResults(),
                                               // must have only one row
    const std::string& conditionRHSName = ""
                     // if empty, conditionRHS must have only one column
    );

      // Assume data type of condition RHS is std::string
      const QueryResults basicQuery(
    const std::string& columnName,
    const std::string& schemaName, // for nominal schema, use ""
    const std::string& tableName,
    const std::string& conditionLHS = "",
    const QueryResults conditionRHS = QueryResults(),
                                               // must have only one row
    const std::string& conditionRHSName = ""
                     // if empty, conditionRHS must have only one column
    );


      // Assume data type of condition RHS is std::string
      const QueryResults basicQueryView(
    const std::vector< std::string >& columnNames,
    const std::string& schemaName, // for nominal schema, use ""
    const std::string& viewName,
    const std::string& conditionLHS = "",
    const QueryResults conditionRHS = QueryResults(),
                                               // must have only one row
    const std::string& conditionRHSName = ""
                     // if empty, conditionRHS must have only one column
    );

      // Assume data type of condition RHS is std::string
      const QueryResults basicQueryView(
    const std::string& columnName,
    const std::string& schemaName, // for nominal schema, use ""
    const std::string& viewName,
    const std::string& conditionLHS = "",
    const QueryResults conditionRHS = QueryResults(),
                                               // must have only one row
    const std::string& conditionRHSName = ""
                     // if empty, conditionRHS must have only one column
    );

      // For any data type of condition RHS.
      // Example usage, for an int key:
      //   results = omdsReader.basicQueryGenericKey<int>(...) ;
      template< class T >
    const QueryResults basicQueryGenericKey(
      const std::vector< std::string >& columnNames,
      const std::string& schemaName, // for nominal schema, use ""
      const std::string& tableName,
      const std::string& conditionLHS = "",
      const QueryResults conditionRHS = QueryResults(),
                                                // must have only one row
      const std::string& conditionRHSName = ""
                        // if empty, conditionRHS must have only one column
      );

      // For any data type of condition RHS.
      // Example usage, for an int key:
      //   results = omdsReader.basicQueryGenericKey<int>(...) ;
      template< class T >
    const QueryResults basicQueryGenericKey(
      const std::string& columnName,
      const std::string& schemaName, // for nominal schema, use ""
      const std::string& tableName,
      const std::string& conditionLHS = "",
      const QueryResults conditionRHS = QueryResults(),
                                               // must have only one row
      const std::string& conditionRHSName = ""
                     // if empty, conditionRHS must have only one column
      );

      template< class T >
    const QueryResults singleAttribute( const T& data ) const ;

      std::vector< std::string > columnNames(
    const std::string& schemaName, // for nominal schema, use ""
    const std::string& tableName );

      std::vector< std::string > columnNamesView(
    const std::string& schemaName, // for nominal schema, use ""
    const std::string& viewName );

      // ---------- static member functions --------------------

      // ---------- member functions ---------------------------

      void connect( const std::string& connectString,
            const std::string& authenticationPath ) ;

   private:
      OMDSReader(const OMDSReader&) = delete; // stop default

      const OMDSReader& operator=(const OMDSReader&) = delete; // stop default

      // ---------- member data --------------------------------
};

  template< class T > const OMDSReader::QueryResults
  OMDSReader::basicQueryGenericKey(
    const std::vector< std::string >& columnNames,
    const std::string& schemaName,
    const std::string& tableName,
    const std::string& conditionLHS,
    const QueryResults conditionRHS,
    const std::string& conditionRHSName ) 
  {
    coral::ISessionProxy& coralSession = session.coralSession();
    coral::ISchema& schema = schemaName.empty() ?
      coralSession.nominalSchema() :
      coralSession.schema( schemaName ) ;

    coral::ITable& table = schema.tableHandle( tableName ) ;

    // Pointer is deleted automatically at end of function.
    boost::shared_ptr< coral::IQuery > query( table.newQuery() ) ;

    // Construct query
    std::vector< std::string >::const_iterator it = columnNames.begin() ;
    std::vector< std::string >::const_iterator end = columnNames.end() ;
    for( ; it != end ; ++it )
      {
    query->addToOutputList( *it ) ;
      }

    // Only apply condition if RHS has one row.
    if( !conditionLHS.empty() && conditionRHS.numberRows() == 1 )
      {
    if( !conditionRHSName.empty() )
      {
        // Use type of dummyVariable to determine type of condition RHS
        coral::AttributeList attList ;
        attList.extend( conditionRHSName, typeid( T ) ) ;
        T tmp = T();
        conditionRHS.fillVariable( conditionRHSName, tmp ) ;
        attList[ conditionRHSName ].data< T >() = tmp ;

        query->setCondition( conditionLHS + " = :" + conditionRHSName,
                 attList ) ;
      }
    else if( conditionRHS.columnNames().size() == 1 )
      // check for only one column
      {
        query->setCondition( conditionLHS + " = :" +
                   conditionRHS.columnNames().front(),
                 conditionRHS.attributeLists().front() ) ;
      }
      }

    coral::ICursor& cursor = query->execute() ;

    // Copy AttributeLists for external use because the cursor is deleted
    // when the query goes out of scope.
    std::vector< coral::AttributeList > atts ;
    while( cursor.next() )
      {
    atts.push_back( cursor.currentRow() ) ;
      } ;

    return QueryResults( columnNames, atts ) ;
  }

  template< class T > const OMDSReader::QueryResults
  OMDSReader::basicQueryGenericKey(
    const std::string& columnName,
    const std::string& schemaName,
    const std::string& tableName,
    const std::string& conditionLHS,
    const QueryResults conditionRHS,
    const std::string& conditionRHSName ) 
  {
    std::vector< std::string > columnNames ;
    columnNames.push_back( columnName ) ;
    return basicQueryGenericKey< T >( columnNames, schemaName, tableName,
                 conditionLHS, conditionRHS, conditionRHSName);
  }

  template< class T > const OMDSReader::QueryResults
  OMDSReader::singleAttribute( const T& data ) const
  {
    std::vector< std::string > names ;
    names.push_back( "dummy" ) ;

    coral::AttributeList attList ;
    attList.extend( "dummy", typeid( T ) ) ;
    attList[ "dummy" ].data< T >() = data ;

    std::vector< coral::AttributeList > atts ;
    atts.push_back( attList ) ;

    return QueryResults( names, atts ) ;
  }

  template< class T > bool
    OMDSReader::QueryResults::fillVariable(
      const std::string& columnName,
      T& outputVariable ) const
    {
      return fillVariableFromRow( columnName, 0, outputVariable ) ;
    }

  template< class T > bool
    OMDSReader::QueryResults::fillVariableFromRow(
      const std::string& columnName,
      int rowNumber,
      T& outputVariable ) const
    {
      // Check index in bounds
      if( rowNumber < 0 || rowNumber >= numberRows() ) return false ;
      const coral::AttributeList& row = m_attributeLists[ rowNumber ] ;
      if( row[ columnName ].isNull() ) return false ;
      outputVariable = row[ columnName ].template data< T >() ;
      return true ;
    }

  template< class T > bool
    OMDSReader::QueryResults::fillVariable( T& outputVariable ) const
    {
      return fillVariableFromRow( 0, outputVariable ) ;
    }

  template< class T > bool
    OMDSReader::QueryResults::fillVariableFromRow( int rowNumber,
                           T& outputVariable ) const
    {
      // Check index in bounds and only one column
      if( rowNumber < 0 || rowNumber >= numberRows() ||
      m_columnNames.size() != 1 ) return false ;
      const coral::AttributeList& row = m_attributeLists[ rowNumber ] ;
      if( row[ m_columnNames.front() ].isNull() ) return false ;
      outputVariable = row[ m_columnNames.front() ].template data< T >() ;
      return true ;
    }

}
#endif