/****************************************************************************/
// SQLSVR.CXX  v1.0 - 27.10.1990 / 06.06.1992
/****************************************************************************/
/*                                                                          */
/*   Copyright (c) 1989-1993 Bernhard Strassl                               */
/*       Institute for Applied Computer Science and Information Systems     */
/*       University of Vienna, Austria                                      */
/*                                                                          */
/*   See file COPYRIGHT in this directory for details. If this file is      */
/*   missing please mail to bernhard@ani.univie.ac.at                       */
/****************************************************************************/

//
// Gupta SQLBase version
//

extern "C"
{
#include <sql.h>
/* #include <errsql.h> */
#include <string.h>
}
#include <stream.hxx>
#include "sqlmisc.hxx"
#include "sqlsvr.hxx"

CbRowId new_row_id()
{
	char* buf = new char[40];
	for(int i = 0; i < 39; i++)
		buf[i] = ' ';
	buf[39] = '\0';
	return((CbRowId )buf);
}

SQLTCUR* guptaCursors;

class LongInfo : private SqlInfo
{
friend class SqlSvr;
	int ndx;
	bool type;      // stream = TRUE
	void* str;      // string or stream
	int length;     // (strings only)

	LongInfo(int i, bool t, void* s, int l = 0) { ndx = i; type = t; str = s; length = l; }

};

class SysDescr : private SqlDescr
{
friend class SqlSvr;
	SysDescr()     {}
	~SysDescr()    {}

	LongInfo* at(int i)     { return((LongInfo* )infoAt(i)); }
	LongInfo* next(int& i)  { return((LongInfo* )infoNext(i)); }
};

class SysCurParam
{
friend class SqlSvr;
	SysDescr* longIn;
	SysDescr* longOut;

	SysCurParam()	{ longIn = longOut = (SysDescr* )NULL; }
};


SqlSvr::SqlSvr()
{
//    if(TheServer)
//        this = TheServer;
//    else
	{
/*
		perrors = new short[30];
		pdlen = new short[30];
		pdtype = new int[30];
*/
		init_sys_data();
		init_cb_data();
		cursors = new CursorInfo*[SS_MAXCURSORS];
		guptaCursors = new SQLTCUR[SS_MAXCURSORS];
		TheServer = this;
	}
}
	
SqlSvr::~SqlSvr()
{
	delete allCursors;
}

CursorInfo* SqlSvr::connect(char* uid, int cursize, short inbufsize, short outbufsize)
{
	SQLTCUR aCurs;
	CursorInfo* ci;

	if(cursize == SS_DEFAULT)
		cursize = int(SS_DEFCURSZ);
	if(inbufsize == SS_DEFAULT)
		inbufsize = short(SS_DEFINSZ);
	if(outbufsize == SS_DEFAULT)
		outbufsize = short(SS_DEFOUTSZ);

	ci = new CursorInfo;
	if(ci->cstat = sqlcon(&aCurs, (unsigned char*)uid, 0, cursize, 0, 1, inbufsize, outbufsize))
	{       error(ci);              // connect failed
		return((CursorInfo* )NULL);
	}
	guptaCursors[ci->cndx] = aCurs;
	ci->sysinfo = (void* )new SysCurParam;
	ci->active = TRUE;
	return(ci);
}

bool SqlSvr::disconnect(CursorInfo* ci)
{
	if(ci->cstat = sqldis(guptaCursors[ci->cndx]))
	{	error(ci);		// disconnect failed
		return(FALSE);
	}
	ci->active = FALSE;
	return(TRUE);
}

bool SqlSvr::compile(CursorInfo* ci, char* stmt)
{
	if(ci->cstat = sqlcom(guptaCursors[ci->cndx], (unsigned char* )stmt, 0))
	{	error(ci);		// compile failed
		cerr << "SQL Statement: " << stmt << "\n";
		return(FALSE);
	}
	return(TRUE);
}

