/* Result Sets Interface */
#ifndef SQL_CRSR
#  define SQL_CRSR
  struct sql_cursor
  {
    unsigned int curocn;
    void *ptr1;
    void *ptr2;
    unsigned int magic;
  };
  typedef struct sql_cursor sql_cursor;
  typedef struct sql_cursor SQL_CURSOR;
#endif /* SQL_CRSR */

/* Thread Safety */
typedef void * sql_context;
typedef void * SQL_CONTEXT;

/* Object support */
struct sqltvn
{
  unsigned char *tvnvsn; 
  unsigned short tvnvsnl; 
  unsigned char *tvnnm;
  unsigned short tvnnml; 
  unsigned char *tvnsnm;
  unsigned short tvnsnml;
};
typedef struct sqltvn sqltvn;

struct sqladts
{
  unsigned int adtvsn; 
  unsigned short adtmode; 
  unsigned short adtnum;  
  sqltvn adttvn[1];       
};
typedef struct sqladts sqladts;

static struct sqladts sqladt = {
  1,1,0,
};

/* Binding to PL/SQL Records */
struct sqltdss
{
  unsigned int tdsvsn; 
  unsigned short tdsnum; 
  unsigned char *tdsval[1]; 
};
typedef struct sqltdss sqltdss;
static struct sqltdss sqltds =
{
  1,
  0,
};

/* File name & Package Name */
struct sqlcxp
{
  unsigned short fillen;
           char  filnam[16];
};
static const struct sqlcxp sqlfpn =
{
    15,
    "hrpcparoraio.pc"
};


static unsigned int sqlctx = 2472131;


static struct sqlexd {
   unsigned int   sqlvsn;
   unsigned int   arrsiz;
   unsigned int   iters;
   unsigned int   offset;
   unsigned short selerr;
   unsigned short sqlety;
   unsigned int   occurs;
      const short *cud;
   unsigned char  *sqlest;
      const char  *stmt;
   sqladts *sqladtp;
   sqltdss *sqltdsp;
            void  **sqphsv;
   unsigned int   *sqphsl;
            int   *sqphss;
            void  **sqpind;
            int   *sqpins;
   unsigned int   *sqparm;
   unsigned int   **sqparc;
   unsigned short  *sqpadto;
   unsigned short  *sqptdso;
   unsigned int   sqlcmax;
   unsigned int   sqlcmin;
   unsigned int   sqlcincr;
   unsigned int   sqlctimeout;
   unsigned int   sqlcnowait;
              int   sqfoff;
   unsigned int   sqcmod;
   unsigned int   sqfmod;
            void  *sqhstv[11];
   unsigned int   sqhstl[11];
            int   sqhsts[11];
            void  *sqindv[11];
            int   sqinds[11];
   unsigned int   sqharm[11];
   unsigned int   *sqharc[11];
   unsigned short  sqadto[11];
   unsigned short  sqtdso[11];
} sqlstm = {12,11};

// Prototypes
extern "C" {
  void sqlcxt (void **, unsigned int *,
               struct sqlexd *, const struct sqlcxp *);
  void sqlcx2t(void **, unsigned int *,
               struct sqlexd *, const struct sqlcxp *);
  void sqlbuft(void **, char *);
  void sqlgs2t(void **, char *);
  void sqlorat(void **, unsigned int *, void *);
}

// Forms Interface
static const int IAPSUCC = 0;
static const int IAPFAIL = 1403;
static const int IAPFTL  = 535;
extern "C" { void sqliem(char *, int *); }

 static const char *sq0003 = 
"select column_number ,cell_number ,right_time_offset ,left_time_offset ,righ\
t_tot_offset ,left_tot_offset ,tdc2time ,tot2charge ,overall_offset  from rpc_\
ana.hwpg_calpar_data where (det_part_id=:b0 and vers_id=:b1)           ";

typedef struct { unsigned short len; unsigned char arr[1]; } VARCHAR;
typedef struct { unsigned short len; unsigned char arr[1]; } varchar;

/* cud (compilation unit data) array */
static const short sqlcud0[] =
{12,4130,1,0,0,
5,0,0,1,64,0,4,106,0,0,1,0,0,1,0,2,3,0,0,
24,0,0,2,166,0,4,160,0,0,5,1,0,1,0,2,3,0,0,2,3,0,0,2,4,0,0,2,4,0,0,1,3,0,0,
59,0,0,3,225,0,9,221,0,0,2,2,0,1,0,1,3,0,0,1,3,0,0,
82,0,0,3,0,0,13,222,0,0,9,0,0,1,0,2,3,0,0,2,3,0,0,2,4,0,0,2,4,0,0,2,4,0,0,2,4,
0,0,2,4,0,0,2,4,0,0,2,4,0,0,
133,0,0,3,0,0,15,234,0,0,0,0,0,1,0,
148,0,0,4,91,0,4,287,0,0,2,0,0,1,0,2,3,0,0,2,9,0,0,
171,0,0,5,128,0,4,334,0,0,3,0,0,1,0,2,3,0,0,2,3,0,0,2,9,0,0,
198,0,0,6,236,0,6,384,0,0,5,5,0,1,0,3,3,0,0,1,3,0,0,1,3,0,0,1,97,0,0,1,97,0,0,
233,0,0,7,242,0,3,446,0,0,11,11,0,1,0,1,3,0,0,1,3,0,0,1,3,0,0,1,3,0,0,1,4,0,0,
1,4,0,0,1,4,0,0,1,4,0,0,1,4,0,0,1,4,0,0,1,4,0,0,
292,0,0,8,109,0,4,479,0,0,1,0,0,1,0,2,3,0,0,
};


//*-- AUTHOR : Ilse Koenig
//*-- Last modified : 21/02/2008 by I. Koenig
//*-- Created : 21/02/2008

//_HADES_CLASS_DESCRIPTION 
//////////////////////////////////////////////////////////////////////////////
// HRpcParOraIo
//
// Interface class to database Oracle for input/output of parameters needed
// by the RPC
// (uses the Oracle C/C++ precompiler)
//
//////////////////////////////////////////////////////////////////////////////
using namespace std;
#include "hrpcparoraio.h"
#include "hades.h"
#include "hspectrometer.h"
#include "hrpcdetector.h"
#include "hrpccalpar.h"
#include "hrpcgeompar.h"
#include "hgeomcompositevolume.h"
#include "hgeomoradetversion.h"
#include <iostream>
#include <iomanip>
#include <unistd.h>

#define SQLCA_STORAGE_CLASS extern
#define ORACA_STORAGE_CLASS extern

// Oracle communication area
#include <oraca.h>
// SQL Communications Area
#include <sqlca.h>

ClassImp(HRpcParOraIo)

