CoraCoolFolder Class Reference

#include <CoraCoolFolder.h>

Collaboration diagram for CoraCoolFolder:

Public Types
typedef std::vector< coral::AttributeList >::const_iterator	const_iterator

Public Member Functions
	CoraCoolFolder (const std::string &coolfolder, coral::ISessionProxy *proxy, cool::IDatabasePtr cooldb, CoraCoolDatabase *coradb, coral::MessageStream &log)
	~CoraCoolFolder ()
	CoraCoolFolder (const CoraCoolFolder &)=delete
CoraCoolFolder &	operator= (const CoraCoolFolder &)=delete
std::string	coralTableName () const
const std::string &	coralFKey () const
const std::string &	coralPKey () const
const cool::IRecordSpecification &	fkSpecification () const
const cool::RecordSpecification	payloadSpecification () const
coral::AttributeList	emptyAttrList () const
cool::IFolderPtr	coolFolder ()
int	storeObject (const cool::ValidityKey &since, const cool::ValidityKey until, const_iterator begin, const_iterator end, const cool::ChannelId &channelId=0, const std::string &tagName="", const bool userTagOnly=false)
bool	setupStorageBuffer ()
void	flushStorageBuffer ()
void	referenceObject (const cool::ValidityKey &since, const cool::ValidityKey &until, const coral::Attribute &fkey, const cool::ChannelId &channelId=0, const std::string &tagName="", const bool userTagOnly=false)
void	referenceObject (const cool::ValidityKey &since, const cool::ValidityKey &until, const int ifkey, const cool::ChannelId &channelId=0, const std::string &tagName="", const bool userTagOnly=false)
void	addPayload (const_iterator begin, const_iterator end)
CoraCoolObjectPtr	findObject (const cool::ValidityKey &pointInTime, const cool::ChannelId &channelId=0, const std::string &tagName="")
CoraCoolObjectIterPtr	browseObjects (const cool::ValidityKey &pointInTime, const cool::ChannelSelection &channels, const std::string &tagName="")
CoraCoolObjectIterPtr	browseObjects (const cool::ValidityKey &since=cool::ValidityKeyMin, const cool::ValidityKey &until=cool::ValidityKeyMax, const cool::ChannelSelection &channels=cool::ChannelSelection(0), const std::string &tagName="")
void	setPrefetchAll (const bool prefetchAll)
bool	setAttrKey (coral::Attribute &attr, const int keyval)
bool	setFieldKey (cool::IField &attr, const int keyval)
bool	setFieldAttr (cool::IField &attr, const coral::Attribute &keyval)
int	getAttrKey (const coral::Attribute &attr)

Private Types
typedef std::vector< std::pair< std::string, std::string > >	AttrVec
typedef AttrVec::const_iterator	AttrItr

Private Member Functions
coral::ISessionProxy *	proxy ()
const coral::ISessionProxy *	proxy () const
coral::ITable *	table ()
void	setOutputSpec (coral::IQuery *query)
bool	decodeAttrSpec ()
cool::StorageType::TypeId	nameToCoolType (const std::string &coolName) const
void	bulkInsert (const_iterator begin, const_iterator end, const int fkey, bool updatefk)

Private Attributes
std::string	m_foldername
std::string	m_dbname
coral::ISessionProxy *	m_proxy
cool::IDatabasePtr	m_cooldb
CoraCoolDatabase *	m_coradb
coral::MessageStream &	m_log
std::string	m_tablename
std::string	m_keycolcoral
std::string	m_keycolcool
std::string	m_pkeycolcoral
bool	m_pkey
cool::IFolderPtr	m_coolfolder
coral::ITable *	m_table
const coral::ITableDescription *	m_tabledesc
AttrVec	m_attrvec
bool	m_bulkactive
coral::AttributeList *	m_payloadbuf
coral::IBulkOperation *	m_bulki
CoraCoolSequence *	m_seqpk
CoraCoolSequence *	m_seqfk
int	m_nextpk
int	m_usedpk
int	m_nextfk
int	m_usedfk

Friends
class	CoraCoolObjectIter

Detailed Description

Definition at line 37 of file CoraCoolFolder.h.

Member Typedef Documentation

AttrItr

typedef AttrVec::const_iterator CoraCoolFolder::AttrItr

private

Definition at line 174 of file CoraCoolFolder.h.

