

Per funzionalità simili a Amazon Timestream for, prendi in considerazione Amazon Timestream LiveAnalytics per InfluxDB. Offre un'acquisizione semplificata dei dati e tempi di risposta alle query di una sola cifra di millisecondi per analisi in tempo reale. [Scopri](https://docs.aws.amazon.com//timestream/latest/developerguide/timestream-for-influxdb.html) di più qui.

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Supporto per SQL
<a name="supported-sql-constructs"></a>

Timestream for LiveAnalytics supporta alcuni costrutti SQL comuni. Puoi leggere di più qui sotto.

**Topics**
+ [SELECT](supported-sql-constructs.SELECT.md)
+ [supporto per le subquery](supported-sql-constructs.subquery-support.md)
+ [Dichiarazioni SHOW](supported-sql-constructs.SHOW.md)
+ [DESCRIVI le dichiarazioni](supported-sql-constructs.DESCRIBE.md)
+ [UNLOAD](supported-sql-constructs.UNLOAD.md)

# SELECT
<a name="supported-sql-constructs.SELECT"></a>

Le istruzioni **SELECT** possono essere utilizzate per recuperare dati da una o più tabelle. **Il linguaggio di interrogazione di Timestream supporta la seguente sintassi per le istruzioni SELECT:**

```
[ WITH with_query [, ...] ]
            SELECT [ ALL | DISTINCT ] select_expr [, ...]
            [ function (expression) OVER (
            [ PARTITION BY partition_expr_list ]
            [ ORDER BY order_list ]
            [ frame_clause ] )
            [ FROM from_item [, ...] ]
            [ WHERE condition ]
            [ GROUP BY [ ALL | DISTINCT ] grouping_element [, ...] ]
            [ HAVING condition]
            [ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select ]
            [ ORDER BY order_list ]
            [ LIMIT [ count | ALL ] ]
```

dove 
+ `function (expression)`[è una delle funzioni di finestra supportate.](window-functions.md)
+ `partition_expr_list`è:

  ```
  expression | column_name [, expr_list ]
  ```
+ `order_list`è:

  ```
  expression | column_name [ ASC | DESC ] 
  [ NULLS FIRST | NULLS LAST ]
  [, order_list ]
  ```
+ `frame_clause`è:

  ```
  ROWS | RANGE
  { UNBOUNDED PRECEDING | expression PRECEDING | CURRENT ROW } |
  {BETWEEN
  { UNBOUNDED PRECEDING | expression { PRECEDING | FOLLOWING } |
  CURRENT ROW}
  AND
  { UNBOUNDED FOLLOWING | expression { PRECEDING | FOLLOWING } |
  CURRENT ROW }}
  ```
+ `from_item`è uno dei:

  ```
  table_name [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
  from_item join_type from_item [ ON join_condition | USING ( join_column [, ...] ) ]
  ```
+ `join_type`è uno dei seguenti:

  ```
  [ INNER ] JOIN
  LEFT [ OUTER ] JOIN
  RIGHT [ OUTER ] JOIN
  FULL [ OUTER ] JOIN
  ```
+ `grouping_element`è uno dei seguenti:

  ```
  ()
  expression
  ```

# supporto per le subquery
<a name="supported-sql-constructs.subquery-support"></a>

 Timestream supporta sottoquery e predicati. `EXISTS` `IN` Il `EXISTS` predicato determina se una sottoquery restituisce delle righe. Il `IN` predicato determina se i valori prodotti dalla sottoquery corrispondono ai valori o all'espressione della clausola IN. Il linguaggio di interrogazione Timestream supporta le sottoquery correlate e di altro tipo. 

```
SELECT t.c1
FROM (VALUES 1, 2, 3, 4, 5) AS t(c1)
WHERE EXISTS
(SELECT t.c2
 FROM (VALUES 1, 2, 3) AS t(c2)
 WHERE t.c1= t.c2
)
ORDER BY t.c1
```


| c1 | 
| --- | 
|  1  | 
|  2  | 
|  3  | 

```
SELECT t.c1
FROM (VALUES 1, 2, 3, 4, 5) AS t(c1)
WHERE t.c1 IN
(SELECT t.c2
 FROM (VALUES 2, 3, 4) AS t(c2)
)
ORDER BY t.c1
```


| c1 | 
| --- | 
|  2  | 
|  3  | 
|  4  | 

# Dichiarazioni SHOW
<a name="supported-sql-constructs.SHOW"></a>

È possibile visualizzare tutti i database di un account utilizzando l'`SHOW DATABASES`estratto conto. La sintassi è esposta di seguito:

```
SHOW DATABASES [LIKE pattern]
```

dove la `LIKE` clausola può essere utilizzata per filtrare i nomi dei database.

È possibile visualizzare tutte le tabelle di un account utilizzando l'`SHOW TABLES`estratto conto. La sintassi è esposta di seguito:

```
SHOW TABLES [FROM database] [LIKE pattern]
```

dove la `FROM` clausola può essere utilizzata per filtrare i nomi dei database e la `LIKE` clausola può essere utilizzata per filtrare i nomi delle tabelle.

