Руководство по языку GQL для графа в Microsoft Fabric

Замечание

Эта функция сейчас доступна в общедоступной предварительной версии. Эта предварительная версия предоставляется без соглашения на уровне обслуживания и не рекомендуется для рабочих нагрузок. Некоторые функции могут не поддерживаться или их возможности могут быть ограничены. Дополнительные сведения см. в разделе Supplemental Terms of Use for Microsoft Azure Previews.

GQL (язык запросов Graph) — это стандартизованный язык запросов ISO для баз данных графов. Используйте GQL для запроса, анализа и эффективной работы с данными графа в Microsoft Fabric.

Та же рабочая группа ISO, которая стандартизирует SQL, разрабатывает GQL. В результате GQL использует множество концепций с SQL, включая выражения, предикаты и типы данных. Если у вас есть опыт РАБОТЫ с SQL, вы можете применить большую часть этих знаний к GQL.

В этой статье содержится исчерпывающая справка по GQL в графе. В нем рассматриваются следующие сведения:

Основные понятия: структуры данных Графа, шаблоны и основы запросов
Основные операторы: MATCH, , FILTERLET, ORDER BY, LIMITиRETURN
Типы данных и выражения: типы значений, операторы и встроенные функции
Расширенные методы: состав с несколькими операторами, определение области переменных и стратегии агрегирования

Замечание

Официальный международный стандарт для GQL — ISO/IEC 39075 Information Technology — языки баз данных — GQL.

Если вы ищете рекомендации, ориентированные на задачи, вместо полной ссылки на язык, ознакомьтесь с руководствами.

Создание общих запросов GQL — соседей , обхода нескольких прыжков, общих подключений и проверок существования сущностей
Фильтрация и агрегирование данных графа — FILTER, WHERE, GROUP BY и агрегатных функций
Запись запросов шаблонов графа — шаблоны с несколькими прыжками, режимы пути, повторное использование переменной и НЕОБЯЗАТЕЛЬНОЕ СОПОСТАВЛЕНИЕ
Оптимизация производительности запросов GQL — стратегия фильтрации, ограничения обхода и рекомендации по ограничению ключей

Предпосылки

Прежде чем начать, убедитесь, что вы знакомы с этими понятиями:

Бассичное понимание баз данных . Опыт работы с любой системой базы данных, такой как реляционная (SQL), NoSQL или граф, полезна.
Основные понятия графа — понимание узлов, ребер и связей в подключенных данных.
Основы запросов — знание основных понятий запросов, таких как фильтрация, сортировка и агрегирование.

Рекомендуемый фон:

Взаимодействие с языками SQL или openCypher упрощает обучение синтаксиса GQL (они корнями GQL).
Знакомство с моделированием данных помогает с проектированием схемы графа.
Понимание конкретного варианта использования данных графа.

Что вам нужно:

Доступ к рабочей области graph с возможностями запроса.
Примеры данных или готовность к работе с нашими примерами социальных сетей.
Базовый текстовый редактор для написания запросов.

Подсказка

Если вы не знакомы с базами данных графов, начните с обзора моделей данных графа , прежде чем продолжить работу с этим руководством.

Что делает GQL особенным

GQL предназначен специально для данных графа. Эта конструкция делает ее естественной и интуитивно понятной для работы с подключенными данными.

В отличие от SQL, который использует соединения таблиц для выражения связей, GQL использует шаблоны визуальных графов. Эти шаблоны напрямую отражают связь сущностей, что упрощает чтение запросов и упрощает причину.

Предположим, вы хотите найти людей и их друзей (людей, которые знают друг друга), которые оба родились до 1999 года. Вот как GQL выражает это условие с помощью шаблона визуального графа:

MATCH (person:Person)-[:knows]-(friend:Person)
WHERE person.birthday < 19990101 
  AND friend.birthday < 19990101
RETURN person.firstName || ' ' || person.lastName AS person_name, 
       friend.firstName || ' ' || friend.lastName AS friend_name

Этот запрос находит друзей (людей, которые знают друг друга), которые родились до 1999 года. (person:Person)-[:knows]-(friend:Person) Шаблон визуально показывает структуру связей, которую вы ищете, так же как рисование схемы данных.

Основы GQL

Прежде чем изучить запросы, ознакомьтесь с этими основными понятиями, которые формируют основу GQL:

Графы хранят данные в виде узлов (сущностей) и ребер (связей), каждый из которых содержит метки и свойства.
Типы графов действуют как схемы, определяя, какие узлы и края могут существовать в графе.
Ограничения — это другие правила и ограничения, которые типы графов накладывают на графы для обеспечения целостности данных.
Запросы используют такие операторы, как MATCH, FILTERи RETURN для обработки данных и отображения результатов.
Шаблоны описывают структуры графов, которые нужно найти с помощью интуитивно понятного визуального синтаксиса.
Выражения выполняют вычисления и сравнения данных, аналогичные выражениям SQL.
Предикаты — это логические выражения значений, которые фильтруют результаты в запросах.
Типы значений определяют, какие типы значений можно обрабатывать и хранить.

Общие сведения о данных графа

Чтобы эффективно работать с GQL, необходимо понять, как структурированы данные графа. Эта основа помогает эффективно создавать лучшие запросы и моделировать данные.

Узлы и края: стандартные блоки

В GQL вы работаете с графами свойств с метками. Граф состоит из двух типов элементов:

Узлы обычно представляют сущности (существительные) в вашей системе — такие как люди, организации, записи или продукты. Они независимые объекты, которые существуют в вашем домене. Иногда также вызывается вершины узлов.
Ребра представляют связи между сущностями (командами) — как сущности подключаются и взаимодействуют.

Например, люди знакомы друг с другом (:knows), организации, работающие в определённых регионах (:operates), или клиенты, которые приобрели товары (:purchased).
Иногда вы также вызываете связи ребер.

Каждый элемент графа имеет следующие характеристики:

Внутренний идентификатор, который однозначно идентифицирует его
Одна или несколько меток — описательные имена, например Person или knows. В графе края всегда имеют ровно одну метку.
Свойства — пары "имя-значение", которые хранят данные об элементе (например firstName: "Alice" , или birthday: "19730108").

Структура графов

Каждый край подключается ровно к двум узлам: источнику и назначению. Это соединение создает структуру графа и показывает, как сущности связаны друг с другом. Направление ребер имеет значение - Person кто follows другой Person создает направленную связь.

Замечание

Graph в настоящее время не поддерживает ненаправленные края.

Графы свойств, поддерживаемые в графе, всегда хорошо сформированы, то есть каждый край подключает два допустимых узла. Если в графе отображается ребра, обе конечные точки существуют в одном графе.

Модели графа и типы графов

Модель графа описывает структуру графа. Он действует как схема базы данных для домена приложения. Модели Графа определяют:

Какие узлы и края могут существовать
Какие метки и свойства они могут иметь
Подключение узлов и ребер

