pcs_input_zfjb.c

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

/* 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 */

   	
   	rtn_code = Init_Input_ZFJB();
    	if ( rtn_code < 0 )
     	{
       	   	ProcessError(LOG_ERROR,"Pcs_Input_ZFJB.x: Calling Function \
       	   			Init_Input_ZFJB() Failed!",END);
	       	exit(-1);
        }
 

	rtn_code = Read_ZFJ_File( argv[1] );
    	if ( rtn_code < 0 )
     	{
       		ProcessError(LOG_ERROR,"Pcs_Input_ZFJB.x: Calling Function \
       				Read_ZFJ_File() Failed!",END);
       		if ( buf_zfjb != NULL ) free( buf_zfjb);
       		fclose(fp);
        	exit(-1);
     	}    	
 
    	rtn_code = Insert_ZFJ_DB();
      	if ( rtn_code < 0 )
       	{
        	ProcessError(LOG_ERROR,"Pcs_Input_ZFJB.x: Calling Function \
        			Insert_ZFJ_DB() Failed!",END);
        	if ( buf_zfjb != NULL ) free( buf_zfjb);
        	exit(-1);
       	}

   	rtn_code = End_PCS_Input_ZFJB();
     	if ( rtn_code < 0 )
      	{
        	ProcessError(LOG_ERROR,"Pcs_Input_ZFJB.x: Calling Function \
        			End_PCS_Input_ZFJB() Failed!",END);
        	exit(-1);
      	}
      

} /* end of main program */


  void Free_Mem()
  {
    	if ( tmp != NULL ) free( tmp );
    	fclose(fp);
    	/* EXEC SQL ROLLBACK RELEASE; */ 

{
     struct sqlexd sqlstm;

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


  }
   
   
int Init_Input_ZFJB()
{

 	/* 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 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:
 	ProcessError(LOG_ERROR,"Connect To DataBase SQL Error!");
 	/* 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);
  if (sqlca.sqlcode < 0) goto sqlerror;
}


 	return(-1);

}



int Read_ZFJ_File(char *file_name )
{
 	int 	len_zfjb_file;

 	fp = fopen(file_name,"r");
	if (fp == NULL) 
 	{
 		ProcessError(LOG_ERROR,"Pcs_Input_ZFJB.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_Input_ZFJB.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 Insert_ZFJ_DB()
{
	char 	zfjbh[9], zfjmc[17], sys_year[5];
	int 	i = 0, j = 0, comma = 0, p = 0, nf, dsn, count_zfj;
	int     round_xh;
	

 	sys_year[0] = '\0';
	/* EXEC SQL SELECT TO_CHAR(SYSDATE,'yyyy') INTO :sys_year FROM SYS.DUAL; */ 

{
 struct sqlexd sqlstm;

 sqlstm.sqlvsn = 8;
 sqlstm.arrsiz = 3;
 sqlstm.stmt = "select TO_CHAR(sysdate ,'yyyy') 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  *)sys_year;
 sqlstm.sqhstl[0] = (unsigned int  )5;
 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;
}


	sys_year[5] = '\0';
	

  	dsn = atoi(sys_year) % 10;  
	
  	if (((ThisYearIsDn ) && (year == '0')) || ((ThisYearIsSn ) && \
  	(year == '1')) ) 
  		nf = atoi(sys_year)+1;
	else 
		nf = atoi(sys_year);  
	
	/* EXEC SQL select count(*) into count_zfj from t_zfj where sjbh=:fsfbh and yxnf=:nf; */ 

{
 struct sqlexd sqlstm;

 sqlstm.sqlvsn = 8;
 sqlstm.arrsiz = 3;
 sqlstm.stmt = "select count(*)  into :b0  from t_zfj where (sjbh=:b1 and y\
xnf=:b2)";
 sqlstm.iters = (unsigned int  )1;
 sqlstm.offset = (unsigned int  )74;
 sqlstm.selerr = (unsigned short)1;
 sqlstm.cud = sqlcud0;
 sqlstm.sqlest = (unsigned char  *)&sqlca;
 sqlstm.sqlety = (unsigned short)0;
 sqlstm.sqhstv[0] = (unsigned char  *)&count_zfj;
 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.sqhstv[2] = (unsigned char  *)&nf;
 sqlstm.sqhstl[2] = (unsigned int  )4;
 sqlstm.sqindv[2] = (         short *)0;
 sqlstm.sqharm[2] = (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;
}


	if ( count_zfj > 0 ) 
		/* EXEC SQL delete from t_zfj where sjbh=:fsfbh and yxnf=:nf; */ 

{
  struct sqlexd sqlstm;

  sqlstm.sqlvsn = 8;
  sqlstm.arrsiz = 3;