Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Utiliser des mesures

Ce document vous explique comment définir et interroger des mesures sur vos graphiques. Vous pouvez utiliser des mesures pour vous assurer que les agrégations sont effectuées correctement sur les jointures.

Présentation

Une mesure est une propriété d'agrégation définie dans la clause PROPERTIES d'une table de nœuds ou d'arêtes. Les mesures sont définies par une expression de mesure, qui est créée en utilisant le mot clé MEASURE autour de l'un des éléments suivants :

une expression d'agrégation
une expression qui combine des fonctions d'agrégation avec des opérations scalaires
Une mesure dérivée, qui est une combinaison de mesures encapsulées dans la fonction AGG définies sur la même table d'éléments.

Les mesures sont compatibles avec les fonctions d'agrégation suivantes :

SUM
AVG
COUNT
MIN
MAX
AGG (pour les mesures dérivées)

Toutes les fonctions d'agrégation, à l'exception de AGG, sont compatibles avec le mot clé DISTINCT. Pour en savoir plus sur les expressions de mesure acceptées, consultez la section sur le type de mesure.

Les mesures définissent leur agrégation en référence à la KEY de la table de nœuds ou d'arêtes sur laquelle elles sont définies. Cela signifie que lorsque vous interrogez une mesure, l'agrégation est effectuée correctement, même si la table sous-jacente est jointe d'une manière qui entraîne la duplication des lignes.

Vous ne pouvez pas référencer une propriété définie par une mesure dans une requête GQL. À la place, vous accédez aux mesures en appelant la fonction TVF GRAPH_EXPAND pour interroger une représentation relationnelle de votre graphique. Par défaut, GRAPH_EXPAND renvoie une représentation de table aplatie de votre graphique avec une colonne par propriété. Vous pouvez également spécifier flatten_results => FALSE pour renvoyer une table hiérarchique avec des colonnes STRUCT imbriquées. Si votre graphique contient plusieurs tables de nœuds racines, vous pouvez spécifier l'argument start_node pour choisir la table racine à parcourir.

Cette fonction n'accepte pas tous les types de graphiques. Pour en savoir plus sur les graphiques qui constituent une entrée valide, consultez les limites d'entrée. Pour exécuter des requêtes GQL, vous devez disposer d'une réservation qui utilise l'édition Enterprise ou Enterprise Plus. Si vous utilisez la tarification à la demande, vous pouvez appeler la fonction GRAPH_EXPAND pour exécuter des requêtes SQL sur votre graphe.

Vous pouvez appeler la fonction AGG sur la sortie de la TVF GRAPH_EXPAND pour agréger les propriétés en fonction de l'agrégation définie dans la mesure.

Définir des mesures

Vous définissez des mesures dans la clause PROPERTIES d'une définition de table de nœuds ou d'arêtes en utilisant le mot clé MEASURE() autour d'une expression de mesure.

L'exemple suivant crée un ensemble de données appelé university et des tables pour les universités, les départements et les cours :

CREATE SCHEMA IF NOT EXISTS university;

CREATE OR REPLACE TABLE university.College (
  college_id INT64 PRIMARY KEY NOT ENFORCED,
  college_name STRING
);

CREATE OR REPLACE TABLE university.Department (
  dept_id INT64 PRIMARY KEY NOT ENFORCED,
  dept_name STRING,
  college_id INT64,
  budget FLOAT64,
  FOREIGN KEY (college_id) REFERENCES university.College(college_id) NOT ENFORCED
);

CREATE OR REPLACE TABLE university.Course (
  course_id INT64 PRIMARY KEY NOT ENFORCED,
  course_name STRING,
  dept_id INT64,
  credits INT64,
  FOREIGN KEY (dept_id) REFERENCES university.Department(dept_id) NOT ENFORCED
);

INSERT INTO university.College (college_id, college_name)
VALUES (101, 'College of Engineering'),
       (102, 'College of Arts');

INSERT INTO university.Department (dept_id, dept_name, college_id, budget)
VALUES (1001, 'Computer Science', 101, 500000),
       (1002, 'Mechanical Engineering', 101, 400000),
       (1003, 'Fine Arts', 102, 200000),
       (1004, 'Research', 101, 50000);

INSERT INTO university.Course (course_id, course_name, dept_id, credits)
VALUES (1, 'Intro to CS', 1001, 3),
       (2, 'Data Structures', 1001, 4),
       (3, 'Thermodynamics', 1002, 3),
       (4, 'Oil Painting', 1003, 2);

