Todos os produtos
Search
Central de documentação

DataWorks:Como funcionam os nós do-while

Última atualização: Jun 27, 2026

O DataWorks oferece o nó do-while para executar um conjunto de tarefas em loop. Orquestre a lógica de negócio dentro de um nó do-while e utilize seu nó end interno para definir a condição de saída. Use esse nó isoladamente ou em conjunto com um nó assignment para iterar sobre o conjunto de dados transmitido por ele. Este tópico descreve os componentes e a lógica de aplicação do nó do-while.

Visão geral

A tabela a seguir apresenta um resumo deste tópico.

Descrição

Referências

Limitações e precauções para nós do-while, incluindo contagem máxima de loops, métodos de teste e visualização de logs.

Limitações, Precauções

Personalização do fluxo de trabalho interno, que deve começar com o nó start integrado e terminar com o nó end integrado.

Componentes e orquestração de fluxo de trabalho

Uso de variáveis integradas para obter parâmetros de loop, com exemplos de recuperação de valores.

Variáveis integradas, Exemplos de recuperação de valores

Controle da saída do loop pelo nó end, com amostras de código.

Código de exemplo: Sair de um loop usando o nó end

Casos de uso típicos do nó do-while.

Caso de uso 1: Uso com um nó assignment e Caso de uso 2: Uso com nós branch e merge

Limitações

  • O nó do-while está disponível apenas no DataWorks Standard Edition e versões posteriores. Para mais informações, consulte Edições e recursos do DataWorks.

  • Um nó do-while pode executar no máximo 1.024 iterações.

  • Não há suporte para execução paralela. Um novo loop só inicia após a conclusão do anterior.

Precauções

Dimensão

Item

Descrição

Suporte a loop

Número máximo de loops

Um nó do-while pode executar no máximo 1.024 iterações. Se o número de loops controlados pelo nó end exceder 1.024, o nó reportará um erro.

Nós internos

Orquestração de fluxo de trabalho

  • Ao personalizar a tarefa de loop, remova dependências entre nós internos e reorganize o fluxo de trabalho. No entanto, o fluxo deve obrigatoriamente começar com o nó start e terminar com o nó end.

  • Se utilizar um nó branch para julgamentos lógicos ou iteração de resultados dentro de um nó do-while, use também um nó merge.

  • Não adicione comentários ao código de um nó end.

Recuperação de valores

O nó fornece variáveis integradas para recuperar valores específicos de um nó assignment upstream.

Depuração

Depuração de tarefas

Em workspaces no modo padrão, não é possível testar um nó do-while diretamente no DataStudio.

Submeta a tarefa que contém o nó ao ambiente de desenvolvimento e execute-a no Operation Center.

Visualização de logs

Para visualizar os logs de execução de um nó do-while no Operation Center, clique com o botão direito na instância e selecione View Inner Nodes.

Dependências

Configurações de dependência

Use o nó do-while sozinho ou com um nó assignment. Contudo, ao fazer backfill de dados no Operation Center, selecione ambos os nós para execução. Executar apenas o nó do-while impede o recebimento de valores do nó assignment.

Componentes e orquestração de fluxo de trabalho

O nó do-while é um tipo especial de nó contêiner que abriga um fluxo de trabalho interno. Ao criar um nó do-while, três nós internos são gerados automaticamente: um nó start (início do loop), um nó shell (tarefa do loop) e um nó end (condição de término do loop). Esses nós internos organizam-se em um fluxo de trabalho para a execução repetida da tarefa.循环节点

  • nó start

    Marca o início do loop. Não contém código de tarefa e não pode ser excluído. Todos os outros nós do loop devem depender do nó start, direta ou indiretamente.

  • Lógica do loop

    Por padrão, o DataWorks cria um nó shell interno para a tarefa do loop. Exclua o nó shell padrão e construa um fluxo de trabalho de negócio personalizado dentro do loop.

    Geralmente, o fluxo de trabalho do loop é utilizado em conjunto com um nó assignment, um nó branch ou um nó merge. Ao personalizar as tarefas do loop, remova as dependências entre os nós internos e reorganize o fluxo conforme necessário. Entretanto, o fluxo deve sempre começar com o nó start e terminar com o nó end.

  • nó end

    • O nó end define a condição de loop para o nó do-while. Ele funciona de maneira semelhante a um nó assignment, retornando true para continuar para a próxima iteração ou false para encerrar o loop.

    • Escreva o código da condição de loop do nó end usando ODPS SQL, Shell ou Python 2. O nó do-while fornece variáveis integradas para simplificar esse código. Para mais detalhes sobre as variáveis integradas, consulte Variáveis integradas e Exemplos de recuperação de valores. Para amostras de código em diferentes linguagens, veja Código de exemplo: Sair de um loop usando o nó end.

    • Todos os nós dentro do loop devem estar posicionados antes do nó end (upstream), o qual não pode ser excluído.

