oracledb.c

电力与银行通讯的源码 1.应用tuxedo中间件. 2.与银行的前置机通讯. 3.proc*c 的应用

			ptrColumn->c_rlen  = (ub2*)malloc((ub4)(MAX_ROWS_PER_INSERT*sizeof(ub2)));
			memset(ptrColumn->c_rlen, 0, MAX_ROWS_PER_INSERT * sizeof(ub2));
			ptrColumn->c_rcode = (ub2*)malloc((ub4)(MAX_ROWS_PER_INSERT*sizeof(ub2)));
			memset(ptrColumn->c_rcode, 0, MAX_ROWS_PER_INSERT * sizeof(ub2));
			ptrColumn->c_buf   = 
                   (ub1 *)malloc((ub4)(MAX_ROWS_PER_INSERT*ptrColumn->c_size));
			memset(ptrColumn->c_buf, 0, MAX_ROWS_PER_INSERT * ptrColumn->c_size);
			ptrColumn->c_curlen = 0;
			if (obndra(&pDatabase->m_cda, 
				(text *)szVar, -1,
				ptrColumn->c_buf, ptrColumn->c_size,
				(sword)nColumnType, (sword) -1,
				(sb2 *)ptrColumn->c_indp, ptrColumn->c_rlen, ptrColumn->c_rcode,
				(ub4)0, (ub4 *)0, 
				(text *)0, -1, -1))
			{
				OracleErrorReport(pDatabase, &pDatabase->m_cda, NULL);
				return FALSE;
			}	 
		}
	}
	ptrColumn = pDatabase->m_pColumn;
	if(pDatabase->m_nBlkRowCount<MAX_ROWS_PER_INSERT)
	{
		for(nColIndex = 0; nColIndex < pDatabase->m_nColumnCount; nColIndex++, ptrColumn++)
		{
			if(ptrColumn->c_type == SQLT_DAT)
			{
				if(nLenArray[nColIndex] == 15)
				{
					strcpy(szTime, ppVarArray[nColIndex]);
				}
				else
				{
					dtDate = *(CS_DATETIME*)(ppVarArray[nColIndex]);
				
					timeDate=(dtDate.dtdays-(70*365+69/4))*24*60*60;
					timeDate+=(dtDate.dttime/300);
					tmDate = *gmtime(&timeDate);
				
					sprintf(szTime, "%4.4d%2.2d%2.2d%2.2d%2.2d%2.2d",
						tmDate.tm_year + 1900,
						tmDate.tm_mon + 1,
						tmDate.tm_mday,
						tmDate.tm_hour,
						tmDate.tm_min,
						tmDate.tm_sec);
				}
				memcpy(ptrColumn->c_buf+pDatabase->m_nBlkRowCount*ptrColumn->c_size, 
					szTime, ptrColumn->c_size);
				
			}
			else if(ptrColumn->c_type == SQLT_STR)
			{
				memcpy(ptrColumn->c_buf+pDatabase->m_nBlkRowCount*ptrColumn->c_size, 
					ppVarArray[nColIndex], ptrColumn->c_size-1);
				(ptrColumn->c_buf+(pDatabase->m_nBlkRowCount+1)*ptrColumn->c_size-1)[0]=0;
			}
			else
			{
				memcpy(ptrColumn->c_buf+pDatabase->m_nBlkRowCount*ptrColumn->c_size, 
					ppVarArray[nColIndex], ptrColumn->c_size);
			}
			*(ptrColumn->c_rlen+pDatabase->m_nBlkRowCount) = ptrColumn->c_size;
		}
		pDatabase->m_nBlkRowCount++;
	}
	
	if(pDatabase->m_nBlkRowCount == MAX_ROWS_PER_INSERT)
	{
	    if(oexn(&pDatabase->m_cda, pDatabase->m_nBlkRowCount, 0))
		{
			pDatabase->m_nBlkRowCount = 0;
			OracleErrorReport(pDatabase, &pDatabase->m_cda, NULL);
			return FALSE;
		}
		pDatabase->m_nBlkRowCount = 0;
	}
	return TRUE;
}
BOOL DB_BlkCopyInDone(CDatabase *pDatabase)
{
	int nColIndex;
	CColumn *ptrColumn;
	if(!pDatabase->m_pColumn) return TRUE;
	
	if(pDatabase->m_nBlkRowCount>0)
	{
	    if(oexn(&pDatabase->m_cda, pDatabase->m_nBlkRowCount, 0))
		{
			OracleErrorReport(pDatabase, &pDatabase->m_cda, NULL);
			return FALSE;
		}
		pDatabase->m_nBlkRowCount = 0;
	}
	ptrColumn = pDatabase->m_pColumn;
	for(nColIndex = 0; nColIndex < pDatabase->m_nColumnCount; nColIndex++, ptrColumn++)
	{
		if(ptrColumn->c_buf)	free(ptrColumn->c_buf);
		if(ptrColumn->c_indp)	free(ptrColumn->c_indp);
		if(ptrColumn->c_rcode)	free(ptrColumn->c_rcode);
		if(ptrColumn->c_rlen)	free(ptrColumn->c_rlen);
	}
	
	free(pDatabase->m_pColumn);
	pDatabase->m_pColumn = NULL;
	return TRUE;
}
BOOL DB_SQLBlkPrepare(CDatabase *pDatabase, char *pTableName, char *pWhereClause, void ***ppVar, long **nLenArray, int *npColumnCount)
{
	int i;
	sb4 nColMaxLen,nColLen;
	sb2 nColType;
	static sb1 szColName[50];
	sb4 nColNameLen=sizeof(szColName)-1;
	static char szSql[512], szSql2[512],szCat[50];
	
	sb2	nPrec, nScale, nNullOk;
	if(!pDatabase->m_bOpened)
	RETURN_IF(pDatabase, CS_FAIL, "Oracle Client 数据库未打开!");
	sprintf(szSql, "select * from %s", pTableName);
	StringReplace(szSql, "#", "Tmp_");
	
	if(oparse(&pDatabase->m_cda, (text*)szSql, (sb4) -1, DEFER_PARSE, (ub4) VERSION_7))
    {
		OracleErrorReport(pDatabase, &pDatabase->m_cda, szSql);
		return FALSE;
    }
    
	pDatabase->m_pColumn = (CColumn *)malloc((ub4)(100 * sizeof(CColumn)));
	sprintf(szSql2, "select ");
	
	for(i=0; ; i++)
	{
		nColNameLen=sizeof(szColName)-1;
		if(odescr(&pDatabase->m_cda, i+1, &nColMaxLen,
				(sb2 *)&nColType, szColName, (sb4 *)&nColNameLen,
				(sb4 *)&nColLen, &nPrec, &nScale, &nNullOk))
		{
			if(pDatabase->m_cda.rc == 1007) break;
			OracleErrorReport(pDatabase, &pDatabase->m_cda, szSql);
			return FALSE;
		}
		strtok(szColName, " ");
		if(nColType == SQLT_CHR || nColType == SQLT_STR || nColType == SQLT_AFC)
		{
			nColType = SQLT_STR;
			nColLen++;
		}
		else if(nColType == SQLT_INT) nColLen = sizeof(sword);
		else if(nColType == SQLT_FLT) nColLen = sizeof(double);
		else if(nColType == SQLT_NUM)
		{
			if(nPrec>0 && nPrec<4 && nScale==0)
			{
				nColType = SQLT_UIN;
				nColLen = sizeof(BYTE);
			}
			else if(nPrec>3 && nPrec<6 && nScale==0)
			{
				nColType = SQLT_UIN;
				nColLen = sizeof(short);
			}
			else if(nPrec<10 && nScale==0)
			{
				nColType = SQLT_UIN;
				nColLen = sizeof(int);
			}
			else
			{
				nColType = SQLT_FLT;
				nColLen = sizeof(double);
			}
		}
		if(nColType == SQLT_DAT)
		{
			/*nColType = SQLT_STR;*/
			sprintf(szCat, "to_char(%s, \'YYYYMMDDHH24MISS\')", szColName);
			nColLen = 15;
		}
		else
			strcpy(szCat, (const char *)szColName);
		if(i!=0) strcat(szSql2, ",");
		strcat(szSql2, szCat);
		pDatabase->m_pColumn[i].c_type = nColType;
		pDatabase->m_pColumn[i].c_size = (short)nColLen;
	}
	
	strcat(szSql2, " from ");
	strcat(szSql2, pTableName);
	if(pWhereClause)
	{
		if(pWhereClause[0])
		{
			strcat(szSql2, " ");
			strcat(szSql2, pWhereClause);
		}
	}
	StringReplace(szSql2, "#", "Tmp_");
	
	ocan(&pDatabase->m_cda);
	
	if(oparse(&pDatabase->m_cda, (text*)szSql2, (sb4) -1, DEFER_PARSE, (ub4) VERSION_7))
	{
		OracleErrorReport(pDatabase, &pDatabase->m_cda, szSql2);
		return FALSE;
	}
	pDatabase->m_nBlkRowCount = 0;
	pDatabase->m_nColumnCount = i;
	pDatabase->m_bBind = FALSE;
	*ppVar = (void**)malloc(pDatabase->m_nColumnCount*sizeof(void *));
	*nLenArray = (long*)malloc(pDatabase->m_nColumnCount*sizeof(long));
	for(i=0;i<pDatabase->m_nColumnCount;i++)
	{
		(*ppVar)[i] = malloc(pDatabase->m_pColumn[i].c_size*MAX_ROWS_PER_SELECT);
		(*nLenArray)[i] = pDatabase->m_pColumn[i].c_size;
		if(pDatabase->m_pColumn[i].c_type == SQLT_DAT)
			nColType = SQLT_STR;
		else
			nColType = pDatabase->m_pColumn[i].c_type;
		if(odefin(&pDatabase->m_cda,
               i+1,
               (ub1 *)(*ppVar)[i],
               pDatabase->m_pColumn[i].c_size,
               nColType,
               -1,
               (sb2 *) &pDatabase->m_nIndicator[i],
               (text *) 0,
               -1,
               -1,
               (ub2 *) 0,
               (ub2 *) 0))
		{
			OracleErrorReport(pDatabase, &pDatabase->m_cda ,szSql2);
			return FALSE;
		}
	}
	
	if(oexec(&pDatabase->m_cda))
	{
		OracleErrorReport(pDatabase, &pDatabase->m_cda, szSql2);
		return FALSE;
	}
	pDatabase->m_cda.rpc = 0;
	*npColumnCount = pDatabase->m_nColumnCount;
	
	return TRUE;
}
BOOL DB_SQLBlkFetch(CDatabase *pDatabase, int *npRowsFetched)
{
	int nRowsFetched;
	nRowsFetched = pDatabase->m_cda.rpc;
	if(ofen(&pDatabase->m_cda, MAX_ROWS_PER_SELECT))
	{
		if(pDatabase->m_cda.rc == 1002) return FALSE;	
		if(pDatabase->m_cda.rc != 1403)
		{
			OracleErrorReport(pDatabase, &pDatabase->m_cda, NULL);
			return FALSE;
		}
	}
	*npRowsFetched = pDatabase->m_cda.rpc - nRowsFetched;
	if(*npRowsFetched == 0) return FALSE;
	return TRUE;
}
BOOL DB_SQLBlkDone(CDatabase *pDatabase)
{
	ocan(&pDatabase->m_cda);
	return TRUE;
}
BOOL DB_ConvertNumericToLong(CDatabase *pDatabase, CS_NUMERIC *npSrc, long* lpDest, int nPrecision, int nScale)
{
	*lpDest = (long)*npSrc;
	return TRUE;
}
BOOL DB_ConvertNumericToDouble(CDatabase *pDatabase, CS_NUMERIC *npSrc, double* lpDest, int nPrecision, int nScale)
{
	*lpDest = *npSrc;
	return TRUE;
}
/***************************************************
 * 函数名：ExecuteStoreProcedure
 * 功能：  执行存储过程，支持输入任意个参数
 * 返回值：成功--TRUE 失败--FALSE
*/ 
BOOL DB_ExecuteStoredProcedure(CDatabase *pDatabase, char *pRpcName, int* npStatus, 
									   const unsigned char* pbParamInfo,...)
{
	static char szSql[256];
	static CS_RETCODE  rc=CS_SUCCEED;			/* 命令返回值 */
	static va_list		argList;	
	static int			nArgc = 0;	
	const unsigned char * pb = pbParamInfo;
	char			szParamArray[256][10];
	int				nParamArray[10];
	unsigned char	tinyIntArray[10];
	unsigned short	smallIntArray[10];
	double			realDataArray[10], floatDataArray[10];
	
	int				cbString=0;
	int				cbInt=0;
	int				cbTinyInt=0;
	int				cbSmallInt=0;
	int				cbRealData=0, cbFloatData=0;
	static void			*pParam;
	int				nTypeLen;
	int				nLoopCount = 0;
	int				nColumnType;
	static char		szVarName[20];
	sprintf(szSql, "begin %s(",pRpcName);
	if(pbParamInfo != NULL)
	{
		nArgc = strlen((const char *)pbParamInfo);
	}
	if(nArgc!=0)
	{
		while (nLoopCount < nArgc)
		{
			sprintf(szVarName, ":col%d", nLoopCount);
			strcat(szSql, szVarName);
			strcat(szSql, ",");
			nLoopCount++;
		}
	}
	sprintf(szVarName, ":col%d", nLoopCount);
	strcat(szSql, szVarName);
	strcat(szSql, ");end;");
    if(oparse(&pDatabase->m_cda, (text*)szSql, -1,
               NO_DEFER_PARSE, (ub4)VERSION_7))
    {
		OracleErrorReport(pDatabase, &pDatabase->m_cda, szSql);
		return FALSE;
    }
	
	nLoopCount=0;
	if(nArgc!=0)
	{
		va_start(argList, pbParamInfo);
		
		while (nLoopCount < nArgc && rc == CS_SUCCEED)
		{
			sprintf(szVarName, ":col%d", nLoopCount);
			switch (pb[nLoopCount++])
			{
			/* 字符串型 */
			case CS_CHAR_TYPE+0x20:
				nColumnType = SQLT_STR;
				pParam = (void *)szParamArray[cbString];
				strcpy(szParamArray[cbString++], va_arg(argList, char*));
				nTypeLen = strlen((char*)pParam)+1;
				break;
			/* 微型整数 */
			case CS_TINYINT_TYPE:
				nColumnType = SQLT_INT;
				pParam = &tinyIntArray[cbTinyInt];
				tinyIntArray[cbTinyInt++] = va_arg(argList, unsigned char);
				nTypeLen = 1;
				break;
			/* 短整数 */
			case CS_SMALLINT_TYPE:
				nColumnType = SQLT_INT;
				pParam = &smallIntArray[cbSmallInt];
				smallIntArray[cbSmallInt++] = va_arg(argList, short);
				nTypeLen = 2;
				break;
			/* 整数 */
			case CS_INT_TYPE:
				nColumnType = SQLT_INT;
				pParam = &nParamArray[cbInt];
				nParamArray[cbInt++] = va_arg(argList, int);
				nTypeLen = 4;
				break;
			
			/* 浮点型 */
			case CS_REAL_TYPE:
				nColumnType = SQLT_NUM;
				pParam = &realDataArray[cbRealData];
				realDataArray[cbRealData++] = va_arg(argList, double);
				nTypeLen = 8;
				break;
			
			case CS_FLOAT_TYPE:
				nColumnType = SQLT_NUM;
				pParam = &floatDataArray[cbFloatData];
				floatDataArray[cbFloatData++] = va_arg(argList, double);
				nTypeLen = 8;
				break;
			default:
				rc = CS_FAIL;
				DB_SetLastError(pDatabase, "DB_ExecuteStoredProcedure 存储过程参数类型不支持!");
				break;
			}
			if( rc == CS_SUCCEED)
			{
				/* bind the parameter */
				if(obndrv(&pDatabase->m_cda, 
					(text *) szVarName, -1, 
					(ub1 *) pParam, (sword) nTypeLen, 
					nColumnType, -1,
					(sb2 *) 0, (text *) 0, -1, -1))
				{
					OracleErrorReport(pDatabase, &pDatabase->m_lda, NULL);
					rc = CS_FAIL;
				}
			}
		}/* End of send parameters loop */
		
		va_end(argList);
	}
		
	if( rc == CS_SUCCEED)
	{
		/* bind the status parameter */
		sprintf(szVarName, ":col%d", nLoopCount);
		nColumnType = SQLT_INT;
		nTypeLen = sizeof(sword);
		if(obndrv(&pDatabase->m_cda, 
			(text *) szVarName, -1, 
			(ub1 *) npStatus, (sword) nTypeLen, 
			nColumnType, -1,
			(sb2 *) 0, (text *) 0, -1, -1))
		{
			OracleErrorReport(pDatabase, &pDatabase->m_cda, NULL);
			rc = CS_FAIL;
		}
	}
	if(rc == CS_SUCCEED)
	{
        /* execute the procedure */
        if(oexec(&pDatabase->m_cda))
        {
			OracleErrorReport(pDatabase, &pDatabase->m_cda, szSql);
			rc = CS_FAIL;
        }
	}
	
	if(rc == CS_SUCCEED) return TRUE;
	
	DB_SetLastError(pDatabase, "ExecuteStoredProcedured 执行失败!");
	return FALSE;
}
BOOL DB_BeginTransaction(CDatabase *pDatabase)
{
    if(ocof(&pDatabase->m_lda))
    {
        DB_Close(pDatabase, TRUE);
		OracleErrorReport(pDatabase, &pDatabase->m_lda, NULL);
        return FALSE;
    }
	return TRUE;
}
BOOL DB_CommitTransaction(CDatabase *pDatabase)
{
    if(ocom(&pDatabase->m_lda))
    {
        DB_Close(pDatabase, TRUE);
		OracleErrorReport(pDatabase, &pDatabase->m_lda, NULL);
        return FALSE;
    }
    if(ocon(&pDatabase->m_lda))
    {
        DB_Close(pDatabase, TRUE);
		OracleErrorReport(pDatabase, &pDatabase->m_lda, NULL);
        return FALSE;
    }
	return TRUE;
}
BOOL DB_RollbackTransaction(CDatabase *pDatabase)
{
	if(orol(&pDatabase->m_lda))
    {
        DB_Close(pDatabase, TRUE);
		OracleErrorReport(pDatabase, &pDatabase->m_lda, NULL);
        return FALSE;
    }
	return TRUE;
}
#endif