csqlctlibrary.cpp

很好用的数据库连接组件

		else
		{
			retcode = ct_cancel (NULL, i_cs_cmd, CS_CANCEL_CURRENT);	//结束当前命令
		}
	}
	else
	{
		if(nAllorCurr==SYBASE_CANCEL_ALL)
		{
			retcode = ct_cancel (i_driver_connection, NULL, CS_CANCEL_ALL);	//结束整个联接的命令
		}
		else
		{
			retcode = ct_cancel (i_driver_connection, NULL, CS_CANCEL_CURRENT);	//结束整个联接的命令
		}
	}
	if (retcode != CS_SUCCEED)	//结束失败
	{
		//    DB_TRACE (6, "SYBASE", ("sybabse_execute_cmd: ct_cancel() failed\n"));
		return SYBASE_RETURN_FAIL;	//返回失败
	}
	return SYBASE_RETURN_SUCCEED;	//返回成功
}


/*================================================================================
** 函数名称： CSYBASEResultPrivate::syb_get_result
** 主要功能： 得到结果集
** 入口参数： 无 
** 序号 参数类型 参数名称 作用 说明
** 
** 
** 
** 出口参数：
** 类型： 作用
** int 成功返回SYBASE_RETURN_SUCCEED，失败返回SYBASE_RETURN_FAIL
** 修改记录：

=================================================================================== */
int
CSYBASEResultPrivate::syb_get_result ()
{
//	TRACE("临时调试");
	i_result_ret_code = ct_results (i_cs_cmd, &i_result_res_type);
	if (i_result_ret_code == CS_FAIL)
	{
		#if 0
		ct_cancel (NULL, i_cs_cmd, CS_CANCEL_CURRENT);	//取消命令失败
		#endif
		ERRLOG(NULL,0,"调用ct_results(...)得到结果集失败，异常返回");
		return SYBASE_RETURN_FAIL;
	}
	else
	{
		LOG(NULL,0,"调用ct_results(...)得到结果集，返回成功");
		return SYBASE_RETURN_SUCCEED;
	}
}


CSYBASEBcpResultPrivate::CSYBASEBcpResultPrivate ()	//构造函数，进行初始化
{
  i_buf = NULL;

  i_nRows = -1;
  i_row_count_read = -1;
  i_nColumns = -1;
}


CSYBASEBcpResultPrivate::~CSYBASEBcpResultPrivate ()	//析构函数
{
  i_cmd->syb_cmd_cleanup ();	//清除查询结果集的命令结构
  i_cmd->syb_con_cleanup ();	////清除查询结果集的联接结构
  delete i_cmd;			//析构查询结果集私有类
  i_cmd = NULL;
#if 0
  i_return_code = ct_con_props (i_driver_connection, CS_SET, CS_BULK_LOGIN,
				(CS_VOID *) CS_FALSE, CS_UNUSED, NULL);
  if (i_return_code != CS_SUCCEED)
  {
//    DB_TRACE (5, "SYBASE", ("ct_con_props(bulk_login,false) failed\n"));
  }
#endif
  i_return_code = blk_drop (i_blk_desc);	//清除bcp描述符
  i_blk_desc = NULL;
  if (i_return_code != CS_SUCCEED)
  {
//    DB_TRACE (5, "SYBASE", ("blk_drop failed\n"));
  }
}


/*================================================================================
** 函数名称： CSYBASEResultPrivate::syb_blk_origin
** 主要功能： 进行bcp之前的准备处理
** 入口参数： 无 
** 序号 参数类型 参数名称 作用 说明
** 出口参数：
** 类型： 作用
** int 成功返回SYBASE_RETURN_SUCCEED，失败返回SYBASE_RETURN_FAIL
** 修改记录：

=================================================================================== */