#define RPC_MAXSEC 6
#define RPC_MAXCELLS 186

HRpcParOraIo::HRpcParOraIo(HOraConn* pC) : HDetParOraIo(pC) {
  // constructor
  // sets the name of the I/O class "HRpcParIo"
  // gets the pointer to the connection class
  fName="HRpcParIo";
  numSectors=0;
  secIds=0;
  initModules=0;
  geomVers=0;
}

HRpcParOraIo::~HRpcParOraIo(void) {
  // destructor
  if (secIds) delete secIds;
  if (initModules) delete initModules;
  if (geomVers) delete geomVers;
}

Bool_t HRpcParOraIo::init(HParSet* pPar,Int_t* set) {
  // calls special read-function for each parameter container
  const Text_t* name=pPar->IsA()->GetName();
  if (startIo(pPar)<=0) return kFALSE;
  if (strcmp(name,"HRpcCalPar")==0) return read(((HRpcCalPar*)pPar),set);
  if (strcmp(name,"HRpcGeomPar")==0) return read(((HRpcGeomPar*)pPar),set);
  // cout<<"initialization of "<<pPar->GetName()<<" not possible from Oracle!"<<endl;
  return kFALSE;
}

Int_t HRpcParOraIo::write(HParSet* pPar) {
  // calls the appropriate write function for the container
  const Text_t* name=pPar->IsA()->GetName();
  if (startIo(pPar)<=0) return 0;
  if (strcmp(name,"HRpcCalPar")==0) return writePar((HRpcCalPar*)pPar);
  if (strcmp(name,"HRpcGeomPar")==0) return writeAlignment((HRpcGeomPar*)pPar);
  cout<<"No write-interface to Oracle for parameter container "
      <<pPar->GetName()<<endl;
  return 0;
}

Int_t HRpcParOraIo::startIo(HParSet* pPar) {
  // gets the run start of the actual run
  // reads the detector setup from Oracle for the first run and returns the number
  //   of modules found
  // returns -1, if the run is not found, or 0, if no modules are found for this run
  runStart=getRunStart(pPar);
  if (runStart>0 && secIds==0) readIds();
  if (runStart==-1 || numSectors<=0) {
    pPar->setInputVersion(-1,inputNumber);
    return -1;
  }
  return runStart;
}

Int_t HRpcParOraIo::readIds(void) {
  // reads the id numbers of all modules defined for the actual run
  //   and stores them in array secIds
  // returns the number of modules found
  HRpcDetector* det=(HRpcDetector*)(gHades->getSetup()->getDetector("Rpc"));

  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int sec[RPC_MAXSEC];
  /* EXEC SQL END DECLARE SECTION; */ 


  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("readIds()"); */ 

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 


  /* EXEC SQL SELECT sector
    INTO :sec
    FROM rpc_ana.detector_setup_at_run_hist; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 1;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "select sector into :b0  from rpc_ana.detector_setup_at_run_\
hist ";
  sqlstm.iters = (unsigned int  )6;
  sqlstm.offset = (unsigned int  )5;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)sec;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )sizeof(int);
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqharc[0] = (unsigned int   *)0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) showSqlError("readIds()");
}



  numSectors=sqlca.sqlerrd[2];
  if (numSectors>0) {
    secIds=new TArrayI(RPC_MAXSEC);
    for(Int_t i=0;i<RPC_MAXSEC;i++) secIds->AddAt(0,i);
    initModules=new TArrayI(RPC_MAXSEC);
  }
  Int_t s;
  for(Int_t i=0;i<numSectors;i++) {
    s=sec[i]-1;
    if (det->getModule(s,0)) {
      secIds->AddAt(sec[i],s);
    }
  }
  // printIds();
  return numSectors;
}

void HRpcParOraIo::printIds(void) {
  // prints the id numbers of all modules
  if (secIds) {
    for(Int_t i=0;i<RPC_MAXSEC;i++) {
      cout<<"sector id: "<<i+1<<"\n";
    }
    cout<<'\n';
  }
}

Int_t HRpcParOraIo::getVersion(HParSet* pPar,Int_t* set,Int_t* versions) {
  // reads the version for the calibration parameters valid for the current event file
  // returns -1, if no data are found
  HParOraSet* oraSet=getOraSet(pPar);
  if (oraSet->contextId==-1) return -1;
  Int_t contVers=pPar->getInputVersion(inputNumber);
  if (contVers!=-1 && runStart>=oraSet->versDate[0] && runStart<=oraSet->versDate[1])
      return contVers;
  oraSet->clearVersDate();
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int context;
    struct {
      int sec[RPC_MAXSEC];
      int vers[RPC_MAXSEC];
      double since[RPC_MAXSEC];
      double until[RPC_MAXSEC];
    } parvers;
  /* EXEC SQL END DECLARE SECTION; */ 

  context=oraSet->contextId;
  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("getVersion(HParOraSet*,Int_t)"); */ 

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 

  const Char_t* containerClass=pPar->IsA()->GetName();
  if (strcmp(containerClass,"HRpcCalPar")==0) {
    /* EXEC SQL SELECT sector, version,
                    hdate.to_ansitime(valid_since),
                    hdate.to_ansitime(valid_until)
             INTO :parvers
             FROM rpc_ana.calpar_vers_at_date
             WHERE context_id = :context; */ 

{
    struct sqlexd sqlstm;
    sqlorat((void **)0, &sqlctx, &oraca);
    sqlstm.sqlvsn = 12;
    sqlstm.arrsiz = 5;
    sqlstm.sqladtp = &sqladt;
    sqlstm.sqltdsp = &sqltds;
    sqlstm.stmt = "select sector ,version ,hdate.to_ansitime(valid_since) ,h\
date.to_ansitime(valid_until) into :s1 ,:s2 ,:s3 ,:s4   from rpc_ana.calpar_ve\
rs_at_date where context_id=:b1";
    sqlstm.iters = (unsigned int  )6;
    sqlstm.offset = (unsigned int  )24;
    sqlstm.selerr = (unsigned short)1;
    sqlstm.cud = sqlcud0;
    sqlstm.sqlest = (unsigned char  *)&sqlca;
    sqlstm.sqlety = (unsigned short)256;
    sqlstm.occurs = (unsigned int  )0;
    sqlstm.sqhstv[0] = (         void  *)parvers.sec;
    sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
    sqlstm.sqhsts[0] = (         int  )sizeof(int);
    sqlstm.sqindv[0] = (         void  *)0;
    sqlstm.sqinds[0] = (         int  )0;
    sqlstm.sqharm[0] = (unsigned int  )0;
    sqlstm.sqharc[0] = (unsigned int   *)0;
    sqlstm.sqadto[0] = (unsigned short )0;
    sqlstm.sqtdso[0] = (unsigned short )0;
    sqlstm.sqhstv[1] = (         void  *)parvers.vers;
    sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
    sqlstm.sqhsts[1] = (         int  )sizeof(int);
    sqlstm.sqindv[1] = (         void  *)0;
    sqlstm.sqinds[1] = (         int  )0;
    sqlstm.sqharm[1] = (unsigned int  )0;
    sqlstm.sqharc[1] = (unsigned int   *)0;
    sqlstm.sqadto[1] = (unsigned short )0;
    sqlstm.sqtdso[1] = (unsigned short )0;
    sqlstm.sqhstv[2] = (         void  *)parvers.since;
    sqlstm.sqhstl[2] = (unsigned int  )sizeof(double);
    sqlstm.sqhsts[2] = (         int  )sizeof(double);
    sqlstm.sqindv[2] = (         void  *)0;
    sqlstm.sqinds[2] = (         int  )0;
    sqlstm.sqharm[2] = (unsigned int  )0;
    sqlstm.sqharc[2] = (unsigned int   *)0;
    sqlstm.sqadto[2] = (unsigned short )0;
    sqlstm.sqtdso[2] = (unsigned short )0;
    sqlstm.sqhstv[3] = (         void  *)parvers.until;
    sqlstm.sqhstl[3] = (unsigned int  )sizeof(double);
    sqlstm.sqhsts[3] = (         int  )sizeof(double);
    sqlstm.sqindv[3] = (         void  *)0;
    sqlstm.sqinds[3] = (         int  )0;
    sqlstm.sqharm[3] = (unsigned int  )0;
    sqlstm.sqharc[3] = (unsigned int   *)0;
    sqlstm.sqadto[3] = (unsigned short )0;
    sqlstm.sqtdso[3] = (unsigned short )0;
    sqlstm.sqhstv[4] = (         void  *)&context;
    sqlstm.sqhstl[4] = (unsigned int  )sizeof(int);
    sqlstm.sqhsts[4] = (         int  )sizeof(int);
    sqlstm.sqindv[4] = (         void  *)0;
    sqlstm.sqinds[4] = (         int  )0;
    sqlstm.sqharm[4] = (unsigned int  )0;
    sqlstm.sqadto[4] = (unsigned short )0;
    sqlstm.sqtdso[4] = (unsigned short )0;
    sqlstm.sqphsv = sqlstm.sqhstv;
    sqlstm.sqphsl = sqlstm.sqhstl;
    sqlstm.sqphss = sqlstm.sqhsts;
    sqlstm.sqpind = sqlstm.sqindv;
    sqlstm.sqpins = sqlstm.sqinds;
    sqlstm.sqparm = sqlstm.sqharm;
    sqlstm.sqparc = sqlstm.sqharc;
    sqlstm.sqpadto = sqlstm.sqadto;
    sqlstm.sqptdso = sqlstm.sqtdso;
    sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
    if (sqlca.sqlcode < 0) showSqlError("getVersion(HParOraSet*,Int_t)");
}


  }
  for(Int_t i=0;i<sqlca.sqlerrd[2];i++) {
    Int_t s=parvers.sec[i]-1;
    if (secIds->At(s)>0) {
      versions[s]=parvers.vers[i];
      if (parvers.since[i]>oraSet->versDate[0]) oraSet->versDate[0]=parvers.since[i];
      if (parvers.until[i]<oraSet->versDate[1]) oraSet->versDate[1]=parvers.until[i];
    }
  }
  if (oraSet->versDate[0]>=0) return getActRunId();
  return -1;
};

