test.c

tuxede下面的编程

/* Result Sets Interface */
#ifndef SQL_CRSR
#  define SQL_CRSR
  struct sql_cursor
  {
    unsigned int curocn;
    void *ptr1;
    void *ptr2;
    unsigned long magic;
  };
  typedef struct sql_cursor sql_cursor;
  typedef struct sql_cursor SQL_CURSOR;
#endif /* SQL_CRSR */

/* Thread Safety */
typedef void * sql_context;
typedef void * SQL_CONTEXT;

/* Object support */
struct sqltvn
{
  unsigned char *tvnvsn; 
  unsigned short tvnvsnl; 
  unsigned char *tvnnm;
  unsigned short tvnnml; 
  unsigned char *tvnsnm;
  unsigned short tvnsnml;
};
typedef struct sqltvn sqltvn;

struct sqladts
{
  unsigned int adtvsn; 
  unsigned short adtmode; 
  unsigned short adtnum;  
  sqltvn adttvn[1];       
};
typedef struct sqladts sqladts;

static struct sqladts sqladt = {
  1,1,0,
};

/* Binding to PL/SQL Records */
struct sqltdss
{
  unsigned int tdsvsn; 
  unsigned short tdsnum; 
  unsigned char *tdsval[1]; 
};
typedef struct sqltdss sqltdss;
static struct sqltdss sqltds =
{
  1,
  0,
};

/* File name & Package Name */
struct sqlcxp
{
  unsigned short fillen;
           char  filnam[9];
};
static const struct sqlcxp sqlfpn =
{
    8,
    "test.cpp"
};


static unsigned long sqlctx = 20044;


static struct sqlexd {
   unsigned int   sqlvsn;
   unsigned int   arrsiz;
   unsigned int   iters;
   unsigned int   offset;
   unsigned short selerr;
   unsigned short sqlety;
   unsigned int   occurs;
      const short *cud;
   unsigned char  *sqlest;
      const char  *stmt;
   sqladts *sqladtp;
   sqltdss *sqltdsp;
            void  **sqphsv;
   unsigned int   *sqphsl;
            int   *sqphss;
            void  **sqpind;
            int   *sqpins;
   unsigned int   *sqparm;
   unsigned int   **sqparc;
   unsigned short  *sqpadto;
   unsigned short  *sqptdso;
            void  *sqhstv[1];
   unsigned int   sqhstl[1];
            int   sqhsts[1];
            void  *sqindv[1];
            int   sqinds[1];
   unsigned int   sqharm[1];
   unsigned int   *sqharc[1];
   unsigned short  sqadto[1];
   unsigned short  sqtdso[1];
} sqlstm = {10,1};

/* SQLLIB Prototypes */
extern void sqlcxt (void **, unsigned long *,
                    struct sqlexd *, const struct sqlcxp *);
extern void sqlcx2t(void **, unsigned long *,
                    struct sqlexd *, const struct sqlcxp *);
extern void sqlbuft(void **, char *);
extern void sqlgs2t(void **, char *);
extern void sqlorat(void **, unsigned long *, void *);

/* Forms Interface */
static const int IAPSUCC = 0;
static const int IAPFAIL = 1403;
static const int IAPFTL  = 535;
extern void sqliem(char *, int *);

typedef struct { unsigned short len; unsigned char arr[1]; } VARCHAR;
typedef struct { unsigned short len; unsigned char arr[1]; } varchar;

/* cud (compilation unit data) array */
static const short sqlcud0[] =
{10,4130,0,0,0,
5,0,0,1,48,0,516,41,0,0,1,0,0,1,0,2,5,0,0,
24,0,0,2,34,0,514,66,0,0,0,0,0,1,0,
39,0,0,3,27,0,515,119,0,0,1,1,0,1,0,1,5,0,0,
};


#include <stdio.h>
#include <atmi.h>
#include <userlog.h>


/* EXEC SQL INCLUDE sqlca;
 */ 
/*
 * $Header: sqlca.h,v 1.3 1994/12/12 19:27:27 jbasu Exp $ sqlca.h 
 */

