Menggunakan ukuran

Dokumen ini menunjukkan cara menentukan dan mengkueri ukuran pada grafik Anda. Anda dapat menggunakan ukuran untuk memastikan bahwa agregasi dilakukan dengan benar di seluruh gabungan.

Ringkasan

Measure adalah properti gabungan yang ditentukan dalam klausa PROPERTIES dari tabel node atau edge. Ukuran ditentukan oleh ekspresi ukuran, yang dibuat menggunakan kata kunci MEASURE di sekitar salah satu hal berikut:

  • ekspresi agregat
  • ekspresi yang menggabungkan fungsi agregat dengan operasi skalar
  • ukuran turunan, yang merupakan kombinasi ukuran yang digabungkan dalam fungsi AGG yang ditentukan pada tabel elemen yang sama

Ukuran mendukung fungsi agregat berikut:

  • SUM
  • AVG
  • COUNT
  • MIN
  • MAX
  • AGG (untuk ukuran turunan)

Semua fungsi agregat kecuali AGG mendukung kata kunci DISTINCT. Untuk mengetahui informasi selengkapnya tentang ekspresi ukuran yang didukung, baca jenis ukuran.

Ukuran menentukan agregasinya dengan mengacu pada KEY tabel node atau edge tempat ukuran tersebut ditentukan. Artinya, saat Anda mengkueri ukuran, agregasi dilakukan dengan benar meskipun tabel pokok digabungkan dengan cara yang menyebabkan baris diduplikasi.

Anda tidak dapat mereferensikan properti yang ditentukan oleh ukuran dalam kueri GQL. Sebagai gantinya, Anda mengakses measure dengan memanggil TVF GRAPH_EXPAND untuk mengkueri representasi relasional grafik Anda. Secara default, GRAPH_EXPAND menampilkan representasi tabel yang di-flatten dari grafik Anda dengan satu kolom per properti. Anda juga dapat menentukan flatten_results => FALSE untuk menampilkan tabel hierarkis dengan kolom STRUCT bertingkat. Jika grafik berisi beberapa tabel node root, Anda dapat menentukan argumen start_node untuk memilih tabel root yang akan dilalui.

Fungsi ini tidak menerima semua jenis grafik. Untuk mengetahui informasi selengkapnya tentang grafik yang membentuk input yang valid, lihat batasan input. Untuk menjalankan kueri GQL, Anda harus memiliki pemesanan yang menggunakan edisi Enterprise atau Enterprise Plus. Jika menggunakan harga on-demand, Anda dapat memanggil fungsi GRAPH_EXPAND untuk menjalankan kueri SQL pada grafik Anda.

Anda dapat memanggil fungsi AGG pada output dari TVF GRAPH_EXPAND untuk menggabungkan properti sesuai dengan agregasi yang ditentukan dalam ukuran.

Menentukan ukuran

Anda menentukan ukuran dalam klausa PROPERTIES definisi tabel node atau edge menggunakan kata kunci MEASURE() di sekitar ekspresi ukuran.

Contoh berikut membuat set data bernama university dan tabel untuk perguruan tinggi, jurusan, dan mata kuliah:

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);

Pernyataan berikut membuat grafik bernama SchoolGraph yang menentukan pengukuran pada properti di node Department dan Course. Anda harus memberikan alias untuk properti yang ditentukan oleh ukuran.

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)
  );

Visualisasi grafik SchoolGraph.

Ukuran total_budget didefinisikan sebagai MEASURE(SUM(budget)). Ukuran mengunci agregasi ke KEY, yaitu dept_id.

Ukuran turunan

Ukuran turunan adalah ukuran yang mereferensikan ukuran lain yang ditentukan pada tabel elemen yang sama menggunakan fungsi AGG(). Fungsi ini memungkinkan Anda membuat hierarki ukuran yang dapat digunakan kembali.

Misalnya, di university.Course, ukuran computed_avg_credits menghitung rasio antara ukuran total_credits dan course_count:

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