È possibile visualizzare tutte le misure di una tabella utilizzando l'`SHOW MEASURES`istruzione. La sintassi è esposta di seguito:

```
SHOW MEASURES FROM database.table [LIKE pattern]
```

dove la `FROM` clausola verrà utilizzata per specificare il nome del database e della tabella e la `LIKE` clausola può essere utilizzata per filtrare i nomi delle misure.

# DESCRIVI le dichiarazioni
<a name="supported-sql-constructs.DESCRIBE"></a>

È possibile visualizzare i metadati di una tabella utilizzando l'`DESCRIBE`istruzione. La sintassi è esposta di seguito:

```
DESCRIBE database.table
```

dove `table` contiene il nome della tabella. L'istruzione describe restituisce i nomi delle colonne e i tipi di dati per la tabella.

# UNLOAD
<a name="supported-sql-constructs.UNLOAD"></a>

Timestream for LiveAnalytics supporta un `UNLOAD` comando come estensione del relativo supporto SQL. I tipi di dati supportati da `UNLOAD` sono descritti in. [Tipi di dati supportati](supported-data-types.md) I `unknown` tipi `time` e non si applicano a`UNLOAD`.

```
UNLOAD (SELECT statement)
 TO 's3://bucket-name/folder'
 WITH ( option = expression [, ...] )
```

dove si trova l'opzione

```
{ partitioned_by = ARRAY[ col_name[,…] ] 
 | format = [ '{ CSV | PARQUET }' ] 
 | compression = [ '{ GZIP | NONE }' ]
 | encryption = [ '{ SSE_KMS | SSE_S3 }' ]
 | kms_key = '<string>'
 | field_delimiter ='<character>'
 | escaped_by = '<character>'
 | include_header = ['{true, false}']
 | max_file_size = '<value>'
}
```

Istruzione SELECT  
L'istruzione di query utilizzata per selezionare e recuperare i dati da uno o più Timestream per le tabelle. LiveAnalytics   

```
(SELECT column 1, column 2, column 3 from database.table
      where measure_name = "ABC" and timestamp between ago (1d) and now() )
```

Clausola TO  

```
TO 's3://bucket-name/folder'
```
or  

```
TO 's3://access-point-alias/folder'
```
La `TO` clausola dell'`UNLOAD`istruzione specifica la destinazione per l'output dei risultati della query. È necessario fornire il percorso completo, incluso il nome del bucket Amazon S3 o Amazon S3 con access-point-alias posizione della cartella su Amazon S3 dove Timestream for scrive gli oggetti del file di output. LiveAnalytics Il bucket S3 deve appartenere allo stesso account e nella stessa regione. Oltre al set di risultati della query, Timestream for LiveAnalytics scrive i file manifest e di metadati nella cartella di destinazione specificata. 

Clausola PARTITIONED\$1BY  

```
partitioned_by = ARRAY [col_name[,…] , (default: none)
```
La `partitioned_by` clausola viene utilizzata nelle query per raggruppare e analizzare i dati a livello granulare. Quando esporti i risultati della query nel bucket S3, puoi scegliere di partizionare i dati in base a una o più colonne nella query di selezione. Durante il partizionamento dei dati, i dati esportati vengono suddivisi in sottoinsiemi in base alla colonna della partizione e ogni sottoinsieme viene archiviato in una cartella separata. All'interno della cartella dei risultati che contiene i dati esportati, viene creata automaticamente una sottocartella. `folder/results/partition column = partition value/` Tuttavia, tieni presente che le colonne partizionate non sono incluse nel file di output.   
`partitioned_by`non è una clausola obbligatoria nella sintassi. Se si sceglie di esportare i dati senza alcun partizionamento, è possibile escludere la clausola nella sintassi.   

**Example**  
Supponendo che tu stia monitorando i dati clickstream del tuo sito Web e che tu abbia 5 canali di traffico, vale a dire,, e. `direct` `Social Media` `Organic Search` `Other` `Referral` Quando si esportano i dati, è possibile scegliere di partizionarli utilizzando la colonna. `Channel` All'interno della tua cartella dati`s3://bucketname/results`, avrai cinque cartelle ciascuna con il rispettivo nome del canale, ad esempio, `s3://bucketname/results/channel=Social Media/.` all'interno di questa cartella troverai i dati di tutti i clienti che sono arrivati sul tuo sito web attraverso il `Social Media` canale. Allo stesso modo, avrai altre cartelle per i canali rimanenti.
Dati esportati partizionati per colonna Channel  