Модели графов также обеспечивают целостность данных с помощью ограничений, особенно ограничений ключа узла , которые указывают, какие свойства однозначно определяют каждый узел.

Замечание

Вы можете указать модели графов с помощью стандартного синтаксиса GQL. В этом случае они называются типами графов.

В этой документации пример социальной сети иллюстрирует основные понятия GQL. Общие сведения об этом домене помогают выполнять примеры и применять аналогичные шаблоны к собственным данным.

Замечание

Пример социальной сети является производным от SNB LDBC (LDBC Social Network Benchmark), опубликованного GDC (Graph Data Council). Дополнительные сведения см. в статье "LdBC Social Network Benchmark".

Наша социальная сеть включает следующие основные типы узлов, представляющих сущности домена:

У людей есть личная информация, например имена, дни рождения и полы. Они живут в городах и формируют социальные связи.

Места образуют географическую иерархию:

Города , такие как "Нью-йорк" или "Лондон"
Countries/regions например "США" или "Соединенное Королевство"
Континенты , такие как "Северная Америка" или "Европа"

Организации , где люди тратят время:

Университеты , где люди учатся
Компании , где работают люди

Содержимое и обсуждения:

Форумы с заголовками, содержащими записи
Записи с содержимым, языком и необязательными изображениями
Комментарии , которые отвечают на сообщения или другие комментарии
Теги , которые классифицируют содержимое и представляют интересы

Как все подключается

Подключения между сущностями делают сеть интересной:

Люди знают друг друга (дружба, :knows).
Люди работают в компаниях (:workAt) или учатся в университетах (:studyAt).
Люди создают записи и комментарии (:hasCreator).
Люди, такие как записи и комментарии (:likes).
Записи, форумы и комментарии могут иметь теги (:hasTag).
Люди имеют интересы в определенных тегах (:hasInterest).
Форумы содержат записи () и члены (:containerOf:hasMember) и модераторы (:hasModerator).

Границы графа представляют связи домена. Эта многофункциональная сеть создает множество возможностей для интересных запросов и анализа.

Просмотр полной спецификации схемы

Первые запросы GQL

Теперь, когда вы понимаете основы графа, давайте посмотрим, как запрашивать данные графа с помощью GQL. Эти примеры создаются из простого в сложный, показывающий, как подход GQL делает графовые запросы интуитивно понятными и мощными.

Начните просто: найти всех людей

Начните с наиболее простого запроса. Найдите имена (имя, фамилия) всех людей (:Persons) в графе.

MATCH (p:Person)
RETURN p.firstName, p.lastName

Этот запрос выполняется следующим образом:

MATCH находит все узлы, помеченные Person.
RETURN отображает свои имена и фамилии.

Добавление фильтрации: поиск определенных пользователей

Теперь найдите людей с определенными характеристиками. В этом случае найдите всех по имени Алиса и покажите свои имена и дни рождения.

MATCH (p:Person)
FILTER p.firstName = 'Annemarie'
RETURN p.firstName, p.lastName, p.birthday

Этот запрос выполняется следующим образом:

MATCH находит всех узлов (p) с меткой Person.
FILTER узлы (p), имя которого — Алиса.
RETURN отображает свое первое, фамилию и день рождения.

Базовая структура запросов

Базовые запросы GQL соответствуют согласованному шаблону: последовательность операторов, которые работают вместе для поиска, фильтрации и возврата данных. Большинство запросов начинаются с MATCH поиска закономерностей в графе и заканчиваются с RETURN указанием результата.

Вот простой запрос, который находит пары знакомых людей с одним днём рождения, а затем возвращает общее количество этих пар друзей.

MATCH (n:Person)-[:knows]-(m:Person)
FILTER n.birthday = m.birthday
RETURN count(*) AS same_age_friends

Этот запрос выполняется следующим образом:

MATCH находит все пары Person узлов, которые знают друг друга.
FILTER держит только пары, где оба человека имеют один день рождения.
RETURN подсчитывает, сколько таких пар друзей существуют.

Подсказка

Вы также можете выполнять фильтрацию непосредственно в рамках шаблона, добавив WHERE предложение. Например, соответствует MATCH (n:Person WHERE n.age > 23) только узлам, Person свойство которых age больше 23.

GQL поддерживает примечания в стиле // C, примечания строки в стиле -- SQL и примечания в стиле /* */ C.

Распространённые утверждения

MATCH: Определяет шаблон графа для поиска — здесь вы определяете структуру интересующих вас данных.
LET: Назначает новые переменные или вычисленные значения на основе сопоставленных данных — добавляет производные столбцы к результату.
FILTER: Сужает круг результатов, применяя условия — удаляет строки, не соответствующие критериям.
ORDER BY: Сортирует отфильтрованные данные — помогает организовать результат по одному или нескольким полям.
OFFSET и LIMIT: Ограничить количество возвращаемых строк — полезно для пагинации или запросов с верхними k.
RETURN: Определяет конечный результат — определяет, какие данные должны быть включены в набор результатов, и выполняет агрегацию.

Совместная работа инструкций

Операторы GQL образуют конвейер, где каждый оператор обрабатывает выход предыдущего. Такое последовательное выполнение облегчает чтение и отладку запросов, поскольку порядок выполнения совпадает с порядком чтения.

Основные моменты:

Операторы фактически выполняются последовательно.
Каждое утверждение преобразует данные и передаёт их следующему.
Этот процесс создает четкий прогнозируемый поток данных, упрощающий сложные запросы.

Это важно

Чтобы повысить производительность, граф может переупорядочение выполнения инструкций и параллельное выполнение отдельных инструкций. Эти оптимизации не влияют на правильность результатов.

Пример композиции инструкций

Следующий запрос в GQL находит первых 10 человек, работающих в компаниях с «Air» в названии, сортирует их по полному имени и возвращает их полное имя вместе с названием их компаний.

-- Data flows: Match → Let → Filter → Order → Limit → Return
MATCH (p:Person)-[:workAt]->(c:Company)           -- Input: unit table, Output: (p, c) table
LET fullName = p.firstName || ' ' || p.lastName   -- Input: (p, c) table, Output: (p, c, fullName) table
FILTER c.name CONTAINS 'Air'                      -- Input: (p, c, fullName) table, Output: filtered table
ORDER BY fullName                                 -- Input: filtered table, Output: sorted table
LIMIT 10                                          -- Input: sorted table, Output: top 10 rows table
RETURN fullName, c.name AS companyName            -- Input: top 10 rows table
                                                  -- Output: projected (fullName, companyName) result table

Этот запрос выполняется следующим образом:

MATCH находит людей, работающих в компаниях с "Air" в их имени.
LET создает полные имена, объединяя имена первых и семейных имен.
FILTER сохраняет только сотрудников Contoso.
ORDER BY выполняет сортировку по полному имени.
LIMIT принимает первые 10 результатов.
RETURN возвращает имена и расположения компании.

