JOINKEYS in JCL

Em sua tarefa diária, você pode se deparar com uma situação em que precisa produzir algumas estatísticas de registros correspondentes ou não correspondentes de dois arquivos separados com base em campos de chaves.
Se você estiver lidando com RDBMS, esta tarefa seria muito simples, você poderia ter escrito uma instrução SQL para gerar as estatísticas desejadas.

Mas, eventualmente, essa tarefa não é simples se você estiver lidando com arquivos simples.
Em tal situação, você escreve algum programa Easytrieve ou COBOL ou usa SORT JOINKEYS.
JOINKEYS em SORT JCL é geralmente a opção preferida, apesar de escrever um programa.

Em termos leigos, o termo JOIN é usado para combinar linhas/colunas de dois arquivos diferentes com base em campos de chaves, por exemplo, você deseja obter uma lista do cliente de dois arquivos separados com base na chave, ou seja, funcionário_no.
Além disso, você pode usar vários subparâmetros como REFORMAT, OMITS, INCLUDE/COPY/SORT, etc. junto com as operações de junção usuais.

No tutorial de hoje, você aprenderá a aplicação do JOINKEYS em SORT JCL's.
Você também terá uma exposição prática a vários exemplos do SORT JOINKEY em tempo real para uma melhor compreensão.
Além disso, você aprenderá as principais dicas e truques associados ao SORT JOINKEYS.

O que é JOINKEYS?

JOINKEYS é um dos recursos mais populares do DFSORT/MFX.
Ele permite que os programadores realizem várias operações de junção em dois arquivos.
Se você não tiver a facilidade SORT JOINKEYS em sua loja, precisará escrever um programa Easytrive ou COBOL para obter os resultados desejados.
Escrever um programa simples para pequenas tarefas do dia-a-dia é uma tarefa tediosa.

Conseqüentemente, o recurso JOINKEYS une transações/registros de dois arquivos diferentes com base em certas chaves (ou seja, campos com informações comuns).
As instruções SORTJNF1 e SORTJNF2 DD foram usadas para especificar esses arquivos.

Por padrão, quando a operação JOINKEYS é aplicada a dois arquivos com registros M e N respectivamente, os registros são unidos usando a cláusula reformat, produzindo registros M*N como entrada para o processamento DFSORT/MFX SORT subsequente.
Este tipo de JOIN é denominado INNER JOIN.

Como funciona o processo JCL SORT JOINKEYS?

O recurso do JOINKEYS no tipo JCL foi projetado para melhorar a produtividade do programador, reduzindo o tempo de projeto, teste e depuração de aplicativos.
O SORT JOINKEYS é um extenso utilitário de processamento de dados.

A operação de junção é controlada por três instruções de controle importantes, ou seja, JOINKEYS, JOIN e REFORMAT.
Quando você aplica uma operação de junção em dois arquivos, cada registro do primeiro arquivo (SORTJNF1) será unido ao segundo arquivo (SORTJNF2) com base nos valores-chave.
Portanto, se m registros do lado esquerdo têm um determinado valor de chave de junção e n do lado direito têm o mesmo valor de chave de junção, a junção resulta em m*n registros com esse valor de chave de junção.

O diagrama de fluxo do processo JOINKEYS é uma representação pictórica do processamento executado para um aplicativo JOINKEYS.

Diagrama de fluxo do processo JOINKEYS.

Existem basicamente quatro etapas básicas envolvidas em qualquer operação de junção.

1. Use a instrução de controle REFORMAT para especificar o nome dos campos, que precisam ser incluídos no registro associado.
2. Selecionando ou eliminando registros de ambos os arquivos ou de qualquer um dos arquivos usando o parâmetro INCLUDE/OMIT da instrução JOINKEYS.
3. Especifique se os dados de junção de entrada já estão classificados de acordo com os campos de controle JOINKEYS usando os parâmetros SORTED.
   O desempenho geral das chaves de junção é melhor se os dados de entrada da junção já estiverem classificados de acordo com os campos JOINKEYS.
4. Use a instrução JOIN para especificar a natureza das junções, isto é (Inner join, left outer join, right outer join e full outer join)

Sintaxe de JOINKEYS.