Bool_t HRpcParOraIo::read(HRpcCalPar* pPar, Int_t* set) {
  // reads the calibration parameters and fill the RpcCalPar container
  Int_t contVers=pPar->getInputVersion(inputNumber);
  Int_t versions[RPC_MAXSEC];
  Int_t version=getVersion(pPar,set,versions);
  if (version==-1) {
    pPar->setInputVersion(-1,inputNumber);
    return kFALSE;
  }
  if (contVers==version) return kTRUE;
  if (inputNumber==1) pPar->clear();
  pPar->setInputVersion(version,inputNumber);
  initModules->Reset();
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int vers;
    int sec;
    struct {
      int col[RPC_MAXCELLS];
      int cell[RPC_MAXCELLS];
      float rtimeo[RPC_MAXCELLS];
      float ltimeo[RPC_MAXCELLS];
      float rtoto[RPC_MAXCELLS];
      float ltoto[RPC_MAXCELLS];
      float t2t[RPC_MAXCELLS];
      float t2c[RPC_MAXCELLS];
      float oo[RPC_MAXCELLS];
    } cal;
  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HRpcCalPar*,Int_t*)"); */ 

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 

  /* EXEC SQL DECLARE cal_cur CURSOR FOR
           SELECT column_number, cell_number,
                  right_time_offset, left_time_offset,
                  right_tot_offset, left_tot_offset,
                  tdc2time, tot2charge, overall_offset
           FROM rpc_ana.hwpg_calpar_data
           WHERE det_part_id = :sec AND vers_id = :vers; */ 

  for(Int_t s=0;s<RPC_MAXSEC;s++) {
    if (set[s]>0 && versions[s]>0) {
      sec=s+1;
      vers=versions[s];
      // cout<<"cal sector: "<<sec<<"   Version: "<<vers<<endl;
      /* EXEC SQL OPEN cal_cur; */ 

{
      struct sqlexd sqlstm;
      sqlorat((void **)0, &sqlctx, &oraca);
      sqlstm.sqlvsn = 12;
      sqlstm.arrsiz = 5;
      sqlstm.sqladtp = &sqladt;
      sqlstm.sqltdsp = &sqltds;
      sqlstm.stmt = sq0003;
      sqlstm.iters = (unsigned int  )1;
      sqlstm.offset = (unsigned int  )59;
      sqlstm.selerr = (unsigned short)1;
      sqlstm.cud = sqlcud0;
      sqlstm.sqlest = (unsigned char  *)&sqlca;
      sqlstm.sqlety = (unsigned short)256;
      sqlstm.occurs = (unsigned int  )0;
      sqlstm.sqcmod = (unsigned int )0;
      sqlstm.sqhstv[0] = (         void  *)&sec;
      sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
      sqlstm.sqhsts[0] = (         int  )0;
      sqlstm.sqindv[0] = (         void  *)0;
      sqlstm.sqinds[0] = (         int  )0;
      sqlstm.sqharm[0] = (unsigned int  )0;
      sqlstm.sqadto[0] = (unsigned short )0;
      sqlstm.sqtdso[0] = (unsigned short )0;
      sqlstm.sqhstv[1] = (         void  *)&vers;
      sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
      sqlstm.sqhsts[1] = (         int  )0;
      sqlstm.sqindv[1] = (         void  *)0;
      sqlstm.sqinds[1] = (         int  )0;
      sqlstm.sqharm[1] = (unsigned int  )0;
      sqlstm.sqadto[1] = (unsigned short )0;
      sqlstm.sqtdso[1] = (unsigned short )0;
      sqlstm.sqphsv = sqlstm.sqhstv;
      sqlstm.sqphsl = sqlstm.sqhstl;
      sqlstm.sqphss = sqlstm.sqhsts;
      sqlstm.sqpind = sqlstm.sqindv;
      sqlstm.sqpins = sqlstm.sqinds;
      sqlstm.sqparm = sqlstm.sqharm;
      sqlstm.sqparc = sqlstm.sqharc;
      sqlstm.sqpadto = sqlstm.sqadto;
      sqlstm.sqptdso = sqlstm.sqtdso;
      sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
      if (sqlca.sqlcode < 0) showSqlError("read(HRpcCalPar*,Int_t*)");
}


      /* EXEC SQL FETCH cal_cur INTO :cal; */ 

{
      struct sqlexd sqlstm;
      sqlorat((void **)0, &sqlctx, &oraca);
      sqlstm.sqlvsn = 12;
      sqlstm.arrsiz = 9;
      sqlstm.sqladtp = &sqladt;
      sqlstm.sqltdsp = &sqltds;
      sqlstm.iters = (unsigned int  )186;
      sqlstm.offset = (unsigned int  )82;
      sqlstm.selerr = (unsigned short)1;
      sqlstm.cud = sqlcud0;
      sqlstm.sqlest = (unsigned char  *)&sqlca;
      sqlstm.sqlety = (unsigned short)256;
      sqlstm.occurs = (unsigned int  )0;
      sqlstm.sqfoff = (           int )0;
      sqlstm.sqfmod = (unsigned int )2;
      sqlstm.sqhstv[0] = (         void  *)cal.col;
      sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
      sqlstm.sqhsts[0] = (         int  )sizeof(int);
      sqlstm.sqindv[0] = (         void  *)0;
      sqlstm.sqinds[0] = (         int  )0;
      sqlstm.sqharm[0] = (unsigned int  )0;
      sqlstm.sqharc[0] = (unsigned int   *)0;
      sqlstm.sqadto[0] = (unsigned short )0;
      sqlstm.sqtdso[0] = (unsigned short )0;
      sqlstm.sqhstv[1] = (         void  *)cal.cell;
      sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
      sqlstm.sqhsts[1] = (         int  )sizeof(int);
      sqlstm.sqindv[1] = (         void  *)0;
      sqlstm.sqinds[1] = (         int  )0;
      sqlstm.sqharm[1] = (unsigned int  )0;
      sqlstm.sqharc[1] = (unsigned int   *)0;
      sqlstm.sqadto[1] = (unsigned short )0;
      sqlstm.sqtdso[1] = (unsigned short )0;
      sqlstm.sqhstv[2] = (         void  *)cal.rtimeo;
      sqlstm.sqhstl[2] = (unsigned int  )sizeof(float);
      sqlstm.sqhsts[2] = (         int  )sizeof(float);
      sqlstm.sqindv[2] = (         void  *)0;
      sqlstm.sqinds[2] = (         int  )0;
      sqlstm.sqharm[2] = (unsigned int  )0;
      sqlstm.sqharc[2] = (unsigned int   *)0;
      sqlstm.sqadto[2] = (unsigned short )0;
      sqlstm.sqtdso[2] = (unsigned short )0;
      sqlstm.sqhstv[3] = (         void  *)cal.ltimeo;
      sqlstm.sqhstl[3] = (unsigned int  )sizeof(float);
      sqlstm.sqhsts[3] = (         int  )sizeof(float);
      sqlstm.sqindv[3] = (         void  *)0;
      sqlstm.sqinds[3] = (         int  )0;
      sqlstm.sqharm[3] = (unsigned int  )0;
      sqlstm.sqharc[3] = (unsigned int   *)0;
      sqlstm.sqadto[3] = (unsigned short )0;
      sqlstm.sqtdso[3] = (unsigned short )0;
      sqlstm.sqhstv[4] = (         void  *)cal.rtoto;
      sqlstm.sqhstl[4] = (unsigned int  )sizeof(float);
      sqlstm.sqhsts[4] = (         int  )sizeof(float);
      sqlstm.sqindv[4] = (         void  *)0;
      sqlstm.sqinds[4] = (         int  )0;
      sqlstm.sqharm[4] = (unsigned int  )0;
      sqlstm.sqharc[4] = (unsigned int   *)0;
      sqlstm.sqadto[4] = (unsigned short )0;
      sqlstm.sqtdso[4] = (unsigned short )0;
      sqlstm.sqhstv[5] = (         void  *)cal.ltoto;
      sqlstm.sqhstl[5] = (unsigned int  )sizeof(float);
      sqlstm.sqhsts[5] = (         int  )sizeof(float);
      sqlstm.sqindv[5] = (         void  *)0;
      sqlstm.sqinds[5] = (         int  )0;
      sqlstm.sqharm[5] = (unsigned int  )0;
      sqlstm.sqharc[5] = (unsigned int   *)0;
      sqlstm.sqadto[5] = (unsigned short )0;
      sqlstm.sqtdso[5] = (unsigned short )0;
      sqlstm.sqhstv[6] = (         void  *)cal.t2t;
      sqlstm.sqhstl[6] = (unsigned int  )sizeof(float);
      sqlstm.sqhsts[6] = (         int  )sizeof(float);
      sqlstm.sqindv[6] = (         void  *)0;
      sqlstm.sqinds[6] = (         int  )0;
      sqlstm.sqharm[6] = (unsigned int  )0;
      sqlstm.sqharc[6] = (unsigned int   *)0;
      sqlstm.sqadto[6] = (unsigned short )0;
      sqlstm.sqtdso[6] = (unsigned short )0;
      sqlstm.sqhstv[7] = (         void  *)cal.t2c;
      sqlstm.sqhstl[7] = (unsigned int  )sizeof(float);
      sqlstm.sqhsts[7] = (         int  )sizeof(float);
      sqlstm.sqindv[7] = (         void  *)0;
      sqlstm.sqinds[7] = (         int  )0;
      sqlstm.sqharm[7] = (unsigned int  )0;
      sqlstm.sqharc[7] = (unsigned int   *)0;
      sqlstm.sqadto[7] = (unsigned short )0;
      sqlstm.sqtdso[7] = (unsigned short )0;
      sqlstm.sqhstv[8] = (         void  *)cal.oo;
      sqlstm.sqhstl[8] = (unsigned int  )sizeof(float);
      sqlstm.sqhsts[8] = (         int  )sizeof(float);
      sqlstm.sqindv[8] = (         void  *)0;
      sqlstm.sqinds[8] = (         int  )0;
      sqlstm.sqharm[8] = (unsigned int  )0;
      sqlstm.sqharc[8] = (unsigned int   *)0;
      sqlstm.sqadto[8] = (unsigned short )0;
      sqlstm.sqtdso[8] = (unsigned short )0;
      sqlstm.sqphsv = sqlstm.sqhstv;
      sqlstm.sqphsl = sqlstm.sqhstl;
      sqlstm.sqphss = sqlstm.sqhsts;
      sqlstm.sqpind = sqlstm.sqindv;
      sqlstm.sqpins = sqlstm.sqinds;
      sqlstm.sqparm = sqlstm.sqharm;
      sqlstm.sqparc = sqlstm.sqharc;
      sqlstm.sqpadto = sqlstm.sqadto;
      sqlstm.sqptdso = sqlstm.sqtdso;
      sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
      if (sqlca.sqlcode < 0) showSqlError("read(HRpcCalPar*,Int_t*)");
}


      HRpcCalParSec& calsec=(*pPar)[s];
      Int_t n=sqlca.sqlerrd[2];
      if (n>0) {
        for(Int_t i=0;i<n;i++) {
          calsec.fill(cal.col[i],cal.cell[i],cal.rtimeo[i],cal.ltimeo[i],
                      cal.rtoto[i],cal.ltoto[i],cal.t2t[i],cal.t2c[i],cal.oo[i]);
        }
        initModules->AddAt(sec,s);
      }
    }
  }     
  /* EXEC SQL CLOSE cal_cur; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 9;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )133;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) showSqlError("read(HRpcCalPar*,Int_t*)");
}


  Bool_t allFound=kTRUE;
  for(Int_t i=0;i<RPC_MAXSEC;i++) {
    if (set[i]>0) {
      if (initModules->At(i)>0) set[i]=0;
      else allFound=kFALSE;
    }
  }
  setChanged(pPar);
  printInfo(pPar->GetName());
  return allFound;
}

Bool_t HRpcParOraIo::read(HRpcGeomPar* pPar, Int_t* set) {
  // reads the geometry of the RPC and fills the RpcGeomPar container
  Bool_t allFound=kTRUE;
  Int_t detId=-1;
  if (!geomVers) {
    detId=getDetectorId(pPar->getDetectorName());
    geomVers=new HGeomOraDetVersion(pPar->getDetectorName(),detId);
  } else {
    detId=geomVers->getDetectorId();
  }
  if (detId<=0) {
    allFound=kFALSE;
    delete geomVers;
    geomVers=0;
  }
  if (detId>0&&pPar->isFirstInitialization()) {
    if (!readModGeomNames(pPar,set) || !readCompGeomNames(pPar,set)) {
      allFound=kFALSE;
      pPar->clear();
    } else addGeomOraSet(pPar);
  }  
  if (allFound) allFound=readDetectorGeometry(pPar,set,geomVers);
  return allFound;    
}

Bool_t HRpcParOraIo::readModGeomNames(HRpcGeomPar* pPar,Int_t* set) {
  // reads the GEANT geometry names of all modules
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    struct {
      int sec[RPC_MAXSEC];
      /* varchar oname[RPC_MAXSEC][9]; */ 