Ukuran turunan mempertahankan properti penguncian tingkat perincian dari kunci tabel elemen yang mendasarinya. Dependensi ukuran diselesaikan pada waktu kompilasi graf. Referensi sirkular antara ukuran akan menampilkan error.

Memahami penghitungan berlebih

Saat Anda menggabungkan tabel, data akan diulang setiap kali ada hubungan one-to-many dalam data Anda. Misalnya, jika Anda menggabungkan tabel Course, Department, dan College, departemen dengan beberapa mata kuliah akan muncul di beberapa baris dalam output:

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 |
 +------------------------+------------------------+-----------------+----------*/

Jika Anda mencoba menghitung total anggaran per perguruan tinggi menggunakan SUM(budget), anggaran jurusan Ilmu Komputer akan dihitung dua kali. Anda dapat menghindari masalah ini dengan mengkueri tabel Department secara langsung, tetapi pendekatan ini tidak akan berhasil jika Anda ingin menghitung beberapa agregasi dari tabel berbeda yang berkontribusi pada data gabungan Anda. Bagian berikut menunjukkan cara pengukuran menyelesaikan masalah ini.

Membuat kueri grafik dengan ukuran

Anda dapat membuat kueri grafik dengan measure menggunakan GQL, tetapi kueri Anda tidak dapat langsung mereferensikan properti apa pun yang ditentukan oleh measure. Misalnya, kueri berikut mereferensikan node yang memiliki properti ukuran yang ditentukan, tetapi tidak menggunakan atau menampilkan kolom ukuran apa pun:

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    |
 +------------------------+------------------------+-----------------*/

Untuk menggunakan measure, Anda menggunakan fungsi bernilai tabel (TVF) GRAPH_EXPAND untuk mengkueri grafik sebagai tabel relasional:

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

Fungsi ini menerima argumen berikut:

  • graph_name: STRING yang berisi nama grafik.
  • start_node: STRING opsional yang menentukan tabel node awal untuk penjelajahan. Argumen ini diperlukan jika grafik memiliki beberapa tabel node root.
  • flatten_results: BOOL opsional (defaultnya adalah TRUE):
    • TRUE: Meratakan semua properti node dan edge menjadi kolom tingkat atas dengan awalan <element>_<property>.
    • FALSE: Menampilkan properti node root sebagai kolom level teratas tanpa awalan dan tabel tetangga yang digabungkan sebagai kolom STRUCT.

Menggunakan output yang di-flatten

Jika flatten_results ditetapkan ke TRUE (mode default), kolom dalam tabel output diberi nama dengan menggabungkan label tabel node atau edge dan nama properti—misalnya, Course_course_name atau Department_total_budget. Kueri berikut menunjukkan contoh output dari 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       |
 +------------------------+------------------------+-------------------+--------------------*/

Fungsi GRAPH_EXPAND menghasilkan tabel yang di-flatten dengan menerapkan serangkaian operasi LEFT JOIN ke tabel node dan edge. Jika Anda tidak menentukan node awal, grafik input harus memiliki satu tabel node root dalam grafik hubungan skema. Demikian pula, tabel node root harus memiliki hubungan many-to-one dengan setiap tabel node lain yang memiliki edge yang sama. Data yang tidak dapat dijangkau dari tabel node root melalui serangkaian gabungan tidak akan muncul dalam output. Pada contoh sebelumnya, Course adalah tabel node root. Jurusan Research dihilangkan dari output karena tidak memiliki kursus.

Anda tidak dapat langsung memilih kolom untuk properti yang ditentukan oleh ukuran. Sebagai gantinya, Anda harus menggabungkannya dalam fungsi AGG(). Fungsi ini memastikan bahwa agregasi yang ditentukan pada ukuran dilakukan tepat satu kali per kunci.

Kueri berikut secara bersamaan menghitung total anggaran dan jumlah total kursus untuk setiap perguruan tinggi:

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             |
 +------------------------+----------------+---------------*/

Menggunakan output hierarkis

