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


static unsigned int sqlctx = 144643;


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

// 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,17,225,0,0,1,1,0,1,0,1,97,0,0,
24,0,0,1,0,0,45,227,0,0,0,0,0,1,0,
39,0,0,1,0,0,13,228,0,0,7,0,0,1,0,2,9,0,0,2,3,0,0,2,3,0,0,2,9,0,0,2,3,0,0,2,3,
0,0,2,9,0,0,
82,0,0,1,0,0,15,248,0,0,0,0,0,1,0,
97,0,0,2,0,0,17,377,0,0,1,1,0,1,0,1,97,0,0,
116,0,0,2,0,0,45,379,0,0,0,0,0,1,0,
131,0,0,2,0,0,13,382,0,0,1,0,0,1,0,2,9,0,0,
150,0,0,2,0,0,15,390,0,0,0,0,0,1,0,
165,0,0,2,0,0,15,394,0,0,0,0,0,1,0,
};


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

//_HADES_CLASS_DESCRIPTION 
/////////////////////////////////////////////////////////////
// HDbColumnTable
//
// Class for an Oracle table
//
/////////////////////////////////////////////////////////////
using namespace std;
#include "hdbtable.h"
#include "hdbconn.h"
#include "hdbfileutil.h"
#include "hdbcolumn.h"
#include "hdbcolumntype.h"
#include <stdio.h>
#include <iostream>
#include <iomanip>

#define SQLCA_STORAGE_CLASS extern
#define ORACA_STORAGE_CLASS extern

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

ClassImp(HDbTable)

#define MAXCOLNUM 254
#define MAXROWS   200

HDbTable::HDbTable() {
  // Default constructor
  dbConn=0;
  dbUtil=0;
  tabColumns=new TList;
  nColumns=0;
  tempTable=kFALSE;
  existing=kTRUE;
}

HDbTable::HDbTable(HDbConn* p, HDbFileUtil* u, const Char_t* tName) {
  // Constructor
  // Parameters: pointer to the Oracle connection class, the Oracle utility class
  // and the name of the table
  dbConn=p;
  dbUtil=u;
  setNames(tName);
  tabColumns=new TList;
  nColumns=0;
  tempTable=kFALSE;
  existing=kTRUE;
}

HDbTable::HDbTable(HDbConn* p, HDbFileUtil* u, HDbTable& t) {
  // Copy constructor
  // Parameters: pointer to the Oracle connection class, the Oracle utility class
  // and reference to an other table
  dbConn=p;
  dbUtil=u;
  setNames(t.GetName());
  tabColumns=new TList;
  nColumns=t.getNColumns();
  for(Int_t i=0;i<nColumns;i++) {
    HDbColumn* tc=t.getColumn(i);
    HDbColumn* c=new HDbColumn(*tc);
    tabColumns->Add(c);
  }  
  tempTable=t.isTempTable();
  existing=t.isExisting();
}

HDbTable::~HDbTable() {
  // Destructor
  if (tabColumns) {
    tabColumns->Delete();
    delete tabColumns;
  }  
}

HDbColumn* HDbTable::getColumn(Int_t n) {
  // Returns the column number n (starting with index 0)
  return (HDbColumn*)tabColumns->At(n);
}

HDbColumn* HDbTable::getColumn(const Char_t* colName) {
  // Returns the column with the specified name
  if (colName) {
    TString c(colName);
    c=c.Strip(c.kBoth);
    if (c.Length()>0)
      c.ToUpper();
      return (HDbColumn*)tabColumns->FindObject(c.Data());
  }
  return 0;
}

HDbColumn* HDbTable::addColumn(const Char_t* colName, const Char_t* columnType) {
  // Adds a column to the list. The type of the column is optional and needed
  // only for the creation of a non-existing table with non default types.
  HDbColumn* p=0;
  TString c(colName);
  c=c.Strip(c.kBoth);
  c.ToUpper();
  if (tabColumns->FindObject(c.Data()))
    cout<<"Column "<<c<<" already exists!"<<endl;
  else {
    p=new HDbColumn(c.Data());
    if(columnType) p->setColType(columnType);
    tabColumns->Add(p);
    nColumns++;
  }
  return p;
}

void HDbTable::addColumn(HDbColumn* p) {
  // Adds a copy of the column p to the list
  if (!p) return;
  if (!tabColumns->FindObject(p->GetName())) {
    HDbColumn* c=new HDbColumn(*p);             // copies the column
    tabColumns->Add(c);
    nColumns++;
  }
  else cout<<"Column "<<p->GetName()<<" already exists!"<<endl;
}


