compare 2 files and move common record into other file

-
 IDENTIFICATION DIVISION.                
 PROGRAM-ID.    SANDEEP.                    
 DATE-COMPILED.                          
 ENVIRONMENT DIVISION.                    
 CONFIGURATION SECTION.                  
 INPUT-OUTPUT SECTION.                    
 FILE-CONTROL.                            
                                          
      SELECT   IN1-FILE ASSIGN   TO IN1                    
      ORGANIZATION IS SEQUENTIAL.        
                                          
      SELECT   IN2-FILE  ASSIGN   TO IN2                    
      ORGANIZATION IS SEQUENTIAL.        
                                          
      SELECT   MATCH-FILE ASSIGN   TO MATCH                  
      ORGANIZATION IS SEQUENTIAL.        
                                          
      SELECT   OUT1-FILE  ASSIGN   TO OUT1                    
      ORGANIZATION IS SEQUENTIAL.        
                                          
      SELECT   OUT2-FILE ASSIGN   TO OUT2                    
      ORGANIZATION IS SEQUENTIAL.        
                                          
 DATA DIVISION.                          
 FILE SECTION.                            
                                          
 FD IN1-FILE                                                                    
 01 IN1-REC.                                
    05 IN1-KEY                  PIC X(10). 
    05 FILLER                    PIC X(70). 
                                            
 FD IN2-FILE                                                                             
 01 IN2-REC.                                
    05 IN2-KEY                  PIC X(10). 
    05 FILLER                    PIC X(70). 
                                            
 FD MATCH-FILE                            
 01 MATCH-REC             PIC X(80). 
                                            
 FD OUT1-FILE                                                                                      
 01 OUT1-REC                  PIC X(80). 
                                            
 FD OUT2-FILE                                                                      
 01 OUT2-REC                  PIC X(80). 
                                            
 WORKING-STORAGE SECTION. 
 01 S-IN1-FILE                  PIC X(01)  VALUE 'N'. 
 01 S-IN2-FILE                  PIC X(01)  VALUE 'N'. 
                                                              
 PROCEDURE DIVISION.                                        
                                                              
      PERFORM 1000-INITIALIZATION                            
                                                              
      PERFORM 2000-MAIN-PROCESS UNTIL                        
              S-IN1-FILE = 'Y' AND S-IN2-FILE = 'Y'          
                                                              
      PERFORM 3000-WRAPUP                                    
                                                              
      STOP RUN.                                                  
      .                                                      
                                                              
 1000-INITIALIZATION.                                        
*********************************************************************
* THIS PARAGRAPH OPENS INPUT AND OUTPUT FILES AND DOES THE     * 
* PRIME READ.                                                                                                            * 
*********************************************************************
                                                              
      OPEN INPUT  IN1-FILE                                    
                  IN2-FILE                                    
           OUTPUT MATCH-FILE                                  
                  OUT1-FILE                                  
                  OUT2-FILE                                  
                                                              
                                                              
      PERFORM 2100-READ-IN1-FILE                              
      PERFORM 2200-READ-IN2-FILE                              
      .                                                      
                                                              
 2000-MAIN-PROCESS.                                          
************************************************************* 
* THIS PARAGRAPH PERFORMS THE MAIN LOGIC                           * 
************************************************************* 

      EVALUATE TRUE                                          
          WHEN IN1-KEY = IN2-KEY                              
               PERFORM 2300-WRITE-MATCH-FILE                  
               PERFORM 2100-READ-IN1-FILE                    
               PERFORM 2200-READ-IN2-FILE                    
          WHEN IN1-KEY < IN2-KEY                              
               PERFORM 2400-WRITE-OUT1-FILE                  
               PERFORM 2100-READ-IN1-FILE                    
          WHEN IN1-KEY > IN2-KEY                              
               PERFORM 2500-WRITE-OUT2-FILE                  
               PERFORM 2200-READ-IN2-FILE                    
      END-EVALUATE                                            
      .                                                                                                                   
 2100-READ-IN1-FILE.                                          
************************************************************* 
* THIS PARAGRAPH READS THE IN1-FILE                                          * 
************************************************************* 
                                                              
      READ IN1-FILE                                          
          AT END                                              
              MOVE 'Y'            TO S-IN1-FILE              
              MOVE  HIGH-VALUES   TO IN1-KEY                  
      END-READ                                                
      .                                                                                                                   
 2200-READ-IN2-FILE.                                          
************************************************************* 
* THIS PARAGRAPH READS THE IN2-FILE                                           * 
************************************************************* 
                                                              
      READ IN2-FILE                                          
          AT END                                              
              MOVE 'Y'            TO S-IN2-FILE              
              MOVE  HIGH-VALUES   TO IN2-KEY                  
      END-READ 
      . 
                                                              
 2300-WRITE-MATCH-FILE.                                      
