AWS Data Pipeline não está mais disponível para novos clientes. Os clientes existentes do AWS Data Pipeline podem continuar usando o serviço normalmente. [Saiba mais](https://aws.amazon.com/blogs/big-data/migrate-workloads-from-aws-data-pipeline/)
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á.
# Expressões e funções do pipeline
Esta seção explica a sintaxe para o uso de expressões e funções nos pipelines, incluindo os tipos de dados associados.
## Tipos de dados simples
Os tipos de dados a seguir podem ser definidos como valores de campo.
**Topics**
+ [DateTime](#dp-datatype-datetime)
+ [Numérico](#dp-datatype-numeric)
+ [Referências de objeto](#dp-datatype-object-reference)
+ [Período](#dp-datatype-period)
+ [String](#dp-datatype-section)
### DateTime
AWS Data Pipeline suporta somente a data e a hora expressas no formato “YYYY-MM-DDTHH:MM:SS”. UTC/GMT O exemplo a seguir define o `startDateTime` campo de um `Schedule` objeto como`1/15/2012, 11:59 p.m.`, no UTC/GMT fuso horário.
```
"startDateTime" : "2012-01-15T23:59:00"
```
### Numérico
AWS Data Pipeline suporta valores inteiros e de ponto flutuante.
### Referências de objeto
Um objeto na definição do pipeline. Ele pode ser o objeto atual, o nome de um objeto definido em outro lugar no pipeline ou um objeto que lista o objeto atual em um campo, referenciado pela palavra-chave `node`. Para saber mais sobre o `node`, consulte [Referenciar campos e objetos](dp-pipeline-expressions.md#dp-pipeline-expressions-reference). Para obter mais informações sobre os tipos de objetos de pipeline, consulte [Referência de objeto de pipeline](dp-pipeline-objects.md).
### Período
Indica a frequência com que um evento programado deve ser executado. Expresso no formato "*N* [`years`\$1`months`\$1`weeks`\$1`days`\$1`hours`\$1`minutes`]", onde *N* é um valor inteiro positivo.
O período mínimo é de 15 minutos, e o máximo é de 3 anos.
O exemplo a seguir define o campo `period` do objeto `Schedule` como "3 hours". Isso cria uma programação que é executada a cada três horas.
```
"period" : "3 hours"
```
### String
Valores de string padrão. As strings precisam estar entre aspas duplas ("). Você pode usar a barra invertida (\$1) nos caracteres de escape em uma string. Não há suporte para strings de várias linhas.
Veja a seguir exemplos de valores de string válidos para o campo `id`.
```
"id" : "My Data Object"
"id" : "My \"Data\" Object"
```
As strings também podem conter expressões avaliadas como valores de string. Elas são inseridas na string e são delimitadas com "\$1\$1" e "\$1". O exemplo a seguir usa uma expressão para inserir o nome do objeto atual em um caminho.
```
"filePath" : "s3://amzn-s3-demo-bucket/#{name}.csv"
```
Para obter mais informações sobre como usar expressões, consulte [Referenciar campos e objetos](dp-pipeline-expressions.md#dp-pipeline-expressions-reference) e [Avaliação de expressões](dp-pipeline-expressions.md#dp-datatype-functions).
# Expressões
Com as expressões, é possível compartilhar um valor nos objetos relacionados. As expressões são processadas pelo serviço AWS Data Pipeline web em tempo de execução, garantindo que todas as expressões sejam substituídas pelo valor da expressão.
As expressões são delimitadas por "\$1\$1" e "\$1". Você pode usar uma expressão em qualquer objeto de definição de pipeline em que uma string é válida. Se um slot for uma referência ou destes tipos: ID, NAME, TYPE ou SPHERE, o valor dele não será avaliado nem usado textualmente.
A expressão a seguir chama uma das AWS Data Pipeline funções. Para obter mais informações, consulte [Avaliação de expressões](#dp-datatype-functions).
```
#{format(myDateTime,'YYYY-MM-dd hh:mm:ss')}
```
## Referenciar campos e objetos
As expressões podem usar campos do objeto atual em que a expressão existe ou campos de outro objeto vinculado por uma referência.
Um slot consiste em uma data de criação seguida pelo horário de criação do objeto, como `@S3BackupLocation_2018-01-31T11:05:33`.
Você também pode fazer referência ao ID do slot exato especificado na definição do pipeline, como o ID do slot do local de backup do Amazon S3. Para fazer referência ao ID do slot, use `#{parent.@id}`.
No exemplo a seguir, o campo `filePath` faz referência ao campo `id` no mesmo objeto para formar um nome de arquivo. O valor de `filePath` é avaliado para "`s3://amzn-s3-demo-bucket/ExampleDataNode.csv`".
```
{
"id" : "ExampleDataNode",
"type" : "S3DataNode",
"schedule" : {"ref" : "ExampleSchedule"},
"filePath" : "s3://amzn-s3-demo-bucket/#{parent.@id}.csv",
"precondition" : {"ref" : "ExampleCondition"},
"onFail" : {"ref" : "FailureNotify"}
}
```
Para usar um campo que existe em outro objeto vinculado por uma referência, use a palavra-chave `node`. Essa palavra-chave só está disponível com objetos de alarme e precondição.
Continuando com o exemplo anterior, uma expressão em `SnsAlarm` pode fazer referência ao intervalo de data e de hora em `Schedule`, pois `S3DataNode` faz referência a ambas.
Especificamente, o campo `message` de `FailureNotify` pode usar os campos de runtime `@scheduledStartTime` e `@scheduledEndTime` de `ExampleSchedule`, pois o campo `onFail` do `ExampleDataNode` faz referência a `FailureNotify` e seu respectivo campo `schedule` faz referência a `ExampleSchedule`.
```
{
"id" : "FailureNotify",
"type" : "SnsAlarm",
"subject" : "Failed to run pipeline component",
"message": "Error for interval #{node.@scheduledStartTime}..#{node.@scheduledEndTime}.",
"topicArn":"arn:aws:sns:us-east-1:28619EXAMPLE:ExampleTopic"
},
```
**nota**
Você pode criar pipelines com dependências, por exemplo, tarefas no seu pipeline que dependem do trabalho de outros sistemas ou de outras tarefas. Se o pipeline exigir determinados recursos, adicione essas dependências a ele usando precondições associadas a nós de dados e a tarefas. Isso faz com que os pipelines sejam depurados com mais facilidade e sejam mais resilientes. Além disso, mantenha suas dependências em um único pipeline sempre que possível, pois é difícil solucionar problemas em entre vários pipelines.
## Expressões aninhadas
AWS Data Pipeline permite aninhar valores para criar expressões mais complexas. Por exemplo, para executar um cálculo de tempo (subtrair 30 minutos de `scheduledStartTime`) e formatar o resultado para usar em uma definição de pipeline, você pode usar a seguinte expressão em uma atividade:
```
#{format(minusMinutes(@scheduledStartTime,30),'YYYY-MM-dd hh:mm:ss')}
```
e usando o `node` prefixo se a expressão fizer parte de uma pré-condição SnsAlarm ou:
```
#{format(minusMinutes(node.@scheduledStartTime,30),'YYYY-MM-dd hh:mm:ss')}
```
## Listas
As expressões podem ser avaliadas em listas e em funções nas listas. Por exemplo, suponha que uma lista seja definida da seguinte maneira: `"myList":["one","two"]`. Se essa lista for usada na expressão `#{'this is ' + myList}`, ela será avaliada como `["this is one", "this is two"]`. Se você tiver duas listas, o Data Pipeline as nivelará na avaliação. Por exemplo, se `myList1` for definida como `[1,2]` e `myList2` como `[3,4]`, a expressão `[#{myList1}, #{myList2}]` será avaliada como `[1,2,3,4]`.
## Expressão de nó
AWS Data Pipeline usa a `#{node.*}` expressão em uma `SnsAlarm` ou `PreCondition` para uma referência anterior ao objeto pai de um componente de pipeline. Como `SnsAlarm` e `PreCondition` são referenciados a partir de uma atividade ou um recurso sem referência inversa, `node` fornece uma forma consultar o indicador. Por exemplo, a definição do pipeline a seguir demonstra como uma notificação de falha pode usar o `node` para fazer referência ao nó principal, neste caso `ShellCommandActivity`, e incluir as horas de início e término programadas desse nó principal na mensagem do `SnsAlarm`. A scheduledStartTime referência em não ShellCommandActivity requer o `node` prefixo porque scheduledStartTime se refere a si mesma.
**nota**
O sinal @ (arroba) que precede os campos indica que eles são campos de tempo de execução.
```
{
"id" : "ShellOut",
"type" : "ShellCommandActivity",
"input" : {"ref" : "HourlyData"},
"command" : "/home/userName/xxx.sh #{@scheduledStartTime} #{@scheduledEndTime}",
"schedule" : {"ref" : "HourlyPeriod"},
"stderr" : "/tmp/stderr:#{@scheduledStartTime}",
"stdout" : "/tmp/stdout:#{@scheduledStartTime}",
"onFail" : {"ref" : "FailureNotify"},
},
{
"id" : "FailureNotify",
"type" : "SnsAlarm",
"subject" : "Failed to run pipeline component",
"message": "Error for interval #{node.@scheduledStartTime}..#{node.@scheduledEndTime}.",
"topicArn":"arn:aws:sns:us-east-1:28619EXAMPLE:ExampleTopic"
},
```
AWS Data Pipeline suporta referências transitivas para campos definidos pelo usuário, mas não campos de tempo de execução. Uma referência transitiva é uma referência entre dois componentes de pipeline que dependem de outro componente de pipeline como intermediário. O exemplo a seguir mostra uma referência a um campo transitivo definido por usuário e uma referência a um campo não transitivo de tempo de execução, ambos válidos. Para obter mais informações, consulte [Campos definidos pelo usuário](dp-writing-pipeline-definition.md#dp-userdefined-fields).
```
{
"name": "DefaultActivity1",
"type": "CopyActivity",
"schedule": {"ref": "Once"},
"input": {"ref": "s3nodeOne"},
"onSuccess": {"ref": "action"},
"workerGroup": "test",
"output": {"ref": "s3nodeTwo"}
},
{
"name": "action",
"type": "SnsAlarm",
"message": "S3 bucket '#{node.output.directoryPath}' succeeded at #{node.@actualEndTime}.",
"subject": "Testing",
"topicArn": "arn:aws:sns:us-east-1:28619EXAMPLE:ExampleTopic",
"role": "DataPipelineDefaultRole"
}
```
## Avaliação de expressões
AWS Data Pipeline fornece um conjunto de funções que você pode usar para calcular o valor de um campo. O exemplo a seguir usa a função `makeDate` para definir o campo `startDateTime` de um objeto `Schedule` como `"2011-05-24T0:00:00"` GMT/UTC.
```
"startDateTime" : "makeDate(2011,5,24)"
```
# Funções matemáticas
As funções a seguir estão disponíveis para uso com valores numéricos.
****
| Função | Description |
| --- | --- |
| \$1 | Adição. Exemplo: `#{1 + 2}` Result: `3` |
| - | Subtração. Exemplo: `#{1 - 2}` Result: `-1` |
| \$1 | Multiplicação. Exemplo: `#{1 * 2}` Result: `2` |
| / | Divisão. Se você dividir dois números inteiros, o resultado será truncado. Exemplo: `#{1 / 2}`, resultado: `0` Exemplo: `#{1.0 / 2}`, resultado: `.5` |
| ^ | Expoente. Exemplo: `#{2 ^ 2}` Result: `4.0` |
# Funções de string
As funções a seguir estão disponíveis para uso com valores de string.
****
| Função | Description |
| --- | --- |
| \$1 | Concatenação. Os valores que não são de string são convertidos primeiro em valores de strings. Exemplo: `#{"hel" + "lo"}` Result: `"hello"` |
# Funções de data e hora
As funções a seguir estão disponíveis para trabalhar com DateTime valores. Nos exemplos, o valor de `myDateTime` é `May 24, 2011 @ 5:10 pm GMT`.
**nota**
O date/time formato para AWS Data Pipeline é Joda Time, que substitui as classes de data e hora do Java. Para obter mais informações, consulte [Joda Time - Class DateTimeFormat](http://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html).
****
| Função | Description |
| --- | --- |
| `int day(DateTime myDateTime)` | Obtém o dia do DateTime valor como um número inteiro. Exemplo: `#{day(myDateTime)}` Result: `24` |
| `int dayOfYear(DateTime myDateTime)` | Obtém o dia do ano do DateTime valor como um número inteiro. Exemplo: `#{dayOfYear(myDateTime)}` Result: `144` |
| `DateTime firstOfMonth(DateTime myDateTime)` | Cria um DateTime objeto para o início do mês no especificado DateTime. Exemplo: `#{firstOfMonth(myDateTime)}` Result: `"2011-05-01T17:10:00z"` |
| `String format(DateTime myDateTime,String format)` | Cria um objeto String que é o resultado da conversão do especificado DateTime usando a string de formato especificada. Exemplo: `#{format(myDateTime,'YYYY-MM-dd HH:mm:ss z')}` Result: `"2011-05-24T17:10:00 UTC"` |
| `int hour(DateTime myDateTime)` | Obtém a hora do DateTime valor como um número inteiro. Exemplo: `#{hour(myDateTime)}` Result: `17` |
| `DateTime makeDate(int year,int month,int day)` | Cria um DateTime objeto, em UTC, com o ano, mês e dia especificados, à meia-noite. Exemplo: `#{makeDate(2011,5,24)}` Result: `"2011-05-24T0:00:00z"` |
| `DateTime makeDateTime(int year,int month,int day,int hour,int minute)` | Cria um DateTime objeto, em UTC, com o ano, mês, dia, hora e minuto especificados. Exemplo: `#{makeDateTime(2011,5,24,14,21)}` Result: `"2011-05-24T14:21:00z"` |
| `DateTime midnight(DateTime myDateTime)` | Cria um DateTime objeto para a meia-noite atual, em relação ao especificado DateTime. Por exemplo, onde `MyDateTime` for `2011-05-25T17:10:00z`, o resultado será o seguinte: Exemplo: `#{midnight(myDateTime)}` Result: `"2011-05-25T0:00:00z"` |
| `DateTime minusDays(DateTime myDateTime,int daysToSub)` | Cria um DateTime objeto que é o resultado da subtração do número especificado de dias do especificado. DateTime Exemplo: `#{minusDays(myDateTime,1)}` Result: `"2011-05-23T17:10:00z"` |
| `DateTime minusHours(DateTime myDateTime,int hoursToSub)` | Cria um DateTime objeto que é o resultado da subtração do número especificado de horas do especificado. DateTime Exemplo: `#{minusHours(myDateTime,1)}` Result: `"2011-05-24T16:10:00z"` |
| `DateTime minusMinutes(DateTime myDateTime,int minutesToSub)` | Cria um DateTime objeto que é o resultado da subtração do número especificado de minutos do especificado. DateTime Exemplo: `#{minusMinutes(myDateTime,1)}` Result: `"2011-05-24T17:09:00z"` |
| `DateTime minusMonths(DateTime myDateTime,int monthsToSub)` | Cria um DateTime objeto que é o resultado da subtração do número especificado de meses do especificado. DateTime Exemplo: `#{minusMonths(myDateTime,1)}` Result: `"2011-04-24T17:10:00z"` |
| `DateTime minusWeeks(DateTime myDateTime,int weeksToSub)` | Cria um DateTime objeto que é o resultado da subtração do número especificado de semanas do especificado. DateTime Exemplo: `#{minusWeeks(myDateTime,1)}` Result: `"2011-05-17T17:10:00z"` |
| `DateTime minusYears(DateTime myDateTime,int yearsToSub)` | Cria um DateTime objeto que é o resultado da subtração do número especificado de anos do especificado. DateTime Exemplo: `#{minusYears(myDateTime,1)}` Result: `"2010-05-24T17:10:00z"` |
| `int minute(DateTime myDateTime)` | Obtém o minuto do DateTime valor como um número inteiro. Exemplo: `#{minute(myDateTime)}` Result: `10` |
| `int month(DateTime myDateTime)` | Obtém o mês do DateTime valor como um número inteiro. Exemplo: `#{month(myDateTime)}` Result: `5` |
| `DateTime plusDays(DateTime myDateTime,int daysToAdd)` | Cria um DateTime objeto que é o resultado da adição do número especificado de dias ao especificado DateTime. Exemplo: `#{plusDays(myDateTime,1)}` Result: `"2011-05-25T17:10:00z"` |
| `DateTime plusHours(DateTime myDateTime,int hoursToAdd)` | Cria um DateTime objeto que é o resultado da adição do número especificado de horas ao especificado DateTime. Exemplo: `#{plusHours(myDateTime,1)}` Result: `"2011-05-24T18:10:00z"` |
| `DateTime plusMinutes(DateTime myDateTime,int minutesToAdd)` | Cria um DateTime objeto que é o resultado da adição do número especificado de minutos ao especificado DateTime. Exemplo: `#{plusMinutes(myDateTime,1)}` Result: `"2011-05-24 17:11:00z"` |
| `DateTime plusMonths(DateTime myDateTime,int monthsToAdd)` | Cria um DateTime objeto que é o resultado da adição do número especificado de meses ao especificado DateTime. Exemplo: `#{plusMonths(myDateTime,1)}` Result: `"2011-06-24T17:10:00z"` |
| `DateTime plusWeeks(DateTime myDateTime,int weeksToAdd)` | Cria um DateTime objeto que é o resultado da adição do número especificado de semanas ao especificado DateTime. Exemplo: `#{plusWeeks(myDateTime,1)}` Result: `"2011-05-31T17:10:00z"` |
| `DateTime plusYears(DateTime myDateTime,int yearsToAdd)` | Cria um DateTime objeto que é o resultado da adição do número especificado de anos ao especificado DateTime. Exemplo: `#{plusYears(myDateTime,1)}` Result: `"2012-05-24T17:10:00z"` |
| `DateTime sunday(DateTime myDateTime)` | Cria um DateTime objeto para o domingo anterior, em relação ao especificado DateTime. Se o especificado DateTime for um domingo, o resultado será o especificado DateTime. Exemplo: `#{sunday(myDateTime)}` Result: `"2011-05-22 17:10:00 UTC"` |
| `int year(DateTime myDateTime)` | Obtém o ano do DateTime valor como um número inteiro. Exemplo: `#{year(myDateTime)}` Result: `2011` |
| `DateTime yesterday(DateTime myDateTime)` | Cria um DateTime objeto para o dia anterior, em relação ao especificado DateTime. O resultado é o mesmo que minusDays (1). Exemplo: `#{yesterday(myDateTime)}` Result: `"2011-05-23T17:10:00z"` |
# Caracteres especiais
AWS Data Pipeline usa certos caracteres que têm um significado especial nas definições de pipeline, conforme mostrado na tabela a seguir.
****
| Caractere especial | Description | Exemplos |
| --- | --- | --- |
| @ | Campo de tempo de execução. Este caractere é um prefixo de nome de campo para um campo que fica disponível apenas quando um pipeline é executado. | @actualStartTime @failureReason @resourceStatus |
| \$1 | Expressão. As expressões são delimitadas por: “\$1 \$1” e “\$1” e o conteúdo das chaves é avaliado por. AWS Data Pipeline Para obter mais informações, consulte [Expressões](dp-pipeline-expressions.md). | \$1 \$1format (myDateTime, 'YYYY-MM-dd hh:mm:ss')\$1 s3://amzn-s3-demo-bucket/\$1\$1id\$1.csv |
| \$1 | Campo criptografado. Esse caractere é um prefixo de nome de campo para indicar que AWS Data Pipeline deve criptografar o conteúdo desse campo em trânsito entre o console ou a CLI e o serviço. AWS Data Pipeline | \$1password |