void HDbTable::removeColumn(const Char_t* colName) {
  // Removes the column with this name and deletes it
  HDbColumn* p=getColumn(colName);
  if (p) {
    tabColumns->Remove(p);
    delete p;
    nColumns--;
  }
}

void HDbTable::clearColumns() {
  // Clears the list of columns
  tabColumns->Delete();
  nColumns=0;
}

void HDbTable::setColumns(const Char_t* colNames, const Char_t* colTypes) {
  // Sets a list of columns and types(optional). The lists must be comma separated.
  TString sNames, sTypes;
  Int_t nlen=0, tlen=0; 
  if (colNames) {
    sNames=colNames;
    sNames.Strip(sNames.kBoth);
    sNames.ToUpper();
    nlen=sNames.Length();
  }
  if (colTypes) {
    sTypes=colTypes;
    sTypes.Strip(sTypes.kBoth);
    sTypes.ToUpper();
    tlen=sTypes.Length();
  }
  if (nlen==0) {
    Error("HDbTable::setColumns","List of column is empty ");
    return;
  }
  TString ssn, sst;
  while (nlen>0) {
    nlen=dbUtil->getTokString(sNames,ssn,",");
    if (tlen>0) {
      tlen=dbUtil->getTokString(sTypes,sst,",");
      if (sst.First("(")>0 && sst.First(")")<0) {
        TString s;
        tlen=dbUtil->getTokString(sTypes,s,",");
        sst=sst + "," + s;
      }
      addColumn(ssn.Data(),sst.Data());
    } else addColumn(ssn.Data(),colDefaultType);
  }
}

void HDbTable::setCondition(const Char_t* s) {
  // Sets the condition for a SELECT statement ("WHERE" is added internally!)
  if (s) {
    cond=s;
    cond=cond.Strip(cond.kBoth);
    cond.ToUpper();
  } else cond="";
}