bool SqlSvr::exec(CursorInfo* ci)
{
	SysDescr* sd;
	LongInfo* li;

	if(sd = ((SysCurParam* )(ci->sysinfo))->longIn)
	{
//	perform write longs.... 
	int i = 0;
	while(li = sd->next(i))
	{	if(!(ci->cstat = sqlbln(guptaCursors[ci->cndx], (unsigned char ) li->ndx)))
		{
		if(li->type)		// a stream...
		{	char* buff = new char[512];
			buff[511] = '\0';
			int strEOF;
			do
			{       ((istream* )li->str)->get(buff, 500, -1);
				if(strEOF = ((istream* )li->str)->eof())
					ci->cstat = sqlwlo(guptaCursors[ci->cndx], (unsigned char* )buff, strlen(buff));
				else
					ci->cstat = sqlwlo(guptaCursors[ci->cndx], (unsigned char* )buff, 500);
				if(ci->cstat)
					break;
			} while(!strEOF);
		}
		else			// a (simple...!) string
			ci->cstat = sqlwlo(guptaCursors[ci->cndx], (unsigned char* )li->str, (unsigned char )li->length);
		} // end if
		if(ci->cstat || (ci->cstat = sqlelo(guptaCursors[ci->cndx])))
		{	error(ci);			// write long failed
			return(FALSE);
		}
	} // end while
	} // end if
	
	if(ci->cstat = sqlexe(guptaCursors[ci->cndx]))
	{	error(ci);		// execute failed
		return(FALSE);
	}
	return(TRUE);
}

bool SqlSvr::compexec(CursorInfo* ci, char* stmt)
{
	if(ci->cstat = sqlcex(guptaCursors[ci->cndx], (unsigned char* )stmt, 0))
	{	error(ci);		// compexec failed
		return(FALSE);
	}
	return(TRUE);
}

bool SqlSvr::bindInput(CursorInfo* ci, BindDescr* bd)
{
	BindInfo* bi;

	int i = 0;
	while(bi = bd->next(i))
	{	if(pdtype[bi->type] <= CB_MAX_PTYPES)
			ci->cstat = sqlbnn(guptaCursors[ci->cndx],
				(unsigned char ) bi->varIndex,
				(unsigned char* ) bi->data,
				(unsigned char ) bi->length,
				(unsigned char ) bi->scale,
				(char ) pdtype[bi->type]);
		else
		{       if(!((SysCurParam* )(ci->sysinfo))->longIn)
				((SysCurParam* )(ci->sysinfo))->longIn = new SysDescr;
			(((SysCurParam* )(ci->sysinfo))->longIn)->addInfo((SqlInfo* )
				new LongInfo(bi->varIndex, (pdtype[bi->type] == CB_PLSTREAM ? TRUE : FALSE), bi->data, bi->length));
		}
		if(ci->cstat)
 		{	error(ci);		// bind failed
			return(FALSE);
		}
	}
	return(TRUE);
}


bool SqlSvr::bindOutput(CursorInfo* ci, BindDescr* bd)
{
	BindInfo* bi;

	int n = 0;
	while(bi = bd->next(n))
	{
		if(pdtype[bi->type] <= CB_MAX_PTYPES)
		{   ci->cstat = sqlssb(guptaCursors[ci->cndx],
				(unsigned char ) bi->varIndex,
				(char ) pdtype[bi->type],
				(unsigned char* ) bi->data,
				(unsigned char ) bi->length,
				(unsigned char ) bi->scale,
				(unsigned char* ) &(bi->retLength),
				(unsigned char* ) &(bi->retCode));
		}
		else
		{   if(!((SysCurParam* )(ci->sysinfo))->longOut)
				((SysCurParam* )(ci->sysinfo))->longOut = new SysDescr;
			(((SysCurParam* )(ci->sysinfo))->longOut)->addInfo((SqlInfo* )
				new LongInfo(bi->varIndex, (pdtype[bi->type] == CB_PLSTREAM ? TRUE : FALSE), bi->data, bi->length));
		}
		if(ci->cstat)
 		{	error(ci);		// bind failed
			return(FALSE);
		}
	}
	return(TRUE);
}

bool SqlSvr::descr(CursorInfo* ci, QryDescr& qd)
{
	QryInfo* qi;
	short itms, headerLength;
	char tmptype;

	itms = headerLength = 0;
	if(ci->cstat = sqlnsi(guptaCursors[ci->cndx], (unsigned char* ) &itms))
 	{	error(ci);
		return(FALSE);
	}
	for(short i = 1; i <= (short ) itms; i++)
	{   qi = new QryInfo;
		qi->nameBuff = new char[CB_MAX_COLNAMELEN];
		if(ci->cstat = sqldes(guptaCursors[ci->cndx],
			(unsigned char )(qi->colIndex = i),
			(unsigned char* ) &tmptype,
			(unsigned char* ) &(qi->dataLength),
			(unsigned char* ) qi->nameBuff,
			(unsigned char* ) &headerLength,
			(unsigned char* ) &(qi->prec),
			(unsigned char* ) &(qi->scale)))
	 	{	error(ci);
			return(FALSE);
		}
		qi->type = CB_PBUFFER;
		for(short j = 0; j < CB_MAX_SYSTYPES; j++)
		{	if(pdtype[j] == tmptype)
				qi->type = pdtype[j];
		}
		*((qi->nameBuff) + headerLength) = '\0';
		qd.addInfo((SqlInfo* )qi);
	}
	return(TRUE);
}


