Docs
La Recherche⌘ K
  • Accueil
  • À propos de The Graph
  • Réseaux pris en charge
  • Contrats du Protocole
  • Subgraphs
    • Substreams
      • Token API
        • AI Suite
          • Indexing
            • Resources
              Subgraphs > Les meilleures pratiques

              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

              1. 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.
              1. 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.
              1. 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 type Int8! 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.

              Bonnes pratiques pour les subgraphs 1-6

              1. Améliorer la vitesse des requêtes avec l’élagage des Subgraphs

              2. Améliorer l’indexation et la réactivité des requêtes en utilisant @derivedFrom

              3. Améliorer l’indexation et les performances des requêtes en utilisant des entités immuables et des Bytes comme IDs

              4. Améliorer la vitesse d’indexation en évitant les eth_calls

              5. Simplifier et optimiser avec les séries chronologiques et les agrégations

              6. Utiliser le greffage pour un déploiement rapide des correctifs

              ⁠Edit on GitHub⁠

              Éviter les eth_callsGreffage et réparation en environement de production
              On this page
              • TLDR
              • Aperçu
              • Avantages des séries chronologiques et des agrégations
              • Points Importants
              • Comment mettre en œuvre des séries chronologiques et des agrégations
              • Prérequis
              • Définition des entités de séries chronologiques
              • Définition des entités d’agrégation
              • Interroger des données agrégées
              • Utilisation des dimensions dans les agrégations
              • Entité de séries chronologiques
              • Entité d’agrégation avec dimension
              • Fonctions et expressions d’agrégation
              • L’argument dans @aggregate peut être
              • Exemples d’expressions d’agrégation
              • Paramètres de requête
              • Notes
              • Conclusion
              • Bonnes pratiques pour les subgraphs 1-6
              The GraphStatusTestnetActifs de la MarqueForumSécuritéPolitique de confidentialitéConditions d'utilisation