/* 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[20];
};
static const struct sqlcxp sqlfpn =
{
    19,
    "hshowerparora2io.pc"
};


static unsigned int sqlctx = 39698211;


static struct sqlexd {
   unsigned long  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;
   unsigned char  **sqphsv;
   unsigned long  *sqphsl;
            int   *sqphss;
            short **sqpind;
            int   *sqpins;
   unsigned long  *sqparm;
   unsigned long  **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;
   unsigned int   sqlpfmem;
   unsigned char  *sqhstv[9];
   unsigned long  sqhstl[9];
            int   sqhsts[9];
            short *sqindv[9];
            int   sqinds[9];
   unsigned long  sqharm[9];
   unsigned long  *sqharc[9];
   unsigned short  sqadto[9];
   unsigned short  sqtdso[9];
} sqlstm = {13,9};

// 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(unsigned char *, signed int *); }

 static const char *sq0002 = 
"select sector ,module ,pad_col ,pad_row ,slope ,offset ,threshold ,gain  fro\
m shower_ana2.shw_calpar_data_view where vers_id=:b0           ";

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[] =
{13,4130,1,0,0,
5,0,0,1,170,0,4,116,0,0,4,1,0,1,0,2,3,0,0,2,4,0,0,2,4,0,0,1,3,0,0,
36,0,0,2,139,0,9,167,0,0,1,1,0,1,0,1,3,0,0,
55,0,0,2,0,0,13,170,0,0,8,0,0,1,0,2,3,0,0,2,3,0,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,
102,0,0,2,0,0,15,202,0,0,0,0,0,1,0,
117,0,0,3,154,0,4,262,0,0,5,0,0,1,0,2,3,0,0,2,3,0,0,2,3,0,0,2,9,0,0,2,9,0,0,
152,0,0,4,251,0,6,336,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,
187,0,0,5,170,0,3,415,0,0,9,9,0,1,0,1,3,0,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,
};


//*-- AUTHOR : Ilse Koenig

//_HADES_CLASS_DESCRIPTION 
//////////////////////////////////////////////////////////////////////////////
// HShowerParOra2Io
//
// Interface class to database Oracle for input/output of parameters needed
// by the SHOWER detector for runs since 2010
// (uses the Oracle C/C++ precompiler)
//
//////////////////////////////////////////////////////////////////////////////
using namespace std;
#include "hshowerparora2io.h"
#include "hparora2set.h"
#include "hshowercalpar.h"
#include "hshowergeompar.h"
#include "hgeomcompositevolume.h"
#include "hora2geomdetversion.h"
#include "TClass.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>
#include <sqlcpr.h>

ClassImp(HShowerParOra2Io)
	
#define SHOWER_MAXSEC      6
#define SHOWER_MAXSECMODS  3
#define SHOWER_MAXMODS 	  18
#define SHOWER_MAXARR 	5000
#define SHOWER_MAXPADS  1024


HShowerParOra2Io::HShowerParOra2Io(HOra2Conn* pC) : HDetParOra2Io(pC) {
  // constructor
  // sets the name of the I/O class "HShowerParIo"
  // gets the pointer to the connection class
  fName="HShowerParIo";
  initModules=new TArrayI(SHOWER_MAXMODS);
  geomVers=0;
}


HShowerParOra2Io::~HShowerParOra2Io() {
  // destructor
  if (initModules) delete initModules;
  if (geomVers) delete geomVers;
}


Bool_t HShowerParOra2Io::init(HParSet* pPar,Int_t* set) {
  // calls special read-function for each parameter container
  if (getRunStart(pPar)<0) {
    pPar->setInputVersion(-1,inputNumber);
    return kFALSE;
  }
  const Text_t* name=pPar->IsA()->GetName();
  if (strcmp(name,"HShowerCalPar")==0)
    return read(((HShowerCalPar*)pPar),set);
  if (strcmp(name,"HShowerGeomPar")==0) 
    return read(((HShowerGeomPar*)pPar),set);
  Error("init","Initialization of %s not possible from Oracle!",name);
  return kFALSE;
}


Int_t HShowerParOra2Io::write(HParSet* pPar) {
  // calls the appropriate write function for the container
  if (getRunStart(pPar)<=0) return -1;
  const Text_t* name=pPar->IsA()->GetName();
  if (!strcmp(name,"HShowerCalPar"))
    return writePar((HShowerCalPar*)pPar);
  if (strcmp(name,"HShowerGeomPar")==0)
    return writeAlignment((HShowerGeomPar*)pPar);
  Error("write","Storage of %s not possible in Oracle!",name);
  return 0;
}

Bool_t HShowerParOra2Io::getVersion(HParSet* pPar,Int_t& version) {
  // checks, if the parameter container needs to be reinitialized
  // reads the newest version valid for the current event file
  // returns kTRUE, if new parameters must be read
  // returns kFALSE, if no reinitialization needed or not valid version found
  HParOra2Set* oraSet=getOraSet(pPar);
  if (oraSet->contextId==-1 || runStart==-1) {
    pPar->setInputVersion(-1,inputNumber);
    version=-1;
    return kFALSE;
  }
  Int_t contVers=pPar->getInputVersion(inputNumber);
  if (contVers!=-1 && runStart>=oraSet->versDate[0] && runStart<=oraSet->versDate[1]) {
    version=contVers;
    return kFALSE;
  }
  const Char_t* containerClass=pPar->IsA()->GetName();
  oraSet->clearVersDate();
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int context;
    int vers;
    double since;
    double until;
  /* EXEC SQL END DECLARE SECTION; */ 

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

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

  if (strcmp(containerClass,"HShowerCalPar")==0) {
    /* EXEC SQL SELECT vers_id,
                    hanadate.date_to_number(valid_since),
                    hanadate.date_to_number(valid_until)
             INTO :vers, :since, :until
             FROM shower_ana2.shw_calpar_vers_at_date
             WHERE context_id = :context; */ 

{
    struct sqlexd sqlstm;
    sqlorat((void **)0, &sqlctx, &oraca);
    sqlstm.sqlvsn = 13;
    sqlstm.arrsiz = 4;
    sqlstm.sqladtp = &sqladt;
    sqlstm.sqltdsp = &sqltds;
    sqlstm.stmt = "select vers_id ,hanadate.date_to_number(valid_since) ,han\
adate.date_to_number(valid_until) into :b0,:b1,:b2  from shower_ana2.shw_calpa\
r_vers_at_date where context_id=:b3";
    sqlstm.iters = (unsigned int  )1;
    sqlstm.offset = (unsigned int  )5;
    sqlstm.selerr = (unsigned short)1;
    sqlstm.sqlpfmem = (unsigned int  )0;
    sqlstm.cud = sqlcud0;
    sqlstm.sqlest = (unsigned char  *)&sqlca;
    sqlstm.sqlety = (unsigned short)4352;
    sqlstm.occurs = (unsigned int  )0;
    sqlstm.sqhstv[0] = (unsigned char  *)&vers;
    sqlstm.sqhstl[0] = (unsigned long )sizeof(int);
    sqlstm.sqhsts[0] = (         int  )0;
    sqlstm.sqindv[0] = (         short *)0;
    sqlstm.sqinds[0] = (         int  )0;
    sqlstm.sqharm[0] = (unsigned long )0;
    sqlstm.sqadto[0] = (unsigned short )0;
    sqlstm.sqtdso[0] = (unsigned short )0;
    sqlstm.sqhstv[1] = (unsigned char  *)&since;
    sqlstm.sqhstl[1] = (unsigned long )sizeof(double);
    sqlstm.sqhsts[1] = (         int  )0;
    sqlstm.sqindv[1] = (         short *)0;
    sqlstm.sqinds[1] = (         int  )0;
    sqlstm.sqharm[1] = (unsigned long )0;
    sqlstm.sqadto[1] = (unsigned short )0;
    sqlstm.sqtdso[1] = (unsigned short )0;
    sqlstm.sqhstv[2] = (unsigned char  *)&until;
    sqlstm.sqhstl[2] = (unsigned long )sizeof(double);
    sqlstm.sqhsts[2] = (         int  )0;
    sqlstm.sqindv[2] = (         short *)0;
    sqlstm.sqinds[2] = (         int  )0;
    sqlstm.sqharm[2] = (unsigned long )0;
    sqlstm.sqadto[2] = (unsigned short )0;
    sqlstm.sqtdso[2] = (unsigned short )0;
    sqlstm.sqhstv[3] = (unsigned char  *)&context;
    sqlstm.sqhstl[3] = (unsigned long )sizeof(int);
    sqlstm.sqhsts[3] = (         int  )0;
    sqlstm.sqindv[3] = (         short *)0;
    sqlstm.sqinds[3] = (         int  )0;
    sqlstm.sqharm[3] = (unsigned long )0;
    sqlstm.sqadto[3] = (unsigned short )0;
    sqlstm.sqtdso[3] = (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("getVersion(HParSet*,Int_t&)");
}


  }
  version=vers;
  oraSet->versDate[0]=since;
  oraSet->versDate[1]=until;
  return kTRUE;
notfound:
  pPar->setInputVersion(-1,inputNumber);
  version=-1;
  return kFALSE;
};