bool SqlSvr::fetch(CursorInfo* ci, short& fcode)
{
	SysDescr* sd;
	LongInfo* li;
	int rlen, i = 0;

	if(ci->cstat = sqlfet(guptaCursors[ci->cndx]))
	{       if((fcode = ci->cstat) != perrors[CB_ERR_EOF])
			error(ci);		// fetch failed
		return(FALSE);
	}
	if(!(sd = ((SysCurParam* )(ci->sysinfo))->longOut))
		return(TRUE);

//	perform read longs.... 

	while(li = sd->next(i))
	{	if(li->type)		// a stream...
		{	char* buff = new char[512];
			buff[511] = '\0';
			do
			{	if(ci->cstat = sqlrlo(guptaCursors[ci->cndx],
					(unsigned char ) li->ndx,
					(unsigned char* )buff,
					500,
					(unsigned int* )&rlen))
					break;
				buff[rlen] = '\0';
				*((ostream* )li->str) << buff;
				if(((ostream* )li->str)->eof())
				{	cb_error("class SqlServer: Output stream buffer overflow in long operation");
					break;
				}
			} while(rlen > 0);
		}
		else			// a string
		{	ci->cstat = sqlrlo(guptaCursors[ci->cndx],
					(unsigned char ) li->ndx,
					(unsigned char* )li->str,
					(unsigned char )li->length,
					(unsigned int* )&rlen);
			((char* )li->str)[rlen] = '\0';
		}
		if(ci->cstat || (ci->cstat = sqlelo(guptaCursors[ci->cndx])))
		{	error(ci);			// write long failed
			return(FALSE);
		}
	}
	return(TRUE);
}


bool SqlSvr::getStatus(CursorInfo* ci, int& rcode)
{
	if(ci->cstat = sqlrcd(guptaCursors[ci->cndx], &rcode))
	{	error(ci);		// get failed
		return(FALSE);
	}
	return(TRUE);
}

bool SqlSvr::getRbFlag(CursorInfo* ci, bool& rbf)
{
	if(ci->cstat = sqlrbf(guptaCursors[ci->cndx], (unsigned char* )&rbf))
	{	error(ci);		// get failed
		return(FALSE);
	}
	return(TRUE);
}

bool SqlSvr::getRowCount(CursorInfo* ci, char* tbl, long& rows)
{
	if(ci->cstat = sqlgnr(guptaCursors[ci->cndx], (unsigned char* )tbl, 0, &rows))
	{	error(ci);		// get failed
		return(FALSE);
	}
	return(TRUE);
}

bool SqlSvr::getCurRowCount(CursorInfo* ci, long& rows)
{
	if(ci->cstat = sqlrow(guptaCursors[ci->cndx], &rows))
	{	error(ci);		// get failed
		return(FALSE);
	}
	return(TRUE);
}

bool SqlSvr::commit(CursorInfo* ci)
{
	if(ci->cstat = sqlcmt(guptaCursors[ci->cndx]))
	{	error(ci);		// commit failed
		return(FALSE);
	}
	return(TRUE);
}

bool SqlSvr::rollback(CursorInfo* ci)
{
	if(ci->cstat = sqlrbk(guptaCursors[ci->cndx]))
	{	error(ci);		// rollback failed
		return(FALSE);
	}
	return(TRUE);
}

void SqlSvr::error(CursorInfo* ci)
{
	bool fatal;

	cb_error("class SqlSvr: error in server function", FALSE);
	allCursors->dump();

	if(ci == (CursorInfo* )NULL)
		cb_error("class SqlSvr: invalid cursor handle", TRUE);

	char* errtxt = new char[CB_MAX_ERRTXTLEN];
	fatal = (!getErrorText(ci, errtxt) ? TRUE : FALSE);
	cb_error(errtxt, fatal);
}

bool SqlSvr::getErrorText(CursorInfo* ci, char* txt)
{
	if(sqlerr(ci->cstat, (unsigned char* )txt))
	{	strcpy("error during processing error: can't get error text", txt);
		return(FALSE);
	}
	return(TRUE);
}