AWS O Mainframe Modernization Service (experiência em Managed Runtime Environment) não está mais aberto a novos clientes. Para recursos semelhantes ao AWS Mainframe Modernization Service (experiência em Managed Runtime Environment), explore o AWS Mainframe Modernization Service (experiência autogerenciada). Os clientes atuais podem continuar usando o serviço normalmente. Para obter mais informações, consulte Alteração na [disponibilidade AWS da modernização do mainframe](https://docs.aws.amazon.com/m2/latest/userguide/mainframe-modernization-availability-change.html). As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Utilitários de conjuntos de dados ## BLUESAMCOPY/BLUESAMCREATE/BLUESAMDELETE/BLUESAMCLEAR Esses programas utilitários fornecem funções essenciais de manipulação de conjuntos de dados em conjuntos de dados [Blusam](https://docs.aws.amazon.com/m2/latest/userguide/ba-shared-blusam.html). O `bypassBluesamStatus` sinalizador (armazenado em JobContext) determina se a validação normal do status do conjunto de dados deve ser ignorada, o que evita conflitos de acesso simultâneo entre processos on-line e em lote. Quando `bypassBluesamStatus` for verdadeiro: + Ignora as verificações normais do status do conjunto de dados durante as operações + Permite acesso a conjuntos de dados que normalmente podem ser bloqueados ### SAMCOPIA AZUL O programa BLUESAMCOPY copia dados e estrutura de metadados de um conjunto de dados Bluesam para outro. #### Parâmetros O programa BLUESAMCOPY usa dois parâmetros: + `FROM=`- Conjunto de dados de origem do qual copiar + `TO=`- Conjunto de dados de destino para o qual copiar #### Comportamento + Se o conjunto de dados de destino não existir, crie-o com a estrutura de metadados da fonte + Se o destino existir, limpe-o antes de copiar (sobrescreve os dados existentes) + A operação prossegue quando os conjuntos de dados não estão em uso por processos on-line ou quando `bypassBluesamStatus` são definidos como verdadeiros + Preserva chaves, compactação, tamanho do registro e outras propriedades de metadados #### Tratamento de erros Retorna o código 1 se o conjunto de dados de origem não existir ou se um dos conjuntos de dados estiver sendo usado por processos on-line. #### Uso da amostra ``` import ... mpr = applicationContext.getBean("com.netfective.bluage.gapwalk.rt.call.ExecutionController",MainProgramRunner.class) // copy bluesam dataset res = mpr.withArguments("FROM=MYBLUESAMTABLE","TO=MYBLUESAMTABLE2").runProgram("BLUESAMCOPY") ``` ### BLUESAM CREATE O programa BLUESAMCREATE cria um conjunto de dados Bluesam com os parâmetros especificados. #### Parâmetros O programa BLUESAMCREATE usa sete parâmetros: + `name=`- Conjunto de dados a ser criado (obrigatório) + `compress=`- Ativar compressão (opcional, padrão: false) + `fixedLength=`- Status de registros de tamanho fixo (opcional, padrão: falso) + `recordLength=`- Tamanho do registro em bytes (opcional, padrão: -1) + `primaryKey=,duplicates=,fields=`- Especificação da chave primária (opcional) + `key=,duplicates=,fields=`- Chave alternativa (pode ter várias ou 0) + `clearExisting=true/false`- Limpar o conjunto de dados existente (padrão opcional: verdadeiro) Explicações específicas dos parâmetros-chave: + `duplicates`: se valores duplicados são permitidos ou não para a chave fornecida; + `fields`: Posições de campo (baseadas em 1) e comprimentos que definem a chave; #### Comportamento + Se o conjunto de dados não existir, crie-o com parâmetros especificados + Se o conjunto de dados existir, limpa-o se `clearExisting=true` + A operação prossegue quando os conjuntos de dados não estão em uso por processos on-line ou quando `bypassBluesamStatus` estão definidos como `true` #### Condições de erro Retorna o código 0 em todos os casos. #### Uso da amostra ``` import ... mpr = applicationContext.getBean("com.netfective.bluage.gapwalk.rt.call.ExecutionController",MainProgramRunner.class) // create bluesam dataset mpr.withArguments( "name=MYBLUESAMTABLE", "compress=FALSE", "fixedLength=true", "recordLength=54", "primaryKey=MYKEY_PK,duplicates=FALSE,fields=0,6") .runProgram("BLUESAMCREATE") ``` ### BLUESAMDELETE O programa BLUESAMDELETE exclui os conjuntos de dados do Bluesam. #### Parâmetros O programa BLUESAMDELETE usa 1 ou mais parâmetros: + ``- conjunto de dados a ser excluído (pode ter vários) #### Comportamento + A operação prossegue quando os conjuntos de dados não estão em uso por processos on-line ou quando `bypassBluesamStatus` estão definidos como `true` + Se o conjunto de dados existir, exclua-o #### Condições de erro Retorna o código 0 em todos os casos. #### Uso da amostra ``` import ... mpr = applicationContext.getBean("com.netfective.bluage.gapwalk.rt.call.ExecutionController",MainProgramRunner.class) // delete bluesam datasets res = mpr.withArguments("MYBLUESAMTABLE","MYBLUESAMTABLE2","MYBLUESAMTABLE3").runProgram("BLUESAMDELETE") ``` ### AZUL SAM TRANSPARENTE O programa BLUESAMCLEAR remove todos os dados dos conjuntos de dados existentes, preservando sua estrutura e metadados. #### Parâmetros O programa BLUESAMCLEAR usa 1 ou mais parâmetros: + ``- conjunto de dados para limpar (pode ter vários) #### Comportamento + A operação prossegue quando os conjuntos de dados não estão em uso por processos on-line ou quando `bypassBluesamStatus` estão definidos como `true` + Se o conjunto de dados existir, limpe-o #### Condições de erro Retorna o código 0 em todos os casos. #### Uso da amostra ``` import ... mpr = applicationContext.getBean("com.netfective.bluage.gapwalk.rt.call.ExecutionController",MainProgramRunner.class) // clear bluesam datasets res = mpr.withArguments("MYBLUESAMTABLE","MYBLUESAMTABLE2").runProgram("BLUESAMCLEAR") ``` ## BPXWDYN Esse programa utilitário simula o serviço z/OS BPXWDYN para alocação e desalocação dinâmica de conjuntos de dados. Em aplicativos modernos, as alocações de arquivos são feitas em scripts Groovy por meio `FileConfigurationUtils` da API do construtor. Esse programa permite o gerenciamento dinâmico dessas alocações sem o Groovy, o que é essencial para o processamento interativo ou condicional de arquivos em aplicativos modernizados. ### Parâmetros O formato do argumento legado é preservado. Espera um único argumento contendo um cabeçalho de 2 bytes seguido pela string de comando. formato de cadeia de comando para alocação: `ALLOC DD() DSN('') SHR?` formato de cadeia de comando para desalocação: `FREE DD()` ### Tratamento de erros + Defina o código de erro 0 para sucesso, 1 para falha + Lança RuntimeException comandos ou parâmetros inválidos ### Uso da amostra Aqui está um exemplo de uso do programa BPXWDYN em Java, resultante de uma modernização do COBOL por meio da transformação da AWS: O código COBOL: ``` 01 WK-AREA. 03 DS-ALLOC-STRING. 05 DS-LENGTH PIC S9(004) COMP VALUE 100. 05 DS-TEXT PIC X(100) VALUE "ALLOC DD(INFILE) DSN('A.B.JCLLIB(XYZ470)') SHR". ... 01 RC-RETURN-CODE-AREA. 03 RC-RETURN-CODE PIC S9(008) COMP. ... CALL 'BPXWDYN' USING DS-ALLOC-STRING RETURNING RC-RETURN-CODE. ``` e a modernização correspondente do Java: ``` private final Group dsAllocString = new Group(root).named("DS-ALLOC-STRING"); private final Elementary dsLength = new Elementary(dsAllocString,new BinaryType(4, 0, "STD", false, false, true),Short.valueOf("100")).named("DS-LENGTH"); private final Elementary dsText = new Elementary(dsAllocString,new AlphanumericType(100),"ALLOC DD(INFILE) DSN('A.B.JCLLIB(XYZ470)') SHR").named("DS-TEXT"); ... private final Group root = new Group(getData()).named("RC-RETURN-CODE-AREA"); private final Elementary rcReturnCode = new Elementary(root,new BinaryType(8, 0, "STD", false, false, true)).named("RC-RETURN-CODE"); ... // Call to utility program BPXWDYN ctrl.callSubProgram( "BPXWDYN", CallBuilder.newInstance().byReference(ctx.getWkArea().getDsAllocStringReference()).getArguments(), ctx); ctx.getRcReturnCodeArea().setRcReturnCode(NumberUtils.convert(ctx.getProgramReturned()).intValue()); ``` ## GDGU TILS GDGs (Generation Data Group) permite que os aplicativos trabalhem com conjuntos de dados versionados em que cada execução cria uma nova geração enquanto mantém o acesso às gerações anteriores. Esse utilitário cria e gerencia essas gerações de conjuntos de dados. Esse utilitário deve ser chamado em scripts groovy. ### Parâmetros a ordem dos parâmetros não importa + `action=`- Operação a ser executada (obrigatória) + `gdgname=`- Nome da base do GDG (obrigatório) + `storageProvider=`- Backend de armazenamento + `relativeGeneration=<+integer>`- Número relativo da geração (por exemplo, \+1 para a próxima) + `absoluteGeneration=integer`- Número absoluto de geração + `recordLength=`- Tamanho do registro no conjunto de dados + `fixedLength=`- Especifica que os registros têm um tamanho fixo no conjunto de dados + `ownerPath=`- O caminho para armazenar o conjunto de dados (específico do sistema de arquivos, obrigatório para esse caso) + `compress=`- Indica que os dados devem permanecer compactados na memória se forem compactados no armazenamento de dados (específico do bluesam) (opcional, false é o valor padrão) + `catalog`- Especifica que o conjunto de dados deve ser catalogado (opcional) + `warmUp`- Indica que o conjunto de dados deve ser carregado na memória quando aberto (específico para bluesam) (opcional) RelativeGeneration ou AbsoluteGeneration: uma dessas propriedades precisa ser definida. ### Operações + criar: cria uma nova geração de conjunto de dados GDG de acordo com os metadados do GDG (lida com o sistema de arquivos e o armazenamento Bluesam) + refreshevents: ajusta o número de geração (metadados Gdg) sem criar novos conjuntos de dados (usado ao reiniciar trabalhos com falha que já criaram conjuntos de dados) ### Tratamento de erros + Defina o código de erro 0 para sucesso, 1 para falha + Lança RuntimeException comandos ou parâmetros inválidos ### Uso da amostra Operação de criação de Gdg: o código a seguir cria uma geração bluesam (43) para o conjunto de dados `IC.PLI.GDGTEST` ``` import ... mpr = applicationContext.getBean("com.netfective.bluage.gapwalk.rt.call.ExecutionController",MainProgramRunner.class) Map params = new Hashtable() params.put("jobContext", jobContext) Object[] args =["action=create","gdgname=IC.PLI.GDGTEST","absoluteGeneration=43","storageProvider=bluesam","recordLength=80"] mpr.withParameters(params).withArguments(args).runProgram("GDGUTILS") ``` Operação Gdg refreshevents: somente RelativeGeneration é relevante para esta operação. O código a seguir atualiza o número da geração (\+1 em comparação com a geração atual) do `IC.PLI.GDGTEST` conjunto de dados ``` import ... mpr = applicationContext.getBean("com.netfective.bluage.gapwalk.rt.call.ExecutionController",MainProgramRunner.class) Map params = new Hashtable() params.put("jobContext", jobContext) Object[] args =["action=refreshevents","gdgname=IC.PLI.GDGTEST","relativeGeneration=1","storageProvider=bluesam"] mpr.withParameters(params).withArguments(args).runProgram("GDGUTILS") ``` ## ICEGENER/SYNCGEN Este programa utilitário imita o comportamento do utilitário de z/OS sistema ICEGENER, ele copia conjuntos de dados da entrada (conjunto de dados) para a saída (SYSUT1 conjunto de dados). SYSUT2 Essa implementação Java fornece funcionalidade equivalente, suportando tanto o sistema de arquivos quanto o armazenamento Bluesam. ### Parâmetros Sem discussão ### Conjuntos de dados necessários + SYSUT1: conjunto de dados/arquivo de entrada + SYSUT2: conjunto de dados/arquivo de saída ### Tratamento de disposição para conjunto de dados SYSUT2 + NOVO: Crie um novo conjunto de dados/arquivo + OLD/SHR: Use existing dataset/file(deve existir) + MOD: Modifique, crie se estiver faltando, anexe se existir ### Tratamento de erros + Defina o código de erro 0 se a cópia for bem-sucedida, 1 se falhar + Lança `IllegalStateException` por uso inválido do conjunto de dados Bluseam ### Uso da amostra Aqui está um exemplo do uso do programa ICEGENER pelo Groovy, resultante de uma modernização da JCL por meio da transformação da AWS: O código JCL: ``` //STEP01 EXEC PGM=ICEGENER //SYSUT1 DD DSN=POI.INPUT,DISP=SHR //SYSUT2 DD DSN=POI.OUTPU, // DISP=(,CATLG,DELETE), // UNIT=3490, // DCB=(RECFM=FB,LRECL=100) /* ``` e a modernização correspondente do Groovy: ``` mpr .withFileConfigurations(new FileConfigurationUtils() .withJobContext(jobContext) .bluesam("SYSUT1") .dataset("POI.INPUT") .disposition("SHR") .build() .bluesam("SYSUT2") .dataset("POI.OUTPU") .normalTermination("CATLG") .abnormalTermination("DELETE") .build() .getFileConfigurations()) .withParameters(params) .runProgram("ICEGENER") ``` ## IDCAMS/KQCAMS Esse programa utilitário imita o comportamento dos programas legados IDCAMS, que é uma ferramenta de gerenciamento de dados de mainframe usada para operações de arquivos VSAM (Virtual Storage Access Method). Ele processa os comandos IDCAMS antigos, mantendo a mesma sintaxe das entradas SYSIN originais. ### Contexto O comportamento do programa pode ser configurado por dois parâmetros definidos em`application-utility-pgm.yml`: + JCLType: identificador do tipo JCL (vse ou mvs). Os PRINT/REPRO comandos do utilitário IDCAMS retornam 4 se o arquivo estiver vazio para não-vse jcl + forcedCharsetIdcams: Substituição opcional do conjunto de caracteres para processamento de IDCAMS ### Parâmetros Sem discussão. As operações são passadas pelo conjunto de dados SYSIN. ### Conjuntos de dados necessários + SYSIN - Contém instruções de comando IDCAMS + Conjuntos de dados de entrada/saída - conforme referenciado nos comandos IDCAMS (dependendo da declaração IDCAMS) ### Principais características/Comandos suportados Os detalhes sobre os comandos IDCAMS encontrados na placa de controle SYSIN não são fornecidos aqui, mas devem ser obtidos nas documentações de plataformas legadas relevantes existentes. + DEFINE - Cria clusters e conjuntos de dados VSAM + EXCLUIR - Remove conjuntos de dados (suporta curingas) + REPRO - Copia dados entre conjuntos de dados + IMPRIMIR - Exibe o conteúdo do conjunto de dados + VERIFY - Valida a existência e a integridade do conjunto de dados + ALTER - Modifica os atributos do conjunto de dados (renomeação) + ALLOC - Aloca conjuntos de dados dinamicamente + SET - Gerencia códigos de condição (LASTCC/MAXCC) + IF-THEN-ELSE - Execução condicional de comandos + CANCELAR - Encerra a execução do trabalho ### Tratamento de erros + Defina o código de erro 0 se o último comando for bem-sucedido, -1 se falhar + Os comandos SET (LASTCC) podem ser usados para substituir o código de erro, por exemplo `SET LASTCC = 0` ### Uso da amostra Aqui está um exemplo do uso do programa IDCAMS pelo Groovy, resultante de uma modernização da JCL por meio da transformação da AWS: O código JCL: ``` //STEP15 EXEC PGM=IDCAMS //SYSPRINT DD SYSOUT=* //ACCTDATA DD DISP=SHR, // DSN=AWS.M2.CARDDEMO.ACCTDATA.PS //ACCTVSAM DD DISP=SHR, // DSN=AWS.M2.CARDDEMO.ACCTDATA.VSAM.KSDS //SYSIN DD * REPRO INFILE(ACCTDATA) OUTFILE(ACCTVSAM) /* ``` e a modernização correspondente do Groovy: ``` mpr.withFileConfigurations(new FileConfigurationUtils() .withJobContext(jobContext) .systemOut("SYSPRINT") .output("*") .build() .bluesam("ACCTDATA") .dataset("AWS.M2.CARDDEMO.ACCTDATA.PS") .disposition("SHR") .build() .bluesam("ACCTVSAM") .dataset("AWS.M2.CARDDEMO.ACCTDATA.VSAM.KSDS") .disposition("SHR") .build() .fileSystem("SYSIN") .stream("REPRO INFILE(ACCTDATA) OUTFILE(ACCTVSAM)", getEncoding()) .build() .getFileConfigurations()) .withParameters(params) .runProgram("IDCAMS") ``` ## IEBGENER/JSDGENER Este programa replica o utilitário IEBGENER. É usado para copiar e manipular conjuntos de dados sequenciais. Essa implementação amplia a funcionalidade básica de cópia ao oferecer suporte às instruções de controle do IEBGENER para operações avançadas de processamento de dados. ### Parâmetros Sem discussão. As operações são passadas pelo conjunto de dados SYSIN. ### Conjuntos de dados necessários + SYSIN: contém instruções de controle (opcional, se não definido, o programa IEBGENER é idêntico ao ICEGENER) + SYSUT1: conjunto de dados/arquivo de entrada + SYSUT2: conjunto de dados/arquivo de saída ### Principais características/Declarações de controle IEBGENER suportadas Os detalhes sobre a declaração de controle do IEBGENER encontrados nos cartões de controle SYSIN não são fornecidos aqui, mas devem ser obtidos nas documentações de plataformas legadas relevantes existentes. + GENERATE - define a estrutura geral do processo de manipulação de dados especificando o número máximo de tipos de registro (MAXNAME) e campos (MAXFLDS) a serem processados + REGISTRO - define o layout e o conteúdo reais de cada tipo de registro especificando a posição, o comprimento e o formato dos campos individuais que serão copiados do conjunto de dados de entrada ou gerados com valores específicos + LABEL/MEMBER/EXITnão são suportados exemplo: ``` GENERATE MAXNAME=3,MAXFLDS=5 RECORD TYPE=1, FIELD=(1,1,CH,VALUE='H'), FIELD=(2,30,CH,VALUE='EMPLOYEE REPORT 2024 ') RECORD TYPE=2, FIELD=(1,1,CH,VALUE='D'), FIELD=(2,10,CH), /* Name */ FIELD=(12,8,CH), /* Birth date */ FIELD=(20,8,CH,VALUE='ACTIVE') RECORD TYPE=3, FIELD=(1,1,CH,VALUE='F'), FIELD=(2,30,CH,VALUE='END OF REPORT ') ``` ### Tratamento de erros Defina o código de erro 0 se a cópia for bem-sucedida, 1 se falhar. ### Uso da amostra Aqui está um exemplo do uso do programa IEBGENER pelo Groovy, resultante de uma modernização da JCL por meio da transformação da AWS: O código JCL: ``` //GENDATA EXEC PGM=IEBGENER //SYSUT1 DD DSN=INPUT.EMPLOYEE.DATA, // DISP=SHR //SYSUT2 DD DSN=OUTPUT.EMPLOYEE.FILE, // DISP=(NEW,CATLG,DELETE), // SPACE=(TRK,(1,1)), // DCB=(RECFM=FB,LRECL=80,BLKSIZE=27920) //SYSIN DD * GENERATE MAXNAME=2,MAXFLDS=5 RECORD TYPE=1, FIELD=(1,1,CH,VALUE='H'), FIELD=(2,30,CH,VALUE='EMPLOYEE SALARY REPORT 2024 ') RECORD TYPE=2, FIELD=(1,1,CH,VALUE='D'), FIELD=(2,10,CH), /* Name from input */ FIELD=(12,8,CH), /* Birth date from input */ FIELD=(20,8,CH), /* Dept from input */ FIELD=(28,8,CH) /* Salary from input */ /* ``` e a modernização correspondente do Groovy: ``` mpr .withFileConfigurations(new FileConfigurationUtils() .withJobContext(jobContext) .systemOut("SYSPRINT") .output("*") .build() .bluesam("SYSUT1") .dataset("INPUT.EMPLOYEE.DATA") .disposition("SHR") .build() .bluesam("SYSUT2") .dataset("OUTPUT.EMPLOYEE.FILE") .disposition("NEW") .normalTermination("CATLG") .abnormalTermination("DELETE") .build() .fileSystem("SYSIN") .stream( """GENERATE MAXNAME=2,MAXFLDS=5 RECORD TYPE=1, FIELD=(1,1,CH,VALUE='H'), FIELD=(2,30,CH,VALUE='EMPLOYEE SALARY REPORT 2024 ') RECORD TYPE=2, FIELD=(1,1,CH,VALUE='D'), FIELD=(2,10,CH), /* Name from input */ FIELD=(12,8,CH), /* Birth date from input */ FIELD=(20,8,CH), /* Dept from input */ FIELD=(28,8,CH) /* Salary from input */""", getEncoding()) .build() .getFileConfigurations()) .withParameters(params) .runProgram("IEBGENER") ``` ## IEFBR14 IEFBR14 é um programa de “não fazer nada” que simplesmente retorna com um código de retorno de 0 (zero). Seu uso principal é para alocação, exclusão ou manutenção de catálogos de conjuntos de dados por meio de instruções DD, sem realizar nenhum processamento real de dados. ### Parâmetros Sem discussão ### Tratamento de erros Defina sempre o código de erro 0. ### Uso da amostra Aqui está um exemplo do uso do IEFBR14 programa pelo Groovy, resultante de uma modernização da JCL por meio da transformação da AWS: O código JCL para criar um novo conjunto de dados sequencial: ``` //STEP1 EXEC PGM=IEFBR14 //NEWSEQ DD DSN=USER.NEW.SEQ.DATA, // DISP=(NEW,CATLG,DELETE), // SPACE=(TRK,(10,5)), // DCB=(RECFM=FB,LRECL=80,BLKSIZE=27920) ``` e a modernização correspondente do Groovy: ``` mpr .withFileConfigurations(new FileConfigurationUtils() .withJobContext(jobContext) .bluesam("NEWSEQ") .dataset("USER.NEW.SEQ.DATA") .disposition("NEW") .normalTermination("CATLG") .abnormalTermination("DELETE") .build() .getFileConfigurations()) .withParameters(params) .runProgram("IEFBR14") ``` O código JCL para excluir um conjunto de dados existente: ``` //STEP3 EXEC PGM=IEFBR14 //DELDD DD DSN=USER.OLD.DATASET, // DISP=(OLD,DELETE,DELETE) ``` e a modernização correspondente do Groovy: ``` mpr .withFileConfigurations(new FileConfigurationUtils() .withJobContext(jobContext) .bluesam("DELDD") .dataset("USER.OLD.DATASET") .disposition("OLD") .normalTermination("DELETE") .abnormalTermination("DELETE") .build() .getFileConfigurations()) .withParameters(params) .runProgram("IEFBR14") ``` ## JCLBCICS Este programa gerencia o status dos conjuntos de dados, define enables/disables conjuntos de dados com base na configuração, suportando arquivos individuais e padrões curinga: ele altera o campo STATUS na tabela JICS file\_table. ### Parâmetros Sem discussão. As operações são passadas por um `DatasetsConfiguration` objeto, por exemplo ``` mpr.withDatasetsConfiguration(new DatasetsConfiguration().close() ``` ### Contexto O comportamento do programa pode ser configurado por dois parâmetros: Em `application-utility-pgm.yml`: + `jclbcics.ddname.size`(o padrão é 8): configura globalmente o tamanho do nome do conjunto de dados; se esse valor for definido e o tamanho do nome do conjunto de dados for menor que esse valor, o nome do conjunto de dados será truncado. Na etapa individual do arquivo Groovy chamando o programa + `JCLBCICS_OVERRIDDEN_SIZE`: ele substitui o tamanho do nome do conjunto de dados global: ``` TreeMap stepMapTransfo = [:] Map stepParams = ["MapTransfo":stepMapTransfo] stepParams["MapTransfo"]["JCLBCICS_OVERRIDDEN_SIZE"] = '6' ``` Se o tamanho do nome dd ajustado (após o truncamento) for menor que 8, o nome dd será considerado um curinga e a função funcionará para todos os conjuntos de dados que começam com esse nome dd. ### Recursos principais As operações suportadas são: + ABERTO: define conjuntos de dados para o status HABILITADO + FECHAR: define os conjuntos de dados para o status DESATIVADO Essas operações são declaradas por meio da classe `DatasetsConfiguration` builder: ``` new DatasetsConfiguration().close(
).open(
) ``` Nome do DD: nome do conjunto de dados, o caractere curinga \* é aceito se o tamanho do nome dd for menor que o tamanho máximo do nome dd (8). ### Tratamento de erros Definir código de erro 0 ### Uso da amostra Aqui está um exemplo do uso do programa JCLBCICS pelo Groovy: ele desativa o conjunto de dados`UFOLJ3P`, habilita todos os conjuntos de dados começando com AX, habilita todos os conjuntos de dados começando com DX ``` import com.netfective.bluage.gapwalk.rt.call.MainProgramRunner import com.netfective.bluage.gapwalk.rt.call.ProgramExecutionResult import com.netfective.bluage.gapwalk.rt.io.support.DatasetsConfiguration MainProgramRunner mpr = applicationContext.getBean("com.netfective.bluage.gapwalk.rt.call.ExecutionController",MainProgramRunner.class) def TreeMap stepMapTransfo = [:] def Map stepParams = ['MapTransfo':stepMapTransfo] stepParams['MapTransfo']['JCLBCICS_OVERRIDDEN_SIZE'] = '7' ProgramExecutionResult res = mpr .withDatasetsConfiguration(new DatasetsConfiguration().close("UFOLJ3P").open("AX*").open("DX")) .withParameters(stepParams) .runProgram("JCLBCICS") ```