Frequentemente, voce tem dois data sets com campos chaves comuns e campos de dados diferentes, e voce gostaria de unir estes registros, que é, para registros com a mesma chave (keys), voce gostaria de criar um registro de saida com alguns campos de um data set e alguns de outros data set.

• Você poderia querer:
  • um registro (F1) para um registro no join (F2) (1:1)
  • um registro (F1) para muitos registros no join (F2) (1:N)
  • muitos registros (F1) para um registro no join (F2) (n:1)
  • ou até mesmo muitos registros (F1) para muitos registros no join (F2) (N:N)

Uma aplicação de JOINKEYS o ajuda a executar várias "JOIN" aplicações em dois data sets por um ou mais chaves.
Você pode fazer um inner join, full outer join, left outer join, right outer join e combinações de unpaired.
Os dois data sets podem ser de tipos diferentes (fixo, variável, VSAM, e assim por diante) e comprimentos, e tem chaves dentro de locais diferentes.

Os registros dos data sets de entrada podem ser processados de varias maneiras antes e depois da utilização das declarações de controle do DFSORT incluindo SORT ou COPY, INCLUDE ou OMIT, INREC, OUTREC e OUTFIL.

Suponha você tem dois data sets de entrada, REGION.IN1 e REGION.IN2 como mostrados nas tabelas 49 e 50.
REGION.IN1 tem RECFM=FB e LRECL=35 e REGION.IN2 tem RECFM=FB e LRECL=27, assim o LRECLs são diferentes.

Destes dois data sets de entrada, você quer criar um data set, REGION.OUT.
Para cada registro em REGION.IN2, você quer observar o Region correspondente em REGION.IN1, e combinar campos dos dois registros em um registro de saída em REGION.OUT, como mostrado na Tabela 51.

O seguinte JCL DFSORT e comandos de controle é usado em uma aplicação JOINKEYS para criar o data set REGION.OUT desde REGION.IN1 e REGION.IN2.