Variáveis integradas

Um nó do-while utiliza o formato ${dag.variable_name} para recuperar variáveis. O DataWorks disponibiliza duas variáveis de sistema integradas: ${dag.loopTimes} e ${dag.offset}. Combine o nó do-while com um nó assignment e use o formato ${dag.variable_name} para obter valores dos parâmetros da atribuição.

  • Variáveis de sistema integradas

    Em cada iteração do loop, utilize as variáveis integradas para obter o número atual do loop e o deslocamento (offset).

    Variável integrada

    Descrição

    Valor

    ${dag.loopTimes}

    Número atual do loop.

    O valor é 1 para o primeiro loop, 2 para o segundo, 3 para o terceiro, e assim sucessivamente, até n para o enésimo loop.

    ${dag.offset}

    Deslocamento (offset).

    O valor é 0 para o primeiro loop, 1 para o segundo, 2 para o terceiro, e assim sucessivamente, até n-1 para o enésimo loop.

  • Recuperar resultados de um nó assignment

    Se utilizar um nó do-while juntamente com um nó assignment, recupere também os valores dos parâmetros da atribuição.

    Nota

    Quando um nó do-while depende de um nó assignment, defina os parâmetros de saída do nó assignment como os Input Parameters do nó do-while. Isso permite que o nó do-while recupere o conjunto de resultados do nó assignment e uma linha específica desse conjunto. O formato é ${dag.variable_name}, onde variable_name deve estar configurado nos Input Parameters do nó do-while. O exemplo neste tópico define o parâmetro input (um dos Input Parameters) no nó do-while para receber o conjunto de resultados do nó assignment. Na prática, substitua este nome pelo seu parâmetro real.

    Variável integrada

    Descrição

    ${dag.input}

    Conjunto de dados transmitido pelo nó assignment upstream.

    ${dag.input[${dag.offset}]}

    Recupera a linha de dados correspondente à iteração atual do loop.

    ${dag.input.length}

    Recupera o tamanho do conjunto de dados.

Exemplos de recuperação de valores

O formato do conjunto de resultados de um nó assignment varia conforme a linguagem utilizada. Para recuperar resultados de um nó assignment baseado em Shell, utilize um array unidimensional. Já para um nó assignment baseado em ODPS SQL, use um array bidimensional. Para mais informações, consulte nó assignment.

Exemplo 1: Nó assignment em Shell

  • Saída do nó

    O nó assignment upstream utiliza sintaxe Shell e sua última saída é 2021-03-28,2021-03-29,2021-03-30,2021-03-31,2021-04-01.

  • Valores das variáveis

    Variável integrada

    Valor no Loop 1

    Valor no Loop 2

    ${dag.input}

    2021-03-28,2021-03-29,2021-03-30,2021-03-31,2021-04-01

    ${dag.input[${dag.offset}]}

    2021-03-28

    2021-03-29

    ${dag.input.length}

    5

    ${dag.loopTimes}

    1

    2

    ${dag.offset}

    0

    1