void HDbTable::setOrderBy(const Char_t* s) {
  // Sets the ORDER BY clause for a SELECT statement
  // Multiple columns must by separated by commas.
  // ("ORDER BY" is added internally!)
  if (s) {
    orderClause=s;
    orderClause=orderClause.Strip(orderClause.kBoth);
    orderClause.ToUpper();
  } else orderClause="";
}

     
Bool_t HDbTable::describeTable() {
  // Gets the table definition (columns, types, nullable) from Oracle
  if (!dbConn->isOpen()) return kFALSE;
  tempTable=kFALSE;
  existing=kTRUE;
  clearColumns();
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    char* dynstmt;
    /* varchar colName[MAXCOLNUM][30]; */ 
struct { unsigned short len; unsigned char arr[30]; } colName[254];

    int     colId[MAXCOLNUM];
    int     dLen[MAXCOLNUM];
    /* varchar colType[MAXCOLNUM][30]; */ 
struct { unsigned short len; unsigned char arr[30]; } colType[254];

    int     dPrec[MAXCOLNUM];
    int     dScale[MAXCOLNUM];
    /* varchar nn[MAXCOLNUM][1]; */ 
struct { unsigned short len; unsigned char arr[2]; } nn[254];

  /* EXEC SQL END DECLARE SECTION; */ 

  /* EXEC SQL WHENEVER SQLERROR GOTO  errorFound; */ 

  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 

  TString s(("select column_name,column_id,data_length,data_type,"
                   "nvl(data_precision,0),nvl(data_scale,0), nullable "
                   "from all_tab_columns where table_name='")); 
  s=s + tabName + "' and owner='" + tabOwner +"' order by column_id";
  dynstmt=(Char_t*)s.Data();
  /* EXEC SQL PREPARE S FROM :dynstmt; */ 

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


  /* EXEC SQL DECLARE C CURSOR FOR S; */ 

  /* EXEC SQL OPEN C; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 1;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )24;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqcmod = (unsigned int )0;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) goto errorFound;
}


  /* EXEC SQL FETCH C INTO :colName, :colId, :dLen, :colType, : dPrec, :dScale, :nn; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 7;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.iters = (unsigned int  )254;
  sqlstm.offset = (unsigned int  )39;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqfoff = (           int )0;
  sqlstm.sqfmod = (unsigned int )2;
  sqlstm.sqhstv[0] = (         void  *)colName;
  sqlstm.sqhstl[0] = (unsigned int  )32;
  sqlstm.sqhsts[0] = (         int  )32;
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqharc[0] = (unsigned int   *)0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqhstv[1] = (         void  *)colId;
  sqlstm.sqhstl[1] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[1] = (         int  )sizeof(int);
  sqlstm.sqindv[1] = (         void  *)0;
  sqlstm.sqinds[1] = (         int  )0;
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqharc[1] = (unsigned int   *)0;
  sqlstm.sqadto[1] = (unsigned short )0;
  sqlstm.sqtdso[1] = (unsigned short )0;
  sqlstm.sqhstv[2] = (         void  *)dLen;
  sqlstm.sqhstl[2] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[2] = (         int  )sizeof(int);
  sqlstm.sqindv[2] = (         void  *)0;
  sqlstm.sqinds[2] = (         int  )0;
  sqlstm.sqharm[2] = (unsigned int  )0;
  sqlstm.sqharc[2] = (unsigned int   *)0;
  sqlstm.sqadto[2] = (unsigned short )0;
  sqlstm.sqtdso[2] = (unsigned short )0;
  sqlstm.sqhstv[3] = (         void  *)colType;
  sqlstm.sqhstl[3] = (unsigned int  )32;
  sqlstm.sqhsts[3] = (         int  )32;
  sqlstm.sqindv[3] = (         void  *)0;
  sqlstm.sqinds[3] = (         int  )0;
  sqlstm.sqharm[3] = (unsigned int  )0;
  sqlstm.sqharc[3] = (unsigned int   *)0;
  sqlstm.sqadto[3] = (unsigned short )0;
  sqlstm.sqtdso[3] = (unsigned short )0;
  sqlstm.sqhstv[4] = (         void  *)dPrec;
  sqlstm.sqhstl[4] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[4] = (         int  )sizeof(int);
  sqlstm.sqindv[4] = (         void  *)0;
  sqlstm.sqinds[4] = (         int  )0;
  sqlstm.sqharm[4] = (unsigned int  )0;
  sqlstm.sqharc[4] = (unsigned int   *)0;
  sqlstm.sqadto[4] = (unsigned short )0;
  sqlstm.sqtdso[4] = (unsigned short )0;
  sqlstm.sqhstv[5] = (         void  *)dScale;
  sqlstm.sqhstl[5] = (unsigned int  )sizeof(int);
  sqlstm.sqhsts[5] = (         int  )sizeof(int);
  sqlstm.sqindv[5] = (         void  *)0;
  sqlstm.sqinds[5] = (         int  )0;
  sqlstm.sqharm[5] = (unsigned int  )0;
  sqlstm.sqharc[5] = (unsigned int   *)0;
  sqlstm.sqadto[5] = (unsigned short )0;
  sqlstm.sqtdso[5] = (unsigned short )0;
  sqlstm.sqhstv[6] = (         void  *)nn;
  sqlstm.sqhstl[6] = (unsigned int  )3;
  sqlstm.sqhsts[6] = (         int  )4;
  sqlstm.sqindv[6] = (         void  *)0;
  sqlstm.sqinds[6] = (         int  )0;
  sqlstm.sqharm[6] = (unsigned int  )0;
  sqlstm.sqharc[6] = (unsigned int   *)0;
  sqlstm.sqadto[6] = (unsigned short )0;
  sqlstm.sqtdso[6] = (unsigned short )0;
  sqlstm.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;
}


  nColumns=sqlca.sqlerrd[2];
  if (nColumns<=0) {
    cout<<"Table "<<GetName()<<" does not exist!"<<endl;
    tempTable=kTRUE;
    existing=kFALSE;
    return kFALSE;
  }
  for(Int_t i=0;i<nColumns;i++) {
    colName[i].arr[colName[i].len]='\0';
    colType[i].arr[colType[i].len]='\0';
    HDbColumn* p=new HDbColumn((const Char_t*)colName[i].arr);
    p->setColumnId(colId[i]);
    p->setColType((const Char_t*)colType[i].arr,dLen[i],dPrec[i],dScale[i]);
    if (nn[i].arr[0]=='N') p->setNullable(kFALSE);
    tabColumns->Add(p);
  }
  return kTRUE;
errorFound:
  dbUtil->showSqlError("HDbTable::describeTable");
  /* EXEC SQL CLOSE C; */ 

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


  return kFALSE;
}

