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.](https://docs.aws.amazon.com/m2/latest/userguide/mainframe-modernization-availability-change.html)
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(...)
.withParameters(params)
.runProgram("")
```
[dove `mpr` è un'`MainProgramRunner`istanza (vedi la sezione Scripts calling programs in questa pagina).](https://docs.aws.amazon.com/m2/latest/userguide/ba-shared-structure.html#ba-shared-structure-run-call) 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, no`SORTIN`), è 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'`ICETOOL`utilità non accetta alcun parametro, ma si basa su set di dati specifici:
+ `TOOLIN`il set di dati contiene le istruzioni di controllo che devono essere elaborate dall'utilità
+ `TOOLMSG`e `DFSMSG` i set di dati non vengono utilizzati dall'`ICETOOL`utilità 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
+ `TOOLMSG`e `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](#sort-syncsort-iceman)
### Firma
È supportata solo la seguente sintassi precedente: `mfsort take `
La chiamata di istruzioni dirette as NON `mfsort ` è supportata.
Non richiede alcun argomento; la direttiva *take* viene emulata utilizzando un set di dati a cui si fa riferimento come`TAKE`, 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 errori](#sort-error)Si 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");
```