Переменные подключают данные

Переменные, такие как pc, и fullName в предыдущих примерах, переносят данные между операторами. При повторном использовании имени переменной GQL автоматически гарантирует, что он ссылается на те же данные, создавая мощные условия соединения. Переменные иногда называются переменными привязки.

Переменные можно классифицировать по-разному:

По источнику привязки:

Переменные шаблона — привязанные к соответствующим шаблонам графа
Обычные переменные — привязанные к другим конструкциям языка

Типы переменных шаблонов:

Переменные элемента — привязка к ссылочным значениям элемента graph
- Переменные узла — привязка к отдельным узлам
- Пограничные переменные — привязка к отдельным краям
Переменные пути — привязка к значениям пути, представляющим соответствующие пути.

По эталонной степени:

Одноэлементные переменные — привязка к отдельным значениям ссылок на элемент из шаблонов
Групповые переменные — привязка к спискам ссылочных значений элементов из шаблонов переменной длины (см. дополнительные методы агрегирования)

Результаты выполнения и результаты

При выполнении запроса возвращается результат выполнения , состоящий из следующих элементов:

Таблица результатов (необязательно) с данными из инструкции RETURN .
Сведения о состоянии , показывающие, выполнен ли запрос успешно или нет.

Таблицы результатов

Таблица результатов ( если она присутствует) является фактическим результатом выполнения запроса.

В таблице результатов содержатся сведения о имени и типе его столбцов, предпочтительной последовательности имен столбцов, используемой для отображения результатов, упорядочения таблицы и фактических строк.

Замечание

Если выполнение завершается сбоем, в результат выполнения не будет включена таблица результатов.

Сведения о состоянии

Во время выполнения запроса процесс обнаруживает различные заметные условия, такие как ошибки или предупреждения. Каждое условие записывается объектом состояния в сведениях о состоянии результата выполнения.

Сведения о состоянии состоят из основного объекта состояния и (возможно, пустого) списка других объектов состояния. Основной объект состояния всегда существует и указывает, успешно ли выполнено выполнение запроса или завершилось сбоем.

Каждый объект состояния содержит пятизначный код состояния (с именем GQLSTATUS), который определяет записанное условие и сообщение, описывающее его.

Коды состояния успешного выполнения:

GQLSTATUS	Message	Когда
00000	примечание. Успешное завершение	Успешное выполнение по крайней мере одной строки
00001	примечание. Успешное завершение — опущен результат	Успех без таблицы (в настоящее время не используется)
02000	примечание. Данные отсутствуют	Успех с нулевыми строками

Другие коды состояния указывают на дополнительные ошибки или предупреждения, обнаруженные процессом выполнения запроса.

Это важно

В коде приложения всегда используются коды состояния для проверки определенных условий. Коды состояния гарантированно будут стабильными, и их общее значение не изменится в будущем. Не проверяйте содержимое сообщений, так как конкретное сообщение, сообщаемое для кода состояния, может измениться в будущем в зависимости от запроса или даже между выполнением одного запроса.

Кроме того, объекты состояния могут содержать объект состояния основной причины и диагностическую запись с дополнительными сведениями, характеризующими записанное условие.

Просмотр полных ссылок на коды GQLSTATUS

Основные понятия и инструкции

В этом разделе рассматриваются основные стандартные блоки, необходимые для записи эффективных запросов GQL. Каждая концепция строится на основе практических навыков написания запросов.

Шаблоны графа: поиск структуры

Шаблоны графов — это сердце запросов GQL. Они позволяют описать структуру данных, которую вы ищете, с помощью интуитивно понятного визуального синтаксиса, который выглядит как связи, которые вы хотите найти.

Простые шаблоны:

Начните с базовых шаблонов связей:

-- Find direct friendships
(p:Person)-[:knows]->(f:Person)

-- Find people working at any company
(p:Person)-[:workAt]->(c:Company)

-- Find cities in any country/region
(ci:City)-[:isPartOf]->(co:Country)

Шаблоны с определенными данными:

-- Find who works at Microsoft specifically
(p:Person)-[:workAt]->(c:Company)
WHERE p.firstName = 'Annemarie'

-- Find friends who are both young
(p:Person)-[:knows]->(f:Person)  
WHERE p.birthday > 19950101 AND f.birthday > 19950101

Выражения меток для гибкого выбора сущностей:

(:Person|Company)-[:isLocatedIn]->(p:City|Country)  -- OR with |
(:Place&City)                                       -- AND with &  
(:Person&!Company)                                  -- NOT with !

Замечание

Узлы могут иметь несколько меток, но пограничные типы с несколькими метками пока не поддерживаются.

Выражения меток позволяют сопоставлять различные типы узлов в одном шаблоне, что делает запросы более гибкими.

Повторное использование переменной создает мощные соединения:

-- Find coworkers: people who work at the same company
(c:Company)<-[:workAt]-(x:Person)-[:knows]-(y:Person)-[:workAt]->(c)

Повторное использование переменной c гарантирует, что оба человека работают в одной компании, создавая ограничение автоматического соединения. Этот шаблон является ключевым шаблоном для выражения связей "одной сущности".

Это важно

Критическое понимание. Повторное использование переменных в шаблонах создает структурные ограничения. Используйте этот метод для выражения сложных связей графа, таких как "друзья, которые работают в той же компании" или "люди в одном городе".

Фильтрация на уровне шаблона с помощью WHERE:

-- Filter during pattern matching (more efficient)
(p:Person WHERE p.birthday < 19940101)-[:workAt]->(c:Company WHERE c.id > 1000)

-- Filter edges during matching  
(p:Person)-[w:workAt WHERE w.workFrom >= 2000]->(c:Company)

Ограниченные шаблоны переменной длины:

(:Person)-[:knows]->{1,3}(:Person)  -- Friends up to 3 degrees away

Режимы пути для управления обходом:

Режимы пути определяют, как обработчик запросов обрабатывает повторяющиеся элементы во время обхода переменной длины:

Режим траектории	Описание
`WALK`	Разрешает повторяющиеся узлы и края. Нет ограничений на обход.
`TRAIL`	Не повторяющиеся края, но узлы могут повторяться. Это режим пути по умолчанию.
`SIMPLE`	Повторяющиеся узлы (кроме первого и последнего могут быть равными).
`ACYCLIC`	Не повторяющиеся узлы вообще, предотвращая любой цикл в пути.

Используйте TRAIL шаблоны для предотвращения циклов во время обхода графа, гарантируя, что каждый край просматривается по крайней мере один раз:

-- Find paths without visiting the same :knows edge twice
MATCH TRAIL (src:Person)-[:knows]->{1,4}(dst:Person)
WHERE src.firstName = 'Alice' AND dst.firstName = 'Bob'
RETURN count(*) AS num_connections

