CoraCoolDatabase Class Reference

#include <CoraCoolDatabase.h>

Collaboration diagram for CoraCoolDatabase:

Public Member Functions
	CoraCoolDatabase (const std::string &m_dbconn, cool::IDatabasePtr cooldb, coral::IConnectionService &coralsvc, const bool readonly=false)
bool	connect ()
bool	disconnect ()
const std::string &	dbname () const
cool::IDatabasePtr	coolDatabase () const
CoraCoolFolderPtr	createFolder (const std::string &coolpath, const std::string &coraltable, const cool::IRecordSpecification &fkspec, const cool::IRecordSpecification &payloadspec, const std::string &coralfk, const std::string &coralpk, const std::string &description="", const cool::FolderVersioning::Mode mode=cool::FolderVersioning::SINGLE_VERSION, const bool createParents=false)
CoraCoolFolderPtr	getFolder (const std::string &coolfolder)
bool	existsFolder (const std::string &coolfolder)
bool	parseFolderDescription (const std::string &folderdesc, std::string &tablename, std::string &keycolcool, std::string &fkeycolcoral, std::string &pkeycolcoral)
bool	deleteFolder (const std::string &coolfolder)

Private Member Functions
bool	extractCoralConStr (std::string_view coolstr)
std::string	encodeAttrSpec (const cool::IRecordSpecification &spec)
bool	storeSpec (const std::string &tablename, const std::string &spec)

Private Attributes
cool::IDatabasePtr	m_cooldb
std::string	m_dbconn
std::string	m_dbname
bool	m_connected
bool	m_readonly
coral::IConnectionService &	m_coralsvc
coral::ISessionProxy *	m_proxy
coral::MessageStream	m_log

Detailed Description

Definition at line 24 of file CoraCoolDatabase.h.

Constructor & Destructor Documentation

CoraCoolDatabase()

CoraCoolDatabase::CoraCoolDatabase	(	const std::string &	m_dbconn,
		cool::IDatabasePtr	cooldb,
		coral::IConnectionService &	coralsvc,
		const bool	readonly = false )

Definition at line 37 of file CoraCoolDatabase.cxx.

                                                        :
  m_cooldb(std::move(cooldb)),
  m_connected(false),
  m_readonly(readonly),
  m_coralsvc(coralsvc),
  m_proxy(0),
  m_log("CoraCool")
{
  if (!extractCoralConStr(dbconn)) {
    m_log << coral::Error << "Cannot derive CORAL connection string from: "
      << dbconn << coral::MessageStream::endmsg;
    throw CoraCoolException("Bad connection string",
                "CoraCoolDatabase::CoraCoolDatabase");
  }
  m_log << coral::Debug << "CORAL dbconnection string is: " << m_dbconn 
    << coral::MessageStream::endmsg;
}

Member Function Documentation

connect()

bool CoraCoolDatabase::connect

(

)

Definition at line 58 of file CoraCoolDatabase.cxx.

                               {
  if (!m_connected) {
    coral::AccessMode access=m_readonly ? coral::ReadOnly : coral::Update;
    try {
      m_proxy=m_coralsvc.connect(m_dbconn,access);
      m_connected=true;
    }
    catch (std::exception& e) {
      m_log << coral::Error << "Exception caught: " << e.what() <<
        coral::MessageStream::endmsg;
      m_connected=false;
    }
  }
  return m_connected;
}

coolDatabase()

cool::IDatabasePtr CoraCoolDatabase::coolDatabase ( ) const

inline

Definition at line 99 of file CoraCoolDatabase.h.

{return m_cooldb; }

createFolder()

CoraCoolFolderPtr CoraCoolDatabase::createFolder	(	const std::string &	coolpath,
		const std::string &	coraltable,
		const cool::IRecordSpecification &	fkspec,
		const cool::IRecordSpecification &	payloadspec,
		const std::string &	coralfk,
		const std::string &	coralpk,
		const std::string &	description = "",
		const cool::FolderVersioning::Mode	mode = cool::FolderVersioning::SINGLE_VERSION,
		const bool	createParents = false )