![\[Folder structure showing channels: Direct, Organic search, Other, Referral, and Social media.\]](http://docs.aws.amazon.com/it_it/timestream/latest/developerguide/images/unload-results.png)


FORMAT  

```
format = [ '{ CSV | PARQUET }' , default: CSV
```
Le parole chiave per specificare il formato dei risultati della query scritti nel bucket S3. È possibile esportare i dati come valore separato da virgole (CSV) utilizzando una virgola (,) come delimitatore predefinito o nel formato Apache Parquet, un efficiente formato di archiviazione a colonne aperto per l'analisi. 

COMPRESSIONE  

```
compression = [ '{ GZIP | NONE }' ], default: GZIP
```
È possibile comprimere i dati esportati utilizzando l'algoritmo di compressione GZIP o decomprimerli specificando l'opzione. `NONE`

ENCRYPTION  

```
encryption = [ '{ SSE_KMS | SSE_S3 }' ], default: SSE_S3
```
I file di output su Amazon S3 vengono crittografati utilizzando l'opzione di crittografia selezionata. Oltre ai dati, anche i file manifest e i file di metadati vengono crittografati in base all'opzione di crittografia selezionata. Attualmente supportiamo la crittografia SSE\$1S3 e SSE\$1KMS. SSE\$1S3 è una crittografia lato server con Amazon S3 che crittografa i dati utilizzando la crittografia AES (Advanced Encryption Standard) a 256 bit. SSE\$1KMS è una crittografia lato server per crittografare i dati utilizzando chiavi gestite dal cliente.

KMS\$1KEY  

```
kms_key = '<string>'
```
KMS Key è una chiave definita dal cliente per crittografare i risultati delle query esportate. KMS Key è gestita in modo sicuro da AWS Key Management Service (AWS KMS) e utilizzata per crittografare i file di dati su Amazon S3.

FIELD\$1DELIMITER  

```
field_delimiter ='<character>' , default: (,)
```
Quando si esportano i dati in formato CSV, questo campo specifica un singolo carattere ASCII utilizzato per separare i campi nel file di output, ad esempio il carattere pipe (\$1), la virgola (,) o il tab (/t). Il delimitatore predefinito per i file CSV è una virgola. Se un valore nei dati contiene il delimitatore scelto, il delimitatore verrà citato tra virgolette. Ad esempio, se il valore dei dati contiene`Time,stream`, questo valore verrà citato come nei dati esportati. `"Time,stream"` Il carattere di virgoletta usato da Timestream per sono le LiveAnalytics virgolette doppie («).  
Evita di specificare il carattere di ritorno al carrello (ASCII 13`0D`, hex, text '\$1 r') o il carattere di interruzione di riga (ASCII 10, hex 0A, text'\$1n') come `FIELD_DELIMITER` se desideri includere le intestazioni nel CSV, poiché ciò impedirà a molti parser di analizzare correttamente le intestazioni nell'output CSV risultante.

ESCAPED\$1BY  

```
escaped_by = '<character>', default: (\)
```
Quando si esportano i dati in formato CSV, questo campo specifica il carattere che deve essere trattato come carattere di escape nel file di dati scritto nel bucket S3. L'escape avviene nei seguenti scenari:  

1. Se il valore stesso contiene il carattere di virgoletta («), verrà eliminato utilizzando un carattere di escape. Ad esempio, se il valore è`Time"stream`, dove (\$1) è il carattere di escape configurato, allora verrà escluso come. `Time\"stream` 

1. Se il valore contiene il carattere di escape configurato, verrà eliminato. Ad esempio, se il valore è`Time\stream`, allora verrà scappato come. `Time\\stream` 
Se l'output esportato contiene tipi di dati complessi come Arrays, Rows o Timeseries, verrà serializzato come stringa JSON. Di seguito è riportato un esempio.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/timestream/latest/developerguide/supported-sql-constructs.UNLOAD.html)

INCLUDE\$1HEADER  

```
include_header = 'true' , default: 'false'
```
Quando si esportano i dati in formato CSV, questo campo consente di includere i nomi delle colonne come prima riga dei file di dati CSV esportati.  
I valori accettati sono «true» e «false» e il valore predefinito è «false». Le opzioni di trasformazione del testo come `escaped_by` e `field_delimiter` si applicano anche alle intestazioni.  
Quando si includono le intestazioni, è importante non selezionare un carattere di ritorno (ASCII 13, hex 0D, testo '\$1 r') o un carattere di interruzione di riga (ASCII 10, hex 0A, text'\$1n') come carattere`FIELD_DELIMITER`, poiché ciò impedirà a molti parser di analizzare correttamente le intestazioni nell'output CSV risultante.

MAX\$1FILE\$1SIZE  

```
max_file_size = 'X[MB|GB]' , default: '78GB'
```
Questo campo specifica la dimensione massima dei file che l'`UNLOAD`istruzione crea in Amazon S3. L'`UNLOAD`istruzione può creare più file, ma la dimensione massima di ogni file scritto in Amazon S3 sarà approssimativamente quella specificata in questo campo.  
Il valore del campo deve essere compreso tra 16 MB e 78 GB, inclusi. È possibile specificarlo in numeri interi come `12GB` o in decimali come o. `0.5GB` `24.7MB` Il valore predefinito è 78 GB.  
La dimensione effettiva del file è approssimativa al momento della scrittura del file, pertanto la dimensione massima effettiva potrebbe non essere esattamente uguale al numero specificato.