Saat Anda menentukan flatten_results => FALSE, GRAPH_EXPAND akan menampilkan relasi hierarkis, bukan kolom dengan awalan:

  • Properti node root awal muncul sebagai kolom tingkat teratas tanpa awalan (misalnya, course_name atau credits).
  • Properti tabel tetangga yang digabungkan, yang mungkin berupa tabel node atau edge, muncul sebagai kolom STRUCT bertingkat yang diberi nama sesuai dengan tabel elemen. Misalnya, jika node awal adalah Course, Anda akan menggunakan properti DeptCourse.Department.CollegeDept.College.college_nameto access thecollege_name`.
  • Ukuran di dalam struct bertingkat dikueri menggunakan notasi titik di dalam AGG()—misalnya, AGG(DeptCourse.Department.total_budget).
  • Jika tabel elemen memiliki properti dengan nama yang sama dengan tabel elemen yang berdekatan, Anda tidak dapat membuat kueri grafik menggunakan flatten_results => FALSE. Sebagai gantinya, Anda harus meratakan hasilnya.
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;

Menggunakan beberapa tabel node root

Grafik sering kali berisi beberapa tabel node root, yang juga disebut tabel fakta, yang menggunakan tabel dimensi yang sama. Untuk membuat kueri grafik dengan beberapa tabel node root, gunakan argumen start_node di GRAPH_EXPAND. Fungsi ini melintasi subgrafik yang dapat dijangkau dari node awal.

Misalnya, Anda dapat menambahkan tabel Instructor ke set data university yang juga ditautkan ke 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);

Anda dapat membuat grafik baru bernama university.SchoolGraphMultiRoot yang mencakup tabel node Instructor dan edge dari Instructor ke 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)
  );

Dalam grafik ini, Course dan Instructor berfungsi sebagai tabel node root yang menautkan ke Department dan College. Anda dapat menargetkan salah satu subgrafik dengan meneruskan 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;

Untuk menganalisis metrik di beberapa tabel fakta, buat kueri setiap subgrafik menggunakan GRAPH_EXPAND dan gabungkan pada dimensi bersama dalam SQL standar:

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) dan AGG(I.Instructor_total_salary) menghitung agregasinya secara akurat pada tingkat masing-masing tanpa gangguan dari penggabungan.

Praktik terbaik

Saat Anda mendesain grafik dengan ukuran, ikuti praktik terbaik berikut:

Menentukan node dan edge dalam satu tabel

Sebaiknya gunakan tabel yang sama untuk definisi tabel node dan definisi tabel edge yang menghubungkannya. Penggunaan kembali tabel memastikan hubungan satu-ke-satu (1:1) antara tabel node dan tabel edge, yang mencegah fan-out dan memastikan bahwa fungsi GRAPH_EXPAND tidak mengabaikan edge sebagai ambigu.

Misalnya, jika Anda memiliki tabel input Enrollment yang berisi kunci asing yang mengarah ke tabel Student dan Course, tentukan node Enrollment dan edge keluarnya menggunakan tabel input Enrollment.

Menghindari penentuan properti yang tidak perlu pada tabel edge

Saat Anda menentukan tabel node dan tabel edge menggunakan tabel fisik yang sama, jangan gunakan klausa PROPERTIES pada tabel edge kecuali jika ada informasi baru yang akan diambil di edge. Karena tabel node dan tabel edge menggunakan tabel fisik yang sama, semua properti ini sudah menjadi bagian dari tabel node.

Menentukan properti redundan pada tabel edge dapat menyebabkan fungsi GRAPH_EXPAND memperlakukan tabel edge sebagai entity terpisah dari tabel node bersama. Untuk mengoptimalkan performa, tentukan NO PROPERTIES pada definisi tabel edge jika tidak ada properti baru yang akan diambil di edge.

Memodelkan hubungan many-to-many sebagai tabel node

Hubungan many-to-many (M:N) terjadi saat baris dalam tabel A dapat sesuai dengan beberapa baris dalam tabel B, dan baris dalam tabel B dapat sesuai dengan beberapa baris dalam tabel A. Misalnya, satu siswa dapat mendaftar di beberapa kursus dan satu kursus dapat memiliki banyak siswa. Anda dapat memisahkan hubungan many-to-many menjadi dua hubungan one-to-many menggunakan tabel penghubung perantara. Misalnya, Anda dapat menentukan tabel Enrollment yang berisi kunci asing yang mengarah ke tabel Student dan Course. Jika Anda memodelkan tabel penghubung perantara sebagai tabel edge yang menghubungkan dua tabel node dimensi dalam pernyataan CREATE PROPERTY GRAPH, seperti dalam contoh berikut, fungsi GRAPH_EXPAND akan mengabaikan edge ini karena hubungannya ambigu: tidak jelas many-to-one atau one-to-one.

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)
  );

Jika semua edge dalam grafik diabaikan, panggilan ke GRAPH_EXPAND atau BQ.SHOW_GRAPH_EXPAND_SCHEMA akan gagal dengan error.

Untuk memodelkan relasi M:N dengan benar untuk ukuran, promosikan tabel junction perantara ke tabel node. Dalam struktur ini, tabel node persimpangan berfungsi sebagai tabel node root tunggal (tabel node dengan in-degree nol). Kemudian, tentukan dua tabel edge many-to-one (N:1) yang menggunakan tabel penghubung yang sama untuk menghubungkan N:1 ke setiap tabel node dimensi:

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)
  );

Dalam struktur ini, Enrollment berfungsi sebagai tabel node root tunggal (in-degree nol) yang menghubungkan N:1 ke tabel dimensi Student dan Course (in-degree satu). Fungsi GRAPH_EXPAND dapat meratakan grafik ini dengan melintasi ke luar dari Enrollment ke Student dan Course. Jika Anda menentukan ukuran pada salah satu tabel ini, Anda dapat memanggil fungsi AGG pada kolom ukuran untuk menghitung agregasi dengan benar tanpa penghitungan berlebih.

Memilih cara pengukuran menangani baris yang tidak cocok

Jika baris tidak memiliki kecocokan dalam tabel elemen yang terhubung, kolom tabel tersebut akan menjadi NULL dalam output GRAPH_EXPAND. Misalnya, jika kursus tidak memiliki nilai dept_id, kolom Department dari baris tersebut adalah NULL. Apakah pengukuran pada node Department menyertakan baris ini bergantung pada tempat Anda menulis ekspresi skalar yang digabungkan oleh pengukuran.

Jika Anda menulis ekspresi di dalam fungsi agregat, ekspresi tersebut akan dievaluasi untuk setiap baris output yang diperluas, termasuk baris yang tidak cocok. Jika ekspresi menampilkan nilai, bukan NULL untuk salah satu baris ini, nilai tersebut akan berkontribusi pada hasil.

Jika Anda menentukan ekspresi sebagai properti dan mereferensikan properti tersebut dari ukuran, ekspresi akan dievaluasi pada baris tabel node, dan baris yang tidak cocok tidak akan berkontribusi pada hasil.

Contoh berikut menentukan ekspresi yang sama dengan kedua cara di 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)

Kedua tindakan tersebut mengganti anggaran NULL dengan 0. Formulir inline juga menggantikan nilai NULL yang dihasilkan untuk kursus yang tidak memiliki departemen, sehingga kursus tersebut dirata-rata sebagai departemen dengan anggaran 0. Pilih formulir yang sesuai dengan yang ingin Anda ukur.

Melihat skema GRAPH_EXPAND

Untuk melihat skema tabel yang ditampilkan oleh fungsi GRAPH_EXPAND tanpa memanggil fungsi, gunakan prosedur sistem BQ.SHOW_GRAPH_EXPAND_SCHEMA:

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

Prosedur ini mengisi variabel schema dengan nama, jenis, dan mode setiap kolom. Tabel ini juga menunjukkan apakah properti yang direferensikan oleh kolom adalah ukuran, dan mencantumkan deskripsi atau sinonim yang Anda tentukan di dalamnya.

Langkah berikutnya