Bool_t HShowerParOra2Io::read(HShowerCalPar* pPar, Int_t* set) {
  // reads the calibration parameters and fill the ShowerCalPar container
  Int_t oraVersion=-1;
  Bool_t rc=getVersion(pPar,oraVersion);
  if (oraVersion<0) return kFALSE;
  if (oraVersion>=0&&rc==kFALSE) return kTRUE;
  pPar->clear();
  initModules->Reset();
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int vers;
    struct {
      int p_sec[SHOWER_MAXARR];
      int p_mod[SHOWER_MAXARR];
      int p_col[SHOWER_MAXARR];
      int p_row[SHOWER_MAXARR];
      float slo[SHOWER_MAXARR];
      float ofs[SHOWER_MAXARR];
      float thr[SHOWER_MAXARR];
      float gai[SHOWER_MAXARR];
    } cal;
  /* EXEC SQL END DECLARE SECTION; */ 

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

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 

  /* EXEC SQL DECLARE cal_cur CURSOR FOR
    SELECT sector, module, pad_col, pad_row, slope, offset, threshold, gain
      FROM shower_ana2.shw_calpar_data_view
      WHERE vers_id = :vers; */ 

  Bool_t isOpenCursor=kFALSE;
  Bool_t allFound=kTRUE;
  Int_t s=-1, m=-1, nTot=0, nLast=0;
  HLocation loc;
  loc.setNIndex(4);
  HShowerCalParCell* pCell=0;
  vers=oraVersion;
  /* EXEC SQL OPEN cal_cur; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 13;
  sqlstm.arrsiz = 4;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = sq0002;
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )36;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.sqlpfmem = (unsigned int  )0;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)4352;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqcmod = (unsigned int )0;
  sqlstm.sqhstv[0] = (unsigned char  *)&vers;
  sqlstm.sqhstl[0] = (unsigned long )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )0;
  sqlstm.sqindv[0] = (         short *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned long )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("read(HShowerCalPar*,Int_t*)");
}


  isOpenCursor=kTRUE;
  do {
    /* EXEC SQL FETCH cal_cur INTO :cal; */ 

{
    struct sqlexd sqlstm;
    sqlorat((void **)0, &sqlctx, &oraca);
    sqlstm.sqlvsn = 13;
    sqlstm.arrsiz = 8;
    sqlstm.sqladtp = &sqladt;
    sqlstm.sqltdsp = &sqltds;
    sqlstm.iters = (unsigned int  )5000;
    sqlstm.offset = (unsigned int  )55;
    sqlstm.selerr = (unsigned short)1;
    sqlstm.sqlpfmem = (unsigned int  )0;
    sqlstm.cud = sqlcud0;
    sqlstm.sqlest = (unsigned char  *)&sqlca;
    sqlstm.sqlety = (unsigned short)4352;
    sqlstm.occurs = (unsigned int  )0;
    sqlstm.sqfoff = (         int )0;
    sqlstm.sqfmod = (unsigned int )2;
    sqlstm.sqhstv[0] = (unsigned char  *)cal.p_sec;
    sqlstm.sqhstl[0] = (unsigned long )sizeof(int);
    sqlstm.sqhsts[0] = (         int  )sizeof(int);
    sqlstm.sqindv[0] = (         short *)0;
    sqlstm.sqinds[0] = (         int  )0;
    sqlstm.sqharm[0] = (unsigned long )0;
    sqlstm.sqharc[0] = (unsigned long  *)0;
    sqlstm.sqadto[0] = (unsigned short )0;
    sqlstm.sqtdso[0] = (unsigned short )0;
    sqlstm.sqhstv[1] = (unsigned char  *)cal.p_mod;
    sqlstm.sqhstl[1] = (unsigned long )sizeof(int);
    sqlstm.sqhsts[1] = (         int  )sizeof(int);
    sqlstm.sqindv[1] = (         short *)0;
    sqlstm.sqinds[1] = (         int  )0;
    sqlstm.sqharm[1] = (unsigned long )0;
    sqlstm.sqharc[1] = (unsigned long  *)0;
    sqlstm.sqadto[1] = (unsigned short )0;
    sqlstm.sqtdso[1] = (unsigned short )0;
    sqlstm.sqhstv[2] = (unsigned char  *)cal.p_col;
    sqlstm.sqhstl[2] = (unsigned long )sizeof(int);
    sqlstm.sqhsts[2] = (         int  )sizeof(int);
    sqlstm.sqindv[2] = (         short *)0;
    sqlstm.sqinds[2] = (         int  )0;
    sqlstm.sqharm[2] = (unsigned long )0;
    sqlstm.sqharc[2] = (unsigned long  *)0;
    sqlstm.sqadto[2] = (unsigned short )0;
    sqlstm.sqtdso[2] = (unsigned short )0;
    sqlstm.sqhstv[3] = (unsigned char  *)cal.p_row;
    sqlstm.sqhstl[3] = (unsigned long )sizeof(int);
    sqlstm.sqhsts[3] = (         int  )sizeof(int);
    sqlstm.sqindv[3] = (         short *)0;
    sqlstm.sqinds[3] = (         int  )0;
    sqlstm.sqharm[3] = (unsigned long )0;
    sqlstm.sqharc[3] = (unsigned long  *)0;
    sqlstm.sqadto[3] = (unsigned short )0;
    sqlstm.sqtdso[3] = (unsigned short )0;
    sqlstm.sqhstv[4] = (unsigned char  *)cal.slo;
    sqlstm.sqhstl[4] = (unsigned long )sizeof(float);
    sqlstm.sqhsts[4] = (         int  )sizeof(float);
    sqlstm.sqindv[4] = (         short *)0;
    sqlstm.sqinds[4] = (         int  )0;
    sqlstm.sqharm[4] = (unsigned long )0;
    sqlstm.sqharc[4] = (unsigned long  *)0;
    sqlstm.sqadto[4] = (unsigned short )0;
    sqlstm.sqtdso[4] = (unsigned short )0;
    sqlstm.sqhstv[5] = (unsigned char  *)cal.ofs;
    sqlstm.sqhstl[5] = (unsigned long )sizeof(float);
    sqlstm.sqhsts[5] = (         int  )sizeof(float);
    sqlstm.sqindv[5] = (         short *)0;
    sqlstm.sqinds[5] = (         int  )0;
    sqlstm.sqharm[5] = (unsigned long )0;
    sqlstm.sqharc[5] = (unsigned long  *)0;
    sqlstm.sqadto[5] = (unsigned short )0;
    sqlstm.sqtdso[5] = (unsigned short )0;
    sqlstm.sqhstv[6] = (unsigned char  *)cal.thr;
    sqlstm.sqhstl[6] = (unsigned long )sizeof(float);
    sqlstm.sqhsts[6] = (         int  )sizeof(float);
    sqlstm.sqindv[6] = (         short *)0;
    sqlstm.sqinds[6] = (         int  )0;
    sqlstm.sqharm[6] = (unsigned long )0;
    sqlstm.sqharc[6] = (unsigned long  *)0;
    sqlstm.sqadto[6] = (unsigned short )0;
    sqlstm.sqtdso[6] = (unsigned short )0;
    sqlstm.sqhstv[7] = (unsigned char  *)cal.gai;
    sqlstm.sqhstl[7] = (unsigned long )sizeof(float);
    sqlstm.sqhsts[7] = (         int  )sizeof(float);
    sqlstm.sqindv[7] = (         short *)0;
    sqlstm.sqinds[7] = (         int  )0;
    sqlstm.sqharm[7] = (unsigned long )0;
    sqlstm.sqharc[7] = (unsigned long  *)0;
    sqlstm.sqadto[7] = (unsigned short )0;
    sqlstm.sqtdso[7] = (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(HShowerCalPar*,Int_t*)");
}


    nLast=sqlca.sqlerrd[2]-nTot;
    if (nLast>0) {
      for (Int_t i=0;i<nLast;i++) {
        s=cal.p_sec[i]-1;
        m=cal.p_mod[i];
        if (set[s*3+m]) {
          loc[0] = s;
          loc[1] = m;
          loc[2] = cal.p_row[i];
          loc[3] = cal.p_col[i];
          pCell = (HShowerCalParCell*)pPar->getSlot(loc);
          if (pCell) {
            pCell = new(pCell) HShowerCalParCell;
            pCell->setSlope(cal.slo[i]);
            pCell->setOffset(cal.ofs[i]);
            pCell->setThreshold(cal.thr[i]);
            pCell->setGain(cal.gai[i]);
          } else {
            Error("read(HShowerCalPar*,Int_t*)",
                  "slot not found:  %i %i %i %i",loc[0],loc[1],loc[2],loc[3]);

            allFound=kFALSE;
            break;
          }
          initModules->AddAt(1,s*3+m);
        }
        nTot++;
      }
    }
  } while (nLast==SHOWER_MAXARR&&nTot<=20000&&allFound);
  if (isOpenCursor) {
    /* EXEC SQL CLOSE cal_cur; */ 

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


    for(Int_t i=0;i<SHOWER_MAXMODS;i++) {
      if (set[i]>0 && initModules->At(i)==0) allFound=kFALSE;
    }
  } else allFound=kFALSE;
  if (allFound) {
    setChanged(pPar,oraVersion);
    printInfo(pPar->GetName());
  } else {
    pPar->setInputVersion(-1,inputNumber);
  }
  return allFound;
}