AttrVec

typedef std::vector<std::pair<std::string,std::string> > CoraCoolFolder::AttrVec

private

Definition at line 173 of file CoraCoolFolder.h.

const_iterator

typedef std::vector<coral::AttributeList>::const_iterator CoraCoolFolder::const_iterator

Definition at line 42 of file CoraCoolFolder.h.

Constructor & Destructor Documentation

CoraCoolFolder() [1/2]

CoraCoolFolder::CoraCoolFolder	(	const std::string &	coolfolder,
		coral::ISessionProxy *	proxy,
		cool::IDatabasePtr	cooldb,
		CoraCoolDatabase *	coradb,
		coral::MessageStream &	log )

Definition at line 40 of file CoraCoolFolder.cxx.

        :
        m_foldername(coolfolder),
        m_proxy(proxy),m_cooldb(std::move(cooldb)),m_coradb(coradb),
        m_log(log),
    m_bulkactive(false),m_payloadbuf(0),m_bulki(0),m_seqpk(0),m_seqfk(0),
    m_nextpk(0),m_usedpk(0),m_nextfk(0),m_usedfk(0)
{
  m_dbname=m_coradb->dbname();
 
  // get information from COOL
  m_log << coral::Debug << "Initialize CoraCoolFolder " << coolfolder << 
    " in database instance " << m_dbname << coral::MessageStream::endmsg;
 
  std::string folderdesc;
  try {
    m_coolfolder=m_cooldb->getFolder(m_foldername);
    folderdesc=m_coolfolder->description();
  }
  catch (cool::Exception& e) {
    throw CoraCoolException(e.what(),"CoraCoolFolder::CoraCoolFolder");
  }
  m_log << coral::Debug << "COOL Folder description is: " << folderdesc 
              << coral::MessageStream::endmsg;
 
  // set up linking information between COOL and CORAL folders
  if (m_coradb->parseFolderDescription(folderdesc,m_tablename,m_keycolcool,
               m_keycolcoral,m_pkeycolcoral)) {
    m_pkey=(m_keycolcoral!=m_pkeycolcoral);
  } else {
    throw CoraCoolException("incorrect <coracool> description string ",
                  "CoraCoolFolder::CoraCoolFolder");
  }
 
  // obtain information about CORAL folder
  try {
    m_proxy->transaction().start(true);
    coral::ISchema& schema=m_proxy->nominalSchema();
    m_table=&schema.tableHandle(m_tablename);
    m_tabledesc=&(m_table->description());
    // find type of foreign key
    // lookup attribute specification for query outputs
    if (!decodeAttrSpec()) throw CoraCoolException(
      "Problem extracting attribute specification",
      "CoraCoolFolder::CoraCoolFolder");
    m_proxy->transaction().commit();
  }
  catch (coral::SessionException& e) {
    throw CoraCoolException("Problem accessing CORAL table "+m_tablename,
                  "CoraCoolFolder::CoraCoolFolder");
  }
}

~CoraCoolFolder()

CoraCoolFolder::~CoraCoolFolder

(

)

Definition at line 95 of file CoraCoolFolder.cxx.

                                {
  delete m_payloadbuf;
  
  if (m_seqpk) delete m_seqpk;
  if (m_seqfk) delete m_seqfk;
}

CoraCoolFolder() [2/2]

CoraCoolFolder::CoraCoolFolder ( const CoraCoolFolder & )

delete

Member Function Documentation

addPayload()

void CoraCoolFolder::addPayload	(	const_iterator	begin,
		const_iterator	end )

