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


static unsigned int sqlctx = 152587;


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[4];
   unsigned int   sqhstl[4];
            int   sqhsts[4];
            void  *sqindv[4];
            int   sqinds[4];
   unsigned int   sqharm[4];
   unsigned int   *sqharc[4];
   unsigned short  sqadto[4];
   unsigned short  sqtdso[4];
} sqlstm = {12,4};

// 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 *); }

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,0,0,27,110,0,0,4,4,0,1,0,1,97,0,0,1,97,0,0,1,10,0,0,1,10,0,0,
36,0,0,2,0,0,32,131,0,0,0,0,0,1,0,
51,0,0,3,0,0,32,147,0,0,0,0,0,1,0,
66,0,0,4,0,0,27,228,0,0,4,4,0,1,0,1,97,0,0,1,97,0,0,1,10,0,0,1,10,0,0,
97,0,0,5,56,0,6,245,0,0,1,1,0,1,0,2,3,0,0,
116,0,0,6,77,0,6,289,0,0,3,3,0,1,0,3,3,0,0,2,3,0,0,2,9,0,0,
143,0,0,7,152,0,6,326,0,0,2,2,0,1,0,1,97,0,0,2,97,0,0,
166,0,0,8,153,0,6,352,0,0,2,2,0,1,0,1,97,0,0,2,97,0,0,
189,0,0,9,159,0,6,379,0,0,2,2,0,1,0,1,3,0,0,2,97,0,0,
};


//*-- AUTHOR : Ilse Koenig
//*-- Modified : 12/06/2002 by Ilse Koenig

//_HADES_CLASS_DESCRIPTION 
/////////////////////////////////////////////////////////////
// HOraConn
//
// Connection class to database Oracle 
// (uses the Oracle C/C++ precompiler)
//
/////////////////////////////////////////////////////////////
using namespace std;
#include "horaconn.h"
#include "hades.h"
#include "hruntimedb.h"
#include "TRandom.h"
#include <stdio.h>
#include <iostream>
#include <iomanip>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

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

ClassImp(HOraConn)

HOraConn::HOraConn() {
  // default constructor
  // defines default values for user ("hades_ana") and the database
  //   ("db-hades", the HADES Oracle 8 database on Linux at GSI)
  // User "hades" has Readonly access to the Oracle tables.
  // The connection to Oracle is not opened!
  strcpy(dbName,"db-hades");
  strcpy(userName,"hades_ana");
  isConnected=kFALSE;
  actRunId=-1;
  runStart=-1;
  expLocation[0]='\0';
  historyDate[0]='\0';
  needsServerCheck=kTRUE;
}


HOraConn::~HOraConn() {
  // default destructor (closes connection)
  close();
}


Bool_t HOraConn::open() {
  // opens default connection with readonly access
  Char_t* password = new Char_t[9];
  strcpy(password,"hades");
  Bool_t rc=openConnection(password);
  if (!rc) close();
  return rc;
}

Bool_t HOraConn::open(Char_t *uName) {
  // opens connection to database Hades for user given by name
  // asks for password
  strncpy(userName,uName,20);
  Char_t* password=getPassword();
  Bool_t rc=openConnection(password);
  if (!rc) close();
  return rc;
}


Bool_t HOraConn::open(Char_t *dbN, Char_t *uN) {
  // opens connection to database with name dbName for user given by name
  // asks for password
  strncpy(dbName,dbN,30);
  strncpy(userName,uN,20);
  Char_t* password=getPassword();
  Bool_t rc=openConnection(password);
  if (!rc) close();
  return rc;
}