L'instruction suivante crée un graphique appelé SchoolGraph qui définit des mesures sur les propriétés des nœuds Department et Course. Vous devez fournir un alias pour les propriétés définies par une mesure.

CREATE OR REPLACE PROPERTY GRAPH university.SchoolGraph
  NODE TABLES (
    university.College
      KEY(college_id)
      PROPERTIES(college_id, college_name),
    university.Department
      KEY(dept_id)
      PROPERTIES(dept_id, dept_name, college_id,
        budget OPTIONS(description="Department budget in USD"),
        MEASURE(SUM(budget)) AS total_budget,
        MEASURE(SUM(budget) * 1.10) AS budget_with_overhead OPTIONS(
          description="Total department budget including 10% overhead",
          extensions=[("unit", "USD"), ("tier", "planning")]
        )),
    university.Course
      KEY(course_id)
      PROPERTIES(
        course_id,
        course_name,
        credits,
        dept_id,
        MEASURE(AVG(credits)) AS avg_credits,
        MEASURE(SUM(credits)) AS total_credits,
        MEASURE(COUNT(course_id)) AS course_count,
        MEASURE(COUNT(DISTINCT CASE WHEN credits >= 3 THEN course_id ELSE NULL END)) AS major_course_count,
        MEASURE(SAFE_DIVIDE(AGG(total_credits), NULLIF(AGG(course_count), 0))) AS computed_avg_credits)
  )
  EDGE TABLES (
    university.Department AS CollegeDept
      SOURCE KEY (college_id) REFERENCES College (college_id)
      DESTINATION KEY (dept_id) REFERENCES Department (dept_id),
    university.Course AS DeptCourse
      SOURCE KEY (dept_id) REFERENCES Department (dept_id)
      DESTINATION KEY (course_id) REFERENCES Course (course_id)
  );

Visualisation du graphique SchoolGraph.

La mesure total_budget est définie comme MEASURE(SUM(budget)). La mesure verrouille l'agrégation sur KEY, qui est dept_id.

Mesures dérivées

Une mesure dérivée est une mesure qui fait référence à d'autres mesures définies sur la même table d'éléments à l'aide de la fonction AGG(). Cette fonctionnalité vous permet de créer des hiérarchies de mesures réutilisables.

Par exemple, dans university.Course, la mesure computed_avg_credits calcule le ratio entre les mesures total_credits et course_count :

MEASURE(SAFE_DIVIDE(AGG(total_credits), NULLIF(AGG(course_count), 0))) AS computed_avg_credits

Les mesures dérivées conservent la propriété de verrouillage de grain de la clé de table d'éléments sous-jacente. Les dépendances de mesure sont résolues au moment de la compilation du graphique. Les références circulaires entre les mesures renvoient une erreur.

Comprendre la surcomptabilisation

Lorsque vous joignez des tables, les données sont répétées chaque fois qu'il existe une relation un à plusieurs dans vos données. Par exemple, si vous joignez les tables Course, Department et College, un département proposant plusieurs cours apparaît sur plusieurs lignes dans le résultat :

SELECT
  college_name,
  dept_name,
  course_name,
  budget
FROM university.Course
LEFT JOIN university.Department
  ON Course.dept_id = Department.dept_id
LEFT JOIN university.College
  ON Department.college_id = College.college_id;

/*------------------------+------------------------+-----------------+----------+
 | college_name           | dept_name              | course_name     | budget   |
 +------------------------+------------------------+-----------------+----------+
 | College of Engineering | Computer Science       | Intro to CS     | 500000.0 |
 | College of Engineering | Computer Science       | Data Structures | 500000.0 |
 | College of Engineering | Mechanical Engineering | Thermodynamics  | 400000.0 |
 | College of Arts        | Fine Arts              | Oil Painting    | 200000.0 |
 +------------------------+------------------------+-----------------+----------*/

Si vous essayez de calculer le budget total par établissement à l'aide de SUM(budget), le budget du département d'informatique est comptabilisé deux fois. Vous pouvez éviter ce problème en interrogeant directement la table Department, mais cette approche ne fonctionne pas si vous souhaitez calculer plusieurs agrégations à partir de différentes tables qui contribuent à vos données jointes. La section suivante montre comment les mesures résolvent ce problème.

Interroger un graphique avec des mesures