Definition at line 293 of file CoraCoolFolder.cxx.

                                                                        { // Copies AttributeList, giving shared specification.
  // add payload to the CORAL table, using existing FKs in data
  // but regenerating primary keys
 
  // only makes sense to use this method for folders with separate pkeys
  if (!m_pkey) throw CoraCoolException("Folder has no primary key",
                       "CoralCoolFolder::addPayload");
  if (m_bulkactive) {
    // via bulk operation buffer
    bulkInsert(begin,end,0,false);
  } else {
    // first count number of CORAL rows to be inserted
    unsigned int nrow=0;
    for (const_iterator payitr=begin;payitr!=end;++payitr) ++nrow;
    m_log << coral::Debug << "Adding " << nrow << " into CoraCool folder " 
      << m_foldername << coral::MessageStream::endmsg;
    // generate keys - start transaction here
    int pkey;
    try {
      m_proxy->transaction().start(false);
      CoraCoolSequence seqfk(m_dbname,m_tablename+"_PK",m_proxy,false);
      pkey=seqfk.fetch(nrow);
      // commit key transaction, releasing lock on keytable
      m_proxy->transaction().commit();
    }
    catch (coral::Exception& e) {
      throw CoraCoolException(e.what(),"CoraCoolFolder::addPayload(key)");
    }
    // insert rows into CORAL
    try {
      m_proxy->transaction().start(false);
      coral::ISchema& schema=m_proxy->nominalSchema();
      m_table=&schema.tableHandle(m_tablename);
      coral::ITableDataEditor& editor=m_table->dataEditor();
 
      for (const_iterator payitr=begin;payitr!=end;++payitr) {
        // store data, updating pkey
        coral::AttributeList data=*payitr;
        setAttrKey(data[m_pkeycolcoral],pkey++);
        editor.insertRow(data);
      }
      m_proxy->transaction().commit();
    }
    catch (coral::Exception& e) {
      throw CoraCoolException(e.what(),"CoraCoolFolder::addPayload(payload)");
    }
  }
}

browseObjects() [1/2]

CoraCoolObjectIterPtr CoraCoolFolder::browseObjects	(	const cool::ValidityKey &	pointInTime,
		const cool::ChannelSelection &	channels,
		const std::string &	tagName = "" )

Definition at line 550 of file CoraCoolFolder.cxx.

                                 {
  return browseObjects(pointInTime,pointInTime,channels,tagName);
}

browseObjects() [2/2]

CoraCoolObjectIterPtr CoraCoolFolder::browseObjects	(	const cool::ValidityKey &	since = cool::ValidityKeyMin,
		const cool::ValidityKey &	until = cool::ValidityKeyMax,
		const cool::ChannelSelection &	channels = cool::ChannelSelection(0),
		const std::string &	tagName = "" )

Definition at line 557 of file CoraCoolFolder.cxx.

{
  // first initialise COOL query
  cool::IObjectIteratorPtr coolitr=m_coolfolder->browseObjects(since,until,
    channels,tagName);
  CoraCoolObjectIterPtr itr(new CoraCoolObjectIter(this,std::move(coolitr)));
  return itr;
}

bulkInsert()

void CoraCoolFolder::bulkInsert ( const_iterator begin, const_iterator end, const int fkey, bool updatefk )

private

Definition at line 496 of file CoraCoolFolder.cxx.

                                              {
  // do bulk insertion into CORAL table buffer
  // if updateFK=true, update rows with given FK value
  try {
    for (const_iterator payitr=begin;payitr!=end;++payitr) {
      // copy data into buffer bound to bulk insert
      m_payloadbuf->fastCopyData(*payitr);
      // update the keys
      if (updatefk) setAttrKey((*m_payloadbuf)[m_keycolcoral],fkey);
      if (m_pkey) {
    setAttrKey((*m_payloadbuf)[m_pkeycolcoral],m_nextpk++);
    ++m_usedpk;
      }
      // add to bulk operation
      m_bulki->processNextIteration();
    }
  }
  catch (coral::Exception& e) {
    throw CoraCoolException(e.what(),"CoraCoolFolder::bulkInsert");
  }
}

coolFolder()

cool::IFolderPtr CoraCoolFolder::coolFolder ( )

inline

Definition at line 197 of file CoraCoolFolder.h.

{ return m_coolfolder; }

coralFKey()

const std::string & CoraCoolFolder::coralFKey ( ) const

inline

Definition at line 191 of file CoraCoolFolder.h.

{ return m_keycolcoral; }

coralPKey()

const std::string & CoraCoolFolder::coralPKey ( ) const

inline

Definition at line 194 of file CoraCoolFolder.h.

{ return m_pkeycolcoral; }

coralTableName()

std::string CoraCoolFolder::coralTableName ( ) const

inline

Definition at line 188 of file CoraCoolFolder.h.

{ return m_tablename.substr(m_dbname.size()+1); }

decodeAttrSpec()

bool CoraCoolFolder::decodeAttrSpec ( )

private