/* Copyright (c) 1985,1986, 1998 by Oracle Corporation. */
 
/*
NAME
  SQLCA : SQL Communications Area.
FUNCTION
  Contains no code. Oracle fills in the SQLCA with status info
  during the execution of a SQL stmt.
NOTES
  **************************************************************
  ***                                                        ***
  *** This file is SOSD.  Porters must change the data types ***
  *** appropriately on their platform.  See notes/pcport.doc ***
  *** for more information.                                  ***
  ***                                                        ***
  **************************************************************

  If the symbol SQLCA_STORAGE_CLASS is defined, then the SQLCA
  will be defined to have this storage class. For example:
 
    #define SQLCA_STORAGE_CLASS extern
 
  will define the SQLCA as an extern.
 
  If the symbol SQLCA_INIT is defined, then the SQLCA will be
  statically initialized. Although this is not necessary in order
  to use the SQLCA, it is a good pgming practice not to have
  unitialized variables. However, some C compilers/OS's don't
  allow automatic variables to be init'd in this manner. Therefore,
  if you are INCLUDE'ing the SQLCA in a place where it would be
  an automatic AND your C compiler/OS doesn't allow this style
  of initialization, then SQLCA_INIT should be left undefined --
  all others can define SQLCA_INIT if they wish.

  If the symbol SQLCA_NONE is defined, then the SQLCA variable will
  not be defined at all.  The symbol SQLCA_NONE should not be defined
  in source modules that have embedded SQL.  However, source modules
  that have no embedded SQL, but need to manipulate a sqlca struct
  passed in as a parameter, can set the SQLCA_NONE symbol to avoid
  creation of an extraneous sqlca variable.
 
MODIFIED
    lvbcheng   07/31/98 -  long to int
    jbasu      12/12/94 -  Bug 217878: note this is an SOSD file
    losborne   08/11/92 -  No sqlca var if SQLCA_NONE macro set 
  Clare      12/06/84 - Ch SQLCA to not be an extern.
  Clare      10/21/85 - Add initialization.
  Bradbury   01/05/86 - Only initialize when SQLCA_INIT set
  Clare      06/12/86 - Add SQLCA_STORAGE_CLASS option.
*/
 
#ifndef SQLCA
#define SQLCA 1
 
struct   sqlca
         {
         /* ub1 */ char    sqlcaid[8];
         /* b4  */ int     sqlabc;
         /* b4  */ int     sqlcode;
         struct
           {
           /* ub2 */ unsigned short sqlerrml;
           /* ub1 */ char           sqlerrmc[70];
           } sqlerrm;
         /* ub1 */ char    sqlerrp[8];
         /* b4  */ int     sqlerrd[6];
         /* ub1 */ char    sqlwarn[8];
         /* ub1 */ char    sqlext[8];
         };

#ifndef SQLCA_NONE 
#ifdef   SQLCA_STORAGE_CLASS
SQLCA_STORAGE_CLASS struct sqlca sqlca
#else
         struct sqlca sqlca
#endif
 
#ifdef  SQLCA_INIT
         = {
         {'S', 'Q', 'L', 'C', 'A', ' ', ' ', ' '},
         sizeof(struct sqlca),
         0,
         { 0, {0}},
         {'N', 'O', 'T', ' ', 'S', 'E', 'T', ' '},
         {0, 0, 0, 0, 0, 0},
         {0, 0, 0, 0, 0, 0, 0, 0},
         {0, 0, 0, 0, 0, 0, 0, 0}
         }
#endif
         ;
#endif
 
#endif
 
/* end SQLCA */

/* EXEC ORACLE OPTION (RELEASE_CURSOR = YES); */ 


/* EXEC SQL BEGIN DECLARE SECTION; */ 

	char    c_ename[20];
	/* EXEC SQL VAR  c_ename 		IS STRING(20); */ 

/* EXEC SQL END DECLARE SECTION; */ 