Vous pouvez interroger un graphe avec des mesures à l'aide de GQL, mais votre requête ne peut pas référencer directement une propriété définie par une mesure. Par exemple, la requête suivante fait référence à des nœuds pour lesquels des propriétés de mesure sont définies, mais n'utilise ni ne renvoie aucun des champs de mesure :

GRAPH university.SchoolGraph
MATCH (c:College)->(d:Department)->(course:Course)
RETURN c.college_name, d.dept_name, course.course_name;

/*------------------------+------------------------+-----------------+
 | college_name           | dept_name              | course_name     |
 +------------------------+------------------------+-----------------+
 | College of Engineering | Computer Science       | Intro to CS     |
 | College of Engineering | Computer Science       | Data Structures |
 | College of Engineering | Mechanical Engineering | Thermodynamics  |
 | College of Arts        | Fine Arts              | Oil Painting    |
 +------------------------+------------------------+-----------------*/

Pour utiliser des mesures, vous utilisez la fonction de valeur de table (TVF) GRAPH_EXPAND pour interroger votre graphe en tant que table relationnelle :

GRAPH_EXPAND(
  graph_name [, start_node => 'NodeName'] [, flatten_results => TRUE|FALSE]
)

La fonction accepte les arguments suivants :

graph_name : STRING contenant le nom du graphique.
start_node : STRING facultatif spécifiant la table de nœuds de départ pour le parcours. Cet argument est obligatoire si le graphique comporte plusieurs tables de nœuds racines.
flatten_results : BOOL facultatif (valeur par défaut : TRUE) :
- TRUE : aplatit toutes les propriétés de nœud et d'arête dans des colonnes de premier niveau avec des préfixes <element>_<property>.
- FALSE : renvoie les propriétés du nœud racine en tant que colonnes de premier niveau sans préfixe et les tables voisines jointes en tant que colonnes STRUCT.

Utiliser les résultats aplatis

Lorsque flatten_results est défini sur TRUE (mode par défaut), les colonnes de la table de sortie sont nommées en concaténant l'étiquette de la table de nœuds ou d'arêtes et le nom de la propriété (par exemple, Course_course_name ou Department_total_budget). La requête suivante montre un exemple de résultat de la TVF GRAPH_EXPAND :

SELECT
  College_college_name,
  Department_dept_name,
  Department_budget,
  Course_course_name
FROM
  GRAPH_EXPAND("university.SchoolGraph");

/*------------------------+------------------------+-------------------+--------------------+
 | College_college_name   | Department_dept_name   | Department_budget | Course_course_name |
 +------------------------+------------------------+-------------------+--------------------+
 | College of Engineering | Computer Science       | 500000.0          | Intro to CS        |
 | College of Engineering | Computer Science       | 500000.0          | Data Structures    |
 | College of Engineering | Mechanical Engineering | 400000.0          | Thermodynamics     |
 | College of Arts        | Fine Arts              | 200000.0          | Oil Painting       |
 +------------------------+------------------------+-------------------+--------------------*/

La fonction GRAPH_EXPAND produit la table aplatie en appliquant une série d'opérations LEFT JOIN aux tables de nœuds et d'arêtes. Si vous ne spécifiez pas de nœud de départ, le graphe d'entrée doit comporter une seule table de nœud racine dans le graphe de relation de schéma. De même, la table du nœud racine doit avoir une relation de type plusieurs à un avec toutes les autres tables de nœuds avec lesquelles elle partage une arête. Les données qui ne sont pas accessibles à partir de la table du nœud racine via une série de jointures n'apparaissent pas dans le résultat. Dans l'exemple précédent, Course est la table du nœud racine. Le service Research est omis du résultat, car il ne propose aucun cours.

Vous ne pouvez pas sélectionner directement une colonne pour une propriété définie par une mesure. Vous devez plutôt les encapsuler dans la fonction AGG(). Cette fonction garantit que l'agrégation définie sur les mesures est effectuée exactement une fois par clé.

La requête suivante calcule simultanément le budget total et le nombre total de cours pour chaque établissement :

SELECT
  College_college_name,
  AGG(Department_total_budget) AS college_budget,
  AGG(Course_course_count) AS total_courses
FROM
  GRAPH_EXPAND("university.SchoolGraph")
GROUP BY
  College_college_name;

/*------------------------+----------------+---------------+
 | College_college_name   | college_budget | total_courses |
 +------------------------+----------------+---------------+
 | College of Engineering | 900000.0       | 3             |
 | College of Arts        | 200000.0       | 1             |
 +------------------------+----------------+---------------*/

Utiliser la sortie hiérarchique

