Utilità di ordinamento - AWS Modernizzazione del mainframe
SORT/SYNCSORT/ICEMANATTREZZO DA GHIACCIOMFSORT

AWS Il servizio di modernizzazione del mainframe (esperienza Managed Runtime Environment) non è più aperto a nuovi clienti. Per funzionalità simili a AWS Mainframe Modernization Service (esperienza Managed Runtime Environment), esplora AWS Mainframe Modernization Service (Self-Managed Experience). I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per ulteriori informazioni, consulta AWS Modifica della disponibilità di Mainframe Modernization.

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Utilità di ordinamento

Le utilità di ordinamento si basano su set di dati il cui riferimento ha un significato speciale per l'utilità. Quindi, tutte le utilità di ordinamento sul lato modernizzato condividono lo stesso schema di invocazione negli script groovy:

mpr.withFileConfigurations(<FILE CONFIGURATIONS DETAILS>...)
   .withParameters(params)
   .runProgram("<SORT UTILITY ALIAS>")

dove mpr è un'MainProgramRunneristanza (vedi la sezione Scripts calling programs in questa pagina). Gli alias delle utilità di ordinamento sono riportati nelle sezioni seguenti.

Le voci DD (definizioni dei set di dati) dello script JCL vengono modernizzate come voci nei dettagli della configurazione del file che fungono da argomento per il metodo. mpr.withFileConfigurations() Vedi gli esempi seguenti per illustrazioni di questo concetto.

SORT/SYNCSORT/ICEMAN

Scopo

