5 minutes
Meilleure pratique pour les subgraphs 5 - Simplifier et optimiser avec les séries chronologiques et les agrégations
TLDR
L’utilisation de la nouvelle fonction de séries Chronologiques et d’agrégations dans les Subgraphs peut améliorer de manière significative la vitesse d’indexation et la performance des requêtes.
Aperçu
Les séries chronologiques et les agrégations réduisent le coûts de traitementt des données et accélèrent les requêtes en déchargeant les calculs d’agrégation dans la base de données et en simplifiant le code de mappage. Cette approche est particulièrement efficace lorsqu’il s’agit de traiter de grands volumes de données chronologiques.
Avantages des séries chronologiques et des agrégations
- Amélioration du temps d’indexation
- Moins de données à charger : Les mappages traitent moins de données puisque les points de données brutes sont stockés sous forme d’entités chronologiques immuables.
- Agrégations gérées par la base de données : Les agrégations sont automatiquement calculées par la base de données, ce qui réduit la charge de travail sur les mappages.
- Code de mappage simplifié
- Pas de calculs manuels : Les développeurs n’ont plus besoin d’écrire une logique d’agrégation complexe dans les mappages.
- Complexité réduite : Simplifie la maintenance du code et minimise les risques d’erreurs.
- Des requêtes beaucoup plus rapides
- Données immuables : Toutes les données de séries chronologiques sont immuables, ce qui permet un stockage et une extraction efficaces.
- Séparation efficace des données : Les agrégats sont stockés séparément des données chronologiques brutes, ce qui permet aux requêtes de traiter beaucoup moins de données, souvent plusieurs ordres de grandeur en moins.
Points Importants
- Données immuables : Les données chronologiques ne peuvent pas être modifiées une fois écrites, ce qui garantit l’intégrité des données et simplifie l’indexation.
- Gestion automatique de l’identification et de l’horodatage : les champs d’identification et d’horodatage sont automatiquement gérés par graph-node, ce qui réduit les erreurs potentielles.
- Stockage efficace des données : En séparant les données brutes des agrégats, le stockage est optimisé et les requêtes s’exécutent plus rapidement.
Comment mettre en œuvre des séries chronologiques et des agrégations
Prérequis
Vous avez besoin de spec version 1.1.0 pour cette fonctionnalité.
Définition des entités de séries chronologiques
Une entité de séries chronologiques représente des points de données brutes collectés au fil du temps. Elle est définie par l’annotation @entity(timeseries : true). Exigences principales :
- Immuable : Les entités de séries chronologiques sont toujours immuables.
- Champs obligatoires :
id: Doit être de typeInt8!et est auto-incrémenté.timestamp: Doit être de type ‘Timestamp!` et est automatiquement fixé à l’horodatage du bloc.
L’exemple:
1type Data @entity(timeseries: true) {2 id: Int8!3 timestamp: Timestamp!4 amount: BigDecimal!5}Définition des entités d’agrégation
Une entité d’agrégation calcule des valeurs agrégées à partir d’une source de séries chronologiques. Elle est définie par l’annotation @aggregation. Composants clés :
- Arguments d’annotation :
intervals: Spécifie les intervalles de temps (par exemple,["hour", "day"]).
L’exemple:
1type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {2 id: Int8!3 timestamp: Timestamp!4 sum: BigDecimal! @aggregate(fn: "sum", arg: "amount")5}Dans cet exemple, Stats agrège le champ montant de Data sur des intervalles horaires et quotidiens, en calculant la somme.
Interroger des données agrégées
Les agrégations sont exposées via des champs de requête qui permettent le filtrage et la recherche sur la base de dimensions et d’intervalles de temps.
L’exemple:
1{2 tokenStats(3 interval: "hour"4 where: { token: "0x1234567890abcdef", timestamp_gte: "1704164640000000", timestamp_lt: "1704251040000000" }5 ) {6 id7 timestamp8 token {9 id10 }11 totalVolume12 priceUSD13 count14 }15}Utilisation des dimensions dans les agrégations
Les dimensions sont des champs non agrégés utilisés pour regrouper des points de données. Elles permettent des agrégations basées sur des critères spécifiques, tels qu’un jeton dans une application financière.
L’exemple:
Entité de séries chronologiques
1type TokenData @entity(timeseries: true) {2 id: Int8!3 timestamp: Timestamp!4 token: Token!5 amount: BigDecimal!6 priceUSD: BigDecimal!7}Entité d’agrégation avec dimension
1type TokenStats @aggregation(intervals: ["hour", "day"], source: "TokenData") {2 id: Int8!3 timestamp: Timestamp!4 token: Token!5 totalVolume: BigDecimal! @aggregate(fn: "sum", arg: "amount")6 priceUSD: BigDecimal! @aggregate(fn: "last", arg: "priceUSD")7 count: Int8! @aggregate(fn: "count", cumulative: true)8}- Champ dimensionnel : le jeton regroupe les données, de sorte que les agrégats sont calculés par jeton.
- Agrégats :
- totalVolume: Somme des montants.
- priceUSD: priceUSD le plus récent Enregistré.
- count: Nombre cumulé d’enregistrements.
Fonctions et expressions d’agrégation
Fonctions d’agrégation prises en charge :
- sum
- count
- min
- max
- first
- last
L’argument dans @aggregate peut être
- Un nom de champ de l’entité de série chronologique.
- Une expression utilisant des champs et des constantes.
Exemples d’expressions d’agrégation
- Addition de la Valeur du jeton: @aggregate(fn: “sum”, arg: “priceUSD _ amount”)
- Montant positif maximum: @aggregate(fn: “max”, arg: “greatest(amount0, amount1, 0)”)
- Somme conditionnelle: @aggregate(fn: “sum”, arg: “case when amount0 > amount1 then amount0 else 0 end”)
Les opérateurs et fonctions pris en charge comprennent l’arithmétique de base (+, -, _, /), les opérateurs de comparaison, les opérateurs logiques (and, or, not) et les fonctions SQL telles que la plus grande, la plus petite, la coalescence, etc.
Paramètres de requête
- interval: Spécifie l’intervalle de temps (e.g., “heure”).
- where: Filtres basés sur les dimensions et les plages d’horodatage.
- timestamp_gte / timestamp_lt: Filtre pour les heures de début et de fin (microsecondes depuis l’epoch).
Notes
- Tri : Les résultats sont automatiquement triés par date et par numéro d’identification, dans l’ordre décroissant.
- Données actuelles : Un argument facultatif de données actuelles peut inclure l’intervalle actuel, partiellement rempli.
Conclusion
La mise en œuvre de séries chronologiques et d’agrégations dans des Subgraphs est une bonne pratique pour les projets traitant de données temporelles. Cette approche :
- Améliore les performances : Accélère l’indexation et l’interrogation en réduisant le coût du traitement des données.
- Simplifie le développement : Élimine la nécessité d’une logique d’agrégation manuelle dans les correspondances.
- Évolue efficacement : Traite d’importants volumes de données sans compromettre la vitesse ou la réactivité.
En adoptant ce modèle, les développeurs peuvent construire des subgraphs plus efficaces et plus évolutifs, offrant un accès aux données plus rapide et plus fiable aux utilisateurs finaux. Pour en savoir plus sur l’implémentation des séries chronologiques et des agrégations, consultez le [Readme des Séries chronologiques et agrégations] (https://github.com/graphprotocol/graph-node/blob/master/docs/aggregations.md) et envisagez d’expérimenter cette fonctionnalité dans vos subgraphs.