Lorsque vous spécifiez flatten_results => FALSE, GRAPH_EXPAND renvoie une relation hiérarchique au lieu de colonnes préfixées :

Les propriétés du nœud racine de départ s'affichent sous forme de colonnes de premier niveau sans préfixe (par exemple, course_name ou credits).
Les propriétés des tables voisines jointes, qui peuvent être des tables de nœuds ou d'arêtes, apparaissent sous forme de champs STRUCT imbriqués nommés d'après la table d'éléments. Par exemple, si le nœud de départ est Course, vous devez utiliser la propriété DeptCourse.Department.CollegeDept.College.college_nameto access thecollege_name`.
Les mesures à l'intérieur de structures imbriquées sont interrogées à l'aide de la notation par points dans AGG() (par exemple, AGG(DeptCourse.Department.total_budget)).
Si une table d'éléments comporte une propriété portant le même nom qu'une table d'éléments adjacente, vous ne pouvez pas interroger le graphique à l'aide de flatten_results => FALSE. Vous devez plutôt aplatir les résultats.

SELECT
  DeptCourse.Department.dept_name AS department_name,
  DeptCourse.Department.CollegeDept.College.college_name,
  AGG(DeptCourse.Department.total_budget) AS total_budget,
  AGG(course_count) AS total_courses
FROM GRAPH_EXPAND(
       "university.SchoolGraph",
       start_node => "Course",
       flatten_results => FALSE)
GROUP BY department_name, college_name;

Utiliser plusieurs tables de nœuds racines

Les graphiques contiennent souvent plusieurs tables de nœuds racines, également appelées tables de faits, qui partagent des tables de dimensions. Pour interroger un graphe comportant plusieurs tables de nœuds racines, utilisez l'argument start_node dans GRAPH_EXPAND. La fonction parcourt le sous-graphe accessible à partir du nœud de départ.

Par exemple, vous pouvez ajouter une table Instructor à l'ensemble de données university qui est également associé à Department :

CREATE OR REPLACE TABLE university.Instructor (
  instructor_id INT64 PRIMARY KEY NOT ENFORCED,
  instructor_name STRING,
  dept_id INT64,
  salary FLOAT64,
  FOREIGN KEY (dept_id) REFERENCES university.Department(dept_id) NOT ENFORCED
);

INSERT INTO university.Instructor (instructor_id, instructor_name, dept_id, salary)
VALUES (501, 'Dr. Dana', 1001, 120000),
       (502, 'Dr. Lee', 1001, 110000),
       (503, 'Dr. Taylor', 1002, 115000),
       (504, 'Prof. Izumi', 1003, 90000);

Vous pouvez créer un graphique appelé university.SchoolGraphMultiRoot qui inclut la table de nœuds Instructor et un arc de Instructor à Department :

CREATE OR REPLACE PROPERTY GRAPH university.SchoolGraphMultiRoot
  NODE TABLES (
    university.College
      KEY(college_id)
      PROPERTIES(college_id, college_name),
    university.Department
      KEY(dept_id)
      PROPERTIES(dept_id, dept_name, college_id, budget,
        MEASURE(SUM(budget)) AS total_budget),
    university.Course
      KEY(course_id)
      PROPERTIES(
        course_id, course_name, credits, dept_id,
        MEASURE(COUNT(course_id)) AS course_count),
    university.Instructor
      KEY(instructor_id)
      PROPERTIES(
        instructor_id, instructor_name, dept_id, salary,
        MEASURE(COUNT(instructor_id)) AS instructor_count,
        MEASURE(SUM(salary)) AS total_salary)
  )
  EDGE TABLES (
    university.Department AS CollegeDept
      SOURCE KEY (college_id) REFERENCES College (college_id)
      DESTINATION KEY (dept_id) REFERENCES Department (dept_id),
    university.Course AS DeptCourse
      SOURCE KEY (dept_id) REFERENCES Department (dept_id)
      DESTINATION KEY (course_id) REFERENCES Course (course_id),
    university.Instructor AS DeptInstructor
      SOURCE KEY (dept_id) REFERENCES Department (dept_id)
      DESTINATION KEY (instructor_id) REFERENCES Instructor (instructor_id)
  );

Dans ce graphique, Course et Instructor servent de tables de nœuds racines qui renvoient vers Department et College. Vous pouvez cibler l'un ou l'autre sous-graphe en transmettant start_node :

-- Expand the Course subgraph (Course -> Department -> College)
SELECT
  College_college_name,
  AGG(Course_course_count) AS total_courses