struct { unsigned short len; unsigned char arr[10]; } oname[6];

    } mods;
    struct {
      short sec[RPC_MAXSEC];
      short oname[RPC_MAXSEC];
    } mods_Ind;
  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("readModGeomNames()"); */ 

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 


  /* EXEC SQL SELECT sector, geom_obj_name
    INTO :mods INDICATOR :mods_Ind
    FROM rpc_ana.detector_setup_at_run_hist; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 9;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "select sector ,geom_obj_name into :s1:s2 ,:s3:s4   from rpc\
_ana.detector_setup_at_run_hist ";
  sqlstm.iters = (unsigned int  )6;
  sqlstm.offset = (unsigned int  )148;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)mods.sec;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )sizeof(int);
  sqlstm.sqindv[0] = (         void  *)mods_Ind.sec;
  sqlstm.sqinds[0] = (         int  )sizeof(short);
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqharc[0] = (unsigned int   *)0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (         void  *)mods.oname;
  sqlstm.sqhstl[1] = (unsigned int  )11;
  sqlstm.sqhsts[1] = (         int  )12;
  sqlstm.sqindv[1] = (         void  *)mods_Ind.oname;
  sqlstm.sqinds[1] = (         int  )sizeof(short);
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqharc[1] = (unsigned int   *)0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) showSqlError("readModGeomNames()");
}



  Int_t nMods=sqlca.sqlerrd[2];
  Int_t s;
  Char_t ref[10];
  initModules->Reset();
  for(Int_t i=0;i<nMods;i++) {
    s=mods.sec[i]-1;
    HModGeomPar* pMod=pPar->getModule(s,0);
    if (pMod && set[s]) {
      if (mods_Ind.oname[i]!=-1) {
        mods.oname[i].arr[mods.oname[i].len]='\0';
        pMod->SetName((Char_t*)(mods.oname[i].arr));
        initModules->AddAt(s+1,s);
        strcpy(ref,(Char_t*)(mods.oname[i].arr));
        ref[4]='1'; // reference module in sector 1
        pMod->setRefName(ref);
        HGeomCompositeVolume* refMod=pPar->getRefVolume(0);
        if (refMod==0) {
          refMod=new HGeomCompositeVolume(pPar->getNumComponents());
          refMod->SetName(ref);
          pPar->addRefVolume(refMod,0);
        }
        pMod->setVolume(refMod);
      }
    }
  }
  Bool_t allFound=kTRUE;
  for(Int_t i=0;i<RPC_MAXSEC;i++) {
    if (set[i]>0 && initModules->At(i)==0) allFound=kFALSE;
  }
  return allFound;
}

Bool_t HRpcParOraIo::readCompGeomNames(HRpcGeomPar* pPar,Int_t* set) {
  // reads the names of all cells in the geometry tables
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    struct {
      int column_number[RPC_MAXCELLS];
      int cell_number[RPC_MAXCELLS];
      /* varchar oname[RPC_MAXCELLS][9]; */ 
