CoraCoolSequence Class Reference

#include <CoraCoolSequence.h>

Collaboration diagram for CoraCoolSequence:

Public Member Functions
	CoraCoolSequence (const std::string &dbname, const std::string &seqname, coral::ISessionProxy *proxy, bool create=false)
int	fetch (const int inc=1)
bool	querySeq (int &keyval, bool update=false, bool gettable=false)
bool	dropSeq ()

Private Member Functions
	CoraCoolSequence ()

Private Attributes
std::string	m_dbname
std::string	m_seqname
coral::ISessionProxy *	m_proxy
coral::ITable *	m_table

Detailed Description

Definition at line 15 of file CoraCoolSequence.h.

Constructor & Destructor Documentation

CoraCoolSequence() [1/2]

CoraCoolSequence::CoraCoolSequence	(	const std::string &	dbname,
		const std::string &	seqname,
		coral::ISessionProxy *	proxy,
		bool	create = false
	)

Definition at line 26 of file CoraCoolSequence.cxx.

                                :
  m_dbname(dbname), m_seqname(seqname), m_proxy(proxy), m_table(0) {
 
  // derive key table name from CoraCool database name
  const std::string keytblname=m_dbname+"_CORACOOLKEYS";
  // check for existance of key table
  try {
    m_table=&(m_proxy->nominalSchema().tableHandle(keytblname));
  }
  catch (coral::SchemaException& e) {
    // try to create the table if requested
    if (create) {
      coral::TableDescription tdesc(keytblname);
      tdesc.setName(keytblname);
      tdesc.insertColumn("SEQNAME","string",63,false);
      tdesc.insertColumn("SEQVAL","int");
      tdesc.setPrimaryKey("SEQNAME");
      m_table=&(m_proxy->nominalSchema().createTable(tdesc));
      // pause for thought
      m_proxy->transaction().commit();
      sleep(1);
      m_proxy->transaction().start(false);
      m_table=&(m_proxy->nominalSchema().tableHandle(keytblname));
    }
  }
  // throw exception here? FIXME
  if (m_table==0) throw CoraCoolException("Cannot create "+keytblname+" table",
                    "CoraCoolSequence::CoraCoolSequence");
  // if not creating, finish here in any case - have pointer to table
  if (!create) return;
 
  int ifk;
  if (!querySeq(ifk,false)) {
    // update table with sequence starting at 0
    coral::AttributeList data;
    data.extend<std::string>("SEQNAME");
    data.extend<int>("SEQVAL");
    data[0].data<std::string>()=m_seqname;
    data[1].data<int>()=0;
    coral::ITableDataEditor& editor=m_table->dataEditor();
    editor.insertRow(data);
  }
}

CoraCoolSequence() [2/2]

CoraCoolSequence::CoraCoolSequence ( )

private

Member Function Documentation

dropSeq()

bool CoraCoolSequence::dropSeq

(

)

Definition at line 124 of file CoraCoolSequence.cxx.

                               {
  coral::AttributeList bindvar;
  bindvar.extend<std::string>("SKEY");
  bindvar[0].data<std::string>()=m_seqname;
  coral::ITableDataEditor& editor=m_table->dataEditor();
  long rows=editor.deleteRows("SEQNAME=:SKEY",bindvar);
  return (rows==1);
}

fetch()

int CoraCoolSequence::fetch

(

const int

inc = 1

)

Definition at line 73 of file CoraCoolSequence.cxx.

                                         {
  int key=0;
  // query sequence setting lock on row
  if (querySeq(key,true)) {
    // got result, now update rows
    coral::AttributeList bindvar;
    bindvar.extend<std::string>("SKEY");
    bindvar[0].data<std::string>()=m_seqname;
    bindvar.extend<int>("SINC");
    bindvar[1].data<int>()=inc;
    coral::ITableDataEditor& editor=m_table->dataEditor();
    int rowsupdated=editor.updateRows("SEQVAL=SEQVAL+:SINC",
                      "SEQNAME=:SKEY",bindvar);
    if (rowsupdated!=1) throw CoraCoolException(
     "Unexpected number of rows locked in keytable",
     "CoraCoolSequence::CoraCoolSequence");
  } else {
    throw CoraCoolException ("Problem generating next key value for "+m_seqname,
                             "CoraCoolSequence::fetch");
  }
  return key;
}

querySeq()

bool CoraCoolSequence::querySeq	(	int &	keyval,
		bool	update = false,
		bool	gettable = false
	)

Definition at line 96 of file CoraCoolSequence.cxx.

                                                                     {
 if (gettable) {
    const std::string keytblname=m_dbname+"_CORACOOLKEYS";
    m_table=&(m_proxy->nominalSchema().tableHandle(keytblname));
  }
   coral::IQuery* query=m_table->newQuery();
   coral::AttributeList bindvar;
  bindvar.extend<std::string>("SKEY");
  bindvar[0].data<std::string>()=m_seqname;
  query->setCondition("SEQNAME=:SKEY",bindvar);
  query->setRowCacheSize(2);
  query->defineOutputType("SEQVAL","int");
  if (update) query->setForUpdate();
  coral::ICursor& cursor=query->execute();
  bool res=true;
  if (!cursor.next()) {
    res=false;
  } else {
    const coral::AttributeList& res=cursor.currentRow();
    keyval=res["SEQVAL"].data<int>();
  }
  if (cursor.next()) {
    res=false;
  }
  delete query;
  return res;
}

Member Data Documentation

m_dbname

std::string CoraCoolSequence::m_dbname

private

Definition at line 40 of file CoraCoolSequence.h.

m_proxy

coral::ISessionProxy* CoraCoolSequence::m_proxy

private

Definition at line 42 of file CoraCoolSequence.h.

m_seqname

std::string CoraCoolSequence::m_seqname

private

Definition at line 41 of file CoraCoolSequence.h.

m_table

coral::ITable* CoraCoolSequence::m_table

private

Definition at line 43 of file CoraCoolSequence.h.

---

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

• CoraCoolSequence.h
• CoraCoolSequence.cxx