FROM GRAPH_EXPAND("university.SchoolGraphMultiRoot", start_node => "Course")
GROUP BY College_college_name;

-- Expand the Instructor subgraph (Instructor -> Department -> College)
SELECT
  College_college_name,
  AGG(Instructor_total_salary) AS total_faculty_salary
FROM GRAPH_EXPAND("university.SchoolGraphMultiRoot", start_node => "Instructor")
GROUP BY College_college_name;

Pour analyser les métriques de plusieurs tables de faits, interrogez chaque sous-graphe à l'aide de GRAPH_EXPAND et joignez-les sur leurs dimensions partagées en SQL standard :

SELECT
  C.College_college_name,
  AGG(C.Course_course_count) AS total_courses,
  AGG(I.Instructor_total_salary) AS total_faculty_salary
FROM GRAPH_EXPAND("university.SchoolGraphMultiRoot", start_node => "Course") AS C
INNER JOIN GRAPH_EXPAND("university.SchoolGraphMultiRoot", start_node => "Instructor") AS I
  ON C.Department_dept_id = I.Department_dept_id
GROUP BY C.College_college_name;

AGG(C.Course_course_count) et AGG(I.Instructor_total_salary) calculent leurs agrégations avec précision à leurs niveaux de précision respectifs, sans interférence de la jointure.

Bonnes pratiques

Lorsque vous concevez un graphique avec des mesures, suivez ces bonnes pratiques :

Définir des nœuds et des arêtes dans une seule table

Nous vous recommandons d'utiliser la même table pour une définition de table de nœuds et ses définitions de table de périphérie de connexion. La réutilisation de la table garantit une relation de un à un (1:1) entre la table de nœuds et la table d'arêtes, ce qui évite la distribution et garantit que la fonction GRAPH_EXPAND n'ignore pas l'arête comme ambiguë.

Par exemple, si vous disposez d'une table d'entrée Enrollment contenant des clés étrangères pointant vers les tables Student et Course, définissez le nœud Enrollment et ses arêtes sortantes à l'aide de la table d'entrée Enrollment.

Éviter de définir des propriétés inutiles sur les tables de périphérie

Lorsque vous définissez une table de nœuds et une table d'arêtes à l'aide de la même table physique, n'utilisez pas la clause PROPERTIES sur la table d'arêtes, sauf si de nouvelles informations doivent être capturées sur l'arête. Étant donné que la table de nœuds et la table d'arêtes utilisent la même table physique, toutes ces propriétés font déjà partie de la table de nœuds.

La définition de propriétés redondantes sur la table d'arêtes peut amener la fonction GRAPH_EXPAND à traiter la table d'arêtes comme une entité distincte de la table de nœuds partagée. Pour optimiser les performances, spécifiez NO PROPERTIES dans la définition de la table de périphérie lorsqu'il n'y a pas de nouvelles propriétés à capturer sur la périphérie.

Modéliser des relations plusieurs à plusieurs en tant que tables de nœuds

Une relation de type plusieurs à plusieurs (M:N) se produit lorsqu'une ligne de la table A peut correspondre à plusieurs lignes de la table B, et qu'une ligne de la table B peut correspondre à plusieurs lignes de la table A. Par exemple, un étudiant peut s'inscrire à plusieurs cours, et un cours peut compter plusieurs étudiants. Vous pouvez séparer une relation de type plusieurs à plusieurs en deux relations de type un à plusieurs à l'aide d'une table de jonction intermédiaire. Par exemple, vous pouvez définir une table Enrollment contenant des clés étrangères pointant vers les tables Student et Course. Si vous modélisez une table de jonction intermédiaire en tant que table d'arêtes qui connecte deux tables de nœuds de dimension dans votre instruction CREATE PROPERTY GRAPH, comme dans l'exemple suivant, la fonction GRAPH_EXPAND ignore ces arêtes, car leur relation est ambiguë : elle n'est pas clairement de type plusieurs-à-un ou un-à-un.

CREATE PROPERTY GRAPH university.SchoolGraph
  NODE TABLES (
    university.Student,
    university.Course
  )
  EDGE TABLES (
    -- Modeling the junction table as a standalone edge causes ambiguity
    university.Enrollment AS StudentEnrollment
      SOURCE KEY (student_id) REFERENCES Student (student_id)
      DESTINATION KEY (course_id) REFERENCES Course (course_id)
  );