-- Find acyclic paths in social networks
MATCH TRAIL (p:Person)-[e:knows]->{,3}(celebrity:Person)
RETURN 
  p.firstName || ' ' || p.lastName AS person_name, 
  celebrity.firstName || ' ' || celebrity.lastName AS celebrity_name, 
  count(e) AS distance
LIMIT 1000

Используйте, ACYCLIC если необходимо гарантировать, что узел не посещается дважды:

-- Find paths where no person appears more than once
MATCH ACYCLIC (src:Person)-[:knows]->{1,4}(dst:Person)
WHERE src.firstName = 'Alice'
RETURN dst.firstName, dst.lastName
LIMIT 100

Привязка ребра переменной длины:

В шаблонах переменной длины пограничные переменные собирают разные сведения на основе контекста:

-- Edge variable 'e' binds to a single edge for each result row
MATCH (p:Person)-[e:knows]->(friend:Person)
RETURN p.firstName, e.creationDate, friend.firstName  -- e refers to one specific relationship
LIMIT 1000

-- Edge variable 'e' binds to a group list of all edges in the path
MATCH (p:Person)-[e:knows]->{2,4}(friend:Person)  
RETURN 
  p.firstName || ' ' || p.lastName AS person_name, 
  friend.firstName || ' ' || friend.lastName AS friend_name, 
  -- e is a list
  size(e) AS num_edges
LIMIT 1000

Это различие имеет решающее значение для правильного использования пограничных переменных.

Сложные шаблоны с несколькими связями:

MATCH (p:Person), (p)-[:workAt]->(c:Company), (p)-[:isLocatedIn]->(city:City)
RETURN p.firstName, p.lastName, c.name AS company_name, city.name AS city_name
LIMIT 1000

Этот шаблон находит людей вместе с рабочим местом и резиденцией, показывая, как один человек подключается к нескольким другим сущностям.

Изучение комплексного синтаксиса шаблонов и расширенных методов

Основные операторы

GQL предоставляет определенные типы инструкций, которые работают вместе для обработки данных графа пошаговые инструкции. Понимание этих инструкций важно для создания эффективных запросов.

заявление `MATCH`

Синтаксис

MATCH <graph pattern>, <graph pattern>, ... [ WHERE <predicate> ]

Оператор MATCH принимает входные данные и находит шаблоны графов. Он объединяет входные переменные с переменными шаблона и выводит все соответствующие сочетания.

Входные и выходные переменные:

-- Input: unit table (no columns, one row)
-- Pattern variables: p, c  
-- Output: table with (p, c) columns for each person-company match
MATCH (p:Person)-[:workAt]->(c:Company)

Фильтрация на уровне инструкций с помощью WHERE:

-- Filter pattern matches
MATCH (p:Person)-[:workAt]->(c:Company) WHERE p.lastName = c.name

Все совпадения можно отфильтровать с помощью .WHERE Этот подход позволяет избежать отдельной FILTER инструкции.

Присоединение с помощью входных переменных:

Если MATCH это не первая инструкция, она присоединяет входные данные с совпадениями шаблонов:

...
-- Input: table with 'targetCompany' column
-- Implicit join: targetCompany (equality join)
-- Output: table with (targetCompany, p, r) columns
MATCH (p:Person)-[r:workAt]->(targetCompany)

Это важно

Graph поддерживает базовую и полную линейную инструкцию (цепочку MATCH, LET, FILTERи RETURNдругие основные операторы). Задайте такие операции, как UNION DISTINCT, EXCEPTи INTERSECTOTHERWISEпока не поддерживаются. Дополнительные сведения см. в статье о текущих ограничениях.

Поведение соединения ключей:

Как MATCH обрабатывает присоединение данных:

Равенство переменных: входные переменные объединяются с переменными шаблона с помощью сопоставления равенства
Внутреннее соединение: входные строки без совпадений шаблонов удаляются. Используется OPTIONAL MATCH для поведения левого внешнего соединения.
Порядок фильтрации: фильтры уровня WHERE инструкций после завершения сопоставления шаблонов
Подключение к шаблону: несколько шаблонов должны совместно использовать по крайней мере одну переменную для надлежащего соединения.
Производительность. Общие переменные создают эффективные ограничения соединения

Это важно

Ограничение. Если эта MATCH инструкция не является первой, по крайней мере одна входная переменная должна присоединиться к переменной шаблона. Несколько шаблонов должны иметь одну переменную в общем.

Для нескольких шаблонов требуются общие переменные:

-- Shared variable 'p' joins the two patterns
-- Output: people with both workplace and residence data
MATCH (p:Person)-[:workAt]->(c:Company), 
      (p)-[:isLocatedIn]->(city:City)

заявление `OPTIONAL MATCH`

Синтаксис

OPTIONAL MATCH <graph pattern> [ WHERE <predicate> ]

OPTIONAL MATCH работает так, MATCH но использует семантику левого внешнего соединения. Если шаблон не находит совпадения для входной строки, запрос сохраняет строку со значениями NULL для несовпаденных переменных вместо отмены.

Example:

-- Find all people and, if available, their workplace
MATCH (p:Person)
OPTIONAL MATCH (p)-[:workAt]->(c:Company)
RETURN p.firstName, p.lastName, c.name AS company_name

Люди, которые не работают в какой-либо компании, по-прежнему появляются в результатах NULLcompany_nameдля .

Подсказка

Используйте OPTIONAL MATCH , если требуется включить сущности, которые могут не иметь определенной связи, аналогично SQL LEFT JOIN.

заявление `LET`

Синтаксис

LET <variable> = <expression>, <variable> = <expression>, ...

Оператор LET создает вычисляемые переменные и включает преобразование данных в конвейере запросов.

Базовое создание переменной:

MATCH (p:Person)
LET fullName = p.firstName || ' ' || p.lastName
RETURN *
LIMIT 1000

Сложные вычисления:

MATCH (p:Person)
LET adjustedAge = 2000 - (p.birthday / 10000),
    fullProfile = p.firstName || ' ' || p.lastName || ' (' || p.gender || ')'
RETURN *
LIMIT 1000

Ключевые действия:

Обработчик запросов вычисляет выражения для каждой входной строки.
Результаты становятся новыми столбцами в выходной таблице.
Переменные могут ссылаться только на существующие переменные из предыдущих инструкций.
Обработчик запросов вычисляет несколько назначений в одной LET инструкции параллельно (без перекрестных ссылок).

заявление `FILTER`

Синтаксис

FILTER [ WHERE ] <predicate>

Инструкция FILTER обеспечивает точный контроль над тем, какие данные передаются через конвейер запросов.

Базовая фильтрация:

MATCH (p:Person)
FILTER p.birthday < 19980101 AND p.gender = 'female'
RETURN *

Сложные логические условия:

MATCH (p:Person)
FILTER (p.gender = 'male' AND p.birthday < 19940101) 
  OR (p.gender = 'female' AND p.birthday < 19990101)
  OR p.browserUsed = 'Edge'
RETURN *