Definition at line 423 of file CoraCoolFolder.cxx.

                                    {
  // read information from the CORACOOLATTR table
  bool bres=false;
  coral::IQuery* query=0;
  try {
    coral::ITable& table=m_proxy->nominalSchema().tableHandle(
                       m_dbname+"_CORACOOLATTR");
    query=table.newQuery();
    coral::AttributeList bindvar;
    bindvar.extend<std::string>("SNAME");
    bindvar[0].data<std::string>()=m_tablename;
    query->setCondition("NAME=:SNAME",bindvar);
    query->setRowCacheSize(1);
    query->defineOutputType("NAME","string");
    coral::ICursor& cursor=query->execute();
    if (cursor.next()) {
      const coral::AttributeList& res=cursor.currentRow();
      std::string spec=res["ATTRSPEC"].data<std::string>();
      // decode specification
      std::string::size_type iofs1,iofs2,iofs3;
      iofs1=0;
      bool last=false;
      while (!last) {
        iofs2=spec.find(':',iofs1);
        iofs3=spec.find(',',iofs2);
        if (iofs3==std::string::npos) {
          iofs3=spec.size();
          last=true;
        }
        m_attrvec.emplace_back(spec.substr(iofs1,iofs2-iofs1),spec.substr(iofs2+1,iofs3-iofs2-1));
        if (!last) iofs1=iofs3+1;
      }
      bres=true;
    } else {
      m_log << coral::Error << "No data obtained for CORACOOLATTR" << 
    coral::MessageStream::endmsg;
    }
  }
  catch (coral::Exception &e) {
    m_log << coral::Error << "Exception reading CORACOOLATTR table: "
                << e.what() << coral::MessageStream::endmsg;
  }
  delete query;
  return bres;
}

emptyAttrList()

coral::AttributeList CoraCoolFolder::emptyAttrList

(

)

const

Definition at line 116 of file CoraCoolFolder.cxx.

                                                       {
  // assemble and return an attributelist for use in constructing payloads
  coral::AttributeList atrlist;
  for (AttrItr itr=m_attrvec.begin();itr!=m_attrvec.end();++itr)
    atrlist.extend(itr->first,
     cool::StorageType::storageType(nameToCoolType(itr->second)).cppType());
  return atrlist;
}

findObject()

CoraCoolObjectPtr CoraCoolFolder::findObject	(	const cool::ValidityKey &	pointInTime,
		const cool::ChannelId &	channelId = 0,
		const std::string &	tagName = "" )

Definition at line 519 of file CoraCoolFolder.cxx.

                             {
  // first query cool to get foreign key
  m_log << coral::Debug << "CoraCoolFolder query time " << pointInTime << 
    " channel " << channelId << " tag " << tagName << coral::MessageStream::endmsg;
  cool::IObjectPtr obj=m_coolfolder->findObject(pointInTime,channelId,tagName);
  // create result object with IOV from COOL
  CoraCoolObjectPtr result(new CoraCoolObject(obj->since(),obj->until(),
                          obj->channelId()));
  // now query CORAL for payload
  try {
    m_proxy->transaction().start(true);
    coral::IQuery* query=m_table->newQuery();
    std::string where=m_keycolcoral+"=:"+m_keycolcool;
    const coral::AttributeList& fkeybind=obj->payload().attributeList();
    query->setCondition(where,fkeybind);
    coral::ICursor& cursor=query->execute();
    while (cursor.next()) {
      const coral::AttributeList& res=cursor.currentRow();
      result->add(res);
    }
    delete query;
    m_proxy->transaction().commit();
  }
  catch (coral::Exception& e) {
    throw CoraCoolException(e.what(),"CoraCoolFolder::findObject");
  }
  return result;
}

fkSpecification()

const cool::IRecordSpecification & CoraCoolFolder::fkSpecification

(

)

const

Definition at line 102 of file CoraCoolFolder.cxx.

{ return m_coolfolder->payloadSpecification(); }

flushStorageBuffer()

void CoraCoolFolder::flushStorageBuffer

(

)

Definition at line 243 of file CoraCoolFolder.cxx.

                                        {
  if (!m_bulkactive) return;
  // execute bulk store
  try {
    m_bulki->flush();
  // update the keys
    if (m_usedpk>0) m_seqpk->fetch(m_usedpk);
    if (m_usedfk>0) m_seqfk->fetch(m_usedfk);
    // commit transaction for payload table and keys
    m_proxy->transaction().commit();
  }
  catch (coral::Exception& e) {
    throw CoraCoolException(e.what(),"CoraCoolFolder::flushStorageBuffer");
  }
  m_coolfolder->flushStorageBuffer();
  m_bulkactive=false;
}

