pcs_snd_zfjb1.c

unix 下用pro*c tuxedo 开发的东西

    	rtn_code = InsertSndZFJBDB();
      	if ( rtn_code < 0 )
       	{
        	ProcessError(LOG_ERROR,"Pcs_Snd_ZFJB1.x: Calling Function \
        			InsertSndZFJBDB() Failed!",END);
        	if ( buf_zfjb != NULL ) free( buf_zfjb);
       		return(-1);
       	}
 
 
    	rtn_code = UpdateSndLogRecStatus();
       	if ( rtn_code < 0 )
        {
        	ProcessError(LOG_ERROR,"Pcs_Snd_ZFJB1.x: Calling Function \
        			UpdateSndLogRecStatus() Failed!",END);
	        return(-1);
        }
 
    	return(1);
}                 /* end of pcssndzfjb funtion*/
  


int InitSndZFJB1()
{

 	/* EXEC SQL BEGIN DECLARE SECTION; */ 

      		/* VARCHAR userid[10]; */ 
struct { unsigned short len; unsigned char arr[10]; } userid;

      		/* VARCHAR password[10]; */ 
struct { unsigned short len; unsigned char arr[10]; } password;

 	/* EXEC SQL END DECLARE SECTION; */ 

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

/* Copyright (c) 1985,1986 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
    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  */ long    sqlabc;
         /* b4  */ long    sqlcode;
         struct
           {
           /* ub2 */ unsigned short sqlerrml;
           /* ub1 */ char           sqlerrmc[70];
           } sqlerrm;
         /* ub1 */ char    sqlerrp[8];
         /* b4  */ long    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 SQL WHENEVER SQLERROR GOTO sqlerror; */ 

 
 	
 	/*****************************
  	| Connect to DataBase	     |
  	*****************************/
  	
 	strcpy( userid.arr,"pcsdba"); 
 	userid.len = strlen (userid.arr);
 	strcpy( password.arr,"dba");
 	password.len = strlen( password.arr);

 	/* EXEC SQL CONNECT :userid IDENTIFIED BY :password; */ 

{
  struct sqlexd sqlstm;

  sqlstm.sqlvsn = 8;
  sqlstm.arrsiz = 3;
  sqlstm.iters = (unsigned int  )10;
  sqlstm.offset = (unsigned int  )16;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)0;
  sqlstm.sqhstv[0] = (unsigned char  *)&userid;
  sqlstm.sqhstl[0] = (unsigned int  )12;
  sqlstm.sqindv[0] = (         short *)0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqhstv[1] = (unsigned char  *)&password;
  sqlstm.sqhstl[1] = (unsigned int  )12;
  sqlstm.sqindv[1] = (         short *)0;
  sqlstm.sqharm[1] = (unsigned int  )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) goto sqlerror;
}


  	return (1);

	sqlerror:
	/* EXEC SQL WHENEVER SQLERROR CONTINUE; */ 

	ProcessError(LOG_ERROR,   "DataBase Error:%s!", sqlca.sqlerrm.sqlerrmc );
 	/* EXEC SQL RollBack; */ 

{
  struct sqlexd sqlstm;

  sqlstm.sqlvsn = 8;
  sqlstm.arrsiz = 3;
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )42;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)0;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
}


 	return(-1);

}



int ReadZFJFileData(char *file_name )
{
 	int 	len_zfjb_file;

 	fp = fopen(file_name,"r");
	if (fp == NULL) 
 	{
 		ProcessError(LOG_ERROR,"Pcs_Snd_ZFJB1.x: Open ZFJB \
 				File Error!",END);
 		return(-1);
 	}
 	
 	file_name = file_name + mypath(file_name);
 	
    	fsfbh[0] = file_name[5];
    	fsfbh[1] = file_name[6];
    	fsfbh[2] = '\0';
    
    	year = file_name[7];

    	fseek( fp,0,2);
    	len_zfjb_file = ftell( fp);           
 
    	buf_zfjb = ( char * )malloc( len_zfjb_file + 1);
    	if (buf_zfjb == NULL) 
 	{
 		ProcessError(LOG_ERROR,"Pcs_Snd_ZFJB1.x: Malloc ZFJB \
 				Buffer Error!",END);
 		return ( -1);
 	}
 	
 	memset( buf_zfjb, '\0', len_zfjb_file + 1 );
    	
    	fseek( fp,0,0);  
    	fread( buf_zfjb,len_zfjb_file,1,fp ); 
	fclose( fp );
	tmp = buf_zfjb;	
 	return(1);      
 	
}