Definition at line 199 of file CoraCoolDatabase.cxx.

                               {
 
  // check input parameters
  if (coraltable.size()>18) throw CoraCoolException(
    "CORAL tablename too long (max 18 chars)",
    "CoraCoolDatabase::createFolder");
  // encode the folder description string
  // first remove any existing coracool string
  std::string::size_type p1,p2;
  std::string newdesc=description;
  p1=description.find("<coracool>");
  p2=description.find("</coracool>");
  if (p1!=std::string::npos && p2!=std::string::npos) {
    newdesc=description.substr(0,p1);
    newdesc.append(description, p2+11);
  }
  // COOL foreign key column is name of COOL payload attribute
  newdesc+="<coracool>";
  newdesc+=coraltable;
  newdesc+=':';
  newdesc+=fkspec[0].name();
  newdesc+=':';
  newdesc+= coralfk;
  newdesc+=':';
  newdesc+=coralpk;
  newdesc+="</coracool>";
  m_log << coral::Debug << "Created new description: " << newdesc << 
    coral::MessageStream::endmsg;
 
  // check for rows in key generation table, create if needed
  // start transaction here
  connect();
  m_proxy->transaction().start(false);
  CoraCoolSequence seqfk(m_dbname,m_dbname+"_"+coraltable+"_FK",m_proxy,true);
  if (coralfk!=coralpk)
   CoraCoolSequence seqpk(m_dbname,m_dbname+"_"+coraltable+"_PK",m_proxy,true);
 
  // endcode and store the attributelist specification in CORACOOLATTR table 
  if (!storeSpec(m_dbname+"_"+coraltable,
         encodeAttrSpec(payloadspec)))
    throw CoraCoolException("Cannot store payload specification",
                "CoraCoolDatabase::createFolder");
 
  // create CORAL table
  try {
    m_log << coral::Debug << "Generate CORAL table:" << coraltable << 
      coral::MessageStream::endmsg;
    coral::TableDescription tdesc("CoraCoolPayload");
    tdesc.setName(m_dbname+"_"+coraltable);
    for (unsigned int i=0;i<payloadspec.size();++i) {
      const cool::IFieldSpecification& field=payloadspec[i];
      int maxsize=field.storageType().maxSize();
      if (field.storageType()==cool::StorageType::Blob64k) maxsize=0;
      const std::string typen=coral::AttributeSpecification::typeNameForId(
          field.storageType().cppType());
      m_log << coral::Debug << "Insert column " << field.name() << 
    " of type " << typen << std::endl;
      tdesc.insertColumn(field.name(),typen,maxsize,false);
    }
    // declare primary key
    tdesc.setPrimaryKey(coralpk);
    // create separate index on FK if different
    if (coralfk!=coralpk) 
      tdesc.createIndex(m_dbname+"_"+coraltable+"F",coralfk,false);
 
    m_proxy->nominalSchema().createTable(tdesc);
    m_proxy->transaction().commit();
    m_log << coral::Debug << "Created coral table " << coral::MessageStream::endmsg;
 
    // disconnect/reconnect to avoid connection problems
    disconnect();
    sleep(1);
    connect();
  }
  catch (std::exception& e) {
    // problem in table creation
    throw CoraCoolException(e.what(),"CoraCoolDatabase::createFolder");
  }
 
  // create corresponding COOL folder
  // this has to go after CORAL manipulations otherwise get problems
  // with schema consistency
  // disconnect/reconnect to COOL first in order to reset COOL
  // avoiding problems due to the reset database connection
  m_log << coral::Debug << "Disconnect/reconnect COOL connection" << 
      coral::MessageStream::endmsg;
  m_cooldb->closeDatabase();
  m_cooldb->openDatabase();
  m_log << coral::Debug << "Create COOL folder" << coolpath << coral::MessageStream::endmsg;
 
  m_cooldb->createFolder(coolpath,
       cool::FolderSpecification(mode,fkspec),newdesc,createParents);
  m_log << coral::Debug << "Created COOL folder" << coral::MessageStream::endmsg;
 
  // all structures created,
  // generate return value by instantiating new folder
  CoraCoolFolderPtr folder(new CoraCoolFolder(coolpath,
               m_proxy, m_cooldb,this,m_log));
  return folder;
}

