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à.

# Ottimizzazione delle query
<a name="query-optimize"></a>

## Filtri per metadati
<a name="metadata-filters"></a>

Quando esegui una query su metadati o dati non elaborati, utilizza la `WHERE` clausola per filtrare in base ai campi di metadati per ridurre la quantità di dati analizzati. Utilizzate i seguenti operatori per limitare la scansione dei metadati:
+ Uguale a (=)
+ Non è uguale a (\$1 =)
+ LIKE
+ IN
+ AND
+ O

Per le proprietà degli attributi, utilizza i seguenti campi per filtrare i risultati. :
+ `double_attribute_value`
+ `int_attribute_value`
+ `boolean_attribute_value`
+ `string_attribute_value`

Questi campi offrono prestazioni migliori rispetto alla tabella **latest\$1value\$1time\$1series** per le proprietà degli asset di tipo di attributo.

**Nota**  
Utilizzate i valori letterali sul lato destro degli operatori per limitare correttamente la scansione dei dati. Ad esempio, la seguente query ha prestazioni peggiori rispetto all'utilizzo di una stringa letterale rigorosa:  

```
SELECT property_id FROM asset_property WHERE property_name = CONCAT('my', 'property')
```

**Example per i filtri di metadati:**  

```
SELECT p.property_name FROM asset_property p
WHERE p.property_type = 'attribute' AND p.string_attribute_value LIKE 'my-property-%'
```

## filtri per dati grezzi
<a name="raw-data-filters"></a>

**Tutte le tabelle di dati grezzi (**raw\$1time\$1series, latest\$1value\$1time\$1series****, precomputed\$1aggregates) hanno timestamp associati alle rispettive righe**.** Oltre ai filtri per i metadati, utilizza i filtri delle clausole sul campo per ridurre la quantità di dati scansionati. `WHERE` `event_timestamp` Utilizza le seguenti operazioni per limitare la scansione dei dati grezzi:
+ Uguale a (=)
+ Maggiore di (>)
+ Minore di (<)
+ Maggiore o uguale a (> =)
+ Minore o uguale a (< =)
+ BETWEEN
+ AND

**Esempi di filtri**:
+  Quando esegui una query sulla tabella **precomputed\$1aggregates**, specifica sempre un filtro di qualità nella clausola. `WHERE` In questo modo si riduce la quantità di dati analizzati dalla query, soprattutto se state cercando dei dati. `BAD` `UNCERTAIN` 

   **Consigliamo inoltre vivamente di utilizzare un filtro di risoluzione (1m, 15m, 1h o 1d) quando si esegue una query sulla tabella precomputed\$1aggregates.** Se non specifichi un filtro di risoluzione, per impostazione predefinita AWS IoT SiteWise verrà eseguita una scansione completa della tabella per tutte le risoluzioni, il che è inefficiente. 
+  Quando si interrogano dati grezzi, è possibile utilizzare anche le funzioni di timestamp nella `WHERE` clausola per filtrare la quantità di dati scansionati. **Ad esempio, la seguente query analizza solo gli ultimi 30 minuti di dati dalla tabella raw\$1time\$1series:** 

  ```
  SELECT r.event_timestamp, r.double_value
  FROM raw_time_series r
  WHERE r.event_timestamp > TIMESTAMP_SUB(MINUTE, 30, NOW())
  ```

**Nota**  
Non è uguale `(!=)` e `OR` gli operatori in genere non applicano filtri significativi alla scansione dei dati grezzi. Inoltre, i filtri sui valori dei dati grezzi (string\$1value, double\$1value, ecc.) non limitano la scansione dei dati grezzi.

## Ottimizzazione JOIN
<a name="join-optimization"></a>

AWS IoT SiteWise SQL supporta la `JOIN` parola chiave per unire due tabelle. Sono supportati solo `JOIN` i filtri attivi su un campo (utilizzando la `ON` parola chiave). I join cartesiani completi sono proibiti.

AWS IoT SiteWise supporta anche i messaggi impliciti `JOIN` senza utilizzare la parola chiave. `JOIN` Sono consentiti tra diverse tabelle di metadati e tra una tabella di metadati e una tabella non elaborata. Ad esempio, questa query:

```
SELECT a.asset_name, p.property_name FROM asset a, asset_property p
```

Prestazioni migliori di questa query equivalente:

```
SELECT a.asset_name, p.property_name FROM asset a
JOIN asset_property p ON a.asset_id = p.asset_id
```

Sono consentiti i seguenti join impliciti (O è consentito, X è vietato):


|  | asset | asset\$1property | latest\$1value\$1time\$1series | serie raw\$1time\$1 | aggregati\$1precalcolati | subquery | 
| --- | --- | --- | --- | --- | --- | --- | 
| asset | X | O | O | O | O | X | 
| asset\$1property | O | X | O | O | O | X | 
| latest\$1value\$1time\$1series | O | O | X | X | X | X | 
| serie raw\$1time\$1 | O | O | X | X | X | X | 
| aggregati\$1precalcolati | O | O | X | X | X | X | 
| subquery | X | X | X | X | X | X | 

Usa s impliciti ove possibile. `JOIN` Se devi usare la `JOIN` parola chiave, applica i filtri sulle singole `JOIN` tabelle di redazione per ridurre al minimo i dati scansionati. Ad esempio, invece di questa query:

```
SELECT level1.asset_id, level2.asset_id, level3.asset_id
FROM asset AS level1
JOIN asset AS level2 ON level2.parent_asset_id = level1.asset_id
JOIN asset AS level3 ON level3.parent_asset_id = level2.asset_id
WHERE level1.asset_name LIKE 'level1%'
AND level2.asset_name LIKE 'level2%'
AND level3.asset_name LIKE 'level3%'
```

Usa questa query più efficiente:

```
SELECT level1.asset_id, level2.asset_id, level3.asset_id
FROM asset AS level1
JOIN (SELECT asset_id, parent_asset_id FROM asset WHERE asset_name LIKE 'level2%') AS level2 ON level2.parent_asset_id = level1.asset_id
JOIN (SELECT asset_id, parent_asset_id FROM asset WHERE asset_name LIKE 'level3%') AS level3 ON level3.parent_asset_id = level2.asset_id
WHERE level1.asset_name LIKE 'level1%'
```

Inserendo i filtri dei metadati nelle sottoquery, ti assicuri che le singole tabelle in `JOIN` s vengano filtrate durante il processo di scansione. È inoltre possibile utilizzare la `LIMIT` parola chiave nelle sottoquery per ottenere lo stesso effetto.

## Query di grandi dimensioni
<a name="large-queries"></a>

Per le query che producono più righe rispetto a quelle predefinite, imposta la dimensione della pagina dell'[ExecuteQuery](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_ExecuteQuery.html)API sul valore massimo di 20000. Ciò migliora le prestazioni complessive delle query.

Utilizza la `LIMIT` clausola per ridurre la quantità di dati analizzati per alcune query. Tieni presente che le funzioni di aggregazione e alcune clausole a livello di tabella (`GROUP BY`,`ORDER BY`,`JOIN`) richiedono una scansione completa prima di applicare la clausola. `LIMIT`

**Nota**  
 AWS IoT SiteWise può eseguire la scansione di una quantità minima di dati anche con la `LIMIT` clausola applicata, in particolare per le interrogazioni di dati non elaborati che eseguono la scansione di più proprietà.