SORT/SYNCSORT/ICEMAN ¿QUÉ BUENA HERRAMIENTA MFSORT

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.

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(<FILE CONFIGURATIONS DETAILS>...)
   .withParameters(params)
   .runProgram("<SORT UTILITY ALIAS>")

dónde mpr está una MainProgramRunner instancia (consulta la sección de Scripts que llama a los programas en esta página). 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, noSORTIN), 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:

TOOLINEl conjunto de datos contiene las sentencias de control que procesará la utilidad
TOOLMSGy la ICETOOL utilidad modernizada no utiliza los DFSMSG conjuntos de datos por ahora (se ignoran)
INes el prefijo de los conjuntos de datos de entrada (registros que se van a procesar)
OUTes 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
TOOLMSGy 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 ejemploSORT 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. TOOLINEstá 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

Signature

Solo se admite la siguiente sintaxis antigua: mfsort take <control card>

NO mfsort <instructions> 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 comoTAKE, 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 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");

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Utilidades de comandos

Otros/Utilidades misceláneas