Bool_t HOraConn::reconnect() {
  // opens connection (contains the SQL-statements)
  if (isConnected) return kTRUE;
  if (strcmp(userName,"hades_ana")!=0) return kFALSE;
  Char_t connId[80];
  Char_t password[]={"hades"};
  strcpy(connId,userName);
  strcat(connId,"@");
  strcat(connId,dbName);    // e.g."hades_ana@db-hades"
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    char* uName;
    char* pWord;
  /* EXEC SQL END DECLARE SECTION; */ 

  uName=connId;
  pWord=password;
  /* EXEC SQL WHENEVER SQLERROR DO
    showSqlError("openConnection(Char_t*)","Wrong user/password"); */ 

  /* EXEC SQL CONNECT :uName IDENTIFIED BY :pWord; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 4;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.iters = (unsigned int  )10;
  sqlstm.offset = (unsigned int  )5;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)uName;
  sqlstm.sqhstl[0] = (unsigned int  )0;
  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  *)pWord;
  sqlstm.sqhstl[1] = (unsigned int  )0;
  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;
  sqlstm.sqlcmax = (unsigned int )100;
  sqlstm.sqlcmin = (unsigned int )2;
  sqlstm.sqlcincr = (unsigned int )1;
  sqlstm.sqlctimeout = (unsigned int )0;
  sqlstm.sqlcnowait = (unsigned int )0;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) showSqlError("openConnection(Char_t*)","Wrong user/password");
}


  if (sqlca.sqlcode==0) {
    isConnected=kTRUE;
    setHistoryDate(historyDate);
  } else Error("reconnect()","*** Failed to connect to Oracle ***");
  return isConnected; 
}


void HOraConn::close() {
  // disconnects from ORACLE
  // A transaction will be automatically rolled back,
  // that means changes in the database are not stored
  // without an explicit COMMIT
  actRunId=-1;
  runStart=-1;
  expLocation[0]='\0';
  historyDate[0]='\0';
  /* EXEC SQL WHENEVER SQLERROR DO
    showSqlError("close()"); */ 

  if (isConnected) {
    /* EXEC SQL ROLLBACK RELEASE; */ 

{
    struct sqlexd sqlstm;
    sqlorat((void **)0, &sqlctx, &oraca);
    sqlstm.sqlvsn = 12;
    sqlstm.arrsiz = 4;
    sqlstm.sqladtp = &sqladt;
    sqlstm.sqltdsp = &sqltds;
    sqlstm.iters = (unsigned int  )1;
    sqlstm.offset = (unsigned int  )36;
    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("close()");
}


    isConnected=kFALSE;
    cout<<"connection to Oracle closed"<<endl;
  }
  needsServerCheck=kTRUE;
}


void HOraConn::disconnect() {
  // disconnects from ORACLE
  // may be opened again via reconnect()
  if (isConnected) {
    actRunId=-1;
    runStart=-1;
    /* EXEC SQL WHENEVER SQLERROR DO
      showSqlError("disconnect()"); */ 

    /* EXEC SQL ROLLBACK RELEASE; */ 

{
    struct sqlexd sqlstm;
    sqlorat((void **)0, &sqlctx, &oraca);
    sqlstm.sqlvsn = 12;
    sqlstm.arrsiz = 4;
    sqlstm.sqladtp = &sqladt;
    sqlstm.sqltdsp = &sqltds;
    sqlstm.iters = (unsigned int  )1;
    sqlstm.offset = (unsigned int  )51;
    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("disconnect()");
}


    isConnected=kFALSE;
    cout<<"connection to Oracle closed"<<endl;
    needsServerCheck=kTRUE;
  }
}


void HOraConn::print() {
  // prints information about the database connection
  if (isConnected)
    cout<<"Oracle-Database: "<<dbName<<"    Username: "<<userName<<'\n';
  else cout<<"*** no connection to Oracle established  ***\n";
  if (strlen(historyDate)==0) cout<<"No history date set\n";
  else cout<<"History date: "<<historyDate<<'\n';
}


void HOraConn::showSqlError(const Char_t* fctName,const Char_t* msg) {
  // shows SQL error messages
  Char_t errmsg[513];
  size_t buflen, msglen;
  buflen=sizeof(errmsg)-1;
  sqlglm(errmsg,&buflen,&msglen);
  if ((++msglen)<buflen) {
    errmsg[msglen]='\0';
  } else {
    errmsg[buflen]='\0';
  }
  if (msg) {
    Error(fctName,"\n%s\n%s\n",errmsg,msg);
  } else {
    Error(fctName,"\n%s\n",errmsg);
  }
}


Char_t* HOraConn::getPassword() {
  // asks for the password
  Char_t* passwd = new Char_t[20];
  Char_t buf[20];
  Int_t ttyfd = 0;
  struct termios tio, itio;
  if ((ttyfd = ::open("/dev/tty", O_RDWR)) < 0) {
    fprintf(stderr, "cannot open tty, using stdin\n");
    ttyfd = 0;
  }
  if (tcgetattr(ttyfd, &tio) < 0) {
    fprintf (stderr, "\nUnable to get terminal characteristics: ");
    cout<<"enter password for user "<<userName<<" > ";
    scanf("%[^\n]%*c",passwd);
    return passwd; 
  }
  itio = tio;
  tio.c_lflag &= ~(ECHO|ICANON);         
  tcsetattr (ttyfd, TCSAFLUSH, &tio);
  cout<<"enter password for user "<<userName<<" > ";
  fgets(buf, 20, stdin);
  tcsetattr (ttyfd, TCSAFLUSH, &itio);
  //close(ttyfd);
  sscanf(buf, "%s", passwd);
  cout<<endl;
  return passwd;
}