int CreateSndLogAndHZRec(char * hz_pc)
{
	int 	sj_count,i=1, pc;
	char 	sjbh_99[3];

	/* EXEC SQL WHENEVER SQLERROR GOTO sqlerror; */ 


	/* EXEC SQL SELECT s_fsxh.nextval INTO :sequ FROM SYS.DUAL; */ 

{
 struct sqlexd sqlstm;

 sqlstm.sqlvsn = 8;
 sqlstm.arrsiz = 3;
 sqlstm.stmt = "select s_fsxh.nextval  into :b0  from SYS.DUAL ";
 sqlstm.iters = (unsigned int  )1;
 sqlstm.offset = (unsigned int  )56;
 sqlstm.selerr = (unsigned short)1;
 sqlstm.cud = sqlcud0;
 sqlstm.sqlest = (unsigned char  *)&sqlca;
 sqlstm.sqlety = (unsigned short)0;
 sqlstm.sqhstv[0] = (unsigned char  *)&sequ;
 sqlstm.sqhstl[0] = (unsigned int  )4;
 sqlstm.sqindv[0] = (         short *)0;
 sqlstm.sqharm[0] = (unsigned int  )0;
 sqlstm.sqphsv = sqlstm.sqhstv;
 sqlstm.sqphsl = sqlstm.sqhstl;
 sqlstm.sqpind = sqlstm.sqindv;
 sqlstm.sqparm = sqlstm.sqharm;
 sqlstm.sqparc = sqlstm.sqharc;
 sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
 if (sqlca.sqlcode < 0) goto sqlerror;
}




	/* EXEC SQL INSERT INTO T_FSRZ 
     		VALUES( :sequ, '4', '1', sysdate ); */ 

{
 struct sqlexd sqlstm;

 sqlstm.sqlvsn = 8;
 sqlstm.arrsiz = 3;
 sqlstm.stmt = "insert into T_FSRZ values (:b0,'4','1',sysdate )";
 sqlstm.iters = (unsigned int  )1;
 sqlstm.offset = (unsigned int  )74;
 sqlstm.cud = sqlcud0;
 sqlstm.sqlest = (unsigned char  *)&sqlca;
 sqlstm.sqlety = (unsigned short)0;
 sqlstm.sqhstv[0] = (unsigned char  *)&sequ;
 sqlstm.sqhstl[0] = (unsigned int  )4;
 sqlstm.sqindv[0] = (         short *)0;
 sqlstm.sqharm[0] = (unsigned int  )0;
 sqlstm.sqphsv = sqlstm.sqhstv;
 sqlstm.sqphsl = sqlstm.sqhstl;
 sqlstm.sqpind = sqlstm.sqindv;
 sqlstm.sqparm = sqlstm.sqharm;
 sqlstm.sqparc = sqlstm.sqharc;
 sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
 if (sqlca.sqlcode < 0) goto sqlerror;
}



	/* EXEC SQL SELECT count(*) INTO :sj_count FROM T_SJBH 
			WHERE SJBH<>'99' AND SJBH<>:fsfbh ; */ 

{
 struct sqlexd sqlstm;

 sqlstm.sqlvsn = 8;
 sqlstm.arrsiz = 3;
 sqlstm.stmt = "select count(*)  into :b0  from T_SJBH where (SJBH<>'99' an\
d SJBH<>:b1)";
 sqlstm.iters = (unsigned int  )1;
 sqlstm.offset = (unsigned int  )92;
 sqlstm.selerr = (unsigned short)1;
 sqlstm.cud = sqlcud0;
 sqlstm.sqlest = (unsigned char  *)&sqlca;
 sqlstm.sqlety = (unsigned short)0;
 sqlstm.sqhstv[0] = (unsigned char  *)&sj_count;
 sqlstm.sqhstl[0] = (unsigned int  )4;
 sqlstm.sqindv[0] = (         short *)0;
 sqlstm.sqharm[0] = (unsigned int  )0;
 sqlstm.sqhstv[1] = (unsigned char  *)fsfbh;
 sqlstm.sqhstl[1] = (unsigned int  )3;
 sqlstm.sqindv[1] = (         short *)0;
 sqlstm.sqharm[1] = (unsigned int  )0;
 sqlstm.sqphsv = sqlstm.sqhstv;
 sqlstm.sqphsl = sqlstm.sqhstl;
 sqlstm.sqpind = sqlstm.sqindv;
 sqlstm.sqparm = sqlstm.sqharm;
 sqlstm.sqparc = sqlstm.sqharc;
 sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
 if (sqlca.sqlcode < 0) goto sqlerror;
}


		

	/* EXEC SQL DECLARE sjbh_cursor CURSOR FOR
        		SELECT SJBH FROM T_SJBH 
			WHERE SJBH<>'99' AND SJBH<>:fsfbh ; */ 


	/* EXEC SQL OPEN sjbh_cursor; */ 

{
 struct sqlexd sqlstm;

 sqlstm.sqlvsn = 8;
 sqlstm.arrsiz = 3;
 sqlstm.stmt = sq0007;
 sqlstm.iters = (unsigned int  )1;
 sqlstm.offset = (unsigned int  )114;
 sqlstm.cud = sqlcud0;
 sqlstm.sqlest = (unsigned char  *)&sqlca;
 sqlstm.sqlety = (unsigned short)0;
 sqlstm.sqhstv[0] = (unsigned char  *)fsfbh;
 sqlstm.sqhstl[0] = (unsigned int  )3;
 sqlstm.sqindv[0] = (         short *)0;
 sqlstm.sqharm[0] = (unsigned int  )0;
 sqlstm.sqphsv = sqlstm.sqhstv;
 sqlstm.sqphsl = sqlstm.sqhstl;
 sqlstm.sqpind = sqlstm.sqindv;
 sqlstm.sqparm = sqlstm.sqharm;
 sqlstm.sqparc = sqlstm.sqharc;
 sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
 if (sqlca.sqlcode < 0) goto sqlerror;
}

	

	pc = atoi( pc );

	for (i=1; i <= sj_count; i++) 
	{
			
		/* EXEC SQL FETCH sjbh_cursor INTO :sjbh_99; */ 

{
  struct sqlexd sqlstm;

  sqlstm.sqlvsn = 8;
  sqlstm.arrsiz = 3;
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )132;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;
  sqlstm.sqlety = (unsigned short)0;
  sqlstm.sqhstv[0] = (unsigned char  *)sjbh_99;
  sqlstm.sqhstl[0] = (unsigned int  )3;
  sqlstm.sqindv[0] = (         short *)0;
  sqlstm.sqharm[0] = (unsigned int  )0;
  sqlstm.sqphsv = sqlstm.sqhstv;
  sqlstm.sqphsl = sqlstm.sqhstl;
  sqlstm.sqpind = sqlstm.sqindv;
  sqlstm.sqparm = sqlstm.sqharm;
  sqlstm.sqparc = sqlstm.sqharc;
  sqlcxt((void **)0, &sqlctx, &sqlstm, &sqlfpn);
  if (sqlca.sqlcode < 0) goto sqlerror;
}



		#ifdef DEBUG
			printf("insert t_hz jssjbh is %s\n",sjbh_99);
		#endif
	     		
		/* EXEC SQL INSERT INTO T_HZ VALUES \
			(sysdate, :sjbh_99, '1', :sequ,'', :pc); */ 

{
  struct sqlexd sqlstm;

  sqlstm.sqlvsn = 8;
  sqlstm.arrsiz = 3;
  sqlstm.stmt = "insert into T_HZ values (sysdate ,:b0,'1',:b1,'',:b2)";
  sqlstm.iters = (unsigned int  )1;
  sqlstm.offset = (unsigned int  )150;
  sqlstm.cud = sqlcud0;
  sqlstm.sqlest = (unsigned char  *)&sqlca;