blktxt.c

sybase数据库ct library的开发,使用了所以有函数

/*
** CreateDatabase()
**
** Type of function:
** 	blktxt program internal api
**
** Purpose:
** 	This routine uses ex_create_db() to create a database. It also enables
** 	the ability to bulkcopy into the newly created database.
**
** Parameters:
** 	connection	- Pointer to CS_CONNECTION structure.
**
** Return:
**	CS_SUCCEED if database was created.
**	Otherwise a Client-Library failure code.
*/

CS_STATIC CS_RETCODE 
CreateDatabase(connection)
CS_CONNECTION   *connection;
{
	CS_CHAR         *cmdbuf;
	CS_RETCODE	retcode;

	/*
	** create database
	*/
	retcode = ex_create_db(connection, Ex_dbname);
	if (retcode != CS_SUCCEED)
	{
		ex_error("CreateDatabase: ex_create_db() failed");
		return retcode;
	}

	/*
	** Allocate the buffer for the command string.
	*/
	cmdbuf = (CS_CHAR *) malloc(EX_BUFSIZE);
	if (cmdbuf == (CS_CHAR *)NULL)
	{
		ex_error("CreateDatabase: malloc() failed");
		return CS_FAIL;
	}


	/*
	** Enable bulkcopy into the new database
	*/
	sprintf(cmdbuf, "exec sp_dboption %s, \"select into/bulkcopy\", true",
		                  Ex_dbname);
        if ((retcode = ex_execute_cmd(connection, cmdbuf)) != CS_SUCCEED)
        {
                ex_error("CreateDatabase: ex_execute_cmd(sp_dboption) failed");
		free (cmdbuf);
		return retcode;
	}

	/*
	** connect to the new database.
	*/
        if ((retcode = ex_use_db(connection, Ex_dbname)) != CS_SUCCEED)
        {
                ex_error("CreateDatabase: ex_use_db(Ex_dbname) failed");
		free (cmdbuf);
                return retcode;
        }

	/*
	** Checkpoint the server
	*/
	sprintf(cmdbuf, "checkpoint");
        if ((retcode = ex_execute_cmd(connection, cmdbuf)) != CS_SUCCEED)
        {
                ex_error("CreateDatabase: ex_execute_cmd(checkpoint) failed");
	}
	free(cmdbuf);	
	return retcode;
}

/*
** CreateTable()
**
** Type of function:
** 	blktxt program internal api
**
** Purpose:
** 	This routine sets up the table for testing - if the table
**	already exists, it first deletes it.
**
** Parameters:
** 	connection	- Pointer to CS_CONNECTION structure.
**
** Return:
**	CS_SUCCEED if table was created.
**	Otherwise a Client-Library failure code.
*/

CS_STATIC CS_RETCODE 
CreateTable(connection)
CS_CONNECTION   *connection;
{

	CS_RETCODE	retcode;
	CS_CHAR		*cmdbuf;

	cmdbuf = (CS_CHAR *) malloc(EX_BUFSIZE);
	if (cmdbuf == (CS_CHAR *)NULL)
	{
		ex_error("CreateTable: malloc() failed");
		return CS_MEM_ERROR;
	}

	/*
	** set up the command to send to the server checking for
	** the the table.
	*/
	sprintf(cmdbuf, "if exists (select name from sysobjects \
			where name = \"%s\")\
				 drop table %s",
					Ex_tabname, Ex_tabname);
        if ((retcode = ex_execute_cmd(connection, cmdbuf)) != CS_SUCCEED)
        {
                ex_error("CreateTable: ex_execute_cmd(drop table) failed");
		free (cmdbuf);
		return retcode;
	}
		
	/*
	** create the table with a column of each kind of data -
	*/
	sprintf(cmdbuf, "create table %s\
                       (pub_id char(4) not null,\
                        pub_name varchar(40) null,\
                        city varchar(20) null,\
                        state char(2) null,\
                        bio text not null)", Ex_tabname);
	
        if ((retcode = ex_execute_cmd(connection, cmdbuf)) != CS_SUCCEED)
        {
                ex_error("CreateTable: ex_execute_cmd(create table) failed");
	}
	free(cmdbuf);
	return retcode;
}