int CSYBASEBcpResultPrivate::syb_blk_origin ()
{
	TRACE("int CSYBASEBcpResultPrivate::syb_blk_origin (...)");
	//CS_BOOL b_mybool=CS_TRUE;
	//  DB_TRACE (5, "SYBASE", ("syb_blk_origin begin\n"));
	if (blk_alloc (i_driver_connection, SYBASE_BLK_VERSION, &i_blk_desc) != CS_SUCCEED)	//分配bcp描述符失败
	{
		//    DB_TRACE (5, "SYBASE", ("BulkCopyIn: blk_alloc() failed\n"));
		return SYBASE_RETURN_FAIL;	//返回失败
	}
#if 0
  CS_INT buffer = CS_TRUE;
  if (blk_props (i_blk_desc, CS_SET, ARRAY_INSERT, &buffer, CS_UNUSED, NULL)
      == CS_FAIL)
  {
//    DB_TRACE (5, "SYBASE", ("BulkCopyIn: blk_props() failed"));
    return (SYBASE_RETURN_FAIL);
  }
#endif

  //将列描述数组清空
  for (int i = 0; i < SYBASE_MAX_TABLE_COLUMNS; i++)
  {
    strcpy (i_cRowBuf[i], "");
    memset (&i_RowDesc[i], 0, CS_SIZEOF (i_RowDesc[i]));
  }
  i_cmd = new CSYBASEResultPrivate ();	//新建查询结果集类，用于命令的执行
  if (i_cmd == NULL)		//分配失败
  {
//    DB_TRACE (5, "SYBASE", ("new failed \n"));
  }


  i_cmd->syb_con_init ();	//初始化查询结果集类的联接
  i_cmd->syb_connect (i_username, i_password, i_server, i_dbname, i_appname);	//用当前联接信息进行联接

  i_cmd->syb_cmd_init ();	//初始化查询结果集类的命令结构
//  DB_TRACE (5, "SYBASE", ("syb_blk_origin end\n"));
  return SYBASE_RETURN_SUCCEED;	//返回成功
}

/*================================================================================
** 函数名称： CSYBASEResultPrivate::syb_blk_init
** 主要功能： 对table_name表进行bcp的初始化
** 入口参数： 
** 序号 参数类型 参数名称 作用 说明
** 1 const char * table_name 记录表名
** 2 int direction 记录bcp的方向 
** 
** 出口参数：
** 类型： 作用
** int 成功返回SYBASE_RETURN_SUCCEED，失败返回SYBASE_RETURN_FAIL
** 修改记录：

=================================================================================== */
int
CSYBASEBcpResultPrivate::syb_blk_init (const char *table_name, int direction)
{
	//TRACE("int CSYBASEBcpResultPrivate::syb_blk_init(...)");
	LOG1(NULL,0,"进行BCP操作预处理 -- 000 --：操作表 = [%s]；",table_name);
	
	i_nColumns = syb_get_table_columns (table_name);	//得到表的列数
	if (i_nColumns <= 0)		//结果不合法
	{
		return SYBASE_RETURN_FAIL;	//返回失败
	}

	if (direction == SYBASE_BLK_IN)	//导入数据
	{
		if (blk_init (i_blk_desc, CS_BLK_IN, (char *) table_name, strlen (table_name)) == CS_FAIL)	//初始化bcp的描述结构失败
		{
			ERRLOG1(NULL,0,"进行BCP操作预处理 -- 001 --：操作表（导入数据） = [%s]；初始化失败",table_name);
			LOG1(NULL,0,"进行BCP操作预处理 -- 001 --：操作表（导入数据） = [%s]；初始化失败",table_name);
			
			return SYBASE_RETURN_FAIL;
		}
		else
		{
			LOG1(NULL,0,"进行BCP操作预处理 -- 002 --：操作表（导入数据） = [%s]；初始化成功",table_name);
		
		}
	}
	else
	{
		if (direction == SYBASE_BLK_OUT)
		{
			if (blk_init (i_blk_desc, CS_BLK_OUT, (char *) table_name, strlen (table_name)) == CS_FAIL)	//初始化bcp的描述结构失败
    			{
				ERRLOG1(NULL,0,"进行BCP操作预处理 -- 003 --：操作表（导出数据） = [%s]；初始化失败",table_name);
				return SYBASE_RETURN_FAIL;
			}
			else
			{
				LOG1(NULL,0,"进行BCP操作预处理 -- 004 --：操作表（导出数据） = [%s]；初始化成功",table_name);
				
			}
		}
		else
		{
			ERRLOG(NULL,0,"输入参数错误");
			return SYBASE_RETURN_FAIL;
		}
	}
	return SYBASE_RETURN_SUCCEED;
}


/*================================================================================
** 函数名称： CSYBASEResultPrivate::syb_blk_get_describe
** 主要功能： 得到bcp结果集的描述信息
** 入口参数： 无 
** 序号 参数类型 参数名称 作用 说明
** 
** 
** 出口参数：
** 类型： 作用
** int 成功返回SYBASE_RETURN_SUCCEED，失败返回SYBASE_RETURN_FAIL
** 修改记录：

=================================================================================== */
int CSYBASEBcpResultPrivate::syb_blk_get_describe ()
{
	//TRACE("int CSYBASEBcpResultPrivate::syb_blk_get_describe(...)");
	CS_INT num_cols;
	CS_INT i;
	CS_INT j;
	CS_INT row_count = 0;
	CS_INT rows_read;
	CS_INT disp_len;

	LOG1(NULL,0,"进行BCP操作预处理 -- 010 --：获取BCP结果集的描述,共有［%d］列",i_nColumns);

	for (i = 0; i < i_nColumns; i++)	//针对每一列
	{
		i_return_code = blk_describe (i_blk_desc, (i + 1), &i_RowDesc[i + 1]);	//得到列的描述信息
		
		LOG1(NULL,0,"进行BCP操作预处理 -- 011 --：获取BCP结果集的描述,［%s］",&i_RowDesc[i + 1]);

		if (i_return_code != CS_SUCCEED)	//失败
		{
			//      DB_TRACE (6, "SYBASE", ("syb_blk_fetch_data: i_blk_describe() failed\n"));
			//return SYBASE_RETURN_FAIL;
		}
	}
	return SYBASE_RETURN_SUCCEED;	//成功返回
}