getAttrKey()

int CoraCoolFolder::getAttrKey

(

const coral::Attribute &

attr

)

Definition at line 406 of file CoraCoolFolder.cxx.

                                                         {
  const std::string typen=attr.specification().typeName();
  if (typen=="int") {
    return attr.data<int>();
  } else if (typen=="unsigned int") {
    return static_cast<int>(attr.data<unsigned int>());
  } else if (typen=="long long") {
    return static_cast<int>(attr.data<long long>());
  } else if (typen=="unsigned long long") {
    return static_cast<int>(attr.data<unsigned long long>());
  } else {
    m_log << coral::Error << "Unrecognised key type " << typen << 
    " in CoraCoolFolder::getAttrKey" << coral::MessageStream::endmsg;
    return 0;
  }
}

nameToCoolType()

cool::StorageType::TypeId CoraCoolFolder::nameToCoolType ( const std::string & coolName ) const

private

Definition at line 469 of file CoraCoolFolder.cxx.

                                                   {
  if (coolName=="Int16") return cool::StorageType::Int16;
  if (coolName=="UInt16") return cool::StorageType::UInt16;
  if (coolName=="Int32") return cool::StorageType::Int32;
  if (coolName=="UInt32") return cool::StorageType::UInt32;
  if (coolName=="UInt63") return cool::StorageType::UInt63;
  if (coolName=="Int64") return cool::StorageType::Int64;
  if (coolName=="Float") return cool::StorageType::Float;
  if (coolName=="Double") return cool::StorageType::Double;
  if (coolName=="String255") return cool::StorageType::String255;
  if (coolName=="String4k") return cool::StorageType::String4k;
  if (coolName=="String64k") return cool::StorageType::String64k;
  if (coolName=="String16M") return cool::StorageType::String16M;
  if (coolName=="Blob64k") return cool::StorageType::Blob64k;
 
  throw CoraCoolException("Undefined type: "+coolName,
    "CoraCoolFolder::nameToCoolType");
}

operator=()

CoraCoolFolder & CoraCoolFolder::operator= ( const CoraCoolFolder & )

delete

payloadSpecification()

const cool::RecordSpecification CoraCoolFolder::payloadSpecification

(

)

const

Definition at line 107 of file CoraCoolFolder.cxx.

                                             {
  // have to assemble a RecordSpecification and return the specification
  // as ITableDescription does not allow to get this directly
  cool::RecordSpecification atrspec;
  for (AttrItr itr=m_attrvec.begin();itr!=m_attrvec.end();++itr)
    atrspec.extend(itr->first,nameToCoolType(itr->second));
  return atrspec;
}

proxy() [1/2]

coral::ISessionProxy * CoraCoolFolder::proxy ( )

inlineprivate

Definition at line 200 of file CoraCoolFolder.h.

{return m_proxy; }

proxy() [2/2]

const coral::ISessionProxy * CoraCoolFolder::proxy ( ) const

inlineprivate

Definition at line 201 of file CoraCoolFolder.h.

{return m_proxy; }

referenceObject() [1/2]

void CoraCoolFolder::referenceObject	(	const cool::ValidityKey &	since,
		const cool::ValidityKey &	until,
		const coral::Attribute &	fkey,
		const cool::ChannelId &	channelId = 0,
		const std::string &	tagName = "",
		const bool	userTagOnly = false )

Definition at line 261 of file CoraCoolFolder.cxx.

                                       {
  // add reference to existing payload object
  // call COOL API, just checking fkey has correct name
  if (fkey.specification().name()==m_keycolcool) {
    cool::Record fkeylist(m_coolfolder->payloadSpecification());
    setFieldAttr(fkeylist[m_keycolcool],fkey);
    m_coolfolder->storeObject(since,until,fkeylist,channelId,tagName,
                      userTagOnly);
  } else {
    throw CoraCoolException("Foreign key name should be "+m_keycolcool,
        "CoraCool::Folder::referenceObject");
  }
}

referenceObject() [2/2]