/*
** BulkCopyIn()
**
** Type of function:
** 	blktxt program internal api
**
** Purpose:
** 	This routine is the main driver for doing the bulk copy operation.
** 	It assumes that the database and tables have been set up.
**
** Parameters:
** 	connection	- Pointer to CS_CONNECTION structure.
**
** Return:
*/

CS_STATIC CS_RETCODE 
BulkCopyIn(connection)
CS_CONNECTION   *connection;
{
	CS_BLKDESC	*blkdesc;
    	CS_DATAFMT	datafmt;	/* hold the variable descriptions  */
	Blk_Data 	*dptr;		/* point to the data for transfer */
	CS_INT		datalen[5];	/* the length of the variable data */
	CS_INT          len;
	CS_INT		numrows;
        CS_INT          buffer=CS_TRUE ;


	/*
	** Ready to start the bulk copy in now that all the connections
	** have been made and have a table name.
	**
	** Start by getting the bulk descriptor and starting the initialization
	*/
	if (blk_alloc(connection, EX_BLK_VERSION, &blkdesc) != CS_SUCCEED)
	{
		ex_error("BulkCopyIn: blk_alloc() failed");
		return CS_FAIL;
	}

        if (blk_props(blkdesc,CS_SET,ARRAY_INSERT,&buffer,CS_UNUSED,NULL) == CS_FAIL)
        {
                ex_error("BulkCopyIn: blk_props() failed");
                return (CS_FAIL);
        }
	if (blk_init(blkdesc, CS_BLK_IN,
				 Ex_tabname, strlen(Ex_tabname)) == CS_FAIL)
	{
		ex_error("BulkCopyIn: blk_init() failed");
		return CS_FAIL;
	}


	/*
	** Now to bind the variables to the columns and transfer the data
	*/
        datafmt.locale = 0;
	datafmt.count = 1;
	dptr = BLKDATA;
	while (dptr->pub_id != DATA_END)
	{
		datafmt.datatype = CS_INT_TYPE;
		datafmt.maxlength = sizeof(CS_INT);
		datalen[0] = CS_UNUSED;

		if (blk_bind(blkdesc, 1, &datafmt, &dptr->pub_id, 
					&datalen[0], NULL) != CS_SUCCEED)
		{
			ex_error("BulkCopyIn: blk_bind(1) failed");
			return CS_FAIL;
		}
		datafmt.datatype = CS_CHAR_TYPE;
		datafmt.maxlength = MAX_PUBNAME - 1;
		datalen[1] = strlen(dptr->pub_name);
		if (blk_bind(blkdesc, 2, &datafmt, (CS_VOID *)dptr->pub_name,
					 &datalen[1], NULL) != CS_SUCCEED)
		{
			ex_error("BulkCopyIn: blk_bind(2) failed");
			return CS_FAIL;
		}
		datafmt.maxlength = MAX_PUBCITY - 1;
		datalen[2] = strlen(dptr->pub_city);
		if (blk_bind(blkdesc, 3, &datafmt, (CS_VOID *)dptr->pub_city,
					 &datalen[2], NULL) != CS_SUCCEED)
		{
			ex_error("BulkCopyIn: blk_bind(3) failed");
			return CS_FAIL;
		}
		datafmt.maxlength = MAX_PUBST - 1;
		datalen[3] = strlen(dptr->pub_st);
		if (blk_bind(blkdesc, 4, &datafmt, (CS_VOID *)dptr->pub_st,
					 &datalen[3], NULL) != CS_SUCCEED)
		{
			ex_error("BulkCopyIn: blk_bind(4) failed");
			return CS_FAIL;
		}
		datafmt.maxlength = MAX_BIO - 1;
		datalen[4] = strlen((char *)dptr->pub_bio);
		if (blk_bind(blkdesc, 5, &datafmt, (CS_VOID *)dptr->pub_bio,
					 &datalen[4], NULL) != CS_SUCCEED)
		{
			ex_error("BulkCopyIn: blk_bind(5) failed");
			return CS_FAIL;
		}
		if (blk_rowxfer (blkdesc) == CS_FAIL)
		{
			ex_error("BulkCopyIn: blk_rowxfer() failed");
			return CS_FAIL;
		}
		dptr++;
	}

	/*
        ** Send these rows over as a batch
	*/	
	if (blk_done(blkdesc, CS_BLK_BATCH, &numrows) == CS_FAIL)
	{
		ex_error("BulkCopyIn: blk_done() failed");
		return CS_FAIL;
	}
	fprintf(stderr, "Number of data rows transferred = %d.\n", numrows);
	fflush(stderr);

	/*
	** Now let's try the whole thing again with textxfer -
	** first get rid of all the previous binds.
        */
	if (blk_bind(blkdesc, CS_UNUSED, NULL, NULL,
		             NULL, NULL) == CS_FAIL)
        {
	        ex_error("BulkCopyIn: blk_bind(clear) failed");
		return CS_FAIL;
        }
	dptr = BLKDATA;
	while (dptr->pub_id != DATA_END)
	{
		datafmt.datatype = CS_INT_TYPE;
		datafmt.count = 1;
		datafmt.maxlength = sizeof(CS_INT);
		datalen[0] = CS_UNUSED;

		if (blk_bind(blkdesc, 1, &datafmt, (CS_VOID *)&dptr->pub_id, 
					&datalen[0], NULL) != CS_SUCCEED)
		{
			ex_error("BulkCopyIn: blk_bind(1) failed");
			return CS_FAIL;
		}
		datafmt.datatype = CS_CHAR_TYPE;
		datafmt.maxlength = MAX_PUBNAME - 1;
		datalen[1] = strlen(dptr->pub_name);
		if (blk_bind(blkdesc, 2, &datafmt, (CS_VOID *)dptr->pub_name,
					 &datalen[1], NULL) != CS_SUCCEED)
		{
			ex_error("BulkCopyIn: blk_bind(2) failed");
			return CS_FAIL;
		}
		datafmt.maxlength = MAX_PUBCITY - 1;
		datalen[2] = strlen(dptr->pub_city);
		if (blk_bind(blkdesc, 3, &datafmt, (CS_VOID *)dptr->pub_city,
					 &datalen[2], NULL) != CS_SUCCEED)
		{
			ex_error("BulkCopyIn: blk_bind(3) failed");
			return CS_FAIL;
		}
		datafmt.maxlength = MAX_PUBST - 1;
		datalen[3] = strlen(dptr->pub_st);
		if (blk_bind(blkdesc, 4, &datafmt, (CS_VOID *)dptr->pub_st,
					 &datalen[3], NULL) != CS_SUCCEED)
		{
			ex_error("BulkCopyIn: blk_bind(4) failed");
			return CS_FAIL;
		}
		datafmt.datatype = CS_TEXT_TYPE;
		datafmt.maxlength = MAX_BIO - 1;
		datalen[4] = strlen((char *)dptr->pub_bio);
		if (blk_bind(blkdesc, 5, &datafmt, NULL,
					 &datalen[4], NULL) != CS_SUCCEED)
		{
			ex_error("BulkCopyIn: blk_bind(5) failed");
			return CS_FAIL;
		}
		if (blk_rowxfer (blkdesc) == CS_FAIL)
		{
			ex_error("BulkCopyIn: EX_BLK - Failed on blk_rowxfer.");
			return CS_FAIL;
		}
		if (blk_textxfer(blkdesc, dptr->pub_bio, datalen[4], &len)
		                   == CS_FAIL)
		{
			ex_error("BulkCopyIn: blk_textxfer() failed");
			return CS_FAIL;
		}
		dptr++;
	}
	/*
	** ALL the rows sent so clear up
	*/
	if (blk_done(blkdesc, CS_BLK_ALL, &numrows) == CS_FAIL)
	{
		ex_error("BulkCopyIn: blk_done() failed");
		return CS_FAIL;
	}
	if (blk_drop(blkdesc) == CS_FAIL)
	{
		ex_error("BulkCopyIn: blk_drop() failed");
		return CS_FAIL;
	}

	/*
	** Give number of rows read/written
	*/
	fprintf(stderr, "Number of data rows transferred = %d.\n", numrows);
	fflush(stderr);

        return CS_SUCCEED;
}