Si toutes les arêtes d'un graphique sont ignorées, les appels à GRAPH_EXPAND ou BQ.SHOW_GRAPH_EXPAND_SCHEMA échouent avec une erreur.

Pour modéliser correctement une relation M:N pour les mesures, transformez la table de jonction intermédiaire en table de nœuds. Dans cette structure, la table de nœuds de jonction sert de table de nœuds racine unique (une table de nœuds avec un degré d'entrée de zéro). Ensuite, définissez deux tables de périphérie de type plusieurs-à-un (N:1) qui partagent la table de jonction pour connecter N:1 à chacune des tables de nœuds de dimension :

CREATE PROPERTY GRAPH university.SchoolGraph
  NODE TABLES (
    university.Student KEY (student_id),
    university.Course KEY (course_id),
    -- Promote the junction table to a node table (acting as the single root node)
    university.Enrollment KEY (enrollment_id)
  )
  EDGE TABLES (
    -- Share (reuse) the Enrollment table to define N:1 edges to each dimension
    university.Enrollment AS EnrollmentToStudent
      SOURCE KEY (enrollment_id) REFERENCES Enrollment (enrollment_id)
      DESTINATION KEY (student_id) REFERENCES Student (student_id),
    university.Enrollment AS EnrollmentToCourse
      SOURCE KEY (enrollment_id) REFERENCES Enrollment (enrollment_id)
      DESTINATION KEY (course_id) REFERENCES Course (course_id)
  );

Dans cette structure, Enrollment sert de table de nœud racine unique (degré entrant de zéro) connectant N:1 aux tables de dimensions Student et Course (degré entrant de un). La fonction GRAPH_EXPAND peut aplatir ce graphique en parcourant vers l'extérieur de Enrollment à Student et Course. Si vous définissez des mesures sur l'une de ces tables, vous pouvez appeler la fonction AGG sur les colonnes de mesure pour calculer correctement les agrégations sans surcomptage.

Choisir comment les mesures gèrent les lignes sans correspondance

Lorsqu'une ligne n'a pas de correspondance dans une table d'éléments connectés, les colonnes de cette table sont NULL dans la sortie GRAPH_EXPAND. Par exemple, si un cours n'a pas de valeur dept_id, les colonnes Department de cette ligne sont NULL. Le fait qu'une mesure sur le nœud Department inclue ou non ces lignes dépend de l'endroit où vous écrivez l'expression scalaire que la mesure agrège.

Si vous écrivez l'expression dans la fonction d'agrégation, elle est évaluée pour chaque ligne de la sortie développée, y compris les lignes sans correspondance. Lorsque l'expression renvoie une valeur plutôt que NULL pour l'une de ces lignes, cette valeur contribue au résultat.

Si vous définissez l'expression en tant que propriété et que vous référencez cette propriété à partir de la mesure, l'expression est évaluée sur les lignes de la table de nœuds, et les lignes sans correspondance ne contribuent pas au résultat.

L'exemple suivant définit la même expression de deux manières sur university.Department :

university.Department
  KEY(dept_id)
  PROPERTIES(dept_id, dept_name, college_id, budget,
    COALESCE(budget, 0) AS budget_or_zero,
    -- Includes courses that have no department, as a budget of 0.
    MEASURE(AVG(COALESCE(budget, 0))) AS avg_budget_inline,
    -- Averages only departments that exist.
    MEASURE(AVG(budget_or_zero)) AS avg_budget_property)

Les deux mesures remplacent un budget NULL par 0. Le formulaire intégré remplace également les valeurs NULL produites pour un cours qui n'a pas de département, de sorte que ce cours est moyenné en tant que département avec un budget de 0. Choisissez le formulaire qui correspond à ce que vous souhaitez mesurer.

Afficher le schéma `GRAPH_EXPAND`

Pour afficher le schéma de la table renvoyée par la fonction GRAPH_EXPAND sans appeler la fonction, utilisez la procédure système BQ.SHOW_GRAPH_EXPAND_SCHEMA :

DECLARE schema STRING DEFAULT '';
CALL BQ.SHOW_GRAPH_EXPAND_SCHEMA('university.SchoolGraph', schema);
SELECT schema;

Cette procédure renseigne la variable schema avec le nom, le type et le mode de chaque colonne. Il indique également si la propriété référencée par la colonne est une mesure, et liste les descriptions ou synonymes que vous avez définis pour elle.

Étapes suivantes

Découvrez comment créer et interroger un graphe.
En savoir plus sur les schémas de graphe