Exemplo 2: Nó assignment em ODPS SQL

  • Saída do nó

    O nó assignment upstream usa sintaxe ODPS SQL e a última instrução SELECT retorna duas linhas:

    +----------------------------------------------+
    | uid            | region         | age_range      | zodiac |
    +----------------------------------------------+
    | 0016359810821  | Hubei Province | 30-40 years old| Cancer |
    | 0016359814159  | Unknown        | 30-40 years old| Cancer |
    +----------------------------------------------+
  • Valores das variáveis

    Variável integrada

    Valor no Loop 1

    Valor no Loop 2

    ${dag.input}

    +----------------------------------------------+
        | uid            | region         | age_range      | zodiac |
        +----------------------------------------------+
        | 0016359810821  | Hubei Province | 30-40 years old| Cancer |
        | 0016359814159  | Unknown        | 30-40 years old| Cancer |
        +----------------------------------------------+

    ${dag.input[${dag.offset}]}

    0016359810821,Hubei Province,30-40 years old,Cancer

    0016359814159,Unknown,30-40 years old,Cancer

    ${dag.input.length}

    2

    Nota

    O tamanho do conjunto de dados corresponde ao número de linhas no array bidimensional.

    ${dag.input[0][1]}

    Nota

    Valor localizado na primeira linha e segunda coluna do array bidimensional.

    Hubei Province

    ${dag.loopTimes}

    1

    2

    ${dag.offset}

    0

    1

Amostras de código do nó end

Escreva o código do nó end em ODPS SQL, Shell ou Python 2. Esta seção apresenta exemplos de código para cada linguagem.

ODPS SQL

SELECT  CASE 
 WHEN COUNT(1) > 0 AND ${dag.offset}<= 9 
  THEN true 
  ELSE false 
 END 
FROM  xc_dpe_e2.xc_rpt_user_info_d  where dt='20200101';

Neste exemplo, o código do nó end limita o número total de iterações comparando a contagem de linhas da tabela e o offset do loop com valores fixos.

Shell

if [ ${dag.loopTimes} -lt 5 ];
then
     echo "True"
else
     echo "False"
fi

Este código compara o número atual do loop, ${dag.loopTimes}, com 5 para limitar o total de iterações.

Por exemplo, ${dag.loopTimes} assume o valor 1 na primeira iteração e 2 na segunda. Quando atinge 5 na quinta iteração, a condição torna-se falsa, o nó end retorna False e o loop é encerrado.

Python 2

if ${dag.loopTimes}<${dag.input.length}:
   print True;
else
   print False;
# If the end node outputs True, the next loop starts.
# If the end node outputs False, the loop terminates.

Este trecho limita a quantidade de iterações comparando o número atual do loop (${dag.loopTimes}) com o tamanho do conjunto de dados proveniente do nó assignment.

Casos de uso

Nó assignment

A tabela abaixo descreve um cenário típico e as precauções necessárias ao utilizar um nó do-while com um nó assignment.

Cenário

Configuração

Passagem de parâmetros

Caso um nó interno dentro de um nó do-while precise recuperar a saída de um nó upstream (como o nó up_node) a cada iteração, utilize um nó assignment (como o nó assign_node) para transmitir os parâmetros.

  • Dependências

    O nó do-while deve depender do nó assignment upstream (assign_node).

    Nota

    Configure essa dependência no próprio nó do-while, e não em seus nós internos (como um nó shell).

  • Parâmetros de contexto

    • Defina os parâmetros de saída na seção Output Parameters do nó assignment (assign_node).

    • Adicione os parâmetros de saída do nó assignment à seção Input Parameters do nó de tarefa de loop interno (nó shell) do nó do-while.

      Nota

      Esse mapeamento de parâmetros é configurado no nó de tarefa de loop interno, não no próprio nó do-while.

Nos Output Parameters do nó assignment, um parâmetro chamado outputs com o valor ${outputs} é adicionado por padrão. No contexto do nó de tarefa de loop interno (o nó shell), adicione este parâmetro como um dos Input Parameters (por exemplo, com o nome de parâmetro input). No script shell, utilize variáveis como ${dag.input} e ${dag.offset} para referenciar o valor de saída transmitido pelo nó assignment.

Nós branch e merge

A tabela a seguir detalha um cenário comum e os cuidados ao empregar um nó do-while junto com um nó branch e um nó merge.典型应用

Caso de uso

Precaução

Para realizar julgamentos lógicos ou iterar sobre resultados dentro de um nó do-while, utilize um nó branch (como branch_node) e um nó merge (como merge_node) para personalizar o fluxo de trabalho interno.

Dentro de um nó do-while, todo nó branch (como branch_node) deve estar obrigatoriamente pareado com um nó merge (como merge_node).