Bool_t HDbTable::createTable() {
  // Creates the table in Oracle (created only in the account of the connected user)
  if (!dbConn->isOpen() || dbConn->isReadonly()) return kFALSE;
  if (nColumns==0) {
    Error("HDbTable::createTable()","No columns defined");
    return kFALSE;
  }
  if (tabOwner.CompareTo(dbConn->getUserName())!=0) {
    Error("HDbTable::createTable()","Table cannot be created in an other user account");
    return kFALSE;
  }
  TString str="create table ";
  str=str + GetName() + " (\n  ";
  TIter next(tabColumns);
  HDbColumn* p;
  Int_t n=0;
  while ((p=(HDbColumn*)next())) {
    str=str + p->GetName() + " " + p->getColType()->getTypeString();
    if (!p->isNullable()) str=str + " " + "NOT NULL";
    if (++n<nColumns) str=str + ",\n  ";
  }
  str=str + " )";
  cout<<"-----------------------------------------"<<endl;
  cout<<"-------------  Create table  ------------"<<endl;
  cout<<"-----------------------------------------"<<endl;
  cout<<str<<endl;
  if (dbUtil->confirm("creation")==kFALSE) return kFALSE;
  Bool_t rc=dbUtil->executeDirect(str);
  if (rc) {
    cout<<"Temporary table "<<GetName()<<" created."<<endl;
    tempTable=kTRUE;
    existing=kTRUE; 
  }
  return rc;
}

Bool_t HDbTable::dropTable() {
  // Drops the table (drops the table only if created inside the current Oracle session)
  if (!dbConn->isOpen() || dbConn->isReadonly()) return kFALSE;
  if (!tempTable) {
    Error("HDbTable::dropTable","\nCannot drop permanent table %s",
          GetName());
    return kFALSE;
  }
  if (!existing) {
    Error("HDbTable::dropTable","Table does not exist");
    return kFALSE;
  }
  if (tabOwner.CompareTo(dbConn->getUserName())!=0) {
    Error("HDbTable::dropTable","\nA table in an other user account cannot be dropped");
    return kFALSE;
  }
  TString s("drop table ");
  s=s + GetName();  TString      tabOwner;       // Owner of the table

  cout<<"-----------------------------------------"<<endl;
  cout<<"-------------  Drop table  --------------"<<endl;
  cout<<"-----------------------------------------"<<endl;
  cout<<s<<endl;
  if (dbUtil->confirm("drop")==kFALSE) return kFALSE;
  Bool_t rc=dbUtil->executeDirect(s);
  if (rc) cout<<"Temporary table "<<GetName()<<" dropped."<<endl;
  return rc;
}

void HDbTable::show() {
  // Shows the table definition 
  TIter next(tabColumns);
  HDbColumn* p;
  cout<<"---------------------------------------------------------------------"<<endl;
  cout<<"            Table: "<<GetName();
  if (tempTable) {
    if (existing) cout<<"   (Existing temporary table)"<<endl;
    else cout<<"   (Non-existing temporary table)"<<endl;
  } 
  else cout<<"  (Permanent table)"<<endl;
  cout<<setiosflags(ios::left)<<setw(30)<<"ColumnName"
                      <<setw(4) <<"NN"
                      <<setw(12)<<"ColumnType"
                      <<setw(6) <<"Size"
                      <<setw(12)<<"Precision"
                      <<setw(12)<<"Scale"<<endl;
  cout<<"---------------------------------------------------------------------"<<endl;
  while ((p=(HDbColumn*)next())) {
    p->show();
  }
}