Bool_t HOraConn::openConnection(Char_t* password) {
  // opens connection (contains the SQL-statements)
  if (isConnected) close();
  Char_t connId[80];
  strcpy(connId,userName);
  strcat(connId,"@");
  strcat(connId,dbName);    // e.g."hades_ana@hadp"
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    char* uName;
    char* pWord;
  /* EXEC SQL END DECLARE SECTION; */ 

  uName=connId;
  pWord=password;
  /* EXEC SQL WHENEVER SQLERROR DO
    showSqlError("openConnection(Char_t*)","Wrong user/password"); */ 

  /* EXEC SQL CONNECT :uName IDENTIFIED BY :pWord; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 4;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.iters = (unsigned int  )10;
  sqlstm.offset = (unsigned int  )66;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)uName;
  sqlstm.sqhstl[0] = (unsigned int  )0;
  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  *)pWord;
  sqlstm.sqhstl[1] = (unsigned int  )0;
  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;
  sqlstm.sqlcmax = (unsigned int )100;
  sqlstm.sqlcmin = (unsigned int )2;
  sqlstm.sqlcincr = (unsigned int )1;
  sqlstm.sqlctimeout = (unsigned int )0;
  sqlstm.sqlcnowait = (unsigned int )0;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) showSqlError("openConnection(Char_t*)","Wrong user/password");
}


  if (sqlca.sqlcode==0) isConnected=kTRUE;
  else cout<<"*** Failed to connect to Oracle ***"<<endl;
  delete [] password;
  actRunId=-1;
  runStart=0;
  expLocation[0]='\0';
  historyDate[0]='\0';
  alignmentOutVers=-1;
  return isConnected; 
}

Int_t HOraConn::checkServerLoad() {
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

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

  /* EXEC SQL WHENEVER SQLERROR GOTO notfound; */ 

  /* EXEC SQL EXECUTE
    BEGIN
      :retval := hanal.check_analysis_sessions;
    END;
  END-EXEC; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 4;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "begin :retval := hanal . check_analysis_sessions ; END ;";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )97;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)&retval;
  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 < 0) goto notfound;
}


  return retval;
notfound:
  showSqlError("checkServerLoad");
  return -1; 
}

Int_t HOraConn::getRunStart(Int_t id) {
  // Gets the actual run id from the current event file and compares it with
  // the last used actRunId for fetching data.
  // If they are different, the run start time (converted to ansi C time) is
  // read from Oracle and stored together with the run id in the data members
  // run_id and runStart
  if (id==actRunId && runStart!=0) return runStart;
  if (needsServerCheck) {
    Int_t l=0;
    UInt_t nTotWait=0;
    l=checkServerLoad();
    while (l==0&&nTotWait<86400000) {
      UInt_t nWait=10000+gRandom->Integer(20000);
      nTotWait+=nWait;
      cout<<"Oracle server busy, retry in "<<nWait/1000<<" seconds"<<endl;
      usleep(nWait*1000);
      l=checkServerLoad();
    }
    if (l>0) needsServerCheck=kFALSE;
    else return -1;
  }
  if (strlen(historyDate)==0) setParamRelease(id);
  actRunId=id;
  alignmentOutVers=-1;
  runStart=-1;
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int ri; 
    int rs;
    /* varchar exp_loc[11]; */ 
struct { unsigned short len; unsigned char arr[11]; } exp_loc;

  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR GOTO notfound; */ 

  ri = actRunId;
  exp_loc.len=11;
  /* EXEC SQL EXECUTE
    BEGIN
      hades_oper.run_query.get_run_start(:ri,:rs,:exp_loc);
    END;
  END-EXEC; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 4;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "begin hades_oper . run_query . get_run_start ( :ri , :rs , \
:exp_loc ) ; END ;";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )116;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)&ri;
  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  *)&rs;
  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  *)&exp_loc;
  sqlstm.sqhstl[2] = (unsigned int  )13;
  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.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) goto notfound;
}


  if (ri==(Int_t)actRunId) {
    runStart=rs;
    exp_loc.arr[exp_loc.len]='\0';
    if (strlen(expLocation)==0) strcpy(expLocation,(Char_t*)exp_loc.arr);
    else {
      if (strcmp(expLocation,(Char_t*)exp_loc.arr)!=0) {
        Error("getRunStart(Int_t)",
          "\nA switch from beamtime runs to simulations runs and vice versa is not "
          "possible\nwithout the close and reopen of the Oracle connection!\n\n");
        runStart=-1;
      }
    }
    /* cout<<"actRunId: "<<actRunId<<"   runStart: "<<runStart
           <<"   expLocation: "<<expLocation<<endl; */
    return runStart;
  }