/*================================================================================
** 函数名称： CSYBASEResultPrivate::syb_blk_bind_data
** 主要功能： 绑定结果集
** 入口参数： 
** 序号 参数类型 参数名称 作用 说明
** 1 char(*)[SYBASE_MAX_COLUMN_LENGTH] buf 缓冲指针 
** 2 int nBufNum 缓冲大小 
** 出口参数：
** 类型： 作用
** int 成功返回SYBASE_RETURN_SUCCEED，失败返回SYBASE_RETURN_FAIL
** 修改记录：

=================================================================================== */
int CSYBASEBcpResultPrivate::syb_blk_bind_data \
	(char (*result_buf)[SYBASE_MAX_COLUMN_LENGTH], int nBufNum)
{
	//TRACE("int CSYBASEBcpResultPrivate::syb_blk_bind_data(...)");
	if (result_buf != NULL && nBufNum < i_nColumns)
	{
		//    DB_TRACE (6, "SYBASE", ("result_buf not enough\n"));
		return SYBASE_RETURN_FAIL;
	}
	if(result_buf!=NULL)
	{
		i_buf=result_buf;
	}
	else
	{
		i_buf=i_cRowBuf;
	}
	LOG(NULL,0,"绑定操作");
	for (int i = 0; i < i_nColumns; i++)	//针对每一列
	{
		memset (&datafmt[i+1], 0, CS_SIZEOF (datafmt[i+1]));
		datafmt[i+1].maxlength = SYBASE_MAX_COLUMN_LENGTH;
		datafmt[i+1].datatype = CS_CHAR_TYPE;	//列类型
		datafmt[i+1].locale = 0;	//
		datafmt[i+1].count = 1;	//每次bcp的行数
		datafmt[i+1].format = CS_FMT_NULLTERM;	//数据格式：字符串以null结束
	}
	return SYBASE_RETURN_SUCCEED;
}
int CSYBASEBcpResultPrivate::syb_blk_mybind_data ()
{
	LOG(NULL,0,"针对每一列，调用sybase库函数blk_bind(...)绑定到内部缓冲");

	for (int i = 0; i < i_nColumns; i++)
	{
		i_colLen[i+1]=strlen(i_buf[i+1]);
		LOG1(&i_buf[i+1],i_colLen[i+1],"列[%d]:",i+1);
		i_return_code = blk_bind (i_blk_desc, (i + 1), &datafmt[i+1],\
					(CS_VOID *)&i_buf[i+1], &i_colLen[i+1], NULL);
		if (i_return_code != CS_SUCCEED)
		{
			ERRLOG1(NULL,0,"针对列[%d]，调用sybase库函数blk_bind(...)执行绑定失败",i+1);
			return SYBASE_RETURN_FAIL;
		}
	}
	return SYBASE_RETURN_SUCCEED;
}

//进行一次bcp处理
int CSYBASEBcpResultPrivate::syb_blk_deal_data ()
{
	long i;
	LOG(NULL,0,"调用私有类CSYBASEBcpResultPrivate::syb_blk_mybind_data(...)");
	syb_blk_mybind_data ();
	LOG(NULL,0,"调用sybase库函数blk_rowxfer (...)进行bcp处理");
	i_return_code = blk_rowxfer (i_blk_desc);
	if (i_return_code!=CS_SUCCEED)
	{
		ERRLOG(NULL,0,"调用sybase库函数blk_rowxfer (...)进行bcp处理，失败");
		return SYBASE_RETURN_FAIL;
	}
	else
	{
		return SYBASE_RETURN_SUCCEED;
	}
}




/*================================================================================
** 函数名称： CSYBASEResultPrivate::syb_blk_done
** 主要功能： 提交处理
** 入口参数： 
** 序号 参数类型 参数名称 作用 说明
** 1 int nOpt 标示部分提交还是全部提交 
** 出口参数：
** 类型： 作用
** int 成功返回SYBASE_RETURN_SUCCEED，失败返回SYBASE_RETURN_FAIL
** 修改记录：

=================================================================================== */