struct { unsigned short len; unsigned char arr[10]; } oname[186];

    } lrecG;
  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("readCompGeomNames(...)"); */ 

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 

  /* EXEC SQL SELECT column_number, cell_number, geom_obj_name
    INTO :lrecG
    FROM rpc_ana.module_cell
    WHERE geom_obj_name IS NOT NULL; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 9;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "select column_number ,cell_number ,geom_obj_name into :s1 ,\
:s2 ,:s3   from rpc_ana.module_cell where geom_obj_name is  not null ";
  sqlstm.iters = (unsigned int  )186;
  sqlstm.offset = (unsigned int  )171;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)lrecG.column_number;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )sizeof(int);
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqharc[0] = (unsigned int   *)0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (         void  *)lrecG.cell_number;
  sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[1] = (         int  )sizeof(int);
  sqlstm.sqindv[1] = (         void  *)0;
  sqlstm.sqinds[1] = (         int  )0;
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqharc[1] = (unsigned int   *)0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqhstv[2] = (         void  *)lrecG.oname;
  sqlstm.sqhstl[2] = (unsigned int  )11;
  sqlstm.sqhsts[2] = (         int  )12;
  sqlstm.sqindv[2] = (         void  *)0;
  sqlstm.sqinds[2] = (         int  )0;
  sqlstm.sqharm[2] = (unsigned int  )0;
  sqlstm.sqharc[2] = (unsigned int   *)0;
  sqlstm.sqadto[2] = (unsigned short )0;
  sqlstm.sqtdso[2] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) showSqlError("readCompGeomNames(...)");
}


  HGeomCompositeVolume* pRefMod=pPar->getRefVolume(0);
  Int_t nCells=sqlca.sqlerrd[2];
  Int_t cell=-1;
  for(Int_t k=0;k<nCells;k++) {
    lrecG.oname[k].arr[lrecG.oname[k].len]='\0';
    cell=pPar->getCompNum(lrecG.column_number[k],lrecG.cell_number[k]);
    HGeomVolume* volu=pRefMod->getComponent(cell);
    if (volu) volu->SetName((Char_t*)(lrecG.oname[k].arr));
    else {
      Error("readCompGeomNames","Index for cell %s not found",(Char_t*)(lrecG.oname[k].arr));
      return kFALSE;
    }
  }
  return (nCells>0) ? kTRUE : kFALSE;
}

Int_t HRpcParOraIo::createVers(HParSet* pPar) {
  // creates a new version for the calibration parameters
  // returns the new version
  cout<<"---------------  "<<pPar->GetName()<<"   ---------------\n";
  if (strlen(pPar->getAuthor())==0) {
    Error("createVers(HParSet*)",
          "author of parameters not defined");
    return -1;
  }
  if (strlen(pPar->getDescription())==0) {
    Error("createVers(HParSet*)",
          "descriction of parameters not defined");
    return -1;
  }
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int   vers=-1;
    int   context;
    int   run;
    char* creator;
    char* descript;
  /* EXEC SQL END DECLARE SECTION; */ 

  context = getContextId(pPar->IsA()->GetName(),pPar->getParamContext());
  if (context==-1) return -1;
  run=getActRunId();
  creator=(Char_t*)pPar->getAuthor();
  descript=(Char_t*)pPar->getDescription();
  /* EXEC SQL WHENEVER SQLERROR GOTO not_found; */ 

  /* EXEC SQL WHENEVER NOT FOUND GOTO not_found; */ 

  const Char_t* contName=pPar->IsA()->GetName();
  if (strcmp(contName,"HRpcCalPar")==0) {
    /* EXEC SQL EXECUTE
      BEGIN
        SELECT rpc_ana.rpc_par_query.next_version INTO :vers FROM DUAL;
        INSERT INTO rpc_ana.calpar_vers
                   (vers_id, orig_context_id, run_id, author, description)
            VALUES (:vers, :context, :run, :creator, :descript);
      END;
    END-EXEC; */ 

{
    struct sqlexd sqlstm;
    sqlorat((void **)0, &sqlctx, &oraca);
    sqlstm.sqlvsn = 12;
    sqlstm.arrsiz = 9;
    sqlstm.sqladtp = &sqladt;
    sqlstm.sqltdsp = &sqltds;
    sqlstm.stmt = "begin SELECT rpc_ana . rpc_par_query . next_version INTO \
:vers FROM DUAL ; INSERT INTO rpc_ana . calpar_vers ( vers_id , orig_context_i\
d , run_id , author , description ) VALUES ( :vers , :context , :run , :creato\
r , :descript ) ; END ;";
    sqlstm.iters = (unsigned int  )1;
    sqlstm.offset = (unsigned int  )198;
    sqlstm.cud = sqlcud0;
    sqlstm.sqlest = (unsigned char  *)&sqlca;
    sqlstm.sqlety = (unsigned short)256;
    sqlstm.occurs = (unsigned int  )0;
    sqlstm.sqhstv[0] = (         void  *)&vers;
    sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
    sqlstm.sqhsts[0] = (         int  )0;
    sqlstm.sqindv[0] = (         void  *)0;
    sqlstm.sqinds[0] = (         int  )0;
    sqlstm.sqharm[0] = (unsigned int  )0;
    sqlstm.sqadto[0] = (unsigned short )0;
    sqlstm.sqtdso[0] = (unsigned short )0;
    sqlstm.sqhstv[1] = (         void  *)&context;
    sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
    sqlstm.sqhsts[1] = (         int  )0;
    sqlstm.sqindv[1] = (         void  *)0;
    sqlstm.sqinds[1] = (         int  )0;
    sqlstm.sqharm[1] = (unsigned int  )0;
    sqlstm.sqadto[1] = (unsigned short )0;
    sqlstm.sqtdso[1] = (unsigned short )0;
    sqlstm.sqhstv[2] = (         void  *)&run;
    sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
    sqlstm.sqhsts[2] = (         int  )0;
    sqlstm.sqindv[2] = (         void  *)0;
    sqlstm.sqinds[2] = (         int  )0;
    sqlstm.sqharm[2] = (unsigned int  )0;
    sqlstm.sqadto[2] = (unsigned short )0;
    sqlstm.sqtdso[2] = (unsigned short )0;
    sqlstm.sqhstv[3] = (         void  *)creator;
    sqlstm.sqhstl[3] = (unsigned int  )0;
    sqlstm.sqhsts[3] = (         int  )0;
    sqlstm.sqindv[3] = (         void  *)0;
    sqlstm.sqinds[3] = (         int  )0;
    sqlstm.sqharm[3] = (unsigned int  )0;
    sqlstm.sqadto[3] = (unsigned short )0;
    sqlstm.sqtdso[3] = (unsigned short )0;
    sqlstm.sqhstv[4] = (         void  *)descript;
    sqlstm.sqhstl[4] = (unsigned int  )0;
    sqlstm.sqhsts[4] = (         int  )0;
    sqlstm.sqindv[4] = (         void  *)0;
    sqlstm.sqinds[4] = (         int  )0;
    sqlstm.sqharm[4] = (unsigned int  )0;
    sqlstm.sqadto[4] = (unsigned short )0;
    sqlstm.sqtdso[4] = (unsigned short )0;
    sqlstm.sqphsv = sqlstm.sqhstv;
    sqlstm.sqphsl = sqlstm.sqhstl;
    sqlstm.sqphss = sqlstm.sqhsts;
    sqlstm.sqpind = sqlstm.sqindv;
    sqlstm.sqpins = sqlstm.sqinds;
    sqlstm.sqparm = sqlstm.sqharm;
    sqlstm.sqparc = sqlstm.sqharc;
    sqlstm.sqpadto = sqlstm.sqadto;
    sqlstm.sqptdso = sqlstm.sqtdso;
    sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
    if (sqlca.sqlcode == 1403) goto not_found;
    if (sqlca.sqlcode < 0) goto not_found;
}


  }
  cout<<"Oracle version for "<<pPar->GetName()<<" created:  "<<vers<<endl;
  return vers;
