dblibrary.cpp

又服务器+客户端,不错的例子. 但是有所不同.

// DBLibraty.cpp: implementation of the DBLibraty class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "DBLibrary.h"
#include "time.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
DBLibrary::DBLibrary()
{
	init();
	dbproc=NULL;
}
DBLibrary::DBLibrary(CDBSession &pDBSession)
{
	init();
	/*
	dbproc=pDBSession->dbproc;
	login=pDBSession->login;
	strcpy(app_name,pDBSession.app_name);
	strcpy(ErrLogFile,pDBSession.ErrLogFile);
	strcpy(LogFileName,pDBSession.LogFileName);*/
	for(int i=0;i<MAXPROCS;i++)
	{
		if (dbproc_status[i]==1)
		{
			this->dbproc=pDBSession.dbproc[i];
			dbproc_status[i]=2;
			proc_id=i;
			break;
		}
	}
	if (i==MAXPROCS)//没有空闲的db process
		ErrCheck(ERR_NONE_FREE_DBPROCESS,NULL);
	this->login=pDBSession.login;
	InitTrans();

}

DBLibrary::~DBLibrary()
{
	if(pTransactionDispenser)
   		pTransactionDispenser->Release();
	COLINFO *p,*q;
	p=q=NULL;
	if(COLUMN!=NULL) q=COLUMN;
	while(q)
	{
		COLUMN=COLUMN->next;
		p=COLUMN;
		delete q;
		q=p;
	}
	if(proc_id>=0)
		dbproc_status[proc_id]=1;

}

void DBLibrary::ErrCheck(int code=ERR_DBSYS,char *str=NULL)
{
	char tmp[100];
	memset(tmp,0,100);
	SetErrCode(code);
	switch(code)
	{
	case ERR_NO_FIND_COL:
		if(str!=NULL)
			sprintf(tmp,ERR_MSG[-code-100],str);
		else strcpy(tmp,ERR_MSG[-code-100]);
		SetErrMsg(tmp);
		break;
	case ERR_BCP_BIND_COL:
		if(str!=NULL)
			sprintf(tmp,ERR_MSG[-code-100],str);
		else strcpy(tmp,ERR_MSG[-code-100]);
		SetErrMsg(tmp);
		break;
	case ERR_COLTYPE_NOT_MATCHING:
		if(str!=NULL)
			sprintf(tmp,ERR_MSG[-code-100],str);
		else strcpy(tmp,ERR_MSG[-code-100]);
		SetErrMsg(tmp);
		break;
    case ERR_MAX_SQLSTR:
		if(str!=NULL)
			sprintf(tmp,ERR_MSG[-code-100],str);
		else strcpy(tmp,ERR_MSG[-code-100]);
		SetErrMsg(tmp);
		break;
	case ERR_BIND_DATABASE_FAIL:
		if(str!=NULL)
			sprintf(tmp,ERR_MSG[-code-100],str);
		else strcpy(tmp,ERR_MSG[-code-100]);
		SetErrMsg(tmp);
		break;
	case ERR_NO_FIND_COMPUTEID:
		if(str!=NULL)
			sprintf(tmp,ERR_MSG[-code-100],str);
		else strcpy(tmp,ERR_MSG[-code-100]);
		SetErrMsg(tmp);
		break;
	case ERR_NO_FIND_COMPUTECOLS:
		if(str!=NULL)
			sprintf(tmp,ERR_MSG[-code-100],str);
		else strcpy(tmp,ERR_MSG[-code-100]);
		SetErrMsg(tmp);
		break;
	case ERR_RESULTS_NOROWS:
		if(str!=NULL)
			sprintf(tmp,ERR_MSG[-code-100],str);
		else strcpy(tmp,ERR_MSG[-code-100]);
		SetErrMsg(tmp);
		break;
	case ERR_DBSYS:
		break;
	default:
		strcpy(tmp,ERR_MSG[-code-100]);
		SetErrMsg(tmp);
	}
	if (GetAutoThrow()) 
		throw (*((DBErr *)this));
		//throw(*((WOCIError *)this));
}