//JN1 EXEC PGM=SORT
//SYSOUT DD SYSOUT=*
//IN1 DD DSN=DSN=A123456.REGION.IN1,DISP=SHR
//IN2 DD DSN=DSN=A123456.REGION.IN2,DISP=SHR
//SORTOUT DD DSN=A123456.REGION.OUT,DISP=(NEW,CATLG,DELETE),UNIT=3390,
// SPACE=(CYL,(5,5))
//SYSIN DD *
  JOINKEYS F1=IN1,FIELDS=(1,5,A)   /* F1 tem o ddname IN1 e key in 1-5
  JOINKEYS F2=IN2,FIELDS=(5,5,A)   /* F2 tem o ddname IN2 e key in 5-9
  REFORMAT FIELDS=(F2:1,4,         /* Office desde F2
                   F1:1,5,21,15,   /* Region e Regional Director desde F1
                   F2:10,4,14,10,  /* Employees e Evaluation desde F2
                   F1:6,15)        /* Headquarters desde F1
  OPTION COPY
/*

São requeridas duas declarações de JOINKEYS: um para o data set F1 e outro para o o data set F2.

Neste caso, a primeira declaração de JOINKEYS identifica IN1 como o ddname para o data set de F1 fixados e indica uma chave ascendente (Region) nas posições 1-5 daquele data set.

A segunda declaração de JOINKEYS identifica IN2 como o ddname para o data set F2 e indica uma chave ascendente (Region) nas posições 5-9 de aquele data set.

Cada chave (key) no data set F1 deve ser do mesmo comprimento e ordem (ascendente ou descendente) como a chave correspondente no data set F2, mas não precisa estar na mesma localização.

As chaves sempre são tratadas como binário sem sinal (INREC pode ser usado para "normalizar" as chaves em cada data set antes que os registros sejam unidos, se necessário).

O data set F1 será ordenado pela chave nas posições 1-5.
O data set F2 será ordenado pela chave nas posições 5-9.
Se os registros em um data set já são ordenados pela chave, você pode especificar SORTED na declaração de JOINKEYS para dizer ao DFSORT para copiar os registros daqueles DATA SET.

Registros com a mesma chave em ambos DATA SETs são unidos e vai gerar outros conforme a declaração REFORMAT, usando campos dos registros de F1 e F2.

• A declaração REFORMAT vai gerar registros com a união dos seguintes campos:
  • Posição de saída 01-04: Office from F2
  • Posição de saída 05-09: Region from F1
  • Posição de saída 10-24: Regional Director from F1
  • Posição de saída 25-28: Employees from F2
  • Posição de saída 29-38: Evaluation from F2
  • Posição de saída 39-53: Headquarters from F1

O seguinte JCL DFSORT e comandos de controle é usado em uma aplicação JOINKEYS para criar o data set CITIES.OUT desde CITIES.IN1 e CITIES.IN2.

//JN2 EXEC PGM=SORT
//SYSOUT DD SYSOUT=*
//SORTJNF1 DD DSN=DSN=A123456.CITIES.IN1,DISP=SHR
//SORTJNF2 DD DSN=DSN=A123456.CITIES.IN2,DISP=SHR
//SORTOUT DD DSN=A123456.CITIES.OUT,DISP=OLD
//SYSIN DD *
* As chaves de F1 são State e City 
* F1 já está ordenado por essas chaves.  
JOINKEYS FILE=F1,FIELDS=(21,15,A,1,20,A),SORTED
* As chaves de F2 são State e City
JOINKEYS FILE=F2,FIELDS=(1,15,A,16,20,A)
* Mantenha os registros de F1 que não tenha contrapartida em F2  
* para o State e City.
JOIN UNPAIRED,F1,ONLY
OPTION COPY
/*

A primeira declaração de JOINKEYS identifica SORTJNF1 como o ddname para o data set F1 e indica chaves ascendente (State e City) nas posições 21-35 e 1-20 deste data set.
Desde que os registros de F1 já estão em ordem pelo campos State e City, SORTED é usado para fazer um COPY dos registros F1 em lugar de um SORT.

A segunda declaração de JOINKEYS identifica SORTJNF2 como o ddname para o data set F2 e indicam chaves ascendente (State e City) nas posições 1-15 e 16-35 deste data set.
Já que os registros de F2 não estão em ordem pelos campos State e City, SORTED não é usado e um Sort é executado para os registros de F2 com as chaves indicadas.

JOIN UNPAIRED,F1,ONLY é usado para restringir a SAÍDA (SORTOUT) para os registros em F1 que não tem as mesmas chaves em F2.
Considerando que nós queremos os registros de F1, nós não precisamos de uma declaração REFORMAT.

Agora suponha nós queremos usar os data sets CITIES.IN1 e CITIES.IN2 novamente, mas desta vez para produzir a seguinte saida com este dois data sets:

• BOTH.OUT : as cidades da CALIFÓRNIA e TEXAS que se aparecem em CITIES.IN1 e CITIES.IN2.
• F1ONLY.OUT: as cidades da CALIFÓRNIA e TEXAS que se aparecem em CITIES.IN1, mas não em CITIES.IN2.
• F2ONLY.OUT: as cidades da CALIFÓRNIA e TEXAS que se aparecem em CITIES.IN2, mas não em CITIES.IN1.

O seguinte JCL DFSORT e comandos de controle é usado em uma aplicação JOINKEYS para criar os data sets BOTH.OUT, F1ONLY.OUT e F2ONLY.OUT desde CITIES.IN1 e CITIES.IN2.

//JN3 EXEC PGM=SORT
//SYSOUT DD SYSOUT=*
//CITIES1 DD DSN=A123456.CITIES.IN1,DISP=SHR
//CITIES2 DD DSN=A123456.CITIES.IN2,DISP=SHR
//JNF1CNTL DD *
OMIT COND=(21,15,CH,EQ,C’VERMONT’)
//JNF2CNTL DD *
OMIT COND=(1,15,CH,EQ,C’VERMONT’)
//BOTH DD DSN=A123456.BOTH.OUT,DISP=OLD
//F1ONLY DD DSN=A123456.F1ONLY.OUT,DISP=OLD
//F2ONLY DD DSN=A123456.F2ONLY.OUT,DISP=OLD
//SYSIN DD *
JOINKEYS F1=CITIES1,FIELDS=(21,15,A,1,20,A),SORTED
JOINKEYS F2=CITIES2,FIELDS=(1,15,A,16,20,A)
JOIN UNPAIRED,F1,F2
REFORMAT FIELDS=(?,F1:1,37,F2:1,35)
OPTION COPY
OUTFIL FNAMES=BOTH,INCLUDE=(1,1,CH,EQ,C’B’),
BUILD=(2,37)
OUTFIL FNAMES=F1ONLY,INCLUDE=(1,1,CH,EQ,C’1’),
BUILD=(2,37)
OUTFIL FNAMES=F2ONLY,INCLUDE=(1,1,CH,EQ,C’2’),
BUILD=(54,20,39,15)
/*

A primeira declaração de JOINKEYS identifica CITIES1 como o ddname para o data set F1 e indica chaves ascendente (State e City) nas posições 21-35 e 1-20 deste data set.

O data set JNF1CNTL contém uma declaração OMIT para não considerar o registro VERMONT dos dados de F1 assim eles não serão unidos.
Como os registros de F1 já estão em ordenados pelo campos State e City, SORTED é usado para fazer um Cópia em lugar de um SORT para o data set F1.

A segunda declaração de JOINKEYS identifica CITIES2 como o ddname para o data set F2 e indica chaves ascendente (State e City) nas posições 1-15 e 16-35 deste data set.

O data set JNF2CNTL contém uma declaração OMIT ignorar os registros VERMONT do data set F2 assim eles não serão unidos.
Considerando que os registros de F2 não estão ordenados pelos campos State e City, SORTED não é usado e um sort é executado para o data set F2.

Considerando que nós queremos separar em BOTH, F1ONLY e F2ONLY a união dos registros, nós usamos uma declaração JOIN com UNPAIRED,F1,F2 manter o unpaired unido registros como também os emparelharam unem registros.

Na declaração REFORMAT, nós usamos? como o primeiro campo para nos dar um indicador de se cada chave foi achada em ambos os registros (' indicador de B'), só em F1 (' 1 ' indicador) ou só em F2 (' 2 ' indicador).
Depois do indicador, nós colocamos posições 1-37 (City, State, District) de F1 e 1-35 (State, City) de F2.

Os registros são unidos, como mostrado na Tabela 56.

Agora nós podemos usar declarações de OUTFIL para criar nossos três data sets diferentes.

• Nós gravamos as posições 2-38 (F1 City, F1 State, F1 District) dos registros unidos com um indicador de 'B' para as posições 1-37 do data set BOTH.OUT.
• Nós gravamos as posições 2-38 (F1 City, F1 State, F1 District) dos registros unidos com um indicador de '1' para posições 1-37 do data set F1ONLY.OUT.
• Nós gravamos as posições 54-73 (F2 City) e 39-53 (F2 State) dos registros unidos com um indicador de '2' para posições 1-35 do data set F2ONLY.OUT.

Os registros resultantes são mostrados nas tabelas 57, 58 e 59.

Estes são um pouco de muitos tipos de operações JOIN com as que você pode fazer JOINKEYS.
Veja z/OS DFSORT Application Programming Guide para detalhes completos de como usar as declarações JOINKEYS, JOIN e REFORMAT junto com outras declarações de DFSORT para executar aplicações de JOINKEYS diferentes.