utilitaires de tri - AWS Modernisation du mainframe
SORT/SYNCSORT/ICEMANOUTIL À GLACEMFSORT

AWS Le service de modernisation du mainframe (expérience de l'environnement d'exécution géré) n'est plus ouvert aux nouveaux clients. Pour des fonctionnalités similaires au service de modernisation AWS du mainframe (expérience de l'environnement d'exécution géré), explorez le service de modernisation AWS du mainframe (expérience autogérée). Les clients existants peuvent continuer à utiliser le service normalement. Pour plus d'informations, consultez la section Modification de la disponibilité de la modernisation du AWS mainframe.

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

utilitaires de tri

Les utilitaires de tri s'appuient sur des ensembles de données dont la référence revêt une signification particulière pour l'utilitaire. Par conséquent, tous les utilitaires de tri du côté modernisé partagent le même modèle d'invocation dans les scripts groovy :

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

où se mpr trouve une MainProgramRunner instance (voir la section Scripts appelant des programmes sur cette page). Les alias des utilitaires de tri sont indiqués dans les sections ci-dessous.

Les entrées DD (définitions des ensembles de données) du script JCL sont modernisées en tant qu'entrées dans les détails de la configuration du fichier qui servent d'argument à la méthode. mpr.withFileConfigurations() Consultez les exemples ci-dessous pour des illustrations de ce concept.

SORT/SYNCSORT/ICEMAN

Objectif

Ce programme émule divers utilitaires de tri du mainframe, utilisés pour les données des ensembles de sort/merge/copy données, en fonction des critères fournis. Les alias de programme suivants peuvent être utilisés (et correspondent au nom de l'utilitaire de tri existant correspondant) :

  • SORT

  • SYNCSORT

  • ICEMAN

Les détails sur les SORT/MERGE directives présentes dans les cartes de contrôle et les fonctionnalités de l'utilitaire de tri existant ne sont pas donnés ici mais doivent être extraits de la documentation des anciennes plateformes existantes pertinentes.

Signature

Le programme ne prend aucun argument mais s'appuie plutôt sur des références d'ensembles de données spécifiques :

  • L'SYSINensemble de données (également appelé « carte de contrôle ») contient les instructions de sort/merge contrôle

  • L'ensemble de SYMNAMES données facultatif contient des directives de substitution de variables dans le contenu SYSIN.

  • L'optionnel SORTXDUP ou le SORTXSUM jeu de données peut être utilisé pour stocker des enregistrements dupliqués

  • Les ensembles de données préfixés par SORTIN ou contenant SORTDBIN des enregistrements à traiter (entrées)

  • L'SORTOUTensemble de données contient les résultats du programme (sortie)

  • Les SORTWK définitions des ensembles de données SORT WORK figurant dans certains anciens scripts de tâches sont ignorées (et ne sont pas représentées dans l'appel modernisé) ; les ensembles de données de travail de tri seront toujours alloués dynamiquement dans l'environnement moderne

  • Les deux ensembles de données dont le DD commence par SORTJN (préfixe) contiennent des enregistrements qui seront concernés par les directives de clés de jointure (utilisées pour joindre des ensembles de données lors du processus de tri)

Par exemple, en considérant les directives suivantes relatives aux clés de jointure :

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

Ici, la clé de jointure a une longueur de 5 et commence à :

  • position 13 pour les enregistrements dans l'ensemble de données SORTJNF1 (concaténation du SORTJN préfixe et du fichier) F1

  • position 24 pour les enregistrements dans l'ensemble de données SORTJNF2 (concaténation du SORTJN préfixe et du fichier) F2

Gestion des contrôles/erreurs

  • Si le fichier d'entrée (SORTIN) possède une SHR disposition mais est introuvable, un message d'erreur est enregistré, le code de retour du programme est défini sur 1 et l'exécution du programme est interrompue (aucun tri n'aura lieu, aucune sortie ne sera produite)

Dans les cas suivants, un message d'RuntimeExceptionattente dédié sera émis :

  • Si l'appel du programme nécessite une connexion à une base de données (lorsque l'ensemble de SORTDBIN données est utilisé, nonSORTIN) mais qu'une source de données non valide peut être trouvée

  • Si le fichier de sortie (SORTOUT) n'est pas correctement défini

  • Si une commande présente dans la carte de contrôle ne peut pas être comprise ou n'est pas prise en charge

  • Si ce n'est pas exactement deux fichiers d'entrée sont fournis pour un SORT JOINKEYS dossier

Utilisation de l'échantillon

Exemple MERGE

Voici un exemple d'ICEMANinvocation à partir d'un extrait de script de tâche :

La carte de contrôle est intégrée et commande de fusionner les champs des fichiers d'entrée (voir l'SYSINentrée)

