/* Result Sets Interface */
#ifndef SQL_CRSR
#  define SQL_CRSR
  struct sql_cursor
  {
    unsigned int curocn;
    void *ptr1;
    void *ptr2;
    unsigned long 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[15];
};
static const struct sqlcxp sqlfpn =
{
    14,
    "hdbfileutil.pc"
};


static unsigned long sqlctx = 1151179;


static struct sqlexd {
   unsigned int   sqlvsn;
   unsigned int   arrsiz;
   unsigned int   iters;
   unsigned int   offset;
   unsigned short selerr;
   unsigned short sqlety;
   unsigned int   unused;
      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;
            void  *sqhstv[1];
   unsigned int   sqhstl[1];
            int   sqhsts[1];
            void  *sqindv[1];
            int   sqinds[1];
   unsigned int   sqharm[1];
   unsigned int   *sqharc[1];
   unsigned short  sqadto[1];
   unsigned short  sqtdso[1];
} sqlstm = {10,1};

// Prototypes
extern "C" {
  void sqlcxt (void **, unsigned long *,
               struct sqlexd *, const struct sqlcxp *);
  void sqlcx2t(void **, unsigned long *,
               struct sqlexd *, const struct sqlcxp *);
  void sqlbuft(void **, char *);
  void sqlgs2t(void **, char *);
  void sqlorat(void **, unsigned long *, 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[] =
{10,4130,0,0,0,
5,0,0,1,0,0,29,30,0,0,0,0,0,1,0,
20,0,0,2,0,0,31,40,0,0,0,0,0,1,0,
35,0,0,3,0,0,24,74,0,0,1,1,0,1,0,1,97,0,0,
};


//*-- AUTHOR : Ilse Koenig
//*-- Modified : 14/09/2000

/////////////////////////////////////////////////////////////
//
// HDbFileUtil
//
// Class for FileI/O to/from Oracle tables
//
/////////////////////////////////////////////////////////////

#include "hdbfileutil.h"
#include "hdbconn.h"
#include <iostream.h>

#define SQLCA_STORAGE_CLASS extern
#define ORACA_STORAGE_CLASS extern
 
// Oracle communication area
#include <oraca.h>
// SQL Communications Area
#include <sqlca.h>
 
ClassImp(HDbFileUtil)

 void HDbFileUtil::commit(void) {
  // commits all changes
  if (!dbConn->isOpen()) return;
  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("HDbConn::commit"); */ 

  /* EXEC SQL COMMIT WORK; */ 

{
  struct sqlexd sqlstm;

  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 10;
  sqlstm.arrsiz = 0;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )5;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)0;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) showSqlError("HDbConn::commit");
}


  cout<<"*************************************************************"<<endl;
  cout<<"******************  Transaction committed  ******************"<<endl;
  cout<<"*************************************************************"<<endl;
}

 void HDbFileUtil::rollback(void) {
  // discards all changes since last commit
  if (!dbConn->isOpen()) return;
  /* EXEC SQL WHENEVER SQLERROR DO showSqlError("HDbConn::rollback"); */ 

  /* EXEC SQL ROLLBACK WORK; */ 

{
  struct sqlexd sqlstm;

  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 10;
  sqlstm.arrsiz = 0;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )20;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)0;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) showSqlError("HDbConn::rollback");
}


  cout<<"*************************************************************"<<endl;
  cout<<"*****************  Transaction rolled back  *****************"<<endl;
  cout<<"*************************************************************"<<endl;
  return;
}

 void HDbFileUtil::showSqlError(const char* f) {
  // shows SQL error messages
  cout<<"*************************************************************"<<endl;
  Error(f,"n%s",sqlca.sqlerrm.sqlerrmc);
  cout<<"*************************************************************"<<endl;
}

 void HDbFileUtil::showDynSqlError(const char* f) {
  sqlca.sqlerrm.sqlerrmc[sqlca.sqlerrm.sqlerrml]='0';
  oraca.orastxt.orastxtc[oraca.orastxt.orastxtl]='0';
  oraca.orasfnm.orasfnmc[oraca.orasfnm.orasfnml]='0';
  cout<<"**************************************************************"<<endl;
  Error(f,"n%sn  in %s...n  on line %d of %s n\n",sqlca.sqlerrm.sqlerrmc,
        oraca.orastxt.orastxtc,oraca.oraslnr,oraca.orasfnm.orasfnmc);
  cout<<"**************************************************************"<<endl;
}

 Bool_t HDbFileUtil::executeDirect(TString& stm) {
  if (stm.Length()==0) {
    Error("HDbFileUtil::executeDirect","Empty statement string");
    return kFALSE;
  }
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

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

  /* EXEC SQL WHENEVER SQLERROR GOTO errorFound; */ 

  dynstmt=(char*)stm.Data();
  /* EXEC SQL EXECUTE IMMEDIATE :dynstmt; */ 

{
  struct sqlexd sqlstm;

  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 10;
  sqlstm.arrsiz = 1;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )35;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)0;
  sqlstm.sqhstv[0] = (         void  *)dynstmt;
  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.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 errorFound;
}


  return kTRUE;
errorFound:
  showSqlError("HDbFileUtil::executeDirect");
  cout<<"SQL statement: "<<endl<<stm<<endl;
  return kFALSE;
}

 Int_t HDbFileUtil::getTokString(TString& s1, TString& s2, const char* delim) {
  Int_t n=s1.First(delim);
  if (n>0) {
    s2=s1(0,n);
    s2=s2.Strip(s2.kBoth);
    n+=strlen(delim);
    s1=s1(n,s1.Length()-n);
    s1=s1.Strip(s1.kLeading);
    return s1.Length();
  }
  if (n==0) {
    s2="";
    s1.Remove(0,strlen(delim)); // remove delimiter
    s1=s1.Strip(s1.kLeading);
    return s1.Length();
  }
  s2=s1.Strip(s1.kLeading);
  s1="";
  return 0;
}

 Bool_t HDbFileUtil::confirm(const char * action) {
  char buf[80];
  cout<<"Confirm "<<action<<" ('y' or 'n') > "<<endl;
  cin>>buf;
  if (buf[0]=='y' || buf[0]=='Y') return kTRUE;
  else return kFALSE;
}