Int_t HDbTable::writeTable(ostream& pout, const Char_t* colDelim,
                           const Char_t* textDelim, const Char_t* nullString) {
  // Writes the content of the table to a stream.
  // Fetches the table in batches of 200 rows.
  if (!dbConn->isOpen()) {
    cout<<"Connection closed before end of reading!"<<endl;
    return -1;
  }
  TString stm("select ");
  HDbColumn* p;
  TString c;
  for(Int_t i=0;i<nColumns;i++) {
    p=(HDbColumn*)tabColumns->At(i);
    if (p->isNullable())
      c=p->getColType()->getNvlSelectString(p->GetName(),textDelim,nullString);
    else c=p->getColType()->getSelectString(p->GetName(),textDelim);
    if (c.Length()==0) return -1;
    stm=stm + c;
    if (i<(nColumns-1)) stm=stm + "||'" + colDelim + "'||";
  }
  stm=stm + "from " + GetName();
  if (cond.Length()>0) {
    stm=stm + " where " + cond;
    pout<<"// Condition:  "<<cond<<endl;
  }
  if (orderClause.Length()>0) {
    stm=stm + " order by " + orderClause;
    pout<<"// Order by:  "<<orderClause<<endl;
  }
  //cout<<stm<<endl;
  /* EXEC SQL BEGIN DECLARE SECTION; */ 

    char* dynstmt;
    /* varchar sResult[MAXROWS][4000]; */ 
struct { unsigned short len; unsigned char arr[4002]; } sResult[200];

  /* EXEC SQL END DECLARE SECTION; */ 

  dynstmt=(Char_t*)stm.Data();
  Int_t nbs=0, nbslast=0;
  /* EXEC SQL WHENEVER SQLERROR GOTO errorFound; */ 

  /* EXEC SQL PREPARE SW FROM :dynstmt; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 7;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "";
  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  *)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;
}


  /* EXEC SQL DECLARE CW CURSOR FOR SW; */ 

  /* EXEC SQL OPEN CW; */ 

{
  struct sqlexd sqlstm;
  sqlorat((void **)0, &sqlctx, &oraca);
  sqlstm.sqlvsn = 12;
  sqlstm.arrsiz = 7;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )116;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqcmod = (unsigned int )0;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) goto errorFound;
}


  /* EXEC SQL WHENEVER NOT FOUND CONTINUE; */ 

  do {
    /* EXEC SQL FETCH CW INTO :sResult; */ 

{
    struct sqlexd sqlstm;
    sqlorat((void **)0, &sqlctx, &oraca);
    sqlstm.sqlvsn = 12;
    sqlstm.arrsiz = 7;
    sqlstm.sqladtp = &sqladt;
    sqlstm.sqltdsp = &sqltds;
    sqlstm.iters = (unsigned int  )200;
    sqlstm.offset = (unsigned int  )131;
    sqlstm.selerr = (unsigned short)1;
    sqlstm.cud = sqlcud0;
    sqlstm.sqlest = (unsigned char  *)&sqlca;
    sqlstm.sqlety = (unsigned short)256;
    sqlstm.occurs = (unsigned int  )0;
    sqlstm.sqfoff = (           int )0;
    sqlstm.sqfmod = (unsigned int )2;
    sqlstm.sqhstv[0] = (         void  *)sResult;
    sqlstm.sqhstl[0] = (unsigned int  )4002;
    sqlstm.sqhsts[0] = (         int  )4004;
    sqlstm.sqindv[0] = (         void  *)0;
    sqlstm.sqinds[0] = (         int  )0;
    sqlstm.sqharm[0] = (unsigned int  )0;
    sqlstm.sqharc[0] = (unsigned int   *)0;
    sqlstm.sqadto[0] = (unsigned short )0;
    sqlstm.sqtdso[0] = (unsigned short )0;
    sqlstm.sqphsv = sqlstm.sqhstv;
    sqlstm.sqphsl = sqlstm.sqhstl;
    sqlstm.sqphss = sqlstm.sqhsts;
    sqlstm.sqpind = sqlstm.sqindv;
    sqlstm.sqpins = sqlstm.sqinds;
    sqlstm.sqparm = sqlstm.sqharm;
    sqlstm.sqparc = sqlstm.sqharc;
    sqlstm.sqpadto = sqlstm.sqadto;
    sqlstm.sqptdso = sqlstm.sqtdso;
    sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
    if (sqlca.sqlcode < 0) goto errorFound;
}

 
    nbs=sqlca.sqlerrd[2] - nbslast;
    nbslast+=nbs;
    for(Int_t i=0;i<nbs;i++) {
      sResult[i].arr[sResult[i].len]='\0';
      pout<<(Char_t*)sResult[i].arr<<endl;
    }
  } while (nbs==MAXROWS);
  /* EXEC SQL CLOSE CW; */ 

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


  return nbslast;
errorFound:
  dbUtil->showSqlError("HDbTable::writeTable");
  /* EXEC SQL CLOSE CW; */ 

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


  cout<<"SQL statement:"<<endl<<stm<<endl;
  return -1;
}

void HDbTable::setNames(const Char_t* tName) {
  // Sets the table owner and name from a concatinated string (separated by ".")
  TString s(tName);
  s.ToUpper();
  s=s.Strip(s.kBoth);
  Ssiz_t n=s.First(".");
  if (n>0) {
    SetName(s.Data());
    tabOwner=s(0,n);
    tabName=s(++n,s.Length()-n);
  } else {
    tabOwner=dbConn->getUserName();
    tabName=s;    
    s=tabOwner;
    s=s + "." + tabName;
    SetName(s.Data());
  }
}