int tpsvrinit(argc, argv)
int argc;
char *argv[];
{
	if(tpopen()==-1)
	{
		userlog("tpopen() failure\n");	
		return -2;
	}
	return 0;
}
void tpsvrdone()
{
	if(tpclose()==-1)
	{
		userlog("tpclose() failure\n");	
	}
}

ENQ(TPSVCINFO *rqst)
{
	char *reqstr;	
	long len;	
	TPQCTL qctl;	

	    
	reqstr=rqst->data;
	 /* EXEC SQL SELECT ename into :c_ename from EMP where empno=1000; */ 

{
  struct sqlexd sqlstm;

  sqlstm.sqlvsn = 10;
  sqlstm.arrsiz = 1;
  sqlstm.sqladtp = &sqladt;
  sqlstm.sqltdsp = &sqltds;
  sqlstm.stmt = "select ename into :b0  from EMP where empno=1000";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )5;
  sqlstm.selerr = (unsigned short)1;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)256;
  sqlstm.occurs = (unsigned int  )0;
  sqlstm.sqhstv[0] = (         void  *)c_ename;
  sqlstm.sqhstl[0] = (unsigned int  )20;
  sqlstm.sqhsts[0] = (         int  )0;
  sqlstm.sqindv[0] = (         void  *)0;
  sqlstm.sqinds[0] = (         int  )0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqadto[0] = (unsigned short )0;
  sqlstm.sqtdso[0] = (unsigned short )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqphss = sqlstm.sqhsts;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqpins = sqlstm.sqinds;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlstm.sqpadto = sqlstm.sqadto;
  sqlstm.sqptdso = sqlstm.sqtdso;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
}


        if(sqlca.sqlcode !=0)
	{
		userlog("%d, %s\n",sqlca.sqlcode,(char *)sqlca.sqlerrm.sqlerrmc);
		strcpy(reqstr,(char *)sqlca.sqlerrm.sqlerrmc);
		tpreturn( TPFAIL, 0, reqstr, 0, 0 );
	}
	if(tpbegin(30,0) == -1)
	{
		userlog("tpbegin() fail=%s\n",tpstrerror(tperrno));
		strcpy(reqstr,tpstrerror(tperrno));
		tpreturn( TPFAIL, 0, reqstr, 0, 0 );
	}
	
	qctl.flags = 0;
	if (tpenqueue("QSPACE", "DEMOQ", (TPQCTL *)&qctl,(char *)reqstr,0, 0) == -1) 
	{
		userlog("tpenqueue() failure: %s\n",tpstrerror(tperrno));
		if (tperrno == TPEDIAGNOSTIC) 
		{
			printf("Queue manager diagnostic %ld\n",qctl.diagnostic);
		}
		strcpy(reqstr,tpstrerror(tperrno));
		tpreturn( TPFAIL, 0, reqstr, 0, 0 );
       }
       /* EXEC SQL delete from EMP where empno=1000; */ 

{
       struct sqlexd sqlstm;

       sqlstm.sqlvsn = 10;
       sqlstm.arrsiz = 1;
       sqlstm.sqladtp = &sqladt;
       sqlstm.sqltdsp = &sqltds;
       sqlstm.stmt = "delete  from EMP  where empno=1000";
       sqlstm.iters = (unsigned int  )1;
       sqlstm.offset = (unsigned int  )24;
       sqlstm.cud = sqlcud0;
       sqlstm.sqlest = (unsigned char  *)&sqlca;
       sqlstm.sqlety = (unsigned short)256;
       sqlstm.occurs = (unsigned int  )0;
       sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
}


	if(sqlca.sqlcode !=0)
	{
		userlog("%d, %s\n",sqlca.sqlcode,(char *)sqlca.sqlerrm.sqlerrmc);
		strcpy(reqstr,(char *)sqlca.sqlerrm.sqlerrmc);
		if(tpabort(0)==-1)
		{
			userlog("tpabort() failure:%s\n",tpstrerror(tperrno));	
			strcpy(reqstr,tpstrerror(tperrno));
		}
		tpreturn( TPFAIL, 0, reqstr, 0, 0 );
	}
	
	if(tpcommit(0) == -1)
	{
		userlog("tpcommit failure: %s\n",tpstrerror(tperrno));
		strcpy(reqstr,tpstrerror(tperrno));
		tpreturn( TPFAIL, 0, reqstr, 0, 0 );
	}
	strcpy(reqstr,"ENQ success!");
	tpreturn( TPSUCCESS, 0, reqstr, 0, 0 );
	
}