dbname()

const std::string & CoraCoolDatabase::dbname ( ) const

inline

Definition at line 97 of file CoraCoolDatabase.h.

{ return m_dbname; }

deleteFolder()

bool CoraCoolDatabase::deleteFolder

(

const std::string &

coolfolder

)

Definition at line 369 of file CoraCoolDatabase.cxx.

                                                               {
  m_log << coral::Debug << "Deleting folder " << coolfolder << coral::MessageStream::endmsg;
  std::string desc;
  // get COOL folder and description
  try {
    cool::IFolderPtr folder=m_cooldb->getFolder(coolfolder);
    desc=folder->description();
    // delete the COOL folder
    m_cooldb->dropNode(coolfolder);
  }
  catch (cool::Exception& e) {
    throw CoraCoolException(e.what(),"CoraCoolDatabase::deleteFolder");
  }
  // extract the CORAL folder name
  std::string tablename,keycolcool,fkeycolcoral,pkeycolcoral;
  if (parseFolderDescription(desc,tablename,keycolcool,
                 fkeycolcoral,pkeycolcoral)) {
    m_log << coral::Debug << "Drop CORAL payload table " << tablename
                << coral::MessageStream::endmsg;
    // drop the CORAL table
    connect();
    m_proxy->transaction().start(false);
    m_proxy->nominalSchema().dropIfExistsTable(tablename);
    // remove primary/foreign key rows from sequence table
    CoraCoolSequence seqfk(m_dbname,tablename+"_FK",m_proxy);
    seqfk.dropSeq();
    if (fkeycolcoral!=pkeycolcoral) {
      CoraCoolSequence seqpk(m_dbname,tablename+"_PK",m_proxy);
      seqpk.dropSeq();
    }
    // remove the row from the CORACOOLATTR table
    coral::AttributeList bindvar;
    bindvar.extend<std::string>("SNAME");
    bindvar[0].data<std::string>()=tablename;
    coral::ITable& table=m_proxy->nominalSchema().tableHandle(
                       m_dbname+"_CORACOOLATTR");
    long rows=table.dataEditor().deleteRows("NAME=:SNAME",bindvar);
    if (rows!=1) m_log << coral::Error << "Unexpected number of rows "
       << rows << " with key " << tablename << 
       " deleted from CORACOOLATTR table" << coral::MessageStream::endmsg;
    m_proxy->transaction().commit();
    // pause for thought
    disconnect();
    sleep(1);
    connect();
  }
  return true;
}

disconnect()

bool CoraCoolDatabase::disconnect

(

)

Definition at line 74 of file CoraCoolDatabase.cxx.

                                  {
  if (m_connected) {
    delete m_proxy;
    m_connected=false;
  }
  return m_connected;
}

encodeAttrSpec()

std::string CoraCoolDatabase::encodeAttrSpec ( const cool::IRecordSpecification & spec )

private

Definition at line 138 of file CoraCoolDatabase.cxx.

                                           {
  std::string result="";
  unsigned int n=spec.size();
  for (unsigned int i=0;i<n;++i) {
    const cool::IFieldSpecification& field=spec[i];
    result+=field.name();
    result+=':';
    result+=field.storageType().name();
    if (i<n-1) result+=',';
  }
  return result;
}

existsFolder()

bool CoraCoolDatabase::existsFolder

(

const std::string &

coolfolder

)

Definition at line 316 of file CoraCoolDatabase.cxx.

                                                               {
  // first check if the COOL folder exists
  if (!m_cooldb->existsFolder(coolfolder)) {
    return false;
  } else {
    // if it does, check the folder description finds a coracool tag
    // note this does not check the CORACOOL table actually exists
    cool::IFolderPtr folder=m_cooldb->getFolder(coolfolder);
    std::string tablename,keycolcool,fkeycolcoral,pkeycolcoral;
    return parseFolderDescription(folder->description(),tablename,
                  keycolcool,fkeycolcoral,pkeycolcoral);
  }
}