//*
//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
/*

Et l'extrait de script groovy modernisé correspondant : veuillez noter que, comme nous l'avons déjà mentionné, les SORTWK entrées ne sont pas prises en compte lors du processus de modernisation et que la carte de contrôle intégrée correspond exactement au contenu de l'ancienne carte de contrôle.

// 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")
                })
        }
    }
}

Échantillon de tri simple

Une ancienne étape de tri simple (extrait de script de tâche) avec carte de contrôle intégrée, extraite de l'exemple d'application 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)
/*

et l'extrait de script groovy modernisé correspondant :

// 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")
                })
        }
    }
}

Veuillez noter que la carte de contrôle intégrée est utilisée « telle quelle », sans aucune modification par rapport au contenu de l'ancienne carte de contrôle.

OUTIL À GLACE

Objectif

L'utilitaire ICETOOL est utilisé pour effectuer plusieurs opérations sur des ensembles de données en une seule étape (manipulation, tri et analyse des données).

Les principaux opérateurs suivants sont pris en charge :

  • COPY- Copie les données des fichiers d'entrée vers les fichiers de sortie

  • SORT- Trie les données en utilisant des cartes/critères de tri spécifiés

  • SELECT- Filtre et sélectionne des enregistrements spécifiques en fonction des conditions

  • SPLICE- Merges/joins des données provenant de sources multiples

  • COUNT- Compte les enregistrements répondant aux critères spécifiés

  • OCCUR- Analyse les modèles d'occurrence dans les données

Pour l'opérateur SPLICE, l'utilitaire utilisera une approche multithread basée sur des stratégies de segmentation des données afin de garantir des performances optimisées.

Les détails sur les opérateurs doivent être extraits de la documentation appropriée de l'ancienne plate-forme.

Signature

L'ICETOOLutilitaire ne prend aucun paramètre, mais s'appuie sur des ensembles de données spécifiques :

  • TOOLINl'ensemble de données contient les instructions de contrôle à traiter par l'utilitaire

  • TOOLMSGet DFSMSG les ensembles de données ne sont pas utilisés par l'ICETOOLutilitaire modernisé pour le moment (ignoré)

  • INest le préfixe des ensembles de données d'entrée (enregistrements à traiter)

  • OUTest le préfixe des ensembles de données en sortie (enregistrements résultant du traitement)

  • d'autres ensembles de données peuvent être référencés par des instructions de contrôle dans la carte de contrôle

Gestion des contrôles/erreurs

Dans les cas suivants, un message associé RuntimeException sera envoyé :

  • Si l'opérateur utilisé dans l'une des instructions de contrôle n'est pas pris en charge

  • Pour tout opérateur, si une directive non prise en charge est fournie

Utilisation de l'échantillon

Exemple ICETOOL SORT

Voici un ancien exemple de jcl utilisant ICETOOL à des fins de tri :

  • chaque instruction de contrôle de l'opérateur SORT utilise une carte de contrôle dédiée, dont la référence est spécifiée par le mot-clé USING

  • toutes les cartes de contrôle sont définies après la TOOLIN définition et sont intégrées (voir SEL1CNTL et suivantes les *CNTL entrées)

//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' '
//*

Une fois modernisé, l'extrait de script groovy correspondant ressemble à ceci :

// 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")
                })
        }
    }
}

Remarques :

  • Les cartes de contrôle intégrées sont utilisées « telles quelles » ; aucune transformation ne s'est produite par rapport aux anciennes cartes de contrôle

  • TOOLMSGet DFSMSG sont définis dans la version modernisée, mais seront ignorés lors de l'exécution

  • Dans les versions anciennes et modernisées, les cartes de contrôle sont définies avec le suffixe, mais référencées sans le CNTL suffixe dans les directives de l'TOOLINensemble de données : par exempleSORT FROM(IN1) TO(OUT1) USING(SEL1), In, le USING(SEL1) fait référence à la définition de l'ensemble de données SEL1CNTL

Échantillon ICETOOL COPY

Voici un autre exemple d'ICETOOL, utilisant l'opérateur COPY. Ceci TOOLIN est intégré dans l'extrait de 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')
//*

Et voici l'extrait de script groovy modernisé correspondant :

// 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

Objectif

Ce programme utilitaire est conçu pour imiter le comportement de l'utilitaire de tri nommé MFSORT utilisé dans les environnements Micro Focus (il est généralement invoqué depuis la ligne de commande ou dans des scripts sur les environnements existants).

En interne, le programme délègue les opérations de tri proprement dites au programme SORT/SYNCSORT/ICEMAN utilitaire.

Signature

Seule la syntaxe héritée suivante est prise en charge : mfsort take <control card>

L'appel d'instructions directes n'mfsort <instructions>est PAS pris en charge.

Elle ne prend aucun argument ; la directive take est émulée à l'aide d'un ensemble de données référencé commeTAKE, qui contient les commandes permettant à MFSORT de fonctionner.

Gestion des contrôles/erreurs

  • Si le TAKE jeu de données est manquant ou non valide, un RuntimeException sera lancé

  • Ils s'Gestion des contrôles/erreursappliquent également ici, compte tenu de la délégation de MFSORT à SORT

Utilisation de l'échantillon

L'appel de commande suivant montre un exemple d'utilisation de MFSORT :

mfsort take TESTSRT1.CTL

Voici l'extrait de script groovy adapté modernisé correspondant :

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