not_found:
  showSqlError("createVers(HParSet*)");
  return vers;
}

Int_t HRpcParOraIo:: writePar(HRpcCalPar* pPar) {
  // creates a new version and writes the calibration parameters to Oracle
  Int_t version=createVers(pPar);
  if (version==-1) return -1;
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int sec[RPC_MAXCELLS];
    int col[RPC_MAXCELLS];
    int cell[RPC_MAXCELLS];
    int vers[RPC_MAXCELLS];
    float rtimeo[RPC_MAXCELLS];
    float ltimeo[RPC_MAXCELLS];
    float rtoto[RPC_MAXCELLS];
    float ltoto[RPC_MAXCELLS];
    float t2t[RPC_MAXCELLS];
    float t2c[RPC_MAXCELLS];
    float oo[RPC_MAXCELLS];
    int rows_to_insert;
  /* EXEC SQL END DECLARE SECTION; */ 

  Int_t nCell=0, maxNumCell=0, nCellO=0;
  for(Int_t s=0; s<pPar->getSize(); s++) {
    if (secIds->At(s)>0) {
      HRpcCalParSec& rSec= (*pPar)[s];
      nCell=0;
      for(Int_t m=0; m<rSec.getSize(); m++) {
        HRpcCalParCol& rCol= rSec[m];
        for(Int_t c=0; c<rCol.getSize(); c++) {
          HRpcCalParCell& rCell= rCol[c];
          sec[nCell]=s+1;
          col[nCell]=m;
          cell[nCell]=c;
          vers[nCell]=version;
          rtimeo[nCell]=rCell.getRightTimeOffset();
          ltimeo[nCell]=rCell.getLeftTimeOffset();
          rtoto[nCell]=rCell.getRightTOTOffset();
          ltoto[nCell]=rCell.getLeftTOTOffset();
          t2t[nCell]=rCell.getTDC2Time();
          t2c[nCell]=rCell.getTOT2Charge();
          oo[nCell]=rCell.getT0();
          nCell++;
        }
      }
      if (nCell==0) continue;
      rows_to_insert=nCell;
      if (nCell>maxNumCell) maxNumCell=nCell;
      /* EXEC SQL WHENEVER SQLERROR GOTO not_found; */ 

      /* EXEC SQL WHENEVER NOT FOUND GOTO not_found; */ 

      /* EXEC SQL FOR :rows_to_insert
        INSERT INTO rpc_ana.calpar_data
               (cell_id, vers_id, right_time_offset, left_time_offset,
                right_tot_offset, left_tot_offset,
                tdc2time, tot2charge, overall_offset)
        VALUES (rpc_ana.rpc_par_query.get_cell_id(:sec,:col,:cell),
                :vers, :rtimeo, :ltimeo, :rtoto, :ltoto, :t2t, :t2c, :oo); */ 

{
      struct sqlexd sqlstm;
      sqlorat((void **)0, &sqlctx, &oraca);
      sqlstm.sqlvsn = 12;
      sqlstm.arrsiz = 11;
      sqlstm.sqladtp = &sqladt;
      sqlstm.sqltdsp = &sqltds;
      sqlstm.stmt = "insert into rpc_ana.calpar_data (cell_id,vers_id,right_\
time_offset,left_time_offset,right_tot_offset,left_tot_offset,tdc2time,tot2cha\
rge,overall_offset) values (rpc_ana.rpc_par_query.get_cell_id(:b1,:b2,:b3),:b4\
,:b5,:b6,:b7,:b8,:b9,:b10,:b11)";
      sqlstm.iters = (unsigned int  )rows_to_insert;
      sqlstm.offset = (unsigned int  )233;
      sqlstm.cud = sqlcud0;
      sqlstm.sqlest = (unsigned char  *)&sqlca;
      sqlstm.sqlety = (unsigned short)256;
      sqlstm.occurs = (unsigned int  )0;
      sqlstm.sqhstv[0] = (         void  *)sec;
      sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
      sqlstm.sqhsts[0] = (         int  )sizeof(int);
      sqlstm.sqindv[0] = (         void  *)0;
      sqlstm.sqinds[0] = (         int  )0;
      sqlstm.sqharm[0] = (unsigned int  )0;
      sqlstm.sqharc[0] = (unsigned int   *)0;
      sqlstm.sqadto[0] = (unsigned short )0;
      sqlstm.sqtdso[0] = (unsigned short )0;
      sqlstm.sqhstv[1] = (         void  *)col;
      sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
      sqlstm.sqhsts[1] = (         int  )sizeof(int);
      sqlstm.sqindv[1] = (         void  *)0;
      sqlstm.sqinds[1] = (         int  )0;
      sqlstm.sqharm[1] = (unsigned int  )0;
      sqlstm.sqharc[1] = (unsigned int   *)0;
      sqlstm.sqadto[1] = (unsigned short )0;
      sqlstm.sqtdso[1] = (unsigned short )0;
      sqlstm.sqhstv[2] = (         void  *)cell;
      sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
      sqlstm.sqhsts[2] = (         int  )sizeof(int);
      sqlstm.sqindv[2] = (         void  *)0;
      sqlstm.sqinds[2] = (         int  )0;
      sqlstm.sqharm[2] = (unsigned int  )0;
      sqlstm.sqharc[2] = (unsigned int   *)0;
      sqlstm.sqadto[2] = (unsigned short )0;
      sqlstm.sqtdso[2] = (unsigned short )0;
      sqlstm.sqhstv[3] = (         void  *)vers;
      sqlstm.sqhstl[3] = (unsigned int  )sizeof(int);
      sqlstm.sqhsts[3] = (         int  )sizeof(int);
      sqlstm.sqindv[3] = (         void  *)0;
      sqlstm.sqinds[3] = (         int  )0;
      sqlstm.sqharm[3] = (unsigned int  )0;
      sqlstm.sqharc[3] = (unsigned int   *)0;
      sqlstm.sqadto[3] = (unsigned short )0;
      sqlstm.sqtdso[3] = (unsigned short )0;
      sqlstm.sqhstv[4] = (         void  *)rtimeo;
      sqlstm.sqhstl[4] = (unsigned int  )sizeof(float);
      sqlstm.sqhsts[4] = (         int  )sizeof(float);
      sqlstm.sqindv[4] = (         void  *)0;
      sqlstm.sqinds[4] = (         int  )0;
      sqlstm.sqharm[4] = (unsigned int  )0;
      sqlstm.sqharc[4] = (unsigned int   *)0;
      sqlstm.sqadto[4] = (unsigned short )0;
      sqlstm.sqtdso[4] = (unsigned short )0;
      sqlstm.sqhstv[5] = (         void  *)ltimeo;
      sqlstm.sqhstl[5] = (unsigned int  )sizeof(float);
      sqlstm.sqhsts[5] = (         int  )sizeof(float);
      sqlstm.sqindv[5] = (         void  *)0;
      sqlstm.sqinds[5] = (         int  )0;
      sqlstm.sqharm[5] = (unsigned int  )0;
      sqlstm.sqharc[5] = (unsigned int   *)0;
      sqlstm.sqadto[5] = (unsigned short )0;
      sqlstm.sqtdso[5] = (unsigned short )0;
      sqlstm.sqhstv[6] = (         void  *)rtoto;
      sqlstm.sqhstl[6] = (unsigned int  )sizeof(float);
      sqlstm.sqhsts[6] = (         int  )sizeof(float);
      sqlstm.sqindv[6] = (         void  *)0;
      sqlstm.sqinds[6] = (         int  )0;
      sqlstm.sqharm[6] = (unsigned int  )0;
      sqlstm.sqharc[6] = (unsigned int   *)0;
      sqlstm.sqadto[6] = (unsigned short )0;
      sqlstm.sqtdso[6] = (unsigned short )0;
      sqlstm.sqhstv[7] = (         void  *)ltoto;
      sqlstm.sqhstl[7] = (unsigned int  )sizeof(float);
      sqlstm.sqhsts[7] = (         int  )sizeof(float);
      sqlstm.sqindv[7] = (         void  *)0;
      sqlstm.sqinds[7] = (         int  )0;
      sqlstm.sqharm[7] = (unsigned int  )0;
      sqlstm.sqharc[7] = (unsigned int   *)0;
      sqlstm.sqadto[7] = (unsigned short )0;
      sqlstm.sqtdso[7] = (unsigned short )0;
      sqlstm.sqhstv[8] = (         void  *)t2t;
      sqlstm.sqhstl[8] = (unsigned int  )sizeof(float);
      sqlstm.sqhsts[8] = (         int  )sizeof(float);
      sqlstm.sqindv[8] = (         void  *)0;
      sqlstm.sqinds[8] = (         int  )0;
      sqlstm.sqharm[8] = (unsigned int  )0;
      sqlstm.sqharc[8] = (unsigned int   *)0;
      sqlstm.sqadto[8] = (unsigned short )0;
      sqlstm.sqtdso[8] = (unsigned short )0;
      sqlstm.sqhstv[9] = (         void  *)t2c;
      sqlstm.sqhstl[9] = (unsigned int  )sizeof(float);
      sqlstm.sqhsts[9] = (         int  )sizeof(float);
      sqlstm.sqindv[9] = (         void  *)0;
      sqlstm.sqinds[9] = (         int  )0;
      sqlstm.sqharm[9] = (unsigned int  )0;
      sqlstm.sqharc[9] = (unsigned int   *)0;
      sqlstm.sqadto[9] = (unsigned short )0;
      sqlstm.sqtdso[9] = (unsigned short )0;
      sqlstm.sqhstv[10] = (         void  *)oo;
      sqlstm.sqhstl[10] = (unsigned int  )sizeof(float);
      sqlstm.sqhsts[10] = (         int  )sizeof(float);
      sqlstm.sqindv[10] = (         void  *)0;
      sqlstm.sqinds[10] = (         int  )0;
      sqlstm.sqharm[10] = (unsigned int  )0;
      sqlstm.sqharc[10] = (unsigned int   *)0;
      sqlstm.sqadto[10] = (unsigned short )0;
      sqlstm.sqtdso[10] = (unsigned short )0;
      sqlstm.sqphsv = sqlstm.sqhstv;
      sqlstm.sqphsl = sqlstm.sqhstl;
      sqlstm.sqphss = sqlstm.sqhsts;
      sqlstm.sqpind = sqlstm.sqindv;
      sqlstm.sqpins = sqlstm.sqinds;
      sqlstm.sqparm = sqlstm.sqharm;
      sqlstm.sqparc = sqlstm.sqharc;
      sqlstm.sqpadto = sqlstm.sqadto;
      sqlstm.sqptdso = sqlstm.sqtdso;
      sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
      if (sqlca.sqlcode == 1403) goto not_found;
      if (sqlca.sqlcode < 0) goto not_found;
}


      cout<<"sector: "<<(s)<<"    "<<rows_to_insert<<" rows inserted\n";
    }
  }
  nCellO=countCells();
  if (maxNumCell!=nCellO) {
    cout<<"WARNING: Number of cells in Oracle = "<<nCellO
        <<" larger then number of inserted cells!\n";
  }
  commit();
  pPar->setChanged(kFALSE);
  return version;
not_found:
  showSqlError("writePar(HRpcCalPar*)");
  rollback();
  pPar->setChanged(kFALSE);
  return -1;
}

Int_t HRpcParOraIo::countCells(void) {
  // returns the total number of cells of a module
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int num;
  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR DO
    showSqlError("countRods(Int_t)"); */ 

  /* EXEC SQL WHENEVER NOT FOUND GOTO notfound; */ 

  /* EXEC SQL SELECT COUNT(cell_index) INTO :num
           FROM rpc_ana.module_cell
           WHERE column_number != -1 AND cell_number != -1 ; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 11;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "select count(cell_index) into :b0  from rpc_ana.module_cell\
 where (column_number<>(-1) and cell_number<>(-1))";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )292;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)&num;
  sqlstm.sqhstl[0] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )0;
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode == 1403) goto notfound;
  if (sqlca.sqlcode < 0) showSqlError("countRods(Int_t)");
}


  return num;
notfound:
  return 0;
}

void HRpcParOraIo::printInfo(const Char_t* contName) {
  // prints the sectors initialized from Oracle
  Bool_t first=kTRUE;
  for(Int_t i=0;i<RPC_MAXSEC;i++) {
    if (initModules->At(i)) {
      if (first) {
        cout<<contName<<": sector(s) initialized from Oracle: ";
        first=kFALSE;
      }
      cout<<i<<" ";
    }
  }
  cout<<'\n';
}