extractCoralConStr()

bool CoraCoolDatabase::extractCoralConStr ( std::string_view coolstr )

private

Definition at line 82 of file CoraCoolDatabase.cxx.

                                                                      {
  // extract CORAL database string from COOL one
  bool dbok=false;
  // first check for initial colon - if so, technology-specific string
  std::string::size_type c1=coolstr.find(':');
  if (c1!=std::string::npos) {
    std::string_view techno,server,schema;
    techno=coolstr.substr(0,c1);
    std::string::size_type c2;
    c2=coolstr.find(';');
    if (c2==std::string::npos) c2=coolstr.size();
    server=coolstr.substr(c1+3,c2-c1-3);
    c1=coolstr.find("schema=");
    if (c1!=std::string::npos) {
      c2=coolstr.find(';',c1+7);
      if (c2==std::string::npos) c2=coolstr.size();
      schema=coolstr.substr(c1+7,c2-c1-7);
    }
    c1=coolstr.find("dbname=");
    if (c1!=std::string::npos) {
      c2=coolstr.find(';',c1+7);
      if (c2==std::string::npos) c2=coolstr.size();
      m_dbname=std::string(coolstr.substr(c1+7,c2-c1-7));
    }
    // construct the connection string
    if (techno=="oracle" || techno=="mysql" || techno=="frontier") {
      if (!server.empty() && !schema.empty()) {
        m_dbconn=std::string(techno);
        m_dbconn+= "://";
        m_dbconn+=server;
        m_dbconn+='/';
        m_dbconn+=schema;
    dbok=true;
      }
    } else if (techno=="sqlite") {
      if (!schema.empty()) {
    m_dbconn="sqlite_file:";
        m_dbconn+=schema;
    dbok=true;
      }
    }
  } else {
    c1=coolstr.find('/');
    if (c1!=std::string::npos) {
      m_dbconn=std::string(coolstr.substr(0,c1));
      m_dbname=std::string(coolstr.substr(c1+1));
      dbok=true;
    }
  }
  if (m_dbname.empty()) dbok=false;
  m_log << coral::Debug << "Extracted CORAL connection string: " << m_dbconn 
   << " and database name: " << m_dbname << " with status " << dbok << 
    coral::MessageStream::endmsg;
  return dbok;
}

getFolder()

CoraCoolFolderPtr CoraCoolDatabase::getFolder

(

const std::string &

coolfolder

)

Definition at line 309 of file CoraCoolDatabase.cxx.

                                                                         {
  connect();
  CoraCoolFolderPtr folder(new CoraCoolFolder(
     coolfolder,m_proxy,m_cooldb,this,m_log));
  return folder;
}

parseFolderDescription()

bool CoraCoolDatabase::parseFolderDescription	(	const std::string &	folderdesc,
		std::string &	tablename,
		std::string &	keycolcool,
		std::string &	fkeycolcoral,
		std::string &	pkeycolcoral )