int DBLibrary::WriteLog(bool ErrLog,const char *format,...)
{
	va_list vlist;
	va_start(vlist,format);
	FILE *lgfp=NULL;
	if (ErrLog)
		lgfp=fopen(ErrLogFile,"a+t");
	else
		lgfp=fopen(LogFileName,"a+t");
	if (lgfp==NULL) 
		return ErrLog ? -1 : -2;
	int rt;
	CTime curtime=CTime::GetCurrentTime();
	char tmptime[15];
	sprintf(tmptime,"%s",curtime.Format("%Y-%m-%d %H:%M:%S"));
	fprintf(lgfp,"[%s] ",tmptime);
	if (_output_to_console)
		rt=vprintf(format,vlist);
	
	rt=vfprintf(lgfp,format,vlist);
	int fmtlen=strlen(format);
	if(fmtlen > 1 && format[fmtlen - 1] !='\n')
	{
		if(_output_to_console)
			printf("\n");
		fprintf(lgfp,"\n");
	}
	va_end(vlist);
	fclose(lgfp);
	return rt;
}
/*
void DBLibrary::WriteSQLLog()
{
	WriteLog(false,"severity:%d %s, DBErrCode:%d, DBErrStr:%s",
		SYSERR.serverity,svrty[SYSERR.serverity],SYSERR.dberr,SYSERR.dberrstr);
	if(SYSERR.oserr != DBNOERR)
		WriteLog(true,"severity:%d %s,OSErrCode:%d, OSErrStr:%s",
			SYSERR.serverity,svrty[SYSERR.serverity],SYSERR.oserr,SYSERR.oserrstr);

}*/
int DBLibrary::SetDataBase(char *DBName)
{
 
	if(dbuse(dbproc,DBName)==FAIL)		 
		ErrCheck(ERR_BIND_DATABASE_FAIL,DBName);
	return 1;

}
int DBLibrary::Open(const char *format,...)
{
	EOFTAG=false;
	INIT_TAG=FALSE;
	dbcancel(dbproc);
	char strSQL[STRSQLMAX];
	int sql_len=0;
	va_list vlist;
	va_start(vlist,format);
	sql_len=vsprintf(strSQL,format,vlist);
	va_end(vlist);
	if (sql_len>=STRSQLMAX - 1)
	{
		char len[5];
		sprintf(len,"%d",STRSQLMAX);
		ErrCheck(ERR_MAX_SQLSTR,len);		
	}
	WriteLog(false,strSQL);

	if(dbcmd(dbproc,strSQL)==FAIL)
		ErrCheck(ERR_SQL_CMD);
	
//	if (!asynchronism) //如果不是异步执行
//	try
//	{
	if (dbsqlexec(dbproc)==FAIL) ErrCheck();	

	if (dbresults(dbproc)== FAIL)
		ErrCheck(ERR_SQL_RESULTS);
	if(dbresults(dbproc)==NO_MORE_RESULTS)
	{
		EOFTAG=true;
		return ERR_RESULTS_NOROWS;
	}
		//ErrCheck(ERR_RESULTS_NOROWS,strSQL);
	COLInit();
	return 1;
		
}

int DBLibrary::InitRead()
{
		 
	if(dbresults(dbproc) !=NO_MORE_RESULTS )//&& !INIT_TAG)
	{
		INIT_TAG=true;
		dbnextrow(dbproc);
		return 1;
	}
	return -1;		

}
int DBLibrary::Next()
{
	RETCODE row_code; 
	if ( !INIT_TAG ) 
		ErrCheck(ERR_NO_INIT_BUFF);
	if(dbresults(dbproc) !=NO_MORE_RESULTS)
	{
		row_code=dbnextrow(dbproc);
		switch(row_code)
		{	
		case NO_MORE_ROWS://没有结果行可读
			INIT_TAG=false;
			return EOFTAG=true;
			break;
		case REG_ROW://常规列
			return REG_ROW;
			break;
		default:
			if(row_code>0)
				return COMPUTE_COLS;
		}
	}

	return NO_MORE_RESULTS;
}