Шаблоны фильтрации с поддержкой NULL:

Используйте эти шаблоны для безопасной обработки значений NULL:

Проверка значений: p.firstName IS NOT NULL имеет имя
Проверка данных: p.id > 0 — допустимый идентификатор
Обработка отсутствующих данных: NOT coalesce(p.locationIP, '10.x.x.x') STARTS WITH '10.x.x.x' не подключались из локальной сети.
Объединение условий: использование AND/OR явных проверок NULL для сложной логики

Caution

Помните, что условия, включающие возвращаемые UNKNOWNзначения NULL, которые фильтруют эти строки. Используйте явные IS NULL проверки, когда требуется логика, включаемая в значение NULL.

заявление `ORDER BY`

Синтаксис

ORDER BY <expression> [ ASC | DESC ], <expression> [ ASC | DESC ], ...

Многоуровневая сортировка с вычисляемых выражений:

MATCH (p:Person)
RETURN *
ORDER BY p.firstName DESC,               -- Primary: by first name (Z-A)
         p.birthday ASC,                 -- Secondary: by age (oldest first)
         p.id DESC                       -- Tertiary: by ID (highest first)

Обработка NULL в сортировке:

ORDER BY coalesce(p.gender, 'not specified') DESC -- Treat NULL as 'not specified'

Сведения о поведении сортировки:

Общие сведения о работе ORDER BY :

Обработчик запросов вычисляет выражения для каждой строки, а затем результаты определяют порядок строк.
Несколько ключей сортировки создают иерархическое упорядочение (первичный, вторичный, третичный и т. д.).
NULL всегда является наименьшим значением в сравнениях.
ASC (возрастание) — это порядок по умолчанию, и необходимо явно указать DESC (убывание).
Вы можете сортировать по вычисляемым значениям, а не только по хранимым свойствам.

Caution

Только следующая инструкция может увидеть порядок сортировки, устанавливающий ORDER BY . Поэтому за ORDER BY ним RETURN * не производится упорядоченный результат.

Сравнивать:

MATCH (a:Person)-[r:knows]->(b:Person)
LET aName = a.firstName || ' ' || a.lastName
LET bName = b.firstName || ' ' || b.lastName
ORDER BY r.creationDate DESC
/* intermediary result _IS_ guaranteed to be ordered here */
RETURN aName, bName, r.creationDate AS since
/* final result _IS_ _NOT_ guaranteed to be ordered here  */

с:

MATCH (a:Person)-[r:knows]->(b:Person)
LET aName = a.firstName || ' ' || a.lastName
LET bName = b.firstName || ' ' || b.lastName
/* intermediary result _IS_ _NOT_ guaranteed to be ordered here */
RETURN aName, bName, r.creationDate AS since
ORDER BY r.creationDate DESC
/* final result _IS_ guaranteed to be ordered here              */

Это различие имеет немедленные последствия для запросов Top-k: LIMIT всегда следует следовать ORDER BY инструкции, которая устанавливает предполагаемый порядок сортировки.

Выражения `OFFSET` и `LIMIT`

Синтаксис

  OFFSET <offset> [ LIMIT <limit> ]
| LIMIT <limit>

Распространенные шаблоны:

-- Basic top-N query
MATCH (p:Person)
RETURN *
ORDER BY p.id DESC
LIMIT 10                                 -- Top 10 by ID

Это важно

Для прогнозируемых результатов разбиения на страницы всегда следует использовать ORDER BY до OFFSET и LIMIT обеспечить согласованное упорядочивание строк в запросах.

`RETURN`: базовая проекция результатов

Синтаксис

RETURN [ DISTINCT ] <expression> [ AS <alias> ], <expression> [ AS <alias> ], ...
[ ORDER BY <expression> [ ASC | DESC ], <expression> [ ASC | DESC ], ... ]
[ OFFSET <offset> ]
[ LIMIT <limit> ]

Оператор RETURN создает окончательные выходные данные запроса, указав, какие данные отображаются в таблице результатов.

Базовые выходные данные:

MATCH (p:Person)-[:workAt]->(c:Company)
RETURN p.firstName || ' ' || p.lastName AS name, 
       p.birthday, 
       c.name

Использование псевдонимов для ясности:

MATCH (p:Person)-[:workAt]->(c:Company)
RETURN p.firstName AS first_name, 
       p.lastName AS last_name,
       c.name AS company_name

Объединение с сортировкой и top-k:

MATCH (p:Person)-[:workAt]->(c:Company)
RETURN p.firstName || ' ' || p.lastName AS name, 
       p.birthday AS birth_year, 
       c.name AS company
ORDER BY birth_year ASC
LIMIT 10

Обработка повторяющихся данных с помощью DISTINCT:

-- Remove duplicate combinations
MATCH (p:Person)-[:workAt]->(c:Company)
RETURN DISTINCT p.gender, p.browserUsed, p.birthday AS birth_year
ORDER BY p.gender, p.browserUsed, birth_year

Объединение с агрегированием:

MATCH (p:Person)-[:workAt]->(c:Company)
RETURN count(DISTINCT p) AS employee_count

`RETURN` с `GROUP BY`: сгруппированная проекция результатов

Синтаксис

RETURN [ DISTINCT ] <expression> [ AS <alias> ], <expression> [ AS <alias> ], ...
GROUP BY <variable>, <variable>, ...
[ ORDER BY <expression> [ ASC | DESC ], <expression> [ ASC | DESC ], ... ]
[ OFFSET <offset> ]
[ LIMIT <limit> ]

Используется GROUP BY для группировки строк по общим значениям и вычислительным агрегатным функциям в каждой группе.

Базовая группировка с агрегированием:

MATCH (p:Person)-[:workAt]->(c:Company)
LET companyName = c.name
RETURN companyName, 
       count(*) AS employeeCount,
       avg(p.birthday) AS avg_birth_year
GROUP BY companyName
ORDER BY employeeCount DESC

Группирование нескольких столбцов:

MATCH (p:Person)
LET gender = p.gender
LET browser = p.browserUsed
RETURN gender,
       browser,
       count(*) AS person_count,
       avg(p.birthday) AS avg_birth_year,
       min(p.creationDate) AS first_joined,
       max(p.id) AS highest_id
GROUP BY gender, browser
ORDER BY avg_birth_year DESC
LIMIT 10

Замечание

Дополнительные методы агрегирования, включая горизонтальное агрегирование по шаблонам переменной длины, см. в разделе "Дополнительные методы агрегирования".

Типы данных: работа со значениями

GQL поддерживает расширенные типы данных для хранения и управления различными типами информации в графе.

Базовые типы значений

Числа: INT64, UINT64FLOAT64 (также называемыйDOUBLE) для вычислений и измерений
Текст: STRING для имен, описаний и текстовых данных
Логика: BOOL с тремя значениями: TRUE, FALSE и UNKNOWN (для обработки null)
Время: ZONED DATETIME метки времени с сведениями о часовом поясе
Коллекции: LIST<T> для нескольких значений одного типа T, PATH для результатов обхода графов
Элементы графа: NODE и EDGE для ссылок на данные графа