void CoraCoolFolder::referenceObject	(	const cool::ValidityKey &	since,
		const cool::ValidityKey &	until,
		const int	ifkey,
		const cool::ChannelId &	channelId = 0,
		const std::string &	tagName = "",
		const bool	userTagOnly = false )

Definition at line 280 of file CoraCoolFolder.cxx.

                                       {
  // add reference to existing payload object, supplying key as int
  cool::Record fkeylist(m_coolfolder->payloadSpecification());
  setFieldKey(fkeylist[m_keycolcool],ifkey);
  m_coolfolder->storeObject(since,until,fkeylist,channelId,tagName,
                userTagOnly);
}

setAttrKey()

bool CoraCoolFolder::setAttrKey	(	coral::Attribute &	attr,
		const int	keyval )

Definition at line 342 of file CoraCoolFolder.cxx.

                                  {
  // set the value of the key in the attribute, regardless of type
  const std::string typen=attr.specification().typeName();
  if (typen=="int") {
    attr.data<int>()=keyval;
  } else if (typen=="unsigned int") {
    attr.data<unsigned int>()=keyval;
  } else if (typen=="long long") {
    attr.data<long long>()=keyval;
  } else if (typen=="unsigned long long") {
    attr.data<unsigned long long>()=keyval;
  } else {
    // throw exception here?
    m_log << coral::Error << "Unrecognised key type " << typen << 
    " in CoraCoolFolder::setAttrKey" << coral::MessageStream::endmsg;
    return false;
  }
  return true;
}

setFieldAttr()

bool CoraCoolFolder::setFieldAttr	(	cool::IField &	attr,
		const coral::Attribute &	keyval )

Definition at line 384 of file CoraCoolFolder.cxx.

                                                {
  // set the value of the key in the Record, from input Attribute
  const cool::StorageType& typen=attr.specification().storageType();
  if (typen==cool::StorageType::Int32) {
    attr.setValue<int>(keyval.data<int>());
  } else if (typen==cool::StorageType::UInt32) {
    attr.setValue<unsigned int>(keyval.data<unsigned int>());
  } else if (typen==cool::StorageType::Int64) {
    attr.setValue<long long>(keyval.data<long long>());
  } else if (typen==cool::StorageType::UInt63) {
    attr.setValue<unsigned long long>(keyval.data<unsigned long long>());
  } else {
    // throw exception here?
    m_log << coral::Error << "Unrecognised key type " << typen.name() << 
      " in CoraCoolFolder::setFieldAttr" << coral::MessageStream::endmsg;
    return false;
  }
  return true;
}

setFieldKey()

bool CoraCoolFolder::setFieldKey	(	cool::IField &	attr,
		const int	keyval )

Definition at line 363 of file CoraCoolFolder.cxx.

                                  {
  // set the value of the key in the Record, regardless of type
  const cool::StorageType& typen=attr.specification().storageType();
  if (typen==cool::StorageType::Int32) {
    attr.setValue<int>(keyval);
  } else if (typen==cool::StorageType::UInt32) {
    attr.setValue<unsigned int>(keyval);
  } else if (typen==cool::StorageType::Int64) {
    attr.setValue<long long>(keyval);
  } else if (typen==cool::StorageType::UInt63) {
    attr.setValue<unsigned long long>(keyval);
  } else {
    // throw exception here?
    m_log << coral::Error << "Unrecognised key type " << typen.name() << 
      " in CoraCoolFolder::setFieldKey" << coral::MessageStream::endmsg;
    return false;
  }
  return true;
}

setOutputSpec()

void CoraCoolFolder::setOutputSpec ( coral::IQuery * query )

private

Definition at line 489 of file CoraCoolFolder.cxx.

                                                     {
  for (AttrItr itr=m_attrvec.begin();itr!=m_attrvec.end();++itr)
    query->defineOutputType(itr->first,
      coral::AttributeSpecification::typeNameForId(
      cool::StorageType::storageType(nameToCoolType(itr->second)).cppType()));
}

setPrefetchAll()

void CoraCoolFolder::setPrefetchAll

(

const bool

prefetchAll

)

Definition at line 570 of file CoraCoolFolder.cxx.

                                                    {
  // pass setting onto COOL - no special actions for CoraCool yet
  m_coolfolder->setPrefetchAll(prefetchAll);
}

setupStorageBuffer()

bool CoraCoolFolder::setupStorageBuffer

(

)

