/* 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,
    "horadetruninfoio.pc"
};


static unsigned int sqlctx = 39089155;


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

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

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,58,0,6,88,0,0,1,1,0,1,0,1,97,0,0,
24,0,0,2,75,0,6,120,0,0,3,3,0,1,0,1,97,0,0,1,97,0,0,2,3,0,0,
51,0,0,3,110,0,6,156,0,0,5,5,0,1,0,1,97,0,0,1,3,0,0,1,3,0,0,2,1,0,0,2,3,0,0,
86,0,0,4,0,0,29,202,0,0,0,0,0,1,0,
101,0,0,5,0,0,31,212,0,0,0,0,0,1,0,
};


//*-- AUTHOR : Ilse Koenig
//*-- Created : 14/10/2004 by Ilse Koenig

//_HADES_CLASS_DESCRIPTION 
//////////////////////////////////////////////////////////////////////////////
//
// HOraDetRunInfoIo
//
// Interface to the analysis run information in Oracle
// It allows to set the quality of runs via a ROOT macro
//
//////////////////////////////////////////////////////////////////////////////

using namespace std;
#include "horadetruninfoio.h"
#include "hdbconn.h"
#include <iostream>
#include <iomanip>

#define SQLCA_STORAGE_CLASS extern
#define ORACA_STORAGE_CLASS extern

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

ClassImp(HOraDetRunInfoIo)

HOraDetRunInfoIo::HOraDetRunInfoIo() {
  // Constructor
  pConn=new HDbConn();
  hasErrors=kFALSE;
  numChanges=0;
}

HOraDetRunInfoIo::~HOraDetRunInfoIo() {
  // Destructor
  if (pConn) {
    close();
    delete pConn;
    pConn=0;
  }
}

Bool_t HOraDetRunInfoIo::open(const Char_t* userName,const Char_t* dbName) {
  // Opens an oracle connection (account userName)
  hasErrors=kFALSE;
  numChanges=0;
  return pConn->connectDb(userName,dbName);
}

void HOraDetRunInfoIo::close() {
  // Disconnects from ORACLE
  pConn->closeDbConn();
}

void HOraDetRunInfoIo::print() {
  // Prints information about the database connection
  if (pConn->isOpen()) {
    cout<<"Connected to Oracle-Database as user "<<pConn->getUserName();
    if (pConn->isReadonly()) {
      cout<<" with read-only access\n";
    } else {
      cout<<" with write access\n";
    }
  } else cout<<"*** no connection to Oracle established  ***\n";
}

Bool_t HOraDetRunInfoIo::isOpen() {
  // Returns kTRUE, if connected to Oracle, otherwise kFALSE;
  return pConn->isOpen();
}

Bool_t HOraDetRunInfoIo::setDetector(const Char_t* detName) {
  // Sets the detector name (might fail if insufficient privilege)
  if (!isOpen()) return kFALSE;
  if (strlen(detName)==0) {
    Error("setDetector","Specify detector name");
    return 0;
  }
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    char* detname;
  /* EXEC SQL END DECLARE SECTION; */ 

  detname=(Char_t*)detName;
  /* EXEC SQL WHENEVER SQLERROR GOTO errorfound; */ 

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

  /* EXEC SQL EXECUTE
    BEGIN
      hanal2.hrv_ana.set_detector(:detname);
    END;
  END-EXEC; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 13;
  sqlstm.arrsiz = 1;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "begin hanal2 . hrv_ana . set_detector ( :detname ) ; END ;";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )5;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)4352;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (unsigned char  *)detname;
  sqlstm.sqhstl[0] = (unsigned long )0;
  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 == 1403) goto errorfound;
  if (sqlca.sqlcode < 0) goto errorfound;
}


  return kTRUE;
errorfound:
  pConn->showSqlError("setDetector");
  hasErrors=kTRUE;
  return kFALSE;
}

Int_t HOraDetRunInfoIo::createComment(const Char_t* author,const Char_t* description) {
  // Creates a new comment and returns the comment id
  if (!isOpen()) return -1;
  if (strlen(author)==0) {
    Error("createComment","Specify author");
    return -1;
  }
  if (strlen(author)==0) {
    Error("createComment","Specify comment");
    return -1;
  }
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    char* auth;
    char* descript;
    int   id;
  /* EXEC SQL END DECLARE SECTION; */ 

  auth=(Char_t*)author;
  descript=(Char_t*)description;
  /* EXEC SQL WHENEVER SQLERROR GOTO errorfound; */ 

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

  /* EXEC SQL EXECUTE
    BEGIN
      hanal2.hrv_ana.create_comment(:auth,:descript,:id);
    END;
  END-EXEC; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 13;
  sqlstm.arrsiz = 3;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "begin hanal2 . hrv_ana . create_comment ( :auth , :descript\
 , :id ) ; END ;";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )24;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)4352;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (unsigned char  *)auth;
  sqlstm.sqhstl[0] = (unsigned long )0;
  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  *)descript;
  sqlstm.sqhstl[1] = (unsigned long )0;
  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  *)&id;
  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.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 errorfound;
  if (sqlca.sqlcode < 0) goto errorfound;
}


  return id;
errorfound:
  pConn->showSqlError("createComment");
  hasErrors=kTRUE;
  return -1;
}

Bool_t HOraDetRunInfoIo::setRunQuality(const Char_t* filename,Int_t quality,
                                       Int_t commentId) {
  // Sets the quality of a run
  if (!isOpen()) return kFALSE;
  if (strlen(filename)==0) {
    Error("setRunQuality","Filename not defined");
    return kFALSE;
  }
  if (commentId<=0) {
    Error("setRunQuality","Comment id not defined");
    return kFALSE;
  }
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    char* fname;
    int   qualityfac;
    int   commentid;
    char  status;
    int   oldqualityfac;
  /* EXEC SQL END DECLARE SECTION; */ 

  fname=(Char_t*)filename;
  qualityfac=quality;
  commentid=commentId;
  /* EXEC SQL WHENEVER SQLERROR GOTO errorfound; */ 

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

  /* EXEC SQL EXECUTE
    BEGIN
      hanal2.hrv_ana.set_run_info(:fname,:qualityfac,:commentid,
                                  :status,:oldqualityfac);
    END;
  END-EXEC; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 13;
  sqlstm.arrsiz = 5;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "begin hanal2 . hrv_ana . set_run_info ( :fname , :qualityfa\
c , :commentid , :status , :oldqualityfac ) ; END ;";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )51;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)4352;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (unsigned char  *)fname;
  sqlstm.sqhstl[0] = (unsigned long )0;
  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  *)&qualityfac;
  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  *)&commentid;
  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  *)&status;
  sqlstm.sqhstl[3] = (unsigned long )1;
  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  *)&oldqualityfac;
  sqlstm.sqhstl[4] = (unsigned long )sizeof(int);
  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 errorfound;
  if (sqlca.sqlcode < 0) goto errorfound;
}


  cout.setf(ios::left,ios::adjustfield);
  cout<<setw(50)<<filename;
  cout.setf(ios::right,ios::adjustfield);
  if (status=='S') {
    cout<<"No change\n";
  } else if (status=='I') { 
    cout<<"New quality: "<<setw(2)<<quality<<'\n';
    numChanges++;
  } else if (status=='U') { 
    cout<<"New quality: "<<setw(2)<<quality<<'\n';
    cout<<setw(63)<<"Old quality: "<<setw(2)<<oldqualityfac<<'\n';
    numChanges++;
  }
  return kTRUE;
errorfound:
  pConn->showSqlError("setRunQuality");
  hasErrors=kTRUE;
  return kFALSE;
}

void HOraDetRunInfoIo::finish() {
  // Asks for commit, if transaction has no errors or makes a rollback
  if (!isOpen()) return;
  cout<<"****************************************************************\n";
  if (hasErrors) rollback();
  else {
    cout<<"Number of changes since last commit/rollback: "<<numChanges<<'\n';
    if (numChanges>0) {
      TString answer;
      cout<<"Do you want to commit the changes (yes or no) > ";
      cin>>answer;
      if (answer.CompareTo("yes")==0) commit();
      else rollback();
    } else rollback();
  }
  cout<<"****************************************************************\n";
}

void HOraDetRunInfoIo::commit() {
  // Commits all changes
  /* EXEC SQL COMMIT WORK; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 13;
  sqlstm.arrsiz = 5;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )86;
  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) goto errorfound;
}


  cout<<"***  Transaction committed"<<endl;
  numChanges=0;
  return;
errorfound:
  pConn->showSqlError("commit");
}

void HOraDetRunInfoIo::rollback() {
  // discards all changes since last commit and clears the error flag
  /* EXEC SQL ROLLBACK WORK; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 13;
  sqlstm.arrsiz = 5;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )101;
  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) goto errorfound;
}


  cout<<"***  Transaction rolled back"<<endl;
  hasErrors=kFALSE;
  numChanges=0;
  return;
errorfound:
  pConn->showSqlError("rollback");
}