méthodes pour accélérer la requête et l'analyse des journaux - Simple Log Service

Appliquez les méthodes suivantes pour accélérer la requête et l'analyse des journaux dans Simple Log Service.

Augmenter le nombre de shards ou activer Dedicated SQL

Augmentez le nombre de shards pour améliorer les capacités de lecture et d'écriture des données. Cette méthode ne s'applique toutefois qu'aux données incrémentielles. Les shards sont des ressources de calcul : la vitesse de traitement augmente avec leur nombre. Veillez à ce que le nombre d'entrées analysées par shard ne dépasse pas 50 millions. Pour augmenter le nombre de shards, scindez-les. Pour plus d'informations, consultez Scinder un shard. Pour en savoir plus sur la facturation des shards, voir Exemples de facturation des shards actifs selon les méthodes de facturation.
Dedicated SQL prend en charge une concurrence plus élevée pour l'analyse et des volumes de données plus importants.

Réduire la plage temporelle et le volume de données

Une plage temporelle étendue ralentit l'exécution d'une requête.

Pour accélérer le traitement, réduisez la plage temporelle de votre requête.
Un volume de données important ralentit l'exécution d'une requête.

Réduisez le volume de données traité par la requête.

Répéter les requêtes

Si les résultats de la requête sont imprécis, relancez l'interrogation des données. À chaque exécution, le mécanisme d'accélération sous-jacent analyse les résultats existants. Après plusieurs itérations, le système renvoie des résultats plus précis.

Optimiser les instructions d'analyse

Une instruction de requête lente présente les caractéristiques suivantes :

La clause GROUP BY regroupe les résultats d'analyse selon une ou plusieurs colonnes de type chaîne.
La clause GROUP BY regroupe les résultats d'analyse selon plus de cinq colonnes.
L'instruction inclut des opérations générant des chaînes de caractères.

Optimisez vos instructions d'analyse en appliquant les méthodes suivantes :

Évitez les opérations générant des chaînes de caractères.
Par exemple, l'utilisation de la fonction date_format pour générer un horodatage dans un format spécifique réduit l'efficacité de la requête. Privilégiez les fonctions date_trunc ou time_series pour générer un horodatage. Exemple :
```
* | select date_format(from_unixtime(__time__) , '%H_%i') as t, count(1) group by t
```
Ne regroupez pas les résultats d'analyse selon une ou plusieurs colonnes de type chaîne.

L'utilisation de la clause GROUP BY pour regrouper les résultats selon des colonnes de type chaîne entraîne une charge de calcul de hachage importante, représentant plus de 50 % de la charge totale. Exemples :
- Instruction de requête efficace
```
* | select count(1) as pv , from_unixtime(__time__-__time__%3600) as time group by __time__-__time__%3600
```
- Instruction de requête inefficace
```
* | select count(1) as pv , date_trunc('hour',__time__) as time group by time
```
Ces deux instructions calculent le nombre de journaux par heure. Dans la seconde, les horodatages sont convertis en chaînes avant le regroupement (par exemple, « 2021-12-12 00:00:00 »). Dans la première, les horodatages à l'heure exacte sont extraits, utilisés pour le regroupement, puis convertis en chaînes.
Pour regrouper les résultats selon plusieurs colonnes, placez le champ ayant le plus grand nombre de valeurs distinctes avant celui qui en a le moins.
Par exemple, si un champ spécifique compte 13 valeurs distinctes et que le champ uid en compte 100 millions, il est recommandé de placer le champ uid avant l'autre champ dans la clause GROUP BY. Exemples :
- Instruction de requête efficace
```
* | select province,uid,count(1) group by uid,province
```
- Instruction de requête inefficace
```
 * | select province,uid,count(1) group by province,uid
```
Utilisez des fonctions d'approximation.
Les fonctions d'approximation offrent de meilleures performances que les fonctions exactes, au prix d'une légère perte de précision. Exemples :
- Instruction de requête efficace
```
 * |select approx_distinct(ip)
```
- Instruction de requête inefficace
```
 * | select count(distinct(ip))
```
Spécifiez uniquement les colonnes nécessaires dans l'instruction d'analyse. Évitez de sélectionner toutes les colonnes.
Dans une instruction d'analyse, interrogez seulement les colonnes requises pour le calcul. Si vous devez consulter toutes les colonnes, utilisez la syntaxe de recherche. Exemples :
- Instruction de requête efficace
```
* |select a,b c 
```
- Instruction de requête inefficace
```
* |select *
```
Placez les colonnes non utilisées pour le regroupement dans une fonction d'agrégation.
Par exemple, si les valeurs des colonnes userid et username correspondent toujours, il suffit de spécifier la colonne userid dans la clause GROUP BY pour effectuer le regroupement. Exemples :
- Instruction de requête efficace
```
 * | select userid, arbitrary(username), count(1) group by userid 
```
- Instruction de requête inefficace
```
* | select userid, username, count(1) group by userid,username
```
Évitez la clause IN.
N'utilisez pas la clause IN dans une instruction d'analyse. Privilégiez la clause OR dans une instruction de recherche. Exemples :
- Instructions de requête et d'analyse rapides
```
key: a or key: b or key: c | select count(1)
```
- Instruction de requête inefficace
```
* | select count(1) where key in ('a','b')
```