Uma operação de junção JCL SORT JOINKEYS exigia duas instruções JOINKEYS:
uma para o primeiro arquivo, ou seja, F1,
e a outra para o segundo arquivo, ou seja, F2.
Consulte a representação pictórica para obter mais detalhes.

Declaração JOINKEYS

JOINKEYS Amostra de JCL.

Aqui está o JCL de amostra com as instruções de controle para um aplicativo de chave de junção interna simples usando SORT JOINKEYS.

//TMXXAXXX JOB (99999),'MAINFRAME FORUM',CLASS=A,MSGCLASS=X,
//       MSGLEVEL=(1,1),NOTIFY=&SYSUID
//*
//* SAMPLE JCL FOR JOINKEYS.
//*
//STEP01 EXEC PGM=SORT
//SYSOUT DD SYSOUT=*
//SORTJNF1 DD DSN=MXXP.EMP.PAY.DT001,DISP=SHR
//SORTJNF2 DD DSN=MXXP.EMP.PAY.DT002,DISP=SHR
//SORTOUT DD SYSOUT=*
//SYSIN DD *
* Control statements for JOINKEYS operation.
 JOINKEYS FILE= F1,FIELDS=(10,2,A,17,4,A)
 JOINKEYS FILE= F2,FIELDS=(20,2,A,23,4,A)
 REFORMAT FIELDS= (F2:1,80,F1:1,80)
