Todos os produtos
Search
Central de documentação

DataWorks:Nó do-while

Última atualização: Jun 27, 2026

O DataWorks oferece o nó do-while, que implementa a lógica de loop "executar primeiro, verificar depois". Esse nó é ideal para repetir uma série de tarefas até que uma condição dinâmica seja atendida, como fazer polling para verificar a existência de um arquivo ou processar dados em lotes até esgotar a origem. Orquestre um fluxo de tarefas dentro do corpo do loop e use um nó End dedicado para controlar a saída do loop.

Casos de uso

No desenvolvimento de dados, o nó do-while simplifica o design de workflows que precisam executar tarefas repetidamente com base em uma condição. Os casos de uso comuns incluem:

  • Polling de API: Chame uma API repetidamente até que ela retorne um status específico, como SUCCESS, ou até que os dados da resposta atendam aos requisitos.

  • Verificações de disponibilidade de dados: Aguarde a geração de um arquivo ou partição de dados upstream. O loop verifica os dados em cada iteração e sai assim que eles estiverem disponíveis, acionando as tarefas downstream.

  • Processamento de dados em lote: Processe uma lista de itens, como nomes de tabelas ou partições de data, fornecida por um nó upstream (por exemplo, um nó de atribuição). O nó do-while itera pela lista e processa um item por vez até esgotá-la.

  • Sincronização de status: Verifique repetidamente o status de um serviço externo. Quando o status mudar para o estado desejado, como "Available" ou "Complete", o loop termina e aciona o workflow subsequente de sincronização ou processamento de dados.

Pré-requisitos

  • Requisitos de versão: Este recurso está disponível apenas no DataWorks Standard Edition ou superior.

  • Permissões: Adicione sua conta RAM ao workspace de destino e atribua a função Development ou Workspace Manager. Para mais informações, consulte Adicionar membros a um workspace.

Como funciona

O nó do-while atua como um contêiner de loop baseado no mecanismo "executar primeiro, verificar depois".

image Start nodeloop body (execute tasks)image End node (evaluate condition)

  1. Início e execução: O loop começa no image Start nodeloop body (execute tasks)image End node (evaluate condition)

  2. Avaliação da condição: Após a conclusão do corpo do loop, o image End node (evaluate condition)

  3. Decisão do loop:

    • Se o image End node (evaluate condition)

    • Se o image End node (evaluate condition)

Recurso principal : O corpo do loop sempre executa pelo menos uma vez, independentemente da condição inicial.

Componentes do nó

Clique duas vezes em um nó do-while para abrir seu canvas interno, composto por três partes principais:

  • image Start nodeloop body (execute tasks)image End node (evaluate condition)

  • Corpo do loop: Canvas personalizável para suas tarefas. Clique em Create Internal Node para adicionar vários tipos de nós internos, como Shell, SQL e Python, formando o processo de negócio repetível.

  • image End node (evaluate condition)

Variáveis integradas

No corpo do loop e no nó End de um nó do-while, utilize as seguintes variáveis integradas para obter o estado atual do loop e os dados de entrada:

Variável integrada

Descrição

Variáveis integradas do sistema

${dag.loopTimes}

Número da iteração atual, começando em 1.

${dag.offset}

Deslocamento da iteração atual, começando em 0. Equivalente a ${dag.loopTimes} - 1.

Uso com nó de atribuição (Supondo que o parâmetro de entrada input esteja vinculado à saída de um nó de atribuição upstream)

${dag.input}

Recupera o conjunto de resultados completo passado do upstream (geralmente um array bidimensional).

${dag.input.length}

Recupera o número de linhas no conjunto de resultados (total de elementos).

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

Recupera a linha de dados processada na iteração atual. O formato de retorno é uma string separada por vírgulas (por exemplo, "user_A,beijing").

${dag.input[i][j]}

(Apenas para arrays bidimensionais) Recupera o valor exato na linha i, coluna j (índices começam em 0).

Exemplo: ${dag.input[0][1]} extrai o valor "beijing" da primeira linha e segunda coluna.

Observações

  • Requisito de edição: Este recurso está disponível apenas no DataWorks Standard Edition ou superior.

  • Limite de loop: O número máximo padrão de iterações é 128. O máximo configurável é 1024. Exceder esse limite causa falha na tarefa.

  • Mecanismo de execução: O nó do-while usa modo de execução serial e não suporta processamento simultâneo. Cada iteração deve ser concluída antes do início da próxima.

  • Limitação de depuração: Não execute testes diretamente na página Data Studio. Primeiro, implante o workflow e, em seguida, use o recurso backfill data no Operation Center para verificar a tarefa.

  • Propagação de dependência: Se o nó do-while depender de um nó de atribuição upstream, inicie o backfill a partir do nó upstream para garantir a integridade do pipeline de dados.

  • Controle de fluxo: Ao usar um Branch node dentro do corpo do loop, garanta que todos os caminhos de ramificação convirjam em um Merge node para evitar quebrar o workflow.