notfound:
  Error("getRunStart(Int_t)","Run not found!\n\n");
  return -1; 
}


Bool_t HOraConn::setHistoryDate(const Char_t* dateString) {
  // Sets the date to retrieve historic data
  // Returns kFALSE when the date string cannot be converted to a valid date.
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    char* d;
    char rd[21];
  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR GOTO notfound; */ 

  d=(Char_t*)dateString;
  rd[0]='\0';
  /* EXEC SQL EXECUTE
    BEGIN
      hades_oper.run_query.set_history_date(:d);
      :rd := to_char(hades_oper.run_query.get_history_date,'DD-MON-YYYY HH24:MI:SS');
    END;
  END-EXEC; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 4;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "begin hades_oper . run_query . set_history_date ( :d ) ; :r\
d := to_char ( hades_oper . run_query . get_history_date , 'DD-MON-YYYY HH24:M\
I:SS' ) ; END ;";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )143;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)d;
  sqlstm.sqhstl[0] = (unsigned int  )0;
  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  *)rd;
  sqlstm.sqhstl[1] = (unsigned int  )21;
  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) goto notfound;
}


  rd[20]='\0';
  strcpy(historyDate,rd);
  cout<<"*************************************************************\n";
  cout<<"     Oracle history date: "<<historyDate<<"\n";
  cout<<"*************************************************************\n";
  return kTRUE;
notfound:
  showSqlError("setHistoryDate(Int_t)");
  return kFALSE;
}

Bool_t HOraConn::setParamRelease(const Char_t* release_name) {
  // Sets the history date to the creation date of the parameter release give by name
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    char* r;
    char rd[21];
  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR GOTO notfound; */ 

  rd[0]='\0';	
  r=(Char_t*)release_name;
  /* EXEC SQL EXECUTE
    BEGIN
      hades_oper.run_query.set_param_release(:r);
      :rd := to_char(hades_oper.run_query.get_history_date,'DD-MON-YYYY HH24:MI:SS');
    END;
  END-EXEC; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 4;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "begin hades_oper . run_query . set_param_release ( :r ) ; :\
rd := to_char ( hades_oper . run_query . get_history_date , 'DD-MON-YYYY HH24:\
MI:SS' ) ; END ;";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )166;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)r;
  sqlstm.sqhstl[0] = (unsigned int  )0;
  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  *)rd;
  sqlstm.sqhstl[1] = (unsigned int  )21;
  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) goto notfound;
}


  rd[20]='\0';
  strcpy(historyDate,rd);
  cout<<"*************************************************************\n";
  cout<<"     Oracle history date: "<<historyDate<<"\n";
  cout<<"*************************************************************\n";
  return kTRUE;
notfound:
  showSqlError("setParamRelease(const Char_t*)");
  return kFALSE;
}

Bool_t HOraConn::setParamRelease(Int_t run) {
  // Sets the history date to the creation date of the parameter release
  // for the corresponding experiment
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    int r;
    char rd[21];
  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR GOTO notfound; */ 

  r=run;
  rd[0]='\0';
  /* EXEC SQL EXECUTE
    BEGIN
      hades_oper.run_query.set_history_date_by_run(:r);	
      :rd := to_char(hades_oper.run_query.get_history_date,'DD-MON-YYYY HH24:MI:SS');
    END;
  END-EXEC; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 4;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "begin hades_oper . run_query . set_history_date_by_run ( :r\
 ) ; :rd := to_char ( hades_oper . run_query . get_history_date , 'DD-MON-YYYY\
 HH24:MI:SS' ) ; END ;";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )189;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)&r;
  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  *)rd;
  sqlstm.sqhstl[1] = (unsigned int  )21;
  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) goto notfound;
}


  rd[20]='\0';
  strcpy(historyDate,rd);
  cout<<"*************************************************************\n";
  cout<<"     Oracle history date: "<<historyDate<<"\n";
  cout<<"*************************************************************\n";
  return kTRUE;
notfound:
  showSqlError("setParamRelease(Int_t)");
  return kFALSE;
}