Para recursos semelhantes aos do Amazon Timestream para, considere o Amazon Timestream LiveAnalytics para InfluxDB. Ele oferece ingestão de dados simplificada e tempos de resposta de consulta de um dígito em milissegundos para análises em tempo real. Saiba mais [aqui](https://docs.aws.amazon.com//timestream/latest/developerguide/timestream-for-influxdb.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á.

# Funcionalidade de séries temporais incorporada
<a name="timeseries-specific-constructs"></a>

O Timestream for LiveAnalytics fornece funcionalidade integrada de séries temporais que trata os dados de séries temporais como um conceito de primeira classe.

A funcionalidade integrada de séries temporais pode ser dividida em duas categorias: visualizações e funções.

Você pode ler sobre cada constructo abaixo.

**Topics**
+ [Visualizações de séries temporais](timeseries-specific-constructs.views.md)
+ [Funções de séries temporais](timeseries-specific-constructs.functions.md)

# Visualizações de séries temporais
<a name="timeseries-specific-constructs.views"></a>

O Timestream for LiveAnalytics suporta as seguintes funções para transformar seus dados no tipo de dados: `timeseries`

**Topics**
+ [CREATE\$1TIME\$1SERIES](#timeseries-specific-constructs.views.CREATE_TIME_SERIES)
+ [UNNEST](#timeseries-specific-constructs.views.UNNEST)

## CREATE\$1TIME\$1SERIES
<a name="timeseries-specific-constructs.views.CREATE_TIME_SERIES"></a>

 **CREATE\$1TIME\$1SERIES** é uma função de agregação que faz todas as medições brutas de uma série temporal (valores de tempo e medida) e retorna um tipo de dados de série temporal. A sintaxe dessa função é a seguinte. 

```
CREATE_TIME_SERIES(time, measure_value::<data_type>)
```

 onde `<data_type>` é o tipo de dados do valor da medida e pode ser bigint, boolean, double ou varchar. O segundo parâmetro não pode ser nulo.

Considere a utilização da CPU das instâncias do EC2 armazenadas em uma tabela chamada **métricas**, conforme mostrado abaixo:


| Hora | region | az | vpc | instance\$1id | measure\$1name | measure\$1value::double | 
| --- | --- | --- | --- | --- | --- | --- | 
|  2019-12-04 19:00:00.000000000  |  us-east-1  |  us-east-1d  |  vpc-1a2b3c4d  |  i-1234567890abcdef0  |  cpu\$1utilization  |  35,0  | 
|  2019-12-04 19:00:01.000000000  |  us-east-1  |  us-east-1d  |  vpc-1a2b3c4d  |  i-1234567890abcdef0  |  cpu\$1utilization  |  38,2  | 
|  2019-12-04 19:00:02.000000000  |  us-east-1  |  us-east-1d  |  vpc-1a2b3c4d  |  i-1234567890abcdef0  |  cpu\$1utilization  |  45,3  | 
|  2019-12-04 19:00:00.000000000  |  us-east-1  |  us-east-1d  |  vpc-1a2b3c4d  |  i-1234567890abcdef1  |  cpu\$1utilization  |  54.1  | 
|  2019-12-04 19:00:01.000000000  |  us-east-1  |  us-east-1d  |  vpc-1a2b3c4d  |  i-1234567890abcdef1  |  cpu\$1utilization  |  42,5  | 
|  2019-12-04 19:00:02.000000000  |  us-east-1  |  us-east-1d  |  vpc-1a2b3c4d  |  i-1234567890abcdef1  |  cpu\$1utilization  |  3.7  | 

Executar a consulta:

```
SELECT region, az, vpc, instance_id, CREATE_TIME_SERIES(time, measure_value::double) as cpu_utilization FROM metrics
    WHERE measure_name=’cpu_utilization’
    GROUP BY region, az, vpc, instance_id
```

retornará todas as séries que tenham `cpu_utilization` como medida um valor. Neste caso, temos duas séries: 


| region | az | vpc | instance\$1id | cpu\$1utilization | 
| --- | --- | --- | --- | --- | 
|  us-east-1  |  us-east-1d  |  vpc-1a2b3c4d  |  i-1234567890abcdef0  |  [\$1time: 2019-12-04 19:00:00.000000000, measure\$1value::double: 35.0\$1, \$1time: 2019-12-04 19:00:01.000000000, measure\$1value::double: 38.2\$1, \$1time: 2019-12-04 19:00:02.000000000, measure\$1value::double: 45.3\$1]  | 
|  us-east-1  |  us-east-1d  |  vpc-1a2b3c4d  |  i-1234567890abcdef1  |  [\$1time: 2019-12-04 19:00:00.000000000, measure\$1value::double: 35.1\$1, \$1time: 2019-12-04 19:00:01.000000000, measure\$1value::double: 38.5\$1, \$1time: 2019-12-04 19:00:02.000000000, measure\$1value::double: 45.7\$1]  | 

## UNNEST
<a name="timeseries-specific-constructs.views.UNNEST"></a>

 `UNNEST` é uma função de tabela que permite transformar dados `timeseries` no modelo plano. A sintaxe é a seguinte: 

 `UNNEST` transforma um `timeseries` em duas colunas, que são `time` e `value`. Você também pode usar aliases com UNNEST, conforme mostrado abaixo: 

```
UNNEST(timeseries) AS <alias_name> (time_alias, value_alias)
```

onde `<alias_name>` é o alias da tabela plana, `time_alias` é o alias da coluna `time` e `value_alias` é o alias da coluna `value`.

Por exemplo, considere o cenário em que algumas das instâncias do EC2 em sua frota estão configuradas para emitir métricas em um intervalo de 5 segundos, outras emitem métricas em um intervalo de 15 segundos e você precisa das métricas médias de todas as instâncias em uma granularidade de 10 segundos nas últimas 6 horas. Para obter esses dados, você transforma suas métricas no modelo de série temporal usando **CREATE\$1TIME\$1SERIES**. Em seguida, você pode usar **INTERPOLATE\$1LINEAR** para obter os valores ausentes na granularidade de 10 segundos. Em seguida, você transforma os dados de volta no modelo plano usando o **UNNEST** e, em seguida, usa o **AVG** para obter as métricas médias em todas as instâncias.

```
WITH interpolated_timeseries AS (
    SELECT region, az, vpc, instance_id,
        INTERPOLATE_LINEAR(
            CREATE_TIME_SERIES(time, measure_value::double),
                SEQUENCE(ago(6h), now(), 10s)) AS interpolated_cpu_utilization
    FROM timestreamdb.metrics 
    WHERE measure_name= ‘cpu_utilization’ AND time >= ago(6h)
    GROUP BY region, az, vpc, instance_id
)
SELECT region, az, vpc, instance_id, avg(t.cpu_util)
FROM interpolated_timeseries
CROSS JOIN UNNEST(interpolated_cpu_utilization) AS t (time, cpu_util)
GROUP BY region, az, vpc, instance_id
```

 A consulta acima demonstra o uso de **UNNEST** com um alias. Abaixo está um exemplo da mesma consulta sem usar um alias para **UNNEST**: 

```
WITH interpolated_timeseries AS (
    SELECT region, az, vpc, instance_id,
        INTERPOLATE_LINEAR(
            CREATE_TIME_SERIES(time, measure_value::double),
                SEQUENCE(ago(6h), now(), 10s)) AS interpolated_cpu_utilization
    FROM timestreamdb.metrics 
    WHERE measure_name= ‘cpu_utilization’ AND time >= ago(6h)
    GROUP BY region, az, vpc, instance_id
)
SELECT region, az, vpc, instance_id, avg(value)
FROM interpolated_timeseries
CROSS JOIN UNNEST(interpolated_cpu_utilization)
GROUP BY region, az, vpc, instance_id
```

# Funções de séries temporais
<a name="timeseries-specific-constructs.functions"></a>

O Amazon Timestream LiveAnalytics for oferece suporte a funções de séries temporais, como derivadas, integrais e correlações, além de outras, para obter insights mais profundos de seus dados de séries temporais. Esta seção fornece informações de uso para cada uma dessas funções, bem como exemplos de consultas. Selecione um tópico abaixo para saber mais. 

**Topics**
+ [Funções de interpolação](timeseries-specific-constructs.functions.interpolation.md)
+ [Funções derivadas](timeseries-specific-constructs.functions.derivatives.md)
+ [Funções integrais](timeseries-specific-constructs.functions.integrals.md)
+ [Funções de correlação](timeseries-specific-constructs.functions.correlation.md)
+ [Funções de filtragem e redução](timeseries-specific-constructs.functions.filter-reduce.md)

# Funções de interpolação
<a name="timeseries-specific-constructs.functions.interpolation"></a>

Se seus dados de série temporal não tiverem valores para eventos em determinados momentos, você poderá estimar os valores desses eventos ausentes usando a interpolação. O Amazon Timestream suporta quatro variantes de interpolação: interpolação linear, interpolação por divisão cúbica, interpolação por última observação transportada (locf) e interpolação constante. Esta seção fornece informações de uso do Timestream para funções de LiveAnalytics interpolação, bem como exemplos de consultas. 



## Informações de uso
<a name="w2aab7c59c13c13c11b7"></a>


| Função | Tipo de dados de saída | Description | 
| --- | --- | --- | 
|  `interpolate_linear(timeseries, array[timestamp])`  |  timeseries  |  Preenche os dados ausentes usando a [interpolação linear](https://wikipedia.org/wiki/Linear_interpolation).  | 
|  `interpolate_linear(timeseries, timestamp)`  |  double  |  Preenche os dados ausentes usando a [interpolação linear](https://wikipedia.org/wiki/Linear_interpolation).  | 
|  `interpolate_spline_cubic(timeseries, array[timestamp])`  |  timeseries  |  Preenche os dados ausentes usando a [interpolação de divisão cúbica](https://wikiversity.org/wiki/Cubic_Spline_Interpolation#:~:text=Cubic%20spline%20interpolation%20is%20a,Lagrange%20polynomial%20and%20Newton%20polynomial.).  | 
|  `interpolate_spline_cubic(timeseries, timestamp)`  |  double  |  Preenche os dados ausentes usando a [interpolação de divisão cúbica](https://wikiversity.org/wiki/Cubic_Spline_Interpolation#:~:text=Cubic%20spline%20interpolation%20is%20a,Lagrange%20polynomial%20and%20Newton%20polynomial.).  | 
|  `interpolate_locf(timeseries, array[timestamp])`  |  timeseries  |  Preenche os dados ausentes usando o último valor amostrado.  | 
|  `interpolate_locf(timeseries, timestamp)`  |  double  |  Preenche os dados ausentes usando o último valor amostrado.  | 
|  `interpolate_fill(timeseries, array[timestamp], double)`  |  timeseries  |  Preenche os dados ausentes usando um valor constante.  | 
|  `interpolate_fill(timeseries, timestamp, double)`  |  double  |  Preenche os dados ausentes usando um valor constante.  | 

## Exemplos de consulta
<a name="w2aab7c59c13c13c11b9"></a>

**Example**  
Encontre a utilização média da CPU armazenada em intervalos de 30 segundos para um host EC2 específico nas últimas 2 horas, preenchendo os valores ausentes usando a interpolação linear:  

```
WITH binned_timeseries AS (
SELECT hostname, BIN(time, 30s) AS binned_timestamp, ROUND(AVG(measure_value::double), 2) AS avg_cpu_utilization
FROM "sampleDB".DevOps
WHERE measure_name = 'cpu_utilization'
    AND hostname = 'host-Hovjv'
    AND time > ago(2h)
GROUP BY hostname, BIN(time, 30s)
), interpolated_timeseries AS (
SELECT hostname,
    INTERPOLATE_LINEAR(
        CREATE_TIME_SERIES(binned_timestamp, avg_cpu_utilization),
            SEQUENCE(min(binned_timestamp), max(binned_timestamp), 15s)) AS interpolated_avg_cpu_utilization
FROM binned_timeseries
GROUP BY hostname
)
SELECT time, ROUND(value, 2) AS interpolated_cpu
FROM interpolated_timeseries
CROSS JOIN UNNEST(interpolated_avg_cpu_utilization)
```

**Example**  
Encontre a utilização média da CPU armazenada em intervalos de 30 segundos para um host EC2 específico nas últimas 2 horas, preenchendo os valores ausentes usando a interpolação com base na última observação realizada:  

```
WITH binned_timeseries AS (
SELECT hostname, BIN(time, 30s) AS binned_timestamp, ROUND(AVG(measure_value::double), 2) AS avg_cpu_utilization
FROM "sampleDB".DevOps
WHERE measure_name = 'cpu_utilization'
    AND hostname = 'host-Hovjv'
    AND time > ago(2h)
GROUP BY hostname, BIN(time, 30s)
), interpolated_timeseries AS (
SELECT hostname,
    INTERPOLATE_LOCF(
        CREATE_TIME_SERIES(binned_timestamp, avg_cpu_utilization),
            SEQUENCE(min(binned_timestamp), max(binned_timestamp), 15s)) AS interpolated_avg_cpu_utilization
FROM binned_timeseries
GROUP BY hostname
)
SELECT time, ROUND(value, 2) AS interpolated_cpu
FROM interpolated_timeseries
CROSS JOIN UNNEST(interpolated_avg_cpu_utilization)
```

# Funções derivadas
<a name="timeseries-specific-constructs.functions.derivatives"></a>

As derivadas são usadas para calcular a taxa de variação de uma determinada métrica e podem ser usadas para responder proativamente a um evento. Por exemplo, suponha que você calcule a derivada da utilização da CPU das instâncias do EC2 nos últimos 5 minutos e observe uma derivada positiva significativa. Isso pode ser indicativo do aumento da demanda em seu workload, então você pode decidir ativar mais instâncias do EC2 para lidar melhor com seu workload. 

O Amazon Timestream oferece suporte a duas variantes de funções derivadas. Esta seção fornece informações de uso do Timestream para funções LiveAnalytics derivadas, bem como exemplos de consultas. 



## Informações de uso
<a name="w2aab7c59c13c13c13b9"></a>


| Função | Tipo de dados de saída | Description | 
| --- | --- | --- | 
|  `derivative_linear(timeseries, interval)`  |  timeseries  |  Calcula a [derivada](https://wikipedia.org/wiki/Derivative) de cada ponto no `timeseries` para o `interval` especificado.  | 
|  `non_negative_derivative_linear(timeseries, interval)`  |  timeseries  |  O mesmo que `derivative_linear(timeseries, interval)`, mas retorna apenas valores positivos.  | 

## Exemplos de consulta
<a name="w2aab7c59c13c13c13c11"></a>

**Example**  
Encontre a taxa de alteração na utilização da CPU a cada 5 minutos na última 1 hora:  

```
SELECT DERIVATIVE_LINEAR(CREATE_TIME_SERIES(time, measure_value::double), 5m) AS result 
FROM “sampleDB”.DevOps 
WHERE measure_name = 'cpu_utilization' 
AND hostname = 'host-Hovjv' and time > ago(1h) 
GROUP BY hostname, measure_name
```

**Example**  
Calcule a taxa de aumento nos erros gerados por um ou mais microsserviços:  

```
WITH binned_view as (
    SELECT bin(time, 5m) as binned_timestamp, ROUND(AVG(measure_value::double), 2) as value            
    FROM “sampleDB”.DevOps  
    WHERE micro_service = 'jwt'  
    AND time > ago(1h) 
    AND measure_name = 'service_error'
    GROUP BY bin(time, 5m)
)
SELECT non_negative_derivative_linear(CREATE_TIME_SERIES(binned_timestamp, value), 1m) as rateOfErrorIncrease
FROM binned_view
```

# Funções integrais
<a name="timeseries-specific-constructs.functions.integrals"></a>

Você pode usar integrais para encontrar a área sob a curva por unidade de tempo para seus eventos de série temporal. Por exemplo, suponha que você esteja monitorando o volume de solicitações recebidas pelo seu aplicativo por unidade de tempo. Nesse cenário, você pode usar a função integral para determinar o volume total de solicitações atendidas por intervalo especificado em um período específico.

O Amazon Timestream oferece suporte a uma variante de funções integrais. Esta seção fornece informações de uso do Timestream para a função LiveAnalytics integral, bem como exemplos de consultas. 



## Informações de uso
<a name="w2aab7c59c13c13c15b9"></a>


| Função | Tipo de dados de saída | Description | 
| --- | --- | --- | 
|  `integral_trapezoidal(timeseries(double))` `integral_trapezoidal(timeseries(double), interval day to second)` `integral_trapezoidal(timeseries(bigint))` `integral_trapezoidal(timeseries(bigint), interval day to second)` `integral_trapezoidal(timeseries(integer), interval day to second)` `integral_trapezoidal(timeseries(integer))`  |  double  |  Aproxima a [integral](https://wikipedia.org/wiki/Integral) conforme o `interval day to second` especificado para o `timeseries` fornecido, usando a regra [trapezoidal](https://wikipedia.org/wiki/Trapezoidal_rule). O parâmetro de intervalo de dia para segundo é opcional e o padrão é `1s`. Para obter mais informações sobre intervalos, consulte [Intervalo e duração](date-time-functions.md#date-time-functions-interval-duration).  | 

## Exemplos de consulta
<a name="w2aab7c59c13c13c15c11"></a>

**Example**  
Calcular o volume total de solicitações atendidas por cinco minutos na última hora por um host específico:  

```
SELECT INTEGRAL_TRAPEZOIDAL(CREATE_TIME_SERIES(time, measure_value::double), 5m) AS result FROM sample.DevOps 
WHERE measure_name = 'request' 
AND hostname = 'host-Hovjv' 
AND time > ago (1h) 
GROUP BY hostname, measure_name
```

# Funções de correlação
<a name="timeseries-specific-constructs.functions.correlation"></a>

Dadas duas séries temporais de duração semelhante, as funções de correlação fornecem um coeficiente de correlação, o que explica a tendência das duas séries temporais ao longo do tempo. O coeficiente de correlação varia de `-1.0` a `1.0`. `-1.0` indica que as duas séries temporais tendem em direções opostas na mesma taxa, enquanto `1.0` indica que as duas séries temporais tendem na mesma direção e na mesma taxa. Um valor de `0` indica que não há correlação entre as duas séries temporais. Por exemplo, se o preço do petróleo aumentar e o preço das ações de uma empresa petrolífera aumentar, a tendência do aumento do preço do petróleo e o aumento do preço da companhia petrolífera terão um coeficiente de correlação positivo. Um alto coeficiente de correlação positivo indicaria que os dois preços tem tendências em uma taxa semelhante. Da mesma forma, o coeficiente de correlação entre os preços dos títulos e o rendimento dos títulos é negativo, indicando que esses dois valores tendem na direção oposta ao longo do tempo.

O Amazon Timestream oferece suporte a duas variantes de funções de correlação. Esta seção fornece informações de uso do Timestream para funções de LiveAnalytics correlação, bem como exemplos de consultas. 



## Informações de uso
<a name="w2aab7c59c13c13c19c11"></a>


| Função | Tipo de dados de saída | Description | 
| --- | --- | --- | 
|  `correlate_pearson(timeseries, timeseries)`  |  double  |  Calcula o [coeficiente de correlação de Pearson](https://wikipedia.org/wiki/Pearson_correlation_coefficient) para os dois `timeseries`. As séries temporais devem ter os mesmos registros de data e hora.  | 
|  `correlate_spearman(timeseries, timeseries)`  |  double  |  Calcula o [coeficiente de correlação de Spearman](https://en.wikipedia.org/wiki/Spearman%27s_rank_correlation_coefficient) para os dois `timeseries`. As séries temporais devem ter os mesmos registros de data e hora.  | 

## Exemplos de consulta
<a name="w2aab7c59c13c13c19c13"></a>

**Example**  

```
WITH cte_1 AS (
    SELECT INTERPOLATE_LINEAR(
        CREATE_TIME_SERIES(time, measure_value::double), 
        SEQUENCE(min(time), max(time), 10m)) AS result 
    FROM sample.DevOps 
    WHERE measure_name = 'cpu_utilization' 
    AND hostname = 'host-Hovjv' AND time > ago(1h) 
    GROUP BY hostname, measure_name
), 
cte_2 AS (
    SELECT INTERPOLATE_LINEAR(
        CREATE_TIME_SERIES(time, measure_value::double), 
        SEQUENCE(min(time), max(time), 10m)) AS result 
    FROM sample.DevOps 
    WHERE measure_name = 'cpu_utilization' 
    AND hostname = 'host-Hovjv' AND time > ago(1h) 
    GROUP BY hostname, measure_name
) 
SELECT correlate_pearson(cte_1.result, cte_2.result) AS result 
FROM cte_1, cte_2
```

# Funções de filtragem e redução
<a name="timeseries-specific-constructs.functions.filter-reduce"></a>

O Amazon Timestream oferece suporte a funções que realizam operações de filtragem e redução em dados de séries temporais. Esta seção fornece informações de uso do Timestream para funções de LiveAnalytics filtragem e redução, bem como exemplos de consultas. 



## Informações de uso
<a name="w2aab7c59c13c13c23b7"></a>


| Função | Tipo de dados de saída | Description | 
| --- | --- | --- | 
|  `filter(timeseries(T), function(T, Boolean))`  |  timeseries(T)  |  Constrói uma série temporal a partir de uma série temporal de entrada, usando valores para os quais o `function` passado retorna como `true`.  | 
|  `reduce(timeseries(T), initialState S, inputFunction(S, T, S), outputFunction(S, R))`  |  R  |  Retorna um valor único, reduzido da série temporal. O `inputFunction` será invocado em cada elemento na série temporal em ordem. Além de pegar o elemento atual, InputFunction pega o estado atual (inicialmente `initialState`) e retorna o novo estado. O `outputFunction` será invocado para transformar o estado final no valor do resultado. `outputFunction` pode ser uma função de identidade.  | 

## Exemplos de consulta
<a name="w2aab7c59c13c13c23b9"></a>

**Example**  
Construir uma série temporal da utilização da CPU de um host e filtrar pontos com medição maior que 70:  

```
WITH time_series_view AS (
    SELECT INTERPOLATE_LINEAR(
        CREATE_TIME_SERIES(time, ROUND(measure_value::double,2)), 
            SEQUENCE(ago(15m), ago(1m), 10s)) AS cpu_user
    FROM sample.DevOps
    WHERE hostname = 'host-Hovjv' and measure_name = 'cpu_utilization'
        AND time > ago(30m)
    GROUP BY hostname
)
SELECT FILTER(cpu_user, x -> x.value > 70.0) AS cpu_above_threshold
from time_series_view
```

**Example**  
Criar uma série temporal da utilização da CPU de um host e determinar a soma quadrada das medições:  

```
WITH time_series_view AS (
    SELECT INTERPOLATE_LINEAR(
        CREATE_TIME_SERIES(time, ROUND(measure_value::double,2)), 
            SEQUENCE(ago(15m), ago(1m), 10s)) AS cpu_user
    FROM sample.DevOps
    WHERE hostname = 'host-Hovjv' and measure_name = 'cpu_utilization'
        AND time > ago(30m)
    GROUP BY hostname
)
SELECT REDUCE(cpu_user,
    DOUBLE '0.0',
    (s, x) -> x.value * x.value + s,
    s -> s)
from time_series_view
```

**Example**  
Criar uma série temporal da utilização da CPU de um host e determinar a fração de amostras que estão acima do limite da CPU:  

```
WITH time_series_view AS (
    SELECT INTERPOLATE_LINEAR(
        CREATE_TIME_SERIES(time, ROUND(measure_value::double,2)), 
            SEQUENCE(ago(15m), ago(1m), 10s)) AS cpu_user
    FROM sample.DevOps
    WHERE hostname = 'host-Hovjv' and measure_name = 'cpu_utilization'
        AND time > ago(30m)
    GROUP BY hostname
)
SELECT ROUND(
    REDUCE(cpu_user, 
      -- initial state 
      CAST(ROW(0, 0) AS ROW(count_high BIGINT, count_total BIGINT)),
      -- function to count the total points and points above a certain threshold
      (s, x) -> CAST(ROW(s.count_high + IF(x.value > 70.0, 1, 0), s.count_total + 1) AS ROW(count_high BIGINT, count_total BIGINT)),
      -- output function converting the counts to fraction above threshold
      s -> IF(s.count_total = 0, NULL, CAST(s.count_high AS DOUBLE) / s.count_total)), 
    4) AS fraction_cpu_above_threshold
from time_series_view
```