/* 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[12];
};
static const struct sqlcxp sqlfpn =
{
11,
"hdbtable.pc"
};
static unsigned long 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 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[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 = {10,7};
// 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,17,224,0,0,1,1,0,1,0,1,97,0,0,
24,0,0,1,0,0,45,226,0,0,0,0,0,1,0,
39,0,0,1,0,0,13,227,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,247,0,0,0,0,0,1,0,
97,0,0,2,0,0,17,373,0,0,1,1,0,1,0,1,97,0,0,
116,0,0,2,0,0,45,375,0,0,0,0,0,1,0,
131,0,0,2,0,0,13,378,0,0,1,0,0,1,0,2,9,0,0,
150,0,0,2,0,0,15,386,0,0,0,0,0,1,0,
165,0,0,2,0,0,15,390,0,0,0,0,0,1,0,
};
//*-- AUTHOR : Ilse Koenig
//*-- Modified : 15/09/2000
/////////////////////////////////////////////////////////////
// HDbColumnTable
//
// Class for an Oracle table
//
/////////////////////////////////////////////////////////////
#include "hdbtable.h"
#include "hdbconn.h"
#include "hdbfileutil.h"
#include "hdbcolumn.h"
#include "hdbcolumntype.h"
#include <stdio.h>
#include <iostream.h>
#include <iomanip.h>
#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* 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* 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* colName, const char* 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* 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* colNames, const char* 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* 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* 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*)s.Data();
/* EXEC SQL PREPARE S FROM :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 )5;
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;
}
/* EXEC SQL DECLARE C CURSOR FOR S; */
/* EXEC SQL OPEN C; */
{
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 )24;
sqlstm.cud = sqlcud0;
sqlstm.sqlest = (unsigned char *)&sqlca;
sqlstm.sqlety = (unsigned short)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 = 10;
sqlstm.arrsiz = 7;
sqlstm.sqladtp = &sqladt;
sqlstm.sqltdsp = &sqltds;
sqlstm.iters = (unsigned int )254;
sqlstm.offset = (unsigned int )39;
sqlstm.cud = sqlcud0;
sqlstm.sqlest = (unsigned char *)&sqlca;
sqlstm.sqlety = (unsigned short)0;
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 )4;
sqlstm.sqhsts[1] = ( int )4;
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 )4;
sqlstm.sqhsts[2] = ( int )4;
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 )4;
sqlstm.sqhsts[4] = ( int )4;
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 )4;
sqlstm.sqhsts[5] = ( int )4;
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*)colName[i].arr);
p->setColumnId(colId[i]);
p->setColType((const char*)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 = 10;
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)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(2)<<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* colDelim,
const char* textDelim, const char* nullString) {
// Writes the content of the table to a stream.
// Fetches the table in batches of 1000 rows.
if (!dbConn->isOpen()) 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*)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 = 10;
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)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 = 10;
sqlstm.arrsiz = 7;
sqlstm.sqladtp = &sqladt;
sqlstm.sqltdsp = &sqltds;
sqlstm.stmt = "";
sqlstm.iters = (unsigned int )1;
sqlstm.offset = (unsigned int )116;
sqlstm.cud = sqlcud0;
sqlstm.sqlest = (unsigned char *)&sqlca;
sqlstm.sqlety = (unsigned short)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 = 10;
sqlstm.arrsiz = 7;
sqlstm.sqladtp = &sqladt;
sqlstm.sqltdsp = &sqltds;
sqlstm.iters = (unsigned int )200;
sqlstm.offset = (unsigned int )131;
sqlstm.cud = sqlcud0;
sqlstm.sqlest = (unsigned char *)&sqlca;
sqlstm.sqlety = (unsigned short)0;
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*)sResult[i].arr<<endl;
}
} while (nbs==MAXROWS);
/* EXEC SQL CLOSE CW; */
{
struct sqlexd sqlstm;
sqlorat((void **)0, &sqlctx, &oraca);
sqlstm.sqlvsn = 10;
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)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 = 10;
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)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* tName) {
// Sets the table owner and name from a concatinated string (separated by ".")
TString s(tName);
s.ToUpper();
s=s.Strip(s.kBoth);
Int_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());
}
ROOT page - Class index - Top of the page
This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.