Definition at line 330 of file CoraCoolDatabase.cxx.

                                                   {
  // parse the folder description string to extract CORAL table and FKs
  // format <coracool>Table:COOL_key:CORAL_fkey:CORAL_pkey</coracool>
  // if CORAL_pkey is missing, assumed to be same as CORAL_fkey
  // return false for parsing problem or missing <coracool> specification
  // otherwise set return arguments
 
  // find <coracool> part of the description
  std::string::size_type p1,p2,c1,c2,c3;
  p1=folderdesc.find("<coracool>");
  p2=folderdesc.find("</coracool>");
  if (p1==std::string::npos || p2==std::string::npos) return false;
  // find the two : separating the values
  c1=folderdesc.find(':',p1+10);
  if (c1==std::string::npos) return false;
  c2=folderdesc.find(':',c1+1);
  if (c2==std::string::npos) return false;
 
  tablename=m_dbname;
  tablename+= '_';
  tablename.append(folderdesc,p1+10,c1-p1-10);
  keycolcool=folderdesc.substr(c1+1,c2-c1-1);
  fkeycolcoral=folderdesc.substr(c2+1,p2-c2-1);
  // check for third colon to specify separate primary key
  c3=folderdesc.find(':',c2+1);
  if (c3!=std::string::npos) {
    fkeycolcoral=folderdesc.substr(c2+1,c3-c2-1);
    pkeycolcoral=folderdesc.substr(c3+1,p2-c3-1);
  } else {
    fkeycolcoral=folderdesc.substr(c2+1,p2-c2-1);
    pkeycolcoral=fkeycolcoral;
  }
  return true;
}

storeSpec()

bool CoraCoolDatabase::storeSpec ( const std::string & tablename, const std::string & spec )

private

Definition at line 152 of file CoraCoolDatabase.cxx.

                                        {
  m_log << coral::Debug << "Store AttrList specification for table " <<
    tablename << " : " << spec <<coral::MessageStream::endmsg;
  // first check for existance of table
  const std::string attrtable=m_dbname+"_CORACOOLATTR";
  coral::ITable* table;
  try {
    table=&(m_proxy->nominalSchema().tableHandle(attrtable));
  }
  catch (coral::SchemaException& e) {
    m_log << coral::Debug << "Creating table " << attrtable << coral::MessageStream::endmsg;
    coral::TableDescription tdesc(attrtable);
    tdesc.setName(attrtable);
    tdesc.insertColumn("NAME","string",31,false);
    tdesc.insertColumn("ATTRSPEC","string",4000,false);
    tdesc.setPrimaryKey("NAME");
    table=&(m_proxy->nominalSchema().createTable(tdesc));
    // pause for thought
    m_proxy->transaction().commit();
    sleep(1);
    m_proxy->transaction().start(false);
    table=&(m_proxy->nominalSchema().tableHandle(attrtable));
  }
  if (table==0) {
    m_log << coral::Error << "No pointer to " << attrtable << coral::MessageStream::endmsg;
    return false;
  }
  // now update table with specification
  try {
    coral::AttributeList data;
    data.extend<std::string>("NAME");
    data.extend<std::string>("ATTRSPEC");
    data[0].data<std::string>()=tablename;
    data[1].data<std::string>()=spec;
    coral::ITableDataEditor& editor=table->dataEditor();
    editor.insertRow(data);
  }
  catch (coral::SchemaException&e) {
    m_log << coral::Error << "Could not insert " << tablename << " into " 
                << attrtable << " exception: " << e.what() <<
      coral::MessageStream::endmsg;
    return false;
  }
  return true;
}

Member Data Documentation

m_connected

bool CoraCoolDatabase::m_connected

private

Definition at line 90 of file CoraCoolDatabase.h.

m_cooldb

cool::IDatabasePtr CoraCoolDatabase::m_cooldb

private

Definition at line 87 of file CoraCoolDatabase.h.

m_coralsvc

coral::IConnectionService& CoraCoolDatabase::m_coralsvc

private

Definition at line 92 of file CoraCoolDatabase.h.

m_dbconn

std::string CoraCoolDatabase::m_dbconn

private

Definition at line 88 of file CoraCoolDatabase.h.

m_dbname

std::string CoraCoolDatabase::m_dbname

private

Definition at line 89 of file CoraCoolDatabase.h.

m_log

coral::MessageStream CoraCoolDatabase::m_log

private

Definition at line 94 of file CoraCoolDatabase.h.

m_proxy

coral::ISessionProxy* CoraCoolDatabase::m_proxy

private

Definition at line 93 of file CoraCoolDatabase.h.

m_readonly

bool CoraCoolDatabase::m_readonly

private

Definition at line 91 of file CoraCoolDatabase.h.

---

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

• CoraCoolDatabase.h
• CoraCoolDatabase.cxx