Bool_t HShowerParOra2Io::read(HShowerGeomPar* pPar, Int_t* set) {
  // reads the geometry of the Shower and fills the ShowerGeomPar container
  Bool_t allFound=kTRUE;
  Int_t detId=-1;
  if (!geomVers) {
    detId=getDetectorId(pPar->getDetectorName());
    geomVers=new HOra2GeomDetVersion(pPar->getDetectorName(),detId);
  } else {
    detId=geomVers->getDetectorId();
  }
  if (detId<=0) {
    allFound=kFALSE;
    delete geomVers;
    geomVers=0;
  }
  if (detId>0&&pPar->isFirstInitialization()) {
    if (!readGeomNames(pPar,set)) {
      allFound=kFALSE;
      pPar->clear();
    } else addGeomOraSet(pPar);
  }  
  if (allFound) allFound=readDetectorGeometry(pPar,set,geomVers);
  return allFound;    
}

Bool_t HShowerParOra2Io::readGeomNames(HShowerGeomPar* pPar,Int_t* set) {
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    struct {
      int id[SHOWER_MAXMODS];
      int sector[SHOWER_MAXMODS];
      int module[SHOWER_MAXMODS];
      /* varchar modName[SHOWER_MAXMODS][9]; */ 
struct { unsigned short len; unsigned char arr[10]; } modName[18];

      /* varchar compName[SHOWER_MAXMODS][9]; */ 
struct { unsigned short len; unsigned char arr[10]; } compName[18];

    } mods;
    struct {
      short id_Ind[SHOWER_MAXMODS];
      short sector_Ind[SHOWER_MAXMODS];
      short module_Ind[SHOWER_MAXMODS];
      short modName_Ind[SHOWER_MAXMODS];
      short compName_Ind[SHOWER_MAXMODS];
    } mods_Ind;
  /* EXEC SQL END DECLARE SECTION; */ 

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

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 


  /* EXEC SQL SELECT module_id, sector, module, geom_module_name, geom_component_name
           INTO :mods INDICATOR :mods_Ind
           FROM shower_ana2.shw_setup_at_date; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 13;
  sqlstm.arrsiz = 8;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "select module_id ,sector ,module ,geom_module_name ,geom_co\
mponent_name into :s1:s2 ,:s3:s4 ,:s5:s6 ,:s7:s8 ,:s9:s10   from shower_ana2.s\
hw_setup_at_date ";
  sqlstm.iters = (unsigned int  )18;
  sqlstm.offset = (unsigned int  )117;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.sqlpfmem = (unsigned int  )0;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)4352;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (unsigned char  *)mods.id;
  sqlstm.sqhstl[0] = (unsigned long )sizeof(int);
  sqlstm.sqhsts[0] = (         int  )sizeof(int);
  sqlstm.sqindv[0] = (         short *)mods_Ind.id_Ind;
  sqlstm.sqinds[0] = (         int  )sizeof(short);
  sqlstm.sqharm[0] = (unsigned long )0;
  sqlstm.sqharc[0] = (unsigned long  *)0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (unsigned char  *)mods.sector;
  sqlstm.sqhstl[1] = (unsigned long )sizeof(int);
  sqlstm.sqhsts[1] = (         int  )sizeof(int);
  sqlstm.sqindv[1] = (         short *)mods_Ind.sector_Ind;
  sqlstm.sqinds[1] = (         int  )sizeof(short);
  sqlstm.sqharm[1] = (unsigned long )0;
  sqlstm.sqharc[1] = (unsigned long  *)0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqhstv[2] = (unsigned char  *)mods.module;
  sqlstm.sqhstl[2] = (unsigned long )sizeof(int);
  sqlstm.sqhsts[2] = (         int  )sizeof(int);
  sqlstm.sqindv[2] = (         short *)mods_Ind.module_Ind;
  sqlstm.sqinds[2] = (         int  )sizeof(short);
  sqlstm.sqharm[2] = (unsigned long )0;
  sqlstm.sqharc[2] = (unsigned long  *)0;
  sqlstm.sqadto[2] = (unsigned short )0;
  sqlstm.sqtdso[2] = (unsigned short )0;
  sqlstm.sqhstv[3] = (unsigned char  *)mods.modName;
  sqlstm.sqhstl[3] = (unsigned long )11;
  sqlstm.sqhsts[3] = (         int  )12;
  sqlstm.sqindv[3] = (         short *)mods_Ind.modName_Ind;
  sqlstm.sqinds[3] = (         int  )sizeof(short);
  sqlstm.sqharm[3] = (unsigned long )0;
  sqlstm.sqharc[3] = (unsigned long  *)0;
  sqlstm.sqadto[3] = (unsigned short )0;
  sqlstm.sqtdso[3] = (unsigned short )0;
  sqlstm.sqhstv[4] = (unsigned char  *)mods.compName;
  sqlstm.sqhstl[4] = (unsigned long )11;
  sqlstm.sqhsts[4] = (         int  )12;
  sqlstm.sqindv[4] = (         short *)mods_Ind.compName_Ind;
  sqlstm.sqinds[4] = (         int  )sizeof(short);
  sqlstm.sqharm[4] = (unsigned long )0;
  sqlstm.sqharc[4] = (unsigned long  *)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("readGeomNames()");
}


  Int_t pos, sec, mod;
  Char_t ref[10];
  initModules->Reset();
  for(Int_t i=0;i<sqlca.sqlerrd[2];i++) {
    sec=mods.sector[i]-1;
    mod=mods.module[i];
    HModGeomPar* pMod=pPar->getModule(sec,mod);
    pos=sec*SHOWER_MAXSECMODS + mod;
    if (pMod && set[pos]) {
      if (mods_Ind.modName_Ind[i]!=-1) {
        mods.modName[i].arr[mods.modName[i].len]='\0';
        pMod->SetName((Char_t*)(mods.modName[i].arr));
        initModules->AddAt(pos+1,pos);
        strcpy(ref,(Char_t*)(mods.modName[i].arr));
        ref[4]='1'; // reference module in sector 1
                    // not yet introduced in database
        pMod->setRefName(ref);
        Int_t mr=pPar->getModNumInMod(ref);
        HGeomCompositeVolume* refMod=pPar->getRefVolume(mr);
        if (refMod==0) {
          refMod=new HGeomCompositeVolume(pPar->getNumComponents());
          refMod->SetName(ref);
          pPar->addRefVolume(refMod,mr);
        }
        pMod->setVolume(refMod);
        //In Shower case this is  a wires plane (3)
        if (mods_Ind.compName_Ind[i]!=-1) {
          HGeomVolume* volu=refMod->getComponent(0);
          mods.compName[i].arr[mods.compName[i].len]='\0';
          volu->SetName((Char_t*)(mods.compName[i].arr));          
        }
      }
    }
  }
  Bool_t allFound=kTRUE;
  for(Int_t i=0;i<SHOWER_MAXMODS;i++) {
    if (set[i]>0 && initModules->At(i)==0) allFound=kFALSE;
  }
  return allFound;
}

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

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

  context = getContextId(contName,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; */ 

  if (strcmp(contName,"HShowerCalPar")==0) {
    /* EXEC SQL EXECUTE
      BEGIN
        SELECT shower_ana2.shower_par_query.next_version INTO :vers FROM DUAL;
        INSERT INTO shower_ana2.shw_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 = 13;
    sqlstm.arrsiz = 8;
    sqlstm.sqladtp = &sqladt;
    sqlstm.sqltdsp = &sqltds;
    sqlstm.stmt = "begin SELECT shower_ana2 . shower_par_query . next_versio\
n INTO :vers FROM DUAL ; INSERT INTO shower_ana2 . shw_calpar_vers ( vers_id ,\
 orig_context_id , run_id , author , description ) VALUES ( :vers , :context ,\
 :run , :creator , :descript ) ; END ;";
    sqlstm.iters = (unsigned int  )1;
    sqlstm.offset = (unsigned int  )152;
    sqlstm.cud = sqlcud0;
    sqlstm.sqlest = (unsigned char  *)&sqlca;
    sqlstm.sqlety = (unsigned short)4352;
    sqlstm.occurs = (unsigned int  )0;
    sqlstm.sqhstv[0] = (unsigned char  *)&vers;
    sqlstm.sqhstl[0] = (unsigned long )sizeof(int);
    sqlstm.sqhsts[0] = (         int  )0;
    sqlstm.sqindv[0] = (         short *)0;
    sqlstm.sqinds[0] = (         int  )0;
    sqlstm.sqharm[0] = (unsigned long )0;
    sqlstm.sqadto[0] = (unsigned short )0;
    sqlstm.sqtdso[0] = (unsigned short )0;
    sqlstm.sqhstv[1] = (unsigned char  *)&context;
    sqlstm.sqhstl[1] = (unsigned long )sizeof(int);
    sqlstm.sqhsts[1] = (         int  )0;
    sqlstm.sqindv[1] = (         short *)0;
    sqlstm.sqinds[1] = (         int  )0;
    sqlstm.sqharm[1] = (unsigned long )0;
    sqlstm.sqadto[1] = (unsigned short )0;
    sqlstm.sqtdso[1] = (unsigned short )0;
    sqlstm.sqhstv[2] = (unsigned char  *)&run;
    sqlstm.sqhstl[2] = (unsigned long )sizeof(int);
    sqlstm.sqhsts[2] = (         int  )0;
    sqlstm.sqindv[2] = (         short *)0;
    sqlstm.sqinds[2] = (         int  )0;
    sqlstm.sqharm[2] = (unsigned long )0;
    sqlstm.sqadto[2] = (unsigned short )0;
    sqlstm.sqtdso[2] = (unsigned short )0;
    sqlstm.sqhstv[3] = (unsigned char  *)creator;
    sqlstm.sqhstl[3] = (unsigned long )0;
    sqlstm.sqhsts[3] = (         int  )0;
    sqlstm.sqindv[3] = (         short *)0;
    sqlstm.sqinds[3] = (         int  )0;
    sqlstm.sqharm[3] = (unsigned long )0;
    sqlstm.sqadto[3] = (unsigned short )0;
    sqlstm.sqtdso[3] = (unsigned short )0;
    sqlstm.sqhstv[4] = (unsigned char  *)descript;
    sqlstm.sqhstl[4] = (unsigned long )0;
    sqlstm.sqhsts[4] = (         int  )0;
    sqlstm.sqindv[4] = (         short *)0;
    sqlstm.sqinds[4] = (         int  )0;
    sqlstm.sqharm[4] = (unsigned long )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()");
  return -1;
}

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

    int p_sec[SHOWER_MAXARR];
    int p_mod[SHOWER_MAXARR];
    int p_col[SHOWER_MAXARR];
    int p_row[SHOWER_MAXARR];
    int vers[SHOWER_MAXPADS];
    float slo[SHOWER_MAXPADS];
    float ofs[SHOWER_MAXPADS];
    float trh[SHOWER_MAXPADS];
    float gai[SHOWER_MAXPADS];
    int rows_to_insert;
  /* EXEC SQL END DECLARE SECTION; */ 

  HLocation loc;
  loc.set(4,0,0,0,0);
  HShowerCalParCell* pCell=0;
  Float_t cs=0, co=0, cg=0, ct=0;
  for(Int_t s=0;s<pPar->getNSectors();s++){ 
    for(Int_t m=0;m<pPar->getNModules();m++){ 
      Int_t nCell=-1;
      Int_t sId=(s+1)*10+m;
      if (sId>0){ 
        loc[0] = s;
        loc[1] = m;
        for(Int_t r=0;r<pPar->getNRows();r++) {
          loc[2]=r;
          for(Int_t c=0;c<pPar->getNColumns();c++){ 
            loc[3]=c;
            pCell = (HShowerCalParCell*)pPar->getObject(loc);
            if (pCell) {
              cs=pCell->getSlope();
              co=pCell->getOffset();
              ct=pCell->getThreshold();
              cg=pCell->getGain();
              if (co!=0 || cs!=1) { // only non-default values
                nCell++;
                if (nCell==SHOWER_MAXPADS) {
                  Error("writePar(HShowerCalPar*)","\n Number of Pads > 1024\n");
                  rollback();
                  return -1;
                }
                p_sec[nCell]=s+1;
                p_mod[nCell]=m;
                p_row[nCell]=r;
                p_col[nCell]=c;
                vers[nCell]=version;
                slo[nCell]=cs;
                ofs[nCell]=co;
                trh[nCell]=ct;
                gai[nCell]=cg;
              }
            }
          }
        }
      }
      if (nCell==-1) continue;
      rows_to_insert=nCell+1;
      /* EXEC SQL WHENEVER SQLERROR GOTO not_found; */ 

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

      /* EXEC SQL FOR :rows_to_insert
        INSERT INTO shower_ana2.shw_calpar_data
            (vers_id, pad_id, slope, offset,threshold,gain )
            VALUES (:vers,
                    shower_ana2.shower_par_query.get_pad_id(:p_sec,:p_mod,:p_row,:p_col),
                    :slo, :ofs, :trh,:gai); */ 

{
      struct sqlexd sqlstm;
      sqlorat((void **)0, &sqlctx, &oraca);
      sqlstm.sqlvsn = 13;
      sqlstm.arrsiz = 9;
      sqlstm.sqladtp = &sqladt;
      sqlstm.sqltdsp = &sqltds;
      sqlstm.stmt = "insert into shower_ana2.shw_calpar_data (vers_id,pad_id\
,slope,offset,threshold,gain) values (:b1,shower_ana2.shower_par_query.get_pad\
_id(:b2,:b3,:b4,:b5),:b6,:b7,:b8,:b9)";
      sqlstm.iters = (unsigned int  )rows_to_insert;
      sqlstm.offset = (unsigned int  )187;
      sqlstm.cud = sqlcud0;
      sqlstm.sqlest = (unsigned char  *)&sqlca;
      sqlstm.sqlety = (unsigned short)4352;
      sqlstm.occurs = (unsigned int  )0;
      sqlstm.sqhstv[0] = (unsigned char  *)vers;
      sqlstm.sqhstl[0] = (unsigned long )sizeof(int);
      sqlstm.sqhsts[0] = (         int  )sizeof(int);
      sqlstm.sqindv[0] = (         short *)0;
      sqlstm.sqinds[0] = (         int  )0;
      sqlstm.sqharm[0] = (unsigned long )0;
      sqlstm.sqharc[0] = (unsigned long  *)0;
      sqlstm.sqadto[0] = (unsigned short )0;
      sqlstm.sqtdso[0] = (unsigned short )0;
      sqlstm.sqhstv[1] = (unsigned char  *)p_sec;
      sqlstm.sqhstl[1] = (unsigned long )sizeof(int);
      sqlstm.sqhsts[1] = (         int  )sizeof(int);
      sqlstm.sqindv[1] = (         short *)0;
      sqlstm.sqinds[1] = (         int  )0;
      sqlstm.sqharm[1] = (unsigned long )0;
      sqlstm.sqharc[1] = (unsigned long  *)0;
      sqlstm.sqadto[1] = (unsigned short )0;
      sqlstm.sqtdso[1] = (unsigned short )0;
      sqlstm.sqhstv[2] = (unsigned char  *)p_mod;
      sqlstm.sqhstl[2] = (unsigned long )sizeof(int);
      sqlstm.sqhsts[2] = (         int  )sizeof(int);
      sqlstm.sqindv[2] = (         short *)0;
      sqlstm.sqinds[2] = (         int  )0;
      sqlstm.sqharm[2] = (unsigned long )0;
      sqlstm.sqharc[2] = (unsigned long  *)0;
      sqlstm.sqadto[2] = (unsigned short )0;
      sqlstm.sqtdso[2] = (unsigned short )0;
      sqlstm.sqhstv[3] = (unsigned char  *)p_row;
      sqlstm.sqhstl[3] = (unsigned long )sizeof(int);
      sqlstm.sqhsts[3] = (         int  )sizeof(int);
      sqlstm.sqindv[3] = (         short *)0;
      sqlstm.sqinds[3] = (         int  )0;
      sqlstm.sqharm[3] = (unsigned long )0;
      sqlstm.sqharc[3] = (unsigned long  *)0;
      sqlstm.sqadto[3] = (unsigned short )0;
      sqlstm.sqtdso[3] = (unsigned short )0;
      sqlstm.sqhstv[4] = (unsigned char  *)p_col;
      sqlstm.sqhstl[4] = (unsigned long )sizeof(int);
      sqlstm.sqhsts[4] = (         int  )sizeof(int);
      sqlstm.sqindv[4] = (         short *)0;
      sqlstm.sqinds[4] = (         int  )0;
      sqlstm.sqharm[4] = (unsigned long )0;
      sqlstm.sqharc[4] = (unsigned long  *)0;
      sqlstm.sqadto[4] = (unsigned short )0;
      sqlstm.sqtdso[4] = (unsigned short )0;
      sqlstm.sqhstv[5] = (unsigned char  *)slo;
      sqlstm.sqhstl[5] = (unsigned long )sizeof(float);
      sqlstm.sqhsts[5] = (         int  )sizeof(float);
      sqlstm.sqindv[5] = (         short *)0;
      sqlstm.sqinds[5] = (         int  )0;
      sqlstm.sqharm[5] = (unsigned long )0;
      sqlstm.sqharc[5] = (unsigned long  *)0;
      sqlstm.sqadto[5] = (unsigned short )0;
      sqlstm.sqtdso[5] = (unsigned short )0;
      sqlstm.sqhstv[6] = (unsigned char  *)ofs;
      sqlstm.sqhstl[6] = (unsigned long )sizeof(float);
      sqlstm.sqhsts[6] = (         int  )sizeof(float);
      sqlstm.sqindv[6] = (         short *)0;
      sqlstm.sqinds[6] = (         int  )0;
      sqlstm.sqharm[6] = (unsigned long )0;
      sqlstm.sqharc[6] = (unsigned long  *)0;
      sqlstm.sqadto[6] = (unsigned short )0;
      sqlstm.sqtdso[6] = (unsigned short )0;
      sqlstm.sqhstv[7] = (unsigned char  *)trh;
      sqlstm.sqhstl[7] = (unsigned long )sizeof(float);
      sqlstm.sqhsts[7] = (         int  )sizeof(float);
      sqlstm.sqindv[7] = (         short *)0;
      sqlstm.sqinds[7] = (         int  )0;
      sqlstm.sqharm[7] = (unsigned long )0;
      sqlstm.sqharc[7] = (unsigned long  *)0;
      sqlstm.sqadto[7] = (unsigned short )0;
      sqlstm.sqtdso[7] = (unsigned short )0;
      sqlstm.sqhstv[8] = (unsigned char  *)gai;
      sqlstm.sqhstl[8] = (unsigned long )sizeof(float);
      sqlstm.sqhsts[8] = (         int  )sizeof(float);
      sqlstm.sqindv[8] = (         short *)0;
      sqlstm.sqinds[8] = (         int  )0;
      sqlstm.sqharm[8] = (unsigned long )0;
      sqlstm.sqharc[8] = (unsigned long  *)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 == 1403) goto not_found;
      if (sqlca.sqlcode < 0) goto not_found;
}


      cout<<"sector: "<<s<<" module: "<<m<<"    "<<rows_to_insert<<" rows inserted\n";
    }
  }
  cout<<"****************************************************************\n";
  commit();
  pPar->setChanged(kFALSE);
  return version;
not_found:
  showSqlError("writePar(HShowerCalPar*)");
  rollback();
  return -1;
}
  