DEQ(TPSVCINFO *rqst)
{
	
	char *reqstr;	
	long len;	
	TPQCTL qctl;	

	
        reqstr=rqst->data;
	qctl.flags = 0;
	if(tpbegin(30,0) == -1)
	{
		userlog("tpbegin() fail=%s\n",tpstrerror(tperrno));
	}
	if (tpdequeue("QSPACE", "DEMOQ", (TPQCTL *)&qctl, (char **)&reqstr,&len, TPNOTIME) == -1) 
        {
		userlog("tpdequeue() failure: %s\n",tpstrerror(tperrno));
		if (tperrno == TPEDIAGNOSTIC) 
                {
			userlog("Queue manager diagnostic %ld\n",qctl.diagnostic);
		}
		strcpy(reqstr,tpstrerror(tperrno));
		tpreturn( TPFAIL, 0, reqstr, 0, 0 );
	}
	userlog("dequeue data:%s\n",reqstr);
	strcpy(c_ename,reqstr);
	/* EXEC SQL INSERT INTO ss values(:c_ename); */ 

{
 struct sqlexd sqlstm;

 sqlstm.sqlvsn = 10;
 sqlstm.arrsiz = 1;
 sqlstm.sqladtp = &sqladt;
 sqlstm.sqltdsp = &sqltds;
 sqlstm.stmt = "insert into ss values (:b0)";
 sqlstm.iters = (unsigned int  )1;
 sqlstm.offset = (unsigned int  )39;
 sqlstm.cud = sqlcud0;
 sqlstm.sqlest = (unsigned char  *)&sqlca;
 sqlstm.sqlety = (unsigned short)256;
 sqlstm.occurs = (unsigned int  )0;
 sqlstm.sqhstv[0] = (         void  *)c_ename;
 sqlstm.sqhstl[0] = (unsigned int  )20;
 sqlstm.sqhsts[0] = (         int  )0;
 sqlstm.sqindv[0] = (         void  *)0;
 sqlstm.sqinds[0] = (         int  )0;
 sqlstm.sqharm[0] = (unsigned int  )0;
 sqlstm.sqadto[0] = (unsigned short )0;
 sqlstm.sqtdso[0] = (unsigned short )0;
 sqlstm.sqphsv = sqlstm.sqhstv;
 sqlstm.sqphsl = sqlstm.sqhstl;
 sqlstm.sqphss = sqlstm.sqhsts;
 sqlstm.sqpind = sqlstm.sqindv;
 sqlstm.sqpins = sqlstm.sqinds;
 sqlstm.sqparm = sqlstm.sqharm;
 sqlstm.sqparc = sqlstm.sqharc;
 sqlstm.sqpadto = sqlstm.sqadto;
 sqlstm.sqptdso = sqlstm.sqtdso;
 sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
}


	if(sqlca.sqlcode !=0)
	{
		userlog("%d, %s\n",sqlca.sqlcode,(char *)sqlca.sqlerrm.sqlerrmc);
		strcpy(reqstr,(char *)sqlca.sqlerrm.sqlerrmc);
		if(tpabort(0)==-1)
		{
			userlog("tpabort() failure: %s\n",tpstrerror(tperrno));	
			strcpy(reqstr,tpstrerror(tperrno));
		}
		tpreturn( TPFAIL, 0, reqstr, 0, 0 );
	}
	if(tpcommit(0) == -1)
	{
		userlog("tpcommit() failure: %s\n",tpstrerror(tperrno));
	}
	tpreturn( TPSUCCESS, 0, reqstr, 0, 0 );
	
}