Questo programma emula varie utilità SORT per mainframe, utilizzate per sort/merge/copy i dati dei set di dati, in base ai criteri forniti. È possibile utilizzare i seguenti alias di programma (che corrispondono al nome dell'utilità di ordinamento esistente corrispondente):

  • SORT

  • SYNCSORT

  • ICEMAN

I dettagli sulle SORT/MERGE direttive presenti nelle schede di controllo e sulle funzionalità legacy dell'utilità di ordinamento non sono forniti qui, ma devono essere recuperati dalla documentazione esistente sulle piattaforme legacy pertinenti.

Firma

Il programma non accetta alcuna argomentazione ma si basa invece su riferimenti a set di dati specifici:

  • Il SYSIN set di dati (noto anche come «scheda di controllo») contiene le istruzioni di controllo sort/merge

  • Il SYMNAMES set di dati opzionale contiene direttive di sostituzione delle variabili nel contenuto SYSIN

  • L'opzionale SORTXDUP o il SORTXSUM set di dati possono essere utilizzati per archiviare record duplicati

  • I set di dati sono SORTDBIN preceduti SORTIN o contengono i record da elaborare (input)

  • Il SORTOUT set di dati contiene i risultati del programma (output)

  • Le SORTWK definizioni per i set di dati SORT WORK presenti in alcuni script di job legacy vengono ignorate (e non sono rappresentate nella chiamata modernizzata); i set di dati di sort work verranno sempre allocati dinamicamente nell'ambiente moderno

  • I due set di dati il cui DD inizia con SORTJN (prefisso) contengono record che riguarderanno le direttive join keys (utilizzate per unire i set di dati durante il processo di ordinamento)

Ad esempio, considerando le seguenti direttive sulle chiavi di unione:

JOINKEYS FILE=F1,FIELDS=(13,5,A)
JOINKEYS FILE=F2,FIELDS=(24,5,A)

Qui, la chiave di unione ha una lunghezza 5 e inizia da:

  • posizione 13 per i record nel set di dati SORTJNF1 (concatenazione di SORTJN prefisso e file) F1

  • posizione 24 per i record nel set di dati (concatenazione di prefisso e SORTJNF2 file) SORTJN F2

Controlli/Gestione degli errori

  • Se il file di input (SORTIN) ha una SHR disposizione ma non può essere trovato, viene registrato un messaggio di errore, il codice di ritorno del programma viene impostato su 1 e l'esecuzione del programma viene interrotta (non verrà eseguito alcun ordinamento, non verrà prodotto alcun output)

Nei seguenti casi, verrà lanciato un messaggio RuntimeException contenente un messaggio dedicato:

  • Se l'invocazione del programma richiede la connessione a un database (quando si utilizza il SORTDBIN set di dati, noSORTIN), è possibile trovare una fonte di dati non valida

  • Se il file di output (SORTOUT) non è definito correttamente

  • Se un comando trovato nella scheda di controllo non può essere compreso o non è supportato

  • In caso contrario, vengono forniti due file di input per SORT JOINKEYS ogni caso

Esempio di utilizzo

Esempio MERGE

Ecco un esempio di ICEMAN richiamo da uno snippet di job script:

La scheda di controllo è in linea e contiene comandi per unire i campi dai file di input (vedi la voce) SYSIN

//*
//PASOSO03 EXEC PGM=ICEMAN,REGION=0M
//SORTIN01 DD DSN=input(input809a.data),DISP=SHR,LRECL=10
//SORTIN02 DD DSN=input(input809b.data),DISP=SHR,LRECL=10
//SORTOUT  DD DSN=output(out809.txt),DISP=(,PASS),LRECL=10
//SORTWK01 DD SPACE=(281,(156300,156300),RLSE),AVGREC=U
//SORTWK02 DD SPACE=(281,(156300,156300),RLSE),AVGREC=U
//SYSIN    DD *
   MERGE  FIELDS=(1,6,PD,A,7,2,CH,A)
   END
/*

E il corrispondente frammento di script groovy modernizzato: tenete presente che, come già detto, le SORTWK voci non vengono prese in considerazione durante il processo di modernizzazione e che la scheda di controllo in linea corrisponde esattamente al contenuto della scheda di controllo precedente.

// STEP PASOSO03 - PGM - ICEMAN***************************************************
def stepPASOSO03(Object shell, Map params, Map programResults){
    shell.with {
        if (checkValidProgramResults(programResults)) {
            return execStep("PASOSO03", "ICEMAN", programResults, {
                mpr
                    .withFileConfigurations(new FileConfigurationUtils()
                        .withJobContext(jobContext)
                        .fileSystem("SORTIN01")
                        .path("input(input809a.data)").recordSize(10)
                        .disposition("SHR")
                        .build()
                        .fileSystem("SORTIN02")
                        .path("input(input809b.data)").recordSize(10)
                        .disposition("SHR")
                        .build()
                        .fileSystem("SORTOUT")
                        .path("output(out809.txt)").recordSize(10)
                        .normalTermination("PASS")
                        .build()
                        .fileSystem("SYSIN")
                        .stream(
"""   MERGE  FIELDS=(1,6,PD,A,7,2,CH,A)
   END                                                                          """, getEncoding())
                        .build()
                        .getFileConfigurations())
                        .withParameters(params)
                    .runProgram("ICEMAN")
                })
        }
    }
}

Esempio di SORT semplice

Un semplice passaggio SORT preesistente (job script snippet) con scheda di controllo integrata, tratto dall'applicazione di esempio carddemo:

//*********************************************************************
//* CREATE COPY OF TRANSACT FILE WITH CARD NUMBER AND TRAN ID AS KEY
//*********************************************************************
//STEP010  EXEC PGM=SORT
//SORTIN   DD  DISP=SHR,DSN=AWS.M2.CARDDEMO.TRANSACT.VSAM.KSDS
//SYSPRINT DD  SYSOUT=*
//SYSOUT   DD  SYSOUT=*
//SORTOUT  DD  DSN=AWS.M2.CARDDEMO.TRXFL.SEQ,
//             DISP=(NEW,CATLG,DELETE),UNIT=SYSDA,
//             DCB=(LRECL=350,BLKSIZE=3500,RECFM=FB),
//             SPACE=(CYL,(1,1),RLSE)
//SYSIN    DD *
  SORT FIELDS=(263,16,CH,A,1,16,CH,A)
  OUTREC FIELDS=(1:263,16,17:1,262,279:279,50)
/*

e lo snippet di script groovy modernizzato corrispondente:

// STEP STEP010 - PGM - SORT******************************************************
def stepSTEP010(Object shell, Map params, Map programResults){
    shell.with {
        if (checkValidProgramResults(programResults)) {
            return execStep("STEP010", "SORT", programResults, {
                mpr
                    .withFileConfigurations(new FileConfigurationUtils()
                        .withJobContext(jobContext)
                        .bluesam("SORTIN")
                        .dataset("AWS.M2.CARDDEMO.TRANSACT.VSAM.KSDS")
                        .disposition("SHR")
                        .build()
                        .systemOut("SYSPRINT")
                        .output("*")
                        .build()
                        .systemOut("SYSOUT")
                        .output("*")
                        .build()
                        .fileSystem("SORTOUT")
                        .path("AWS.M2.CARDDEMO.TRXFL.SEQ").recordSize(350)
                        .disposition("NEW")
                        .normalTermination("CATLG")
                        .abnormalTermination("DELETE")
                        .build()
                        .fileSystem("SYSIN")
                        .stream(
"""  SORT FIELDS=(263,16,CH,A,1,16,CH,A)
  OUTREC FIELDS=(1:263,16,17:1,262,279:279,50)""", getEncoding())
                        .build()
                        .getFileConfigurations())
                    .withParameters(params)
                    .runProgram("SORT")
                })
        }
    }
}

Si noti che la scheda di controllo integrata viene utilizzata «così com'è», senza alcuna modifica rispetto al contenuto della scheda di controllo precedente.

ATTREZZO DA GHIACCIO

Scopo

L'utilità ICETOOL viene utilizzata per eseguire più operazioni sui set di dati in un'unica fase di lavoro (manipolazione, ordinamento e analisi dei dati).

Sono supportati i seguenti operatori principali:

  • COPY- Copia i dati dai file di input a quelli di output

  • SORT- Ordina i dati utilizzando schede/criteri di ordinamento specificati

  • SELECT- Filtra e seleziona record specifici in base alle condizioni

  • SPLICE- Merges/joins dati provenienti da più fonti

  • COUNT- Conta i record che soddisfano i criteri specificati

  • OCCUR- Analizza i modelli di occorrenza nei dati

Per l'operatore SPLICE, l'utilità utilizzerà un approccio multithread basato su strategie di suddivisione dei dati per garantire prestazioni ottimizzate.

I dettagli sugli operatori devono essere recuperati dalla documentazione appropriata della piattaforma legacy.

Firma

L'ICETOOLutilità non accetta alcun parametro, ma si basa su set di dati specifici:

  • TOOLINil set di dati contiene le istruzioni di controllo che devono essere elaborate dall'utilità

  • TOOLMSGe DFSMSG i set di dati non vengono utilizzati dall'ICETOOLutilità modernizzata per ora (ignorati)

  • INè il prefisso per i set di dati di input (record da elaborare)

  • OUTè il prefisso per i set di dati di output (record risultanti dall'elaborazione)

  • altri set di dati potrebbero essere referenziati dalle istruzioni di controllo nella scheda di controllo

Controlli/Gestione degli errori

Nei seguenti casi, RuntimeException verrà generato un messaggio con un messaggio correlato:

  • Se l'operatore utilizzato in una delle istruzioni di controllo non è supportato

  • Per qualsiasi operatore, se viene fornita una direttiva non supportata

Esempio di utilizzo

Esempio di ICETOOL SORT

Ecco un esempio di jcl precedente che utilizza ICETOOL per scopi di ordinamento:

  • ogni istruzione di controllo dell'operatore SORT utilizza una scheda di controllo dedicata, il cui riferimento è specificato tramite la parola chiave USING

  • tutte le schede di controllo sono definite dopo la TOOLIN definizione e sono in linea (vedere SEL1CNTL le *CNTL voci seguenti)

//SAMPLO52 EXEC PGM=ICETOOL,REGION=1024K
//TOOLMSG  DD SYSOUT=*
//DFSMSG   DD SYSOUT=*
//IN1      DD DSN=input(input846a.data),DISP=SHR
//            DCB=(RECFM=F,LRECL=8)
//IN2      DD DSN=input(input846b.data),DISP=SHR
//            DCB=(RECFM=F,LRECL=8)
//OUT1     DD DSN=output(out846a.txt),DISP=(,CATLG)
//            DCB=(RECFM=F,LRECL=8)
//OUT2     DD DSN=output(out846b.txt),DISP=(,CATLG)
//            DCB=(RECFM=V)
//OUT3     DD DSN=output(out846c.txt),DISP=(,CATLG)
//            DCB=(RECFM=V)
//TOOLIN   DD *
  SORT FROM(IN1) TO(OUT1) USING(SEL1)
  SORT FROM(IN2) TO(OUT1) USING(SEL2)
  SORT FROM(IN1) TO(OUT2) USING(SEL3)
  SORT FROM(IN2) TO(OUT2) USING(SEL4)
  SORT FROM(IN1) TO(OUT3) USING(SEL5)
  SORT FROM(IN2) TO(OUT3) USING(SEL6)
/*
//SEL1CNTL DD *
    OPTION COPY
    OUTFIL BUILD=(1,8,JFY=(SHIFT=LEFT,TRAIL=C'*'))
//*
//SEL2CNTL DD *
   OPTION COPY,SKIPREC=1
   OUTFIL BUILD=(1,8,JFY=(SHIFT=LEFT,TRAIL=C'*'))
//*
//SEL3CNTL DD *
    OPTION COPY
    OUTFIL BUILD=(1,8,JFY=(SHIFT=LEFT,TRAIL=C'*')),
    FTOV,VLTRIM=C' '
//*
//SEL4CNTL DD *
    OPTION COPY,SKIPREC=1
    OUTFIL BUILD=(1,8,JFY=(SHIFT=LEFT,TRAIL=C'*')),
    FTOV,VLTRIM=C' '
//*
//SEL5CNTL DD *
    OPTION COPY
    OUTFIL BUILD=(1,8,JFY=(SHIFT=LEFT,TRAIL=C'*')),
    FTOV,VLTRIM=C' '
//*
//SEL6CNTL DD *
    OPTION COPY,SKIPREC=1
    OUTFIL BUILD=(1,7,JFY=(SHIFT=LEFT,TRAIL=C'*')),
    FTOV,VLTRIM=C' '
//*

Una volta modernizzato, lo snippet di script groovy corrispondente ha il seguente aspetto:

// STEP SAMPLO52 - PGM - ICETOOL**************************************************
def stepSAMPLO52(Object shell, Map params, Map programResults){
    shell.with {
        if (checkValidProgramResults(programResults)) {
            return execStep("SAMPLO52", "ICETOOL", programResults, {
                mpr
                    .withFileConfigurations(new FileConfigurationUtils()
                        .withJobContext(jobContext)
                        .systemOut("TOOLMSG")
                        .output("*")
                        .build()
                        .systemOut("DFSMSG")
                        .output("*")
                        .build()
                        .fileSystem("IN1")
                        .path("input(input846a.data)").recordSize(8)
                        .disposition("SHR")
                        .build()
                        .fileSystem("IN2")
                        .path("input(input846b.data)").recordSize(8)
                        .disposition("SHR")
                        .build()
                        .fileSystem("OUT1")
                        .path("output(out846a.txt)").recordSize(8)
                        .normalTermination("CATLG")
                        .build()
                        .fileSystem("OUT2")
                        .path("output(out846b.txt)").rdw(true)
                        .normalTermination("CATLG")
                        .build()
                        .fileSystem("OUT3")
                        .path("output(out846c.txt)").rdw(true)
                        .normalTermination("CATLG")
                        .build()
                        .fileSystem("TOOLIN")
                        .stream(
"""  SORT FROM(IN1) TO(OUT1) USING(SEL1)
  SORT FROM(IN2) TO(OUT1) USING(SEL2)
  SORT FROM(IN1) TO(OUT2) USING(SEL3)
  SORT FROM(IN2) TO(OUT2) USING(SEL4)
  SORT FROM(IN1) TO(OUT3) USING(SEL5)
  SORT FROM(IN2) TO(OUT3) USING(SEL6)               """, getEncoding())
                        .build()
                        .fileSystem("SEL1CNTL")
                        .stream(
"""    OPTION COPY
    OUTFIL BUILD=(1,8,JFY=(SHIFT=LEFT,TRAIL=C'*')) """, getEncoding())
                        .build()
                        .fileSystem("SEL2CNTL")
                        .stream(
"""   OPTION COPY,SKIPREC=1
   OUTFIL BUILD=(1,8,JFY=(SHIFT=LEFT,TRAIL=C'*'))""", getEncoding())
                        .build()
                        .fileSystem("SEL3CNTL")
                        .stream(
"""    OPTION COPY
    OUTFIL BUILD=(1,8,JFY=(SHIFT=LEFT,TRAIL=C'*')),
    FTOV,VLTRIM=C' '""", getEncoding())
                        .build()
                        .fileSystem("SEL4CNTL")
                        .stream(
"""    OPTION COPY,SKIPREC=1
    OUTFIL BUILD=(1,8,JFY=(SHIFT=LEFT,TRAIL=C'*')),
    FTOV,VLTRIM=C' '""", getEncoding())
                        .build()
                        .fileSystem("SEL5CNTL")
                        .stream(
"""    OPTION COPY
    OUTFIL BUILD=(1,8,JFY=(SHIFT=LEFT,TRAIL=C'*')),
    FTOV,VLTRIM=C' '""", getEncoding())
                        .build()
                        .fileSystem("SEL6CNTL")
                        .stream(
"""    OPTION COPY,SKIPREC=1
    OUTFIL BUILD=(1,7,JFY=(SHIFT=LEFT,TRAIL=C'*')),
    FTOV,VLTRIM=C' '""", getEncoding())
                        .build()
                        .getFileConfigurations())
                    .withParameters(params)
                    .runProgram("ICETOOL")
                })
        }
    }
}

Note:

  • Le schede di controllo in linea vengono utilizzate «così come sono»; non è avvenuta alcuna trasformazione rispetto alle schede di controllo precedenti

  • TOOLMSGe DFSMSG sono definite nella versione modernizzata, ma verranno ignorate in fase di esecuzione

  • Sia nelle versioni precedenti che in quelle modernizzate, le schede di controllo sono definite con il CNTL suffisso, ma nelle direttive del set di dati fanno riferimento senza il suffisso: ad esempio In, si riferisce alla definizione del TOOLIN set di dati SORT FROM(IN1) TO(OUT1) USING(SEL1) USING(SEL1) SEL1CNTL

Esempio di copia di ICETOOL

Ecco un altro esempio di ICETOOL, che utilizza l'operatore COPY. TOOLINÈ incluso nel frammento di script jcl:

//SAMPLO51 EXEC PGM=ICETOOL,REGION=1024K
//TOOLMSG  DD SYSOUT=*
//DFSMSG   DD SYSOUT=*
//IN1      DD DSN=input(input831.data),DISP=SHR
//            DCB=(RECFM=F,LRECL=12)
//OUT1     DD DSN=output(out831a.txt),DISP=OLD
//            DCB=(RECFM=F,LRECL=12)
//OUT2     DD DSN=output(out831b.txt),DISP=OLD
//            DCB=(RECFM=F,LRECL=12)
//TOOLIN   DD *
  COPY FROM(IN1) TO(OUT1,OUT2) USING(SEL1)
/*
//SEL1CNTL DD *
  OPTION COPY
  OUTFIL INCLUDE=(7,2,CH,EQ,C'10')
//*

Ed ecco lo snippet di script groovy modernizzato corrispondente:

// STEP SAMPLO51 - PGM - ICETOOL**************************************************
def stepSAMPLO51(Object shell, Map params, Map programResults){
    shell.with {
        if (checkValidProgramResults(programResults)) {
            return execStep("SAMPLO51", "ICETOOL", programResults, {
                mpr
                    .withFileConfigurations(new FileConfigurationUtils()
                        .withJobContext(jobContext)
                        .systemOut("TOOLMSG")
                        .output("*")
                        .build()
                        .systemOut("DFSMSG")
                        .output("*")
                        .build()
                        .fileSystem("IN1")
                        .path("input(input831.data)").recordSize(12)
                        .disposition("SHR")
                        .build()
                        .fileSystem("OUT1")
                        .path("output(out831a.txt)").recordSize(12)
                        .disposition("OLD")
                        .build()
                        .fileSystem("OUT2")
                        .path("output(out831b.txt)").recordSize(12)
                        .disposition("OLD")
                        .build()
                        .fileSystem("TOOLIN")
                        .stream(
"""  COPY FROM(IN1) TO(OUT1,OUT2) USING(SEL1)
  COPY FROM(IN1) TO(OUT3,OUT4)
  COPY FROM(IN1) TO(OUT4)
  COPY FROM(IN1) TO(OUT5,OUT6)                       """, getEncoding())
                        .build()
                        .fileSystem("SEL1CNTL")
                        .stream(
"""  OPTION COPY
  OUTFIL INCLUDE=(7,2,CH,EQ,C'10')""", getEncoding())
                        .build()
                        .getFileConfigurations())
                    .withParameters(params)
                    .runProgram("ICETOOL")
                })
        }
    }
}

MFSORT

Scopo

Questo programma di utilità ha lo scopo di imitare il comportamento dell'utilità di ordinamento denominata MFSORT presente negli ambienti Micro Focus (di solito viene richiamata dalla riga di comando o negli script in ambienti legacy).

Internamente, il programma delega le operazioni di ordinamento effettive al programma di utilità. SORT/SYNCSORT/ICEMAN

Firma

È supportata solo la seguente sintassi precedente: mfsort take <control card>

La chiamata di istruzioni dirette as NON mfsort <instructions> è supportata.

Non richiede alcun argomento; la direttiva take viene emulata utilizzando un set di dati a cui si fa riferimento comeTAKE, che contiene i comandi per il funzionamento di MFSORT.

Controlli/Gestione degli errori

  • Se il TAKE set di dati è mancante o non valido, RuntimeException verrà generato un

  • Controlli/Gestione degli erroriSi applicano anche in questo caso, data la delega da MFSORT a SORT

Esempio di utilizzo

La seguente chiamata al comando mostra un esempio di utilizzo di MFSORT:

mfsort take TESTSRT1.CTL

Ecco lo snippet di script groovy adattato e modernizzato corrispondente:

mpr.withFileConfigurations(new FileConfigurationUtils()
.fileSystem("TAKE")
.path("input(TESTSRT1.CTL)")
.build()
.getFileConfigurations())
.withArguments("input") // relative path for use and give files
.runProgram("MFSORT");