void HShowerParOra2Io::printInfo(const Char_t* contName) {
  // prints the modules initialized from Oracle
  Bool_t first=kTRUE;
  cout<<'\n';
  for(Int_t i=0;i<SHOWER_MAXMODS;i++) {
    if (initModules->At(i)>0) {
      if (first) {
        cout<<contName<<": modules(s) initialized from Oracle: ";
        first=kFALSE;
      }
      cout<<i<<" ";
    }
  }
  cout<<endl;
}





/*
Bool_t HShowerParOra2Io::fillGeom(HShowerGeometry* pPar){
  //Function for calculating the module centers and tranformation used in analysis
  //(corresponding to the PAD_FIBREs)
  //For more info see documentation:
  //http://hades.if.uj.edu.pl/docs/shower/geometry
  HGeomVector vm[3] = { HGeomVector(0.000 , 0.00 ,  -4.0), 
                        HGeomVector(0.000 , 0.00 ,  67.6), 
                        HGeomVector(0.000 , 0.00 , 134.9)};
  pPar->m_nSectors = pPar->getMaxSectors();
  pPar->m_nModules = pPar->getMaxModules();
  pPar->m_nRows = 32; //! 
  pPar->m_nColumns = 32;//!
  pPar->m_nLab = 1;//!
  Int_t angle[6] = {0,300,240,180,120,60};
  for (Int_t s=0;s<pPar->getMaxSectors();s++){
    pPar->sectors[s].reset();
    pPar->sectors[s].setAngleRot(angle[s]);
    pPar->sectors[s].transform.setRotMatrix(
                     pPar->getModule(s,0)->getLabTransform().getRotMatrix());
    pPar->sectors[s].transform.setTransVector(
                     pPar->getModule(s,0)->getLabTransform().getTransVector());
    for(Int_t m=0;m<pPar->getMaxModules();m++){
      HModGeomPar* pMod = pPar->getModule(s,m);
      HShowerModuleGeom *pModGeom = new HShowerModuleGeom;
      pModGeom->setModuleID(m);
      HGeomRotation rotM = pMod->getLabTransform().getRotMatrix();
      pModGeom->transform.setRotMatrix(pMod->getLabTransform().getRotMatrix());
      HGeomVector v = pMod->getLabTransform().getTransVector();
      HGeomVector v_mod = rotM*vm[m]+v;
      //set new vector for modules;
      pModGeom->transform.setTransVector(v_mod);
      pPar->sectors[s].addModule(pModGeom);
    }  
  }
  HGeomVector *points[4];
  HShowerFrameCorner *pFC;

  for(Int_t m = 0; m < 3; m++) {
    HGeomCompositeVolume* refMod=pPar->getRefVolume(m);
    HGeomVolume *comp = refMod->getComponent(0);//only one comp; wires plane
    points[0] = comp->getPoint(3);//geant coordinate system is left-handed!! 
    points[1] = comp->getPoint(2);//
    points[2] = comp->getPoint(1);//
    points[3] = comp->getPoint(0);//
    pPar->frames[m].reset();
    pPar->frames[m].setModuleID(m);
    for (Int_t i=0;i<4;i++){
      pFC = new HShowerFrameCorner;
      pFC->setX(points[i]->getX()*0.1);
      pFC->setY(points[i]->getY()*0.1);
      if(i==0 || i==3) pFC->setFlagArea(1);
      else pFC->setFlagArea(0);
      pPar->frames[m].addCorner(pFC);
    }
  }
  if(!readGeom(pPar)) return kFALSE;
  pPar->attachTables(); 
  return kTRUE;
}


Bool_t HShowerParOra2Io::readGeom(HShowerGeometry* pPar){
  //Function for reading information about pads, wires etc.
  //which is not accesible via HDetGeomPar interface
  EXEC SQL BEGIN DECLARE SECTION;
    struct  {
      int id[267]; //3*89 wires
      int wire_id[267];
      float wire_coord[267];
      float distance[267];
      int   module_type_id[267];
    }wire;
    struct {
      int id[SHOWER_MAXPADS];
      int module_type_id[SHOWER_MAXPADS];
      float x_ld[SHOWER_MAXPADS];
      float x_lu[SHOWER_MAXPADS];
      float x_rd[SHOWER_MAXPADS];
      float x_ru[SHOWER_MAXPADS];
      float y_ld[SHOWER_MAXPADS];
      float y_lu[SHOWER_MAXPADS];
      float y_rd[SHOWER_MAXPADS];
      float y_ru[SHOWER_MAXPADS];
      int pad_flag[SHOWER_MAXPADS];
      int linked_to[SHOWER_MAXPADS] ;
    }data;
    int mod_id;
  EXEC SQL END DECLARE SECTION;

  EXEC SQL WHENEVER SQLERROR DO showSqlError("readWires()");
  EXEC SQL WHENEVER NOT FOUND CONTINUE;
  EXEC SQL DECLARE pad_cur CURSOR FOR
            SELECT id,module_type_id,
                   X_LD,Y_LD, X_LU, Y_LU, X_RD,Y_RD, X_RU,Y_RU,PAD_FLAG,LINKED_TO  
            FROM shower_ana.shw_pad_geom
            WHERE module_type_id= :mod_id;
  Int_t l;
  for(Int_t m=0;m<3;m++){  //3 modules 0,1,2
    mod_id=m;
    EXEC SQL OPEN pad_cur;
    EXEC SQL FETCH pad_cur INTO :data;
    Int_t nPads = sqlca.sqlerrd[2];
    pPar->pads[m].createPads(32,32);
    pPar->pads[m].setModuleID(m);
    HShowerPad* p = new HShowerPad;
    for(Int_t i=0; i <nPads; i++) {
      p->setPadNr((data.id[i]-1)-(m*1024));
      pPar->pads[m].setPad(p, (data.id[i]-1)-(m*1024));
    }
    delete p;
    for(Int_t n=0; n<nPads;n++){
      HShowerPad* pad = pPar->pads[m].getPad((data.id[n]-1)-(m*1024));
      if(pad){
        pad->fXld = data.x_ld[n];
        pad->fYld = data.x_lu[n];
        pad->fXlu = data.x_rd[n];
        pad->fYlu = data.x_ru[n];
        pad->fXrd = data.y_ld[n];
        pad->fYrd = data.y_lu[n];
        pad->fXru = data.y_rd[n];
        pad->fYru = data.y_ru[n];
        pPar->pads[m].setFrame(pPar->getFrame(m));
        //Calculate pad flag (0,1,2)  
        HShowerFrame* phFrame = pPar->pads[m].getFrame();
        if ((!phFrame->isOut(pad->fXld, pad->fYld)) &&
            (!phFrame->isOut(pad->fXlu, pad->fYlu)) &&
            (!phFrame->isOut(pad->fXru, pad->fYru)) &&
            (!phFrame  ->isOut(pad->fXrd, pad->fYrd))) {
          pad->setPadFlag(1);
        } else if (!phFrame->isOut(pad->fXld, pad->fYld) ||
                   !phFrame->isOut(pad->fXlu, pad->fYlu) ||
                   !phFrame->isOut(pad->fXru, pad->fYru) ||
                   !phFrame->isOut(pad->fXrd, pad->fYrd)) {
          pad->setPadFlag(2);
        } else {
          pad->setPadFlag(0);
        }

        pad->setLinkedNr(data.pad_flag[n]);
        if (pad->getLinkedNr()) {
          if (pad->linkPad) delete [] pad->linkPad;
          pad->linkPad = new HShowerPad*[pad->getLinkedNr()];
          for (Int_t k=0; k<pad->getLinkedNr(); k++) {
            l = data.linked_to[n];
            pad->linkPad[k] = pPar->pads[m].getPad(l);
          }
        }
      }
    }
  }
  EXEC SQL CLOSE pad_cur;
  EXEC SQL SELECT id,wire_id,wire_coord,distance,module_type_id
           INTO :wire
           FROM shower_ana.shw_wire
           ORDER BY id;
  HShowerWire* pWire;
  Int_t nWires = sqlca.sqlerrd[2];
  pPar->wires[0].reset();
  pPar->wires[1].reset();
  pPar->wires[2].reset();

  for(Int_t w=0;w<nWires;w++){
    pPar->wires[wire.module_type_id[w]].setModuleID(wire.module_type_id[w]);
    pWire = new HShowerWire;
    pWire->setNrWire(wire.wire_id[w]);
    pWire->setYWire(wire.wire_coord[w]);
    pPar->wires[wire.module_type_id[w]].setDistWire(wire.distance[w]);
    pPar->wires[wire.module_type_id[w]].addWire(pWire);
  }
  return kTRUE;
}                  

*/