int DBLibrary::COLInit()
{
	
	int cols=dbnumcols(dbproc);
	if(cols<1)
		ErrCheck(ERR_RESULTS_NOCOLS,"COLInit->dbnumcols()");
	COLINFO *p,*q;
	int i=0;
	p=q=NULL;
	if(COLUMN!=NULL) q=COLUMN;
	while(q)
	{
		COLUMN=COLUMN->next;
		p=COLUMN;
		delete q;
		q=p;
	}
	COLUMN=NULL;
	
	while(++i<=cols)
	{
		p=new COLINFO;
		sprintf(p->name,"%s",strupr((char*)dbcolname(dbproc,i)));
		p->index=i;
		p->type=dbcoltype(dbproc,i);
		p->len=dbdatlen(dbproc,i);
		p->next=NULL;
	    if(COLUMN==NULL)
			COLUMN=q=p;
		else
		{
			q->next=p;
			q=q->next;
		}
	}
	int tmp=dbresults(dbproc);
	if(tmp==NO_MORE_RESULTS)
	{
		INIT_TAG=FALSE;
		EOFTAG=TRUE;
		return EOFTAG;
	}
	if(tmp !=NO_MORE_RESULTS && !INIT_TAG)
	{
		INIT_TAG=true;
		dbnextrow(dbproc);
		return EOFTAG;
	}
	return 1;
}
int DBLibrary::GetColID(char *colName)
{
	char curcol[COLEN];
	sprintf((char *)curcol,"%s",colName);
	for(COL=COLUMN;COL;COL=COL->next)
		if(strcmp(strupr(curcol),COL->name)==0)
			break;
	if(COL) return 1;
	return ERR_NO_FIND_COL;
}
int DBLibrary::GetComputeValue(int computeID,int columnID,
								long *pcValue)
{
	char tmp[4];
	memset(tmp,0,4);
	sprintf(tmp,"%d",columnID);
	int cptID=dbnumcompute(dbproc);
	if ( cptID != computeID)  
		ErrCheck(ERR_NO_FIND_COMPUTEID,tmp);
	int cptCols=dbnumalts(dbproc,cptID);
	if (cptCols<columnID || cptCols<1 || columnID<1) 
		ErrCheck(ERR_NO_FIND_COMPUTECOLS,tmp);
	
	switch(dbalttype(dbproc,computeID,columnID))
	{
	case SQLINT1:
	case SQLINT2:
	case SQLINT4:
	case SQLINTN:
		if(dbconvert(dbproc,SQLINT4,dbadata(dbproc,computeID,columnID),
			(DBINT)-1,SQLINT4,(LPBYTE)pcValue,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,tmp);
	    return 1;
		break;
	default:
		ErrCheck(ERR_COLTYPE_NOT_MATCHING,"compute field");
	}
	return ERR_UNKNOW;

}

int DBLibrary::GetComputeValue(int computeID,int columnID,
								double *pcValue)
{
	char tmp[4];
	memset(tmp,0,4);
	sprintf(tmp,"%d",columnID);
	int cptID=dbnumcompute(dbproc);//取COMPUTE子句标号
	
	if ( cptID != computeID)  
		ErrCheck(ERR_NO_FIND_COMPUTEID,tmp);
	int cptCols=dbnumalts(dbproc,cptID);
	if (cptCols<columnID || cptCols<1 || columnID<1) 
		ErrCheck(ERR_NO_FIND_COMPUTECOLS,tmp);
	
	switch(dbalttype(dbproc,computeID,columnID))
	{
	case SQLFLT4:
	    if(dbconvert(dbproc,SQLFLT4,dbadata(dbproc,computeID,columnID),
			(DBINT)-1,SQLFLT8,(LPBYTE)pcValue,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,tmp);
			return 1;
		break;
	case SQLFLTN:
	    if(dbconvert(dbproc,SQLFLTN,dbadata(dbproc,computeID,columnID),
			(DBINT)-1,SQLFLT8,(LPBYTE)pcValue,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,tmp);
			return 1;
		break;
	case SQLFLT8:
	    if(dbconvert(dbproc,SQLFLT8,dbadata(dbproc,computeID,columnID),
			(DBINT)-1,SQLFLT8,(LPBYTE)pcValue,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,tmp);
			return 1;
		break;
	case SQLDECIMAL:
	    if(dbconvert(dbproc,SQLDECIMAL,dbadata(dbproc,computeID,columnID),
			(DBINT)-1,SQLDECIMAL,(LPBYTE)pcValue,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,tmp);
			return 1;
		break;
	case SQLNUMERIC:
	    if(dbconvert(dbproc,SQLNUMERIC,dbadata(dbproc,computeID,columnID),
			(DBINT)-1,SQLNUMERIC,(LPBYTE)pcValue,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,tmp);
			return 1;
		break;
	case SQLMONEY4:
	    if(dbconvert(dbproc,SQLMONEY4,dbadata(dbproc,computeID,columnID),
			(DBINT)-1,SQLFLT8,(LPBYTE)pcValue,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,tmp);
			return 1;
		break;
	case SQLMONEY:
	    if(dbconvert(dbproc,SQLMONEY,dbadata(dbproc,computeID,columnID),
			(DBINT)-1,SQLFLT8,(LPBYTE)pcValue,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,tmp);
			return 1;
		break;
	case SQLMONEYN:
	    if(dbconvert(dbproc,SQLMONEYN,dbadata(dbproc,computeID,columnID),
			(DBINT)-1,SQLFLT8,(LPBYTE)pcValue,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,tmp);
			return 1;
		break;
	default:
		ErrCheck(ERR_COLTYPE_NOT_MATCHING,tmp);
	}
	return ERR_UNKNOW;
}
long DBLibrary::GetValue(char *colName)
{
	long *lv=0;
	unsigned char bit[2];//tinyint byte(1),bit
	char smint[3];//smallint byte(2),多加1byte存放符号
	memset(bit,0,2);
	memset(smint,0,3);
	int id=GetColID(colName);
	if (id==ERR_NO_FIND_COL) ErrCheck(ERR_NO_FIND_COL,colName);
	switch(COL->type)
	{
	case SQLINT1:
		if(dbconvert(dbproc,SQLINT1,dbdata(dbproc,COL->index),
			(DBINT)-1,SQLCHAR,(LPBYTE)bit,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
		return atol((char *)bit);
	case SQLINT2:
		if(dbconvert(dbproc,SQLINT2,dbdata(dbproc,COL->index),
			(DBINT)-1,SQLCHAR,(LPBYTE)smint,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
		return atol((char *)smint);
	case SQLINT4:
	case SQLINTN:
		lv=(DBINT*)(dbdata(dbproc,COL->index));
		return *lv;
	case SQLBIT:
		if(dbconvert(dbproc,SQLBIT,dbdata(dbproc,COL->index),
			(DBINT)-1,SQLCHAR,(LPBYTE)bit,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
		return atol((char *)bit);
	default:
		ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
	}
	return 1;
}

int DBLibrary::GetValue(char *colName,double *pdresult)
{
	int id=GetColID(colName);
	if (id==ERR_NO_FIND_COL) 
		ErrCheck(ERR_NO_FIND_COL,colName);
	if(dbresults(dbproc) !=NO_MORE_RESULTS)
	{
	
		switch(COL->type)
		{
		case SQLFLT4:
			if(dbconvert(dbproc,SQLFLT4,dbdata(dbproc,COL->index),
				(DBINT)-1,SQLFLT4,(LPBYTE)pdresult,(DBINT)-1)==FAIL)
				ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
			break;
		case SQLFLTN:
			if(dbconvert(dbproc,SQLFLTN,dbdata(dbproc,COL->index),
				(DBINT)-1,SQLFLTN,(LPBYTE)pdresult,(DBINT)-1)==FAIL)
				ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
			break;
		case SQLFLT8:
			if(dbconvert(dbproc,SQLFLT8,dbdata(dbproc,COL->index),
				(DBINT)-1,SQLFLT8,(LPBYTE)pdresult,(DBINT)-1)==FAIL)
				ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
			break;
		case SQLDECIMAL:
			if(dbconvert(dbproc,SQLDECIMAL,dbdata(dbproc,COL->index),
				(DBINT)-1,SQLDECIMAL,(LPBYTE)pdresult,(DBINT)-1)==FAIL)
				ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
			break;
		case SQLNUMERIC:
			if(dbconvert(dbproc,SQLNUMERIC,dbdata(dbproc,COL->index),
				(DBINT)-1,SQLNUMERIC,(LPBYTE)pdresult,(DBINT)-1)==FAIL)
				ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
			break;
		case SQLMONEY4:
			if(dbconvert(dbproc,SQLMONEY4,dbdata(dbproc,COL->index),
				(DBINT)-1,SQLFLT8,(LPBYTE)pdresult,(DBINT)-1)==FAIL)
				ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
			break;
		case SQLMONEY:
			if(dbconvert(dbproc,SQLMONEY,dbdata(dbproc,COL->index),
				(DBINT)-1,SQLFLT8,(LPBYTE)pdresult,(DBINT)-1)==FAIL)
				ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
			break;
		default:
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
		}
	}
	return 1;
}
int DBLibrary::GetValue(char *colName,char *cpresult) //char,text,varchar,money,smallmoney
{
	
	int id=0;
	id=GetColID(colName);
	if (id==ERR_NO_FIND_COL) 
		ErrCheck(ERR_NO_FIND_COL,colName);
	switch(COL->type)
	{
	case SQLCHAR:
	case SQLVARCHAR:
	case SQLTEXT:
		memset(cpresult,0,strlen(cpresult));
		strncpy(cpresult,(char *)dbdata(dbproc,COL->index),dbdatlen(dbproc,COL->index));
		//return dbbind(dbproc,COL->index,NTBSTRINGBIND,(DBINT)0,(LPBYTE)cpresult);
		break;
	default:
		ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
	}