Это важно

Не удается использовать определенные типы значений в качестве типов значений свойств. В частности, нельзя использовать какие-либо значения, связанные со ссылочными значениями элементов графа в качестве значений свойств (например, списков узлов или путей).

Примеры литералы

42                                     -- Integer literal
"Hello, graph!"                        -- String  literal
TRUE                                   -- Boolean literal
ZONED_DATETIME('2024-01-15T10:30:00Z') -- DateTime with timezone literakl
[1, 2, 3]                              -- Literal list of integers

Критически важные шаблоны обработки null

-- Equality predicates with NULL always returns UNKNOWN
5 = NULL                              -- Evaluates to UNKNOWN (not FALSE!)
NULL = NULL                           -- Evaluates to UNKNOWN (not TRUE!)

-- Use IS NULL predicates for explicit null testing
p.nickname IS NULL                    -- Evaluates to TRUE if nickname is null
p.nickname IS NOT NULL                -- Evaluates to TRUE if nickname has a value

-- Use the COALESCE function for null-safe value selection
coalesce(p.nickname, p.firstName, '???')  -- Evaluates to first non-null value

Трехзначные последствия логики

-- In FILTER statements, only TRUE values pass through
FILTER p.birthday > 0        -- Removes rows where birthday is null or missing or zero

-- It's important to understand that NOT UNKNOWN = UNKNOWN
FILTER NOT (p.birthday > 0)  -- Removes rows where birthday is null or missing or positive

-- Use explicit null handling for inclusive filtering
FILTER p.birthday < 19980101 OR p.birthday IS NULL -- Includes null birthdays

Caution

Трехзначная логика означает NULL = NULL возврат UNKNOWN, а не TRUE. Это поведение влияет на фильтрацию и соединения. Всегда используется IS NULL для пустых тестов.

Подробные сведения о системе типов

Выражения: преобразование и анализ данных

Выражения позволяют вычислять, сравнивать и преобразовывать данные в запросах. Они похожи на выражения в SQL, но имеют дополнительные функции для обработки данных графа.

Распространенные типы выражений

p.birthday < 19980101   -- Birth year comparison  
p.firstName || ' ' || p.lastName               -- String concatenation
count(*)                                       -- Aggregation
p.firstName IN ['Alice', 'Bob']                -- List membership
coalesce(p.firstName, p.lastName)              -- Null handling

Сложная композиция предиката

-- Combine conditions with proper precedence
FILTER (p.birthday > 19560101 AND p.birthday < 20061231) 
  AND ((p.gender IN ['male', 'female']) OR (p.browserUsed IS NOT NULL))

-- Use parentheses for clarity and correctness
FILTER p.gender = 'female' AND (p.firstName STARTS WITH 'A' OR p.id > 1000)

Сопоставление шаблонов строк

-- Pattern matching with different operators
p.locationIP CONTAINS '192.168'      -- Substring search
p.firstName STARTS WITH 'John'       -- Prefix matching  
p.lastName ENDS WITH 'son'           -- Suffix matching

-- Case-insensitive operations
upper(p.firstName) = 'ALICE'         -- Convert to uppercase for comparison

Встроенные функции по категориям

GQL предоставляет следующие категории функций для различных потребностей в обработке данных:

Статистические функции: count(), , sum()avg()min(), max() для суммирования данных

Условные выражения: CASE/WHEN/THEN/ELSE/END и NULLIF() для условной логики. Рассмотрим пример.

MATCH (p:Person)
RETURN p.firstName,
  CASE WHEN p.birthday < 20000101 THEN 'Before 2000' ELSE '2000 or later' END AS era,
  NULLIF(p.gender, 'unknown') AS gender

Строковые функции: char_length(), upper(), lower()trim()для обработки текста (US ASCII только для сопоставления регистра)
Функции графа: nodes(), , edges()elements()labels()path_length() для анализа структур графа
Общие функции: coalesce()для to_json_string() обработки значений NULL и сериализации

Приоритет оператора для сложных выражений

Доступ к свойствам (.)
Умножение и деление (*, /)
Сложение и вычитание (+, -)
Сравнение (=, , <><, >, <=) >=
Логическое отрицание (NOT)
Логическое сочетание (AND)
Логическая эксклюзивная дисъюнкция (XOR)
Логическое дисъюнкция (OR)

В приведенном выше списке оператор с меньшим числом "привязывается жестко", чем оператор с более высоким числом. Например, это NOT n.prop OR m.prop не так (NOT n.prop) OR m.propNOT (n.prop OR m.prop).

Подсказка

Используйте скобки для явного приоритета. Сложные выражения проще читать и отлаживать при очистке группировки.

Изучение полного синтаксиса выражений и всех встроенных функций

Расширенные методы запросов

В этом разделе рассматриваются сложные шаблоны и методы создания сложных, эффективных запросов графа. Эти шаблоны выходят за рамки базового использования инструкций, помогая создавать мощные аналитические запросы.

Сложная состав многостатии

Это важно

Graph поддерживает базовую и полную линейную композицию инструкций. Задайте такие операции, как UNION DISTINCT, EXCEPTи INTERSECTOTHERWISEпока не поддерживаются. Дополнительные сведения см. в статье о текущих ограничениях.

Понимание эффективного создания сложных запросов имеет решающее значение для расширенного запроса графа.

`UNION ALL`

Используется UNION ALL для объединения результатов из двух или нескольких блоков линейных запросов:

-- Combine results from two separate pattern matches
MATCH (p:Person)-[:workAt]->(c:Company)
RETURN p.firstName AS name, c.name AS affiliation
UNION ALL
MATCH (p:Person)-[:studyAt]->(u:University)
RETURN p.firstName AS name, u.name AS affiliation

UNION ALL сохраняет все строки, включая дубликаты. UNION DISTINCT (которое удаляет дубликаты) пока не поддерживается.

Прогрессирование шаблонов с несколькими шагами

Цепочка нескольких операторов для постепенного построения сложного анализа:

-- Build complex analysis step by step
MATCH (company:Company)<-[:workAt]-(employee:Person)
LET companyName = company.name
MATCH (employee)-[:isLocatedIn]->(city:City)
FILTER employee.birthday < 19850101
LET cityName = city.name
RETURN companyName, cityName, avg(employee.birthday) AS avgBirthday, count(employee) AS employeeCount
GROUP BY companyName, cityName
ORDER BY avgBirthday DESC

Этот запрос постепенно усложняет: найти компании, их сотрудников, местоположения сотрудников, фильтровать компании по сотрудникам, родившимся до 1985 года, рассчитать средний день рождения, а также суммировать и отсортировать результаты.

Использование горизонтальной агрегирования

Горизонтальные агрегаты агрегируются по шаблонам переменной длины в одной строке:

-- Find people and their minimum distance to people working at Microsoft
MATCH TRAIL (p:Person)-[e:knows]->{,5}(:Person)-[:workAt]->(:Company { name: 'Microsoft'})
LET p_name = p.lastName || ', ' || p.firstName
RETURN p_name, min(count(e)) AS minDistance 
GROUP BY p_name
ORDER BY minDistance DESC

Замечание

Этот запрос пока не поддерживается (известная проблема).

Область переменных и расширенный элемент управления потоками

Переменные подключают данные между операторами запросов и обеспечивают сложные обходы графов. Общие сведения о правилах расширенной области помогают создавать сложные запросы с несколькими операторами.

Привязка переменных и шаблоны области

-- Variables flow forward through subsequent statements 
MATCH (p:Person)                                    -- Bind p 
LET fullName = p.firstName || ' ' || p.lastName     -- Bind concatenation of p.firstName and p.lastName as fullNume
FILTER fullName CONTAINS 'Smith'                    -- Filter for fullNames with “Smith” substring (p is still bound)
RETURN p.id, fullName                               -- Only return p.id and fullName (p is dropped from scope)

Повторное использование переменной для соединений между операторами

-- Multi-statement joins using variable reuse
MATCH (p:Person)-[:workAt]->(:Company)          -- Find people with jobs
MATCH (p)-[:isLocatedIn]->(:City)               -- Same p: people with both job and residence
MATCH (p)-[:knows]->(friend:Person)             -- Same p: their social connections
RETURN *

Критически важные правила и ограничения области

-- ✅ Backward references work
MATCH (p:Person)
LET adult = p.birthday < 20061231  -- Can reference p from previous statement
RETURN *

-- ❌ Forward references don't work  
LET adult = p.birthday < 20061231  -- Error: p not yet defined
MATCH (p:Person)
RETURN *

-- ❌ Variables in same LET statement can't reference each other
MATCH (p:Person)
LET name = p.firstName || ' ' || p.lastName,
    greeting = 'Hello, ' || name     -- Error: name not visible yet
RETURN *

-- ✅ Use separate statements for dependent variables
MATCH (p:Person)
LET name = p.firstName || ' ' || p.lastName
LET greeting = 'Hello, ' || name     -- Works: name now available
RETURN *

Видимость переменных в сложных запросах

-- Variables remain visible until overridden or query ends
MATCH (p:Person)                     -- p available from here
LET gender = p.gender                -- gender available from here  
MATCH (p)-[:knows]->(e:Person)       -- p still refers to original person
                                     -- e is new variable for managed employee
RETURN p.firstName AS manager, e.firstName AS friend, gender

Caution

Переменные в одной инструкции не могут ссылаться друг на друга, за исключением шаблонов графов. Используйте отдельные инструкции для создания зависимых переменных.

Расширенные методы агрегирования

GQL поддерживает два разных типа агрегирования для анализа данных между группами и коллекциями: вертикальное агрегирование с GROUP BY использованием и горизонтальной агрегированием по шаблонам переменной длины.

Вертикальное агрегирование с помощью GROUP BY

Вертикальная агрегирование (покрываемая RETURNGROUP BY) группирует строки по общим значениям и вычисляет агрегаты в каждой группе:

MATCH (p:Person)-[:workAt]->(c:Company)
RETURN c.name AS companyName, 
       count(*) AS employee_count, 
       avg(p.birthday) AS avg_birth_year
GROUP BY companyName

Этот подход создает одну строку результатов для каждой компании, агрегируя всех сотрудников в каждой группе.

Горизонтальное агрегирование с переменными списка групп

Горизонтальное агрегирование вычисляет агрегаты по коллекциям, привязанным шаблонами переменной длины. При использовании ребер переменной длины переменная становится переменной списка групп , которая содержит все края в каждом сопоставленном пути:

-- Group list variable 'edges' enables horizontal aggregation
MATCH (p:Person)-[edges:knows]->{2,4}(friend:Person)
RETURN p.firstName || ' ' || p.lastName AS person_name, 
       friend.firstName || ' ' || friend.lastName AS friend_name,
       size(edges) AS degrees_of_separation,
       avg(edges.creationDate) AS avg_connection_age,
       min(edges.creationDate) AS oldest_connection

Замечание

Этот запрос пока не поддерживается (известная проблема).

Основные различия между вертикальной и горизонтальной агрегированием:

Вертикальное агрегирование суммирует строки или группы строк и суммирует между строками в каждой группе.
Горизонтальное агрегирование суммирует элементы в отдельных пограничных коллекциях.
Переменные списка групп приходят только из шаблонов ребер переменной длины.

Контексты привязки границ переменной длины

Понимание привязки пограничных переменных в шаблонах переменной длины имеет решающее значение:

Во время сопоставления шаблонов (одноэлементный контекст):

-- Edge variable 'e' refers to each individual edge during filtering
MATCH (p:Person)-[e:knows WHERE e.creationDate > zoned_datetime('2000-01-01T00:00:00Z')]->{2,4}(friend:Person)
-- 'e' is evaluated for each edge in the path during matching
RETURN *

В выражениях результатов (контекст группы):

-- Edge variable 'edges' becomes a list of all qualifying edges
MATCH (p:Person)-[e:knows]->{2,4}(friend:Person)
RETURN size(e) AS num_edges,                    -- Number of edges in path
       e[0].creationDate AS first_edge,         -- First edge in path
       avg(e.creationDate) AS avg_age           -- Horizontal aggregation

Замечание

Этот запрос пока не поддерживается (известная проблема).

Объединение вертикальной и горизонтальной агрегирования

Оба типа агрегирования можно объединить в сложных шаблонах анализа:

Замечание

Этот запрос пока не поддерживается (известная проблема).

-- Find average connection age by city pairs
MATCH (p1:Person)-[:isLocatedIn]->(c1:City)
MATCH (p2:Person)-[:isLocatedIn]->(c2:City)
MATCH (p1)-[e:knows]->{1,3}(p2)
RETURN c1.name AS city1,
       c2.name AS city2,
       count(*) AS connection_paths,                  -- Vertical: count paths per city pair
       avg(size(e)) AS avg_degrees,                   -- Horizontal then vertical: path lengths
       avg(avg(e.creationDate)) AS avg_connection_age -- Horizontal then vertical: connection ages
GROUP BY city1, city2

Подсказка

Горизонтальное агрегирование всегда имеет приоритет над вертикальной агрегированием. Чтобы преобразовать список групп в обычный список, используйте collect_list(edges).

Замечание

Подробные справочные материалы по агрегатной функции см. в разделе "Выражения и функции GQL".

Стратегии обработки ошибок

Общие сведения о шаблонах ошибок помогают создавать надежные запросы.

Обработка отсутствующих данных корректно:

MATCH (p:Person)
-- Use COALESCE for missing properties
LET displayName = coalesce(p.firstName, p.lastName, 'Unknown')
LET contact = coalesce(p.locationIP, p.browserUsed, 'No info')
RETURN *

Используйте явные проверки NULL:

MATCH (p:Person)
-- Be explicit about null handling
FILTER p.id IS NOT NULL AND p.id > 0
-- Instead of just: FILTER p.id > 0
RETURN *

Дополнительные сведения

Коды GQLSTATUS

Как описано в разделе о результатах запроса, GQL сообщает подробные сведения о состоянии, связанные с успешной или потенциальной ошибкой выполнения. Дополнительные сведения см. в справочнике по кодам состояния GQL для полного списка.

Зарезервированные слова

GQL резервирует определенные ключевые слова, которые нельзя использовать в качестве идентификаторов, таких как переменные, имена свойств или имена меток. См. справочник по зарезервированным словам GQL для полного списка.

Если вам нужно использовать зарезервированные слова в качестве идентификаторов, побежите их с помощью обратных выражений: `match`, . `return`

Чтобы избежать экранирования зарезервированных слов, используйте это соглашение об именовании:

Для идентификаторов с одним словом добавьте символ подчеркивания: :Product_
Для идентификаторов с несколькими словами используйте верблюдьи регистр или PascalCase: :MyEntity, :hasAttributetextColor

Дальнейшие шаги

Теперь, когда вы понимаете основы GQL, вот ваш рекомендуемый путь обучения:

Продолжить создание навыков GQL

Для начинающих:

Ознакомьтесь с кратким руководством . Следуйте практическим руководствам и учебникам , чтобы получить практический опыт
Базовые запросы. Примеры из этого руководства с собственными данными
Изучение шаблонов графов . Изучение комплексного синтаксиса шаблонов
Изучение типов данных. Общие сведенияо значениях и типах значений GQL

Для опытных пользователей:

Расширенные выражения — изучение выражений и функций GQL
Проектирование схемы — сведения о типах и ограничениях графов GQL
Изучение типов данных. Общие сведенияо значениях и типах значений GQL

Справочные материалы

Следите за этими ссылками для быстрого поиска:

Краткий справочник по GQL — краткий справочник по синтаксису
Коды состояния GQL — полный справочник по коду ошибки
Зарезервированные слова GQL — полный список зарезервированных ключевых слов

Изучение графа

Узнайте о платформе:

Модели данных Графа . Общие сведения о концепциях графа и моделировании
Граф и реляционные базы данных — выбор правильного подхода
Try Microsoft Fabric бесплатно — практический опыт
Комплексные учебники. Завершение сценариев обучения

Сообщество

Предоставление общего доступа к отзыву . Справка по улучшению документации и средств
Присоединение сообщества — подключение к другим специалистам по базам данных graph
Оставайтесь обновленными . Следуйте объявлениям графа для новых функций

Подсказка

Начните с руководства по краткому руководству , если вы предпочитаете учиться, используя шаблоны графов , если вы хотите сначала узнать язык запросов.

Практическое руководство.

Написание распространенных запросов GQL — практические шаблоны запросов для соседей, многохоповых, общих подключений и многое другое.
Фильтрация и агрегирование данных графа — FILTER, WHERE, GROUP BY и агрегатных функций.
Написание запросов шаблонов графа — обход с несколькими прыжками, режимы пути, повторное использование переменных и необязательное сопоставление.
Оптимизация производительности запросов GQL — рекомендации по написанию эффективных запросов GQL.

Дополнительные сведения о ключевых разделах:

Пример схемы социальной сети — полный рабочий пример схемы графа.
Шаблоны графов GQL — комплексный синтаксис шаблонов и расширенные методы сопоставления.
Выражения и функции GQL — все типы выражений и встроенные функции.
Типы графов GQL — типы и ограничения графов.
Значения и типы значений GQL — обработка системных ссылок и значений полного типа.

Краткие ссылки:

Ссылка на GQL abridged — краткий справочник по синтаксису .
Коды состояния GQL — полный справочник по коду ошибки.
Зарезервированные слова GQL — полный список зарезервированных ключевых слов.

График:

модели данных графа — общие сведения о концепциях графа и моделировании.
граф и реляционные базы данных — различия и когда следует использовать каждый из них.
Try Microsoft Fabric бесплатно.
учебники End-to-end в Microsoft Fabric.

Обратная связь

Были ли сведения на этой странице полезными?

Last updated on 2026-04-27

Руководство по языку GQL для графа в Microsoft Fabric

Предпосылки

Что делает GQL особенным

Основы GQL

Общие сведения о данных графа

Узлы и края: стандартные блоки

Структура графов

Модели графа и типы графов

Практический пример: социальная сеть

Сущности социальной сети

Как все подключается

Первые запросы GQL

Начните просто: найти всех людей

Добавление фильтрации: поиск определенных пользователей

Базовая структура запросов

Распространённые утверждения

Совместная работа инструкций

Пример композиции инструкций

Переменные подключают данные

Результаты выполнения и результаты

Таблицы результатов

Сведения о состоянии

Основные понятия и инструкции

Шаблоны графа: поиск структуры

Основные операторы

заявление MATCH

заявление OPTIONAL MATCH

заявление LET

заявление FILTER

заявление ORDER BY

Выражения OFFSET и LIMIT

RETURN: базовая проекция результатов

RETURN с GROUP BY: сгруппированная проекция результатов

Типы данных: работа со значениями

Базовые типы значений

Примеры литералы

Критически важные шаблоны обработки null

Трехзначные последствия логики

Выражения: преобразование и анализ данных

Распространенные типы выражений

Сложная композиция предиката

Сопоставление шаблонов строк

Встроенные функции по категориям

Приоритет оператора для сложных выражений

Расширенные методы запросов

Сложная состав многостатии

UNION ALL

Прогрессирование шаблонов с несколькими шагами

Использование горизонтальной агрегирования

Область переменных и расширенный элемент управления потоками

Привязка переменных и шаблоны области

Повторное использование переменной для соединений между операторами

Критически важные правила и ограничения области

Видимость переменных в сложных запросах

Расширенные методы агрегирования

Вертикальное агрегирование с помощью GROUP BY

Горизонтальное агрегирование с переменными списка групп

Контексты привязки границ переменной длины

Объединение вертикальной и горизонтальной агрегирования

Стратегии обработки ошибок

Дополнительные сведения

Коды GQLSTATUS

Зарезервированные слова

Дальнейшие шаги

Продолжить создание навыков GQL

Справочные материалы

Изучение графа

Сообщество

Связанный контент

Обратная связь

Дополнительные ресурсы

заявление `MATCH`

заявление `OPTIONAL MATCH`

заявление `LET`

заявление `FILTER`

заявление `ORDER BY`

Выражения `OFFSET` и `LIMIT`

`RETURN`: базовая проекция результатов

`RETURN` с `GROUP BY`: сгруппированная проекция результатов

`UNION ALL`