int
CSYBASEBcpResultPrivate::syb_blk_done (int nOpt)
{
	if (nOpt == SYBASE_BLK_DONE_ALL)	//全部提交
	{
		blk_done (i_blk_desc, CS_BLK_ALL, &i_row_count_read);
	}
	else				//部分提交
	{
		blk_done (i_blk_desc, CS_BLK_BATCH, &i_row_count_read);
	}
	return SYBASE_RETURN_SUCCEED;	//成功返回
}

/*================================================================================
** 函数名称： CSYBASEResultPrivate::syb_get_table_columns
** 主要功能： 得到表的列数
** 入口参数： 
** 序号 参数类型 参数名称 作用 说明
** 1 const char * table_name 记录表名
** 
** 
** 出口参数：
** 类型： 作用
** int 成功返回SYBASE_RETURN_SUCCEED，失败返回SYBASE_RETURN_FAIL
** 修改记录：

=================================================================================== */
int
CSYBASEBcpResultPrivate::syb_get_table_columns (const char *table_name)
{
	char cTemp[1024];
	char* pTab;
	int nReturn;
	char cDatabase[64];
	char cTable[64];
	strcpy(cDatabase,"");
	strcpy(cTable,table_name);
	strcpy(cTemp,table_name);
  
//	TRACE("int CSYBASEBcpResultPrivate::syb_get_table_columns(...)");
  
	if((pTab=strstr(cTemp,".."))!=NULL)
	{
		strcpy(cTable,pTab+2);
		*pTab='\0';
		strcpy(cDatabase,cTemp);
	}
	#if 0
	strcpy (cTemp, "SELECT	count(*) \n\
			FROM	syscolumns \n\
			WHERE	id = \n\
			(SELECT	id FROM sysobjects \n\
			WHERE	type = 'U' \n\
			AND	name = '");
	#endif
	strcpy (cTemp, "SELECT count(*) FROM ");
	strcat(cTemp,cDatabase);
	strcat(cTemp,"..syscolumns \n");
	strcat(cTemp,"WHERE id = \n");
	strcat(cTemp,"(SELECT id from ");
	strcat(cTemp,cDatabase);
	strcat(cTemp,"..sysobjects \n");
	strcat(cTemp,"WHERE type = 'U' \n");
	strcat(cTemp,"AND name = '");
	strcat (cTemp,cTable);
	strcat (cTemp, "')");
	i_cmd->syb_end_cmd ();
	LOG(NULL,0,"将上一条命令作结束处理，执行SQL命令");
	LOG1(NULL,0,"SQL = %s",cTemp);
	nReturn = i_cmd->syb_execute_cmd (cTemp);
	if (nReturn != SYBASE_RETURN_SUCCEED)
	{
		ERRLOG(NULL,0,"SQL执行失败，作结束处理，返回失败");
		i_cmd->syb_end_cmd ();
		return (SYBASE_RETURN_FAIL);
	}
	nReturn = i_cmd->syb_get_result ();
	if (nReturn != SYBASE_RETURN_SUCCEED)
	{
		ERRLOG(NULL,0,"获取SQL执行结果集失败，做结束处理，返回失败");
		i_cmd->syb_end_cmd ();
		return (SYBASE_RETURN_FAIL);
	}
	nReturn = i_cmd->syb_get_describe ();
	if (nReturn != SYBASE_RETURN_SUCCEED)
	{
		ERRLOG(NULL,0,"获取SQL执行结果集描述失败，做结束处理，返回失败");
		i_cmd->syb_end_cmd ();
		return (SYBASE_RETURN_FAIL);
	}
	nReturn = i_cmd->syb_bind_data ();
	if (nReturn != SYBASE_RETURN_SUCCEED)
	{
		ERRLOG(NULL,0,"绑定SQL执行结果集失败，做结束处理，返回失败");
		i_cmd->syb_end_cmd ();
		return (SYBASE_RETURN_FAIL);
	}
	nReturn = i_cmd->syb_fetch_data ();
	if (nReturn != SYBASE_RETURN_SUCCEED)
	{
		ERRLOG(NULL,0,"索取一行数据失败，做结束处理，返回失败");
		i_cmd->syb_end_cmd ();
		return (SYBASE_RETURN_FAIL);
	}
	i_cmd->syb_end_cmd ();
	LOG1(NULL,0,"结束处理，返回行数[%d]",atoi (i_cmd->i_cRowBuf[1]));
	return (atoi (i_cmd->i_cRowBuf[1]));
}