Definition at line 211 of file CoraCoolFolder.cxx.

                                        {
  // flush any existing data first to get clean state
  if (m_bulkactive) flushStorageBuffer();
  if (m_payloadbuf==0) {
    // actions done if this is the first time setupStorageBuffer done for
    // this folder
    // create AttributeList as bulk buffer
    m_payloadbuf=new coral::AttributeList(emptyAttrList());
    // setup bulk storage for the COOL folder
    m_coolfolder->setupStorageBuffer();
  }
  // setup bulk operation buffer - transaction begins here
  m_proxy->transaction().start(false);
  coral::ISchema& schema=m_proxy->nominalSchema();
  m_table=&schema.tableHandle(m_tablename);
  coral::ITableDataEditor& editor=m_table->dataEditor();
  m_bulki=editor.bulkInsert(*m_payloadbuf,WB_SIZE);
  // prepare the key sequences
  if (m_pkey) {
    if (m_seqpk==0) 
      m_seqpk=new CoraCoolSequence(m_dbname,m_tablename+"_PK",m_proxy,false);
    m_seqpk->querySeq(m_nextpk,true,true);
    m_usedpk=0;
  }
  if (m_seqfk==0) 
    m_seqfk=new CoraCoolSequence(m_dbname,m_tablename+"_FK",m_proxy,false);
  m_seqfk->querySeq(m_nextfk,true,true);
  m_usedfk=0;
  m_bulkactive=true;
  return true;
}

storeObject()

int CoraCoolFolder::storeObject	(	const cool::ValidityKey &	since,
		const cool::ValidityKey	until,
		const_iterator	begin,
		const_iterator	end,
		const cool::ChannelId &	channelId = 0,
		const std::string &	tagName = "",
		const bool	userTagOnly = false )

Definition at line 125 of file CoraCoolFolder.cxx.

                                   {
  // store objects into CORAL table, and reference in COOL table
  // generate new FK and PK for CORAL data as needed
 
  int fkey=0;
  if (m_bulkactive) {
    fkey=m_nextfk++;
    ++m_usedfk;
    bulkInsert(begin,end,fkey,true);
  } else {
    // non-bulk insert
    // first count number of CORAL rows to be inserted
    unsigned int nrow=0;
    for (const_iterator payitr=begin;payitr!=end;++payitr) ++nrow;
    m_log << coral::Debug << "Storing " << nrow << " rows in CoraCool folder " 
      << m_foldername << " channel " << channelId << 
      coral::MessageStream::endmsg;
 
    // generate keys - start transaction here
    int pkey;
    try {
      m_proxy->transaction().start(false);
      CoraCoolSequence seqfk(m_dbname,m_tablename+"_FK",m_proxy,false);
      fkey=seqfk.fetch();
      if (m_pkey) {
        CoraCoolSequence seqfk(m_dbname,m_tablename+"_PK",m_proxy,false);
        pkey=seqfk.fetch(nrow);
      } else {
        pkey=0; // set to 0 to satisfy compiler
      }
      // commit key transaction, releasing lock on keytable
      m_proxy->transaction().commit();
    }
    catch (coral::Exception& e) {
      throw CoraCoolException(e.what(),"CoraCoolFolder::storeObject(key)");
    }
 
    // insert rows into CORAL, using bulk operation
    try {
      m_proxy->transaction().start(false);
      coral::ISchema& schema=m_proxy->nominalSchema();
      m_table=&schema.tableHandle(m_tablename);
      coral::ITableDataEditor& editor=m_table->dataEditor();
      coral::AttributeList data=*begin;
      coral::IBulkOperation* bulki=editor.bulkInsert(data,WB_SIZE);
 
      for (const_iterator payitr=begin;payitr!=end;++payitr) {
        // copy data from iterator
        data.fastCopyData(*payitr);
        // update the keys
        setAttrKey(data[m_keycolcoral],fkey);
        if (m_pkey) setAttrKey(data[m_pkeycolcoral],pkey++);
        // store data into CORAL table
        bulki->processNextIteration();
      }
      bulki->flush();
      m_proxy->transaction().commit();
    }
    catch (coral::Exception& e) {
      throw CoraCoolException(e.what(),"CoraCoolFolder::storeObject(payload)");
    }
 
    // now store data in COOL, with correct foreign key (bulk/non bulk)
    // in bulk case, the COOL operation is already going via storage buffer
  }
  cool::Record coolfk(m_coolfolder->payloadSpecification());
  setFieldKey(coolfk[m_keycolcool],fkey);
  try {
    m_coolfolder->storeObject(since,until,coolfk,channelId,tagName,
                  userTagOnly);
  }
  catch (cool::Exception &e) {
    throw CoraCoolException(e.what(),"CoraCoolFolder::storeObject");
  }
  // return FK value, in case user wants to use it in a reference object call
  return fkey;
}