************************************************************* 
* THIS PARAGRAPH WRITES RECORDS WHICH MATCHES ON BOTH FILES.* 
************************************************************* 
                                                              
      MOVE SPACES                 TO MATCH-REC                
      MOVE IN1-REC                TO MATCH-REC                
      WRITE MATCH-REC                                        
      .                                                      
                                                              
 2400-WRITE-OUT1-FILE.                                        
******************************************************************8
* THIS PARAGRAPH WRITES RECORDS WHICH ARE ONLY IN IN1 FILE. * 
*******************************************************************
                                                              
      MOVE SPACES                 TO OUT1-REC                
      MOVE IN1-REC                TO OUT1-REC                
      WRITE OUT1-REC                                          
      .                                                      
                                                              
 2500-WRITE-OUT2-FILE.                                        
*******************************************************************
* THIS PARAGRAPH WRITES RECORDS WHICH ARE ONLY IN IN2 FILE.  * 
******************************************************************* 
                                                              
      MOVE SPACES                 TO OUT2-REC                
      MOVE IN2-REC                TO OUT2-REC                
      WRITE OUT2-REC                                          
      . 
 3000-WRAPUP. 
************************************************************* 
* THIS PARAGRAPH CLOSES THE INPUT & OUTPUT FILES.             * 
************************************************************* 
                                                              
      CLOSE  IN1-FILE                                        
             IN2-FILE                                        
             MATCH-FILE                                      
             OUT1-FILE                                        
             OUT2-FILE.


---------------------------------------------------------------------------------------
COMPILER:
//KC03P85R JOB 123.'SANDEEP',NOTIFY=&SYSUID
//STEP1 EXEC IGYWCL
//COBOL.SYSIN  DD DSN=KC03P85.JOB.SAMPLE,DISP=SHR
//LKED.SYSLMOD    DD DSN=KC03P85.JOB.LOAD(L1),DISP=SHR

-----------------------------------------------------------------------------------------

RUN JCL
//KC03P85T JOB 123.'SANDEEP',NOTIFY=&SYSUID.
//JOBLIB DD DSN=KC03PP85.JOB.LOAD,DISP=SHR
//STEP1 EXEC PGM=LI
//IN1 DD DSN=KC03P85.JOB.PS1,DISP=SHR
//IN2DD DSN=KC03P85.JOB.PS2,DISP=SHR
//MATCH DD DSN=KC03P85.JOB.MATCH,DISP=SHR
//OUT1  DD DSN=KC03P85.JOB.OUT1,DISP=SHR
//OUT2 DD DSN=KC03P85.JOB.OUT2,DISP=SHR
//SYSPRINT DD SYSOUT=*
//SYSOUT DD SYSOUY=*
//







               

Comments

Post a Comment

Popular posts from this blog

COBOL + DB2 complication process.

-
Image
There are various step involved before we run/execute a COBOL + DB2 program.   Below step are the various steps.   Precompile.   Compile.   Link edit.   Bind.   Package & plan. Step 1: Precompile               COBOL compiler did not understand about SQL statement so, it undergoes to precompile. In precompile.     Expands all include copybooks which are written in program.     Extracts all SQL statements into DBRM and SQL statement are convert into call statements.    Generates time-stamp for modified source codes and DBRM .there are checked at run time.   Check syndicated error of SQL statements and validates the fields based on the table declaration from dclgen copybook.    Notes: precompilation process can be executed even if DB2 is down. DSNHPC    ----------- It is the program used for precompilation. Step 2:  Compile            It is same as normal COBOL compilation.it takes modified source as input and compilers.  IGYRCTL --
Read more

ABEND list for JCL

-
what is ABEND?   An ABEND (abnormal end) is an exception condition which results in the abnormal termination of a program or software. It is a common terminology used in the mainframe world where a JCL terminates with an error code.  S0CB -    Attempting to divide by 0 and not using ON SIZE ERROR S002 -    Very large record length/ wrong record length Sx22 -   Job has been cancelled. The value of x will vary depending on the way the job was  cancelled. . S222 -    Means job was cancelled by a user or operator without a dump.                If a TSO session times out you will probably get an S522 ABEND code. S222 -    The job was cancelled (by subsystem or operator) because it violated               Some restriction. S522 -    JOB or TSO session exceeded maximum job wait time OR               Operator did not mount the require tape within allowed time limit    S806 -    Load module not found SB37
Read more

difference between jes2 and jes3

-
JES2 JES3       1.        Decentralization.       2.        Every processor the incoming job individually.       3.        It is prestep allocation.       4.        Dataset allowed before step is executed.       5.        It is a local process.       6.        Control statement (//*). 1. Centralization. 2. It control process and assign job to sub processor. 3. It is prejob allocation. 4. Dataset allowed before job is schedule. 5. It is global process. 6. Control statement (/*).
Read more