AWS El servicio de modernización de mainframes (experiencia en entornos de ejecución gestionados) ya no está abierto a nuevos clientes. Para obtener prestaciones similares a las del Servicio de Modernización de AWS Mainframe (experiencia en entornos de ejecución gestionados), explore el Servicio de Modernización de AWS Mainframe (experiencia autogestionada). Los clientes existentes pueden seguir utilizando el servicio con normalidad. Para obtener más información, consulte Cambio en la disponibilidad de la modernización del [AWS mainframe.](https://docs.aws.amazon.com/m2/latest/userguide/mainframe-modernization-availability-change.html) Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Utilidades de ordenación Las utilidades de ordenación se basan en conjuntos de datos cuya referencia tiene un significado especial para la utilidad. Por lo tanto, todas las utilidades de ordenación de la versión modernizada comparten el mismo patrón de invocación en las escrituras geniales: ``` mpr.withFileConfigurations(...) .withParameters(params) .runProgram("") ``` [dónde `mpr` está una `MainProgramRunner` instancia (consulta la sección de Scripts que llama a los programas en esta página).](https://docs.aws.amazon.com/m2/latest/userguide/ba-shared-structure.html#ba-shared-structure-run-call) Los alias de las utilidades de ordenación se indican en las siguientes secciones. Las entradas `DD` (definiciones de conjuntos de datos) del script JCL se modernizan como entradas en los detalles de la configuración del archivo que sirven de argumento al método. `mpr.withFileConfigurations()` Consulte los ejemplos que aparecen a continuación para ver ilustraciones de ese concepto. ## SORT/SYNCSORT/ICEMAN ### Finalidad Este programa emula varias utilidades SORT de mainframe, que se utilizan para obtener sort/merge/copy datos de conjuntos de datos, según los criterios proporcionados. Se pueden usar los siguientes alias del programa (que coincidan con el nombre de la utilidad de clasificación anterior correspondiente): + `SORT` + `SYNCSORT` + `ICEMAN` Los detalles sobre las SORT/MERGE directivas que se encuentran en las tarjetas de control y las funciones de la utilidad de clasificación antigua no se proporcionan aquí, sino que deben consultarse en la documentación pertinente de las plataformas antiguas existentes. ### Signature El programa no acepta ningún argumento, sino que se basa en referencias a conjuntos de datos específicos: + El `SYSIN` conjunto de datos (también conocido como la «tarjeta de control») contiene las sentencias de control sort/merge + El `SYMNAMES` conjunto de datos opcional contiene directivas de sustitución de variables en el contenido de SYSIN + El `SORTXSUM` conjunto de datos `SORTXDUP` o opcional se puede usar para almacenar registros duplicados + Los conjuntos de datos tienen el prefijo `SORTIN` o `SORTDBIN` contienen registros que se van a procesar (entradas) + El `SORTOUT` conjunto de datos contiene los resultados del programa (salida) + Las `SORTWK` definiciones de los conjuntos de datos de SORT WORK que se encuentran en algunos scripts de trabajos antiguos se ignoran (y no se representan en la llamada modernizada); los conjuntos de datos de sort WORK siempre se asignan de forma dinámica en el entorno moderno + Los dos conjuntos de datos cuyo DD comienza con `SORTJN` (prefijo) contienen registros que se regirán por las directivas de combinación de claves (utilizadas para unir conjuntos de datos durante el proceso de clasificación) Por ejemplo, teniendo en cuenta las siguientes directivas de combinación de claves: ``` JOINKEYS FILE=F1,FIELDS=(13,5,A) JOINKEYS FILE=F2,FIELDS=(24,5,A) ``` En este caso, la clave de unión tiene una longitud de 5 y comienza en: + posición 13 para los registros del conjunto de datos `SORTJNF1` (concatenación del `SORTJN` prefijo y el archivo) `F1` + posición 24 para los registros del conjunto de datos `SORTJNF2` (concatenación del prefijo y el archivo) `SORTJN` `F2` ### Comprobaciones/manejo de errores + Si el archivo de entrada (`SORTIN`) tiene una `SHR` disposición pero no se puede encontrar, se registra un mensaje de error, el código de retorno del programa se establece en 1 y la ejecución del programa se detiene (no se realizará ninguna clasificación, no se generará ningún resultado) En los siguientes casos, `RuntimeException` aparecerá un mensaje específico en espera: + Si la invocación del programa requiere conexión a una base de datos (cuando se utiliza un `SORTDBIN` conjunto de datos, no`SORTIN`), pero no se puede encontrar una fuente de datos válida + Si el archivo de salida (`SORTOUT`) no está definido correctamente + Si un comando que se encuentra en la tarjeta de control no se entiende o no es compatible + Si no es así, se proporcionan exactamente dos archivos de entrada para cada `SORT JOINKEYS` caso ### Ejemplo de uso #### Ejemplo de MERGE A continuación, se muestra un ejemplo de `ICEMAN` invocación extraída de un fragmento de script de trabajo: La tarjeta de control está alineada y permite combinar los campos de los archivos de entrada (consulte la entrada) `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 /* ``` Y el correspondiente fragmento de texto modernizado y genial. Tenga en cuenta que, como ya se ha mencionado, `SORTWK` las entradas no se tienen en cuenta durante el proceso de modernización y que la tarjeta de control integrada coincide exactamente con el contenido de la tarjeta de control anterior. ``` // 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") }) } } } ``` #### Ejemplo sencillo de clasificación Un sencillo paso de SORT tradicional (fragmento de guion de trabajo) con una tarjeta de control integrada, extraída de la aplicación de ejemplo 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) /* ``` y el correspondiente fragmento de código groovy modernizado: ``` // 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") }) } } } ``` Tenga en cuenta que la tarjeta de control integrada se utiliza «tal cual», sin modificar el contenido de la tarjeta de control anterior. ## ¿QUÉ BUENA HERRAMIENTA ### Finalidad La utilidad ICETOOL se utiliza para realizar múltiples operaciones en conjuntos de datos en un solo paso de trabajo (manipulación, clasificación y análisis de datos). Se admite a los siguientes operadores principales: + `COPY`- Copia los datos de los archivos de entrada a los archivos de salida + `SORT`- Ordena los datos utilizando cartas/criterios de clasificación específicos + `SELECT`- Filtra y selecciona registros específicos en función de las condiciones + `SPLICE`- Merges/joins datos de múltiples fuentes + `COUNT`- Cuenta los registros que cumplen con los criterios especificados + `OCCUR`- Analiza los patrones de ocurrencia en los datos Para el operador de SPLICE, la empresa utilizará un enfoque de subprocesos múltiples basado en estrategias de fragmentación de datos para garantizar un rendimiento optimizado. Los detalles sobre los operadores deben consultarse en la documentación correspondiente de la plataforma antigua. ### Signature La `ICETOOL` utilidad no toma ningún parámetro, sino que se basa en conjuntos de datos específicos: + `TOOLIN`El conjunto de datos contiene las sentencias de control que procesará la utilidad + `TOOLMSG`y la `ICETOOL` utilidad modernizada no utiliza los `DFSMSG` conjuntos de datos por ahora (se ignoran) + `IN`es el prefijo de los conjuntos de datos de entrada (registros que se van a procesar) + `OUT`es el prefijo de los conjuntos de datos de salida (registros resultantes del procesamiento) + Es posible que las sentencias de control de la tarjeta de control hagan referencia a otros conjuntos de datos ### Control de comprobaciones y errores En los siguientes casos, se `RuntimeException` mostrará un mensaje relacionado con él: + Si el operador utilizado en una de las sentencias de control no es compatible + Para cualquier operador, si se proporciona una directiva no compatible ### Ejemplo de uso #### Ejemplo de ICETOOL SORT Esta es una muestra antigua de jcl que utiliza ICETOOL para clasificarla: + cada sentencia de control del operador SORT utiliza una tarjeta de control específica, cuya referencia se especifica mediante la palabra clave USING + todas las tarjetas de control se definen después de la `TOOLIN` definición y están alineadas (consulte `SEL1CNTL` `*CNTL` las entradas siguientes) ``` //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 vez modernizado, el fragmento de groovy script correspondiente tiene el siguiente aspecto: ``` // 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") }) } } } ``` Notas: + Las tarjetas de control alineadas se utilizan «tal cual»; no se ha producido ninguna transformación con respecto a las cartas de control antiguas + `TOOLMSG`y `DFSMSG` están definidas en la versión modernizada, pero se ignorarán en tiempo de ejecución + Tanto en las versiones antiguas como en las modernizadas, las tarjetas de control se definen con el `CNTL` sufijo, pero se hace referencia a ellas sin el sufijo en las directivas del `TOOLIN` conjunto de datos: por ejemplo`SORT FROM(IN1) TO(OUT1) USING(SEL1)`, In, `USING(SEL1)` se refiere a la definición del conjunto de datos `SEL1CNTL` #### Ejemplo de ICETOOL COPY Aquí hay otro ejemplo de ICETOOL, utilizando el operador COPY. `TOOLIN`Está incluido en el fragmento 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') //* ``` Y aquí está el fragmento de código groovy modernizado correspondiente: ``` // 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 ### Finalidad El objetivo de este programa de utilidad es imitar el comportamiento de la utilidad de clasificación denominada MFSORT que se encuentra en los entornos de Micro Focus (por lo general, se invoca desde la línea de comandos o en los scripts de los entornos antiguos). Internamente, el programa delega las operaciones de clasificación propiamente dichas en el programa utilitario. [SORT/SYNCSORT/ICEMAN](#sort-syncsort-iceman) ### Signature Solo se admite la siguiente sintaxis antigua: `mfsort take ` NO `mfsort ` se admite la llamada directa como. No se necesita ningún argumento; la directiva *take* se emula mediante un conjunto de datos al que se hace referencia como`TAKE`, que contiene los comandos para que MFSORT funcione. ### Control de comprobaciones/manejo de errores + Si el `TAKE` conjunto de datos falta o no es válido, se `RuntimeException` lanzará un + También se [Comprobaciones/manejo de errores](#sort-error) aplican aquí, dada la delegación de MFSORT a SORT ### Ejemplo de uso La siguiente invocación de comandos muestra un ejemplo de uso de MFSORT: ``` mfsort take TESTSRT1.CTL ``` Este es el fragmento de código groovy adaptado modernizado correspondiente: ``` mpr.withFileConfigurations(new FileConfigurationUtils() .fileSystem("TAKE") .path("input(TESTSRT1.CTL)") .build() .getFileConfigurations()) .withArguments("input") // relative path for use and give files .runProgram("MFSORT"); ```