Procedimento: Criar uma tarefa de loop simples

Este exemplo orienta a criação de uma tarefa que repete 5 vezes e imprime o número da iteração atual em cada loop.

Etapa 1: Configure o corpo do loop (adicionar um nó Shell)

  1. Crie um nó do-while no workflow.

  2. Clique duas vezes no nó para abrir o canvas interno. Na área do corpo do loop, clique em Create Internal Node, selecione Shell e nomeie-o como print_loop_times.

  3. Clique com o botão direito no nó e selecione Open Node.

  4. Insira o seguinte comando no editor de código:

    # Use the built-in variable ${dag.loopTimes} to get the current loop count
    echo "This is loop number: ${dag.loopTimes}"
  5. Clique no ícone de salvar para salvar o nó.

Etapa 2: Defina a condição de saída

  1. Retorne ao canvas interno do do-while, clique com o botão direito no image End node (evaluate condition)

  2. Altere a linguagem para Python.

  3. Insira o seguinte código Python:

    # When the loop count is less than 5, output True and continue looping
    # When the loop count reaches 5, output False and exit the loop
    if ${dag.loopTimes} < 5:
        print True
    else:
        print False
  4. Salve o nó End.

Etapa 3: Implantar, execute e verifique

  1. Retorne ao canvas principal do workflow e clique em Deploy na barra de ferramentas para implantar todo o workflow.

  2. Acesse o Operation Center e localize o nó do-while.

  3. Clique com o botão direito no nó e escolha Backfill Data > Current Node para iniciar uma execução de teste.

  4. Após a execução bem-sucedida da instância, clique com o botão direito no nó novamente e selecione View Internal Nodes.

  5. Visualize as cinco iterações do loop. Expanda qualquer iteração (por exemplo, a 5ª), clique com o botão direito na instância print_loop_times interna e selecione View Runtime Log. A saída esperada é:

    This is loop number: 5

Uso avançado: Processar uma lista de dados com um nó de atribuição

Cenário comum e prático: usar um nó do-while para iterar e processar um conjunto de dados gerado por um nó de atribuição upstream. Neste exemplo, um nó de atribuição ODPS SQL upstream consulta duas linhas de informações de usuário, e o nó do-while processa cada linha.

Etapa 1: Configure o nó de atribuição upstream

  1. Crie um nó de atribuição (por exemplo, chamado assign_sql_data) e defina-o como upstream do nó do-while.

  2. Use ODPS SQL para consultar dados no nó:

    SELECT 'user_A', 'beijing'
    UNION ALL
    SELECT 'user_B', 'shanghai';
  3. Salve o nó. O parâmetro outputs gerará um array bidimensional contendo duas linhas de dados.

Etapa 2: Configure o nó do-while para consumir dados

  1. No painel Schedule Settings, à direita do nó do-while, localize Input Parameters of This Node.

  2. Clique em Add e configure o seguinte parâmetro:

    • Parameter Name: input (personalizável)

    • Value Source: Selecione assign_sql_data.outputs

    • No corpo do loop do nó do-while, crie um nó Shell e insira o seguinte script para processar a linha atual:

      # Get the data row being processed in the current loop iteration
      echo "Processing data row: ${dag.input[${dag.offset}]}"
    • Abra o image End node (evaluate condition)

      # If the number of times executed is less than the total number of data rows, continue looping
      if ${dag.loopTimes} < ${dag.input.length}:
          print True
      else:
          print False
    • Implante o workflow e, no Operation Center, inicie o backfill a partir do nó assign_sql_data para garantir o fluxo correto dos dados para o loop.

    • Após uma execução bem-sucedida, os logs mostrarão que as duas iterações processaram "user_A,beijing" e "user_B,shanghai", respectivamente.

      Apêndice: Comparação entre nós do-while e for-each

      Recurso

      Nó Do-while

      Nó For-each

      Lógica principal

      Orientado por condição: Repete a execução até que uma condição deixe de ser atendida.

      Orientado por dados: Executa uma vez para cada elemento na lista de entrada.

      Número de iterações

      Indeterminado; depende de quando a condição é atendida.

      Determinado; igual ao número de elementos na lista de entrada.

      Garantia de execução

      Executa pelo menos uma vez (mesmo se a condição inicial já não for atendida).

      Se a entrada estiver vazia, nenhuma execução ocorre.

      Casos de uso

      Polling, espera, verificações de status e processamento em lote até esgotar a origem.

      Processamento em lote de uma lista conhecida (como sincronizar um conjunto de tabelas ou processar múltiplas partições).

      Método de controle

      Controlado pelo End node, que gera True / False para determinar se o loop continua.

      Termina automaticamente após percorrer todos os elementos.