table()

coral::ITable * CoraCoolFolder::table ( )

private

Definition at line 575 of file CoraCoolFolder.cxx.

                                   { 
  return &(m_proxy->nominalSchema().tableHandle(m_tablename));
}

Friends And Related Symbol Documentation

CoraCoolObjectIter

friend class CoraCoolObjectIter

friend

Definition at line 39 of file CoraCoolFolder.h.

Member Data Documentation

m_attrvec

AttrVec CoraCoolFolder::m_attrvec

private

Definition at line 175 of file CoraCoolFolder.h.

m_bulkactive

bool CoraCoolFolder::m_bulkactive

private

Definition at line 177 of file CoraCoolFolder.h.

m_bulki

coral::IBulkOperation* CoraCoolFolder::m_bulki

private

Definition at line 179 of file CoraCoolFolder.h.

m_cooldb

cool::IDatabasePtr CoraCoolFolder::m_cooldb

private

Definition at line 160 of file CoraCoolFolder.h.

m_coolfolder

cool::IFolderPtr CoraCoolFolder::m_coolfolder

private

Definition at line 169 of file CoraCoolFolder.h.

m_coradb

CoraCoolDatabase* CoraCoolFolder::m_coradb

private

Definition at line 161 of file CoraCoolFolder.h.

m_dbname

std::string CoraCoolFolder::m_dbname

private

Definition at line 158 of file CoraCoolFolder.h.

m_foldername

std::string CoraCoolFolder::m_foldername

private

Definition at line 157 of file CoraCoolFolder.h.

m_keycolcool

std::string CoraCoolFolder::m_keycolcool

private

Definition at line 166 of file CoraCoolFolder.h.

m_keycolcoral

std::string CoraCoolFolder::m_keycolcoral

private

Definition at line 165 of file CoraCoolFolder.h.

m_log

coral::MessageStream& CoraCoolFolder::m_log

private

Definition at line 162 of file CoraCoolFolder.h.

m_nextfk

int CoraCoolFolder::m_nextfk

private

Definition at line 184 of file CoraCoolFolder.h.

m_nextpk

int CoraCoolFolder::m_nextpk

private

Definition at line 182 of file CoraCoolFolder.h.

m_payloadbuf

coral::AttributeList* CoraCoolFolder::m_payloadbuf

private

Definition at line 178 of file CoraCoolFolder.h.

m_pkey

bool CoraCoolFolder::m_pkey

private

Definition at line 168 of file CoraCoolFolder.h.

m_pkeycolcoral

std::string CoraCoolFolder::m_pkeycolcoral

private

Definition at line 167 of file CoraCoolFolder.h.

m_proxy

coral::ISessionProxy* CoraCoolFolder::m_proxy

private

Definition at line 159 of file CoraCoolFolder.h.

m_seqfk

CoraCoolSequence* CoraCoolFolder::m_seqfk

private

Definition at line 181 of file CoraCoolFolder.h.

m_seqpk

CoraCoolSequence* CoraCoolFolder::m_seqpk

private

Definition at line 180 of file CoraCoolFolder.h.

m_table

coral::ITable* CoraCoolFolder::m_table

private

Definition at line 170 of file CoraCoolFolder.h.

m_tabledesc

const coral::ITableDescription* CoraCoolFolder::m_tabledesc

private

Definition at line 171 of file CoraCoolFolder.h.

m_tablename

std::string CoraCoolFolder::m_tablename

private

Definition at line 164 of file CoraCoolFolder.h.

m_usedfk

int CoraCoolFolder::m_usedfk

private

Definition at line 185 of file CoraCoolFolder.h.

m_usedpk

int CoraCoolFolder::m_usedpk

private

Definition at line 183 of file CoraCoolFolder.h.

---

The documentation for this class was generated from the following files:

• CoraCoolFolder.h
• CoraCoolFolder.cxx