* Control statements for main-task (joined records)
SORT FIELDS=COPY
/*

Instrução JOIN.

A instrução de controle JOIN em SORT JOINKEYS é um parâmetro importante e, se você não especificar esse parâmetro, por padrão, apenas os registros emparelhados dos arquivos F1 e F2 são processados pela tarefa principal como registros de transações unidas.
Este tipo de operação de junção é denominado INNER JOIN.

Você pode usar a instrução de junção para especificar quais registros precisam ser incluídos e processados pela tarefa principal.
Além disso, você deve especificar o operando UNPAIRED.
No entanto, F1, F2 e ONLY são parâmetros opcionais.

Declaração JOIN em JOINKEYS

Quando você especifica os operandos JOIN, a operação SORT JOINKEYS retém os registros combinados e esses registros são processados pela tarefa principal da seguinte maneira:

• UNPAIRED, F1, F2 ou UNPAIRED: retém os registros desemparelhados dos arquivos F1 e F2 junto com os registros emparelhados.
  Esse tipo de junção é denominado FULL OUTER JOIN.
• UNPAIRED, F1: retém os registros desemparelhados do arquivo F1 junto com os registros emparelhados.
  Este tipo de junção é denominado LEFT OUTER JOIN.
• UNPAIRED, F2: retém os registros desemparelhados do arquivo F2 junto com os registros emparelhados.
  Esse tipo de junção é denominado RIGHT OUTER JOIN.
• UNPAIRED, F1, F2, ONLY ou UNPAIRED, ONLY: Retenha os registros desemparelhados dos arquivos F1 e F2.
• UNPAIRED, F1, ONLY: Retenha os registros desemparelhados do arquivo F1.
• UNPAIRED, F2, ONLY: Retém os registros desemparelhados do arquivo F2.

JOINKEYS: Parâmetros SORTED/NOSEQCK.

Por padrão, DFSORT/MFX classificará os arquivos de entrada com base nas chaves especificadas.
Se você sabe que os registros do arquivo de entrada já estão classificados em ordem, você pode usar o parâmetro SORTED para dizer ao DFSORT/MFX para copiar os registros do arquivo, apesar de classificá-los novamente.
Além disso, use o operando NOSEQCH para informar ao DFSORT para não verificar a ordem dos registros.
Por exemplo, se você especificar:

• JOINKEYS FILE=F1,FIELDS=(22,3,A),SORTED,NOSEQCH
• JOINKEYS FILE=F2,FIELDS=(15,3,A),SORTED

JOINKEYS: parâmetro TYPE.
Outro parâmetro importante é TYPE, que é usado para especificar o comprimento de processamento para um arquivo de entrada VSAM.
Por exemplo, se você especificar:

• TYPE=V: DFSORT usaria processamento de comprimento variável para o arquivo VSAM.
• TYPE=F: DFSORT usaria processamento de comprimento fixo para o arquivo VSAM.

JOINKEYS F1=VSAM1,FIELDS=(23,6,A),TYPE=V
JOINKEYS F2=VSAM2,FIELDS=(16,6,A),TYPE=F

JOINKEYS: Parâmetros INLUCDE/OMIT.

O desempenho de SORT JOINKEYS pode ser melhorado usando dois parâmetros principais, isto é, INCLUDE/OMIT.
Esses dois parâmetros são amplamente usados para incluir ou excluir registros do arquivo durante as operações de junção.

Parâmetros JOINKEYS INCLUDE/OMIT.

Ambos os parâmetros podem ser especificados na instrução JOIN de JONKEYS.
Mas você deve sempre especificar o parâmetro INCLUDE/OMIT em JNF1CNTL ou JNF2CNTL.
Por exemplo:

//*
//* INCLUDE/OMIT Specified at JOIN statements.
//*
 JOINKEYS FILE=F1,FIELDS=(35,8,A),
  OMIT=(10,15,CH,EQ,C'MAINFRAME FORUM')
 JOINKEYS FILE=F2,FIELDS=(37,8,A),
  INCLUDE=(1,20,SS,EQ,C'TRAN')

//*
//* INLCLUDE/OMIT specified at JFN1CNTL/JNF2CNTL
//*
//SYSIN DD *
 JOINKEYS FILE=F1,FIELDS=(35,8,A)
 JOINKEYS FILE=F2,FIELDS=(37,8,A)
...
//JNF1CNTL DD *
 OMIT COND=(10,15,CH,EQ,C'MAINFRAME FORUM')
//JNF2CNTL DD *
 INCLUDE COND=(1,20,SS,EQ,C'TRAN')

Exemplo 1: Gerar relatório de saída com registros de transação emparelhados de F1/F2 sem duplicatas.

//TMXXXSDX JOB (99999),'MAINFRAME FORUM',CLASS=A,MSGCLASS=X,

//       MSGLEVEL=(1,1),NOTIFY=&SYSUID
//*
//* SAMPLE JCL FOR JOINKEYS.
//*
//STEP01 EXEC PGM=SORT
//SYSOUT DD SYSOUT=*
//SORTJNF1 DD *
 00100   ROGGER  $1000.00
 00200   MURPHY  $2000.00
 00300   CIARA   $3000.00
/*
//SORTJNF2 DD *
 00100   ROGGER  $1000.00 JAN
 00200   MURPHY  $2000.00 JAN
 00300   CIARA   $3000.00 JAN
 00300   CIARA   $3000.00 JAN
/*
//SORTOUT DD SYSOUT=*
//SYSIN DD *
* Control statements for JOINKEYS application
 JOINKEYS FILE=F1,FIELDS=(1,05,A)
 JOINKEYS FILE=F2,FIELDS=(1,05,A)
 REFORMAT FIELDS=(F1:1,5,13,10,F2:33,03,F1:23,8)
* Control statements for main task (joined records)
 OPTION COPY
 OUTFIL REMOVECC,
 HEADER2=(1:'EMPID',11:'F-NAME',26:'EP-SAL',36:'SL-MNTH',/,
 1:7'-',11:14'-',26:7'-',36:7'-'),
 BUILD=(1:1,5,11:13,10,26:23,08,36:33,03)
/*

Resultado. 

EMPID   F-NAME         EP-SAL  SL-MNTH
------- -------------- -------- -------
00100   ROGGER         $1000.00 JAN
00200   MURPHY         $2000.00 JAN
00300   CIARA          $3000.00 JAN

RESUMO.

DFSORT / MFX são ferramentas poderosas de manipulação de dados disponíveis na plataforma de mainframe.
Essas ferramentas têm a capacidade de classificar, mesclar, copiar e gerar o relatório para análise de negócios.
JOINKEYS no SORT JCL oferece suporte a vários recursos, como JOINKEYS, JOIN, REFORMAT, JKFROM, TOJUL, TOGREG, WEEKDAY, DT, DTNS, operador MERGE, MERGEIN, etc.