GQL 언어 가이드

비고

이 기능은 현재 공개 미리 보기로 제공됩니다. 이 미리 보기는 서비스 수준 계약 없이 제공되며 프로덕션 워크로드에는 사용하지 않는 것이 좋습니다. 특정 기능이 지원되지 않거나 기능이 제한될 수 있습니다. 자세한 내용은 Microsoft Azure Preview에 대한 추가 사용 약관을 참조하세요.

GQL 그래프 쿼리 언어는 그래프 데이터베이스에 대한 ISO 표준화된 쿼리 언어입니다. 그래프 데이터를 효율적으로 쿼리하고 작업하는 데 도움이 됩니다.

GQL은 SQL을 표준화하는 동일한 ISO 작업 그룹에서 개발하여 일관성과 엄격성을 보장합니다. SQL에 익숙하다면 GQL과 많은 유사점(식, 술어, 타입)을 발견할 수 있어 시작하는 데 더 쉽습니다. 이 가이드는 GQL 기본 사항을 배우는 신규 이민자와 고급 기술과 포괄적인 참조 정보를 찾는 숙련된 사용자를 모두 제공합니다.

비고

GQL의 공식 국제 표준은 ISO/IEC 39075 정보 기술 - 데이터베이스 언어 - GQL입니다.

필수 조건

GQL을 살펴보기 전에 다음 개념을 잘 알고 있어야 합니다.

• 데이터베이스에 대한 기본 이해 - 관계형(SQL), NoSQL, 그래프 등 어떤 데이터베이스 시스템이든 경험이 있으면 도움이 됩니다
• 그래프 개념 - 연결된 데이터의 노드, 에지 및 관계 이해
• 쿼리 기본 사항 - 필터링, 정렬 및 집계와 같은 기본 쿼리 개념에 대한 지식

권장되는 배경:

• SQL이나 openCypher 언어 경험은 GQL 문법을 배우는 데 도움이 됩니다(GQL의 뿌리입니다).
• 데이터 모델링에 대한 친숙함은 그래프 스키마 디자인에 도움이 됩니다.
• 그래프 데이터에 대한 특정 사용 사례 이해

필요한 항목:

• 그래프 기능을 사용하여 Microsoft Fabric에 액세스
• 샘플 데이터 또는 소셜 네트워크 예제를 사용하려는 의지
• 쿼리 작성을 위한 기본 텍스트 편집기

팁 (조언)

그래프 데이터베이스를 접하는 경우 이 가이드를 계속 진행하기 전에 그래프 데이터 모델 개요 부터 시작합니다.

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의 기초를 형성하는 이러한 핵심 개념을 이해합니다.

• 그래프는 데이터를 노드(엔티티)와 간선(관계)으로 저장하며, 각각 라벨과 속성을 가집니다
• 그래프 형식 은 스키마처럼 작동하여 그래프에 존재할 수 있는 노드와 에지를 정의합니다.
• 제약 조건은 그래프 유형이 그래프에 부과하여 데이터 무결성을 강제하기 위해 부과하는 추가 규칙과 제한입니다
• 쿼리는 < a0/>와 같은 문을 사용하고 데이터를 처리하고 결과를 표시합니다.
• 패턴은 직관적인 시각적 구문을 사용하여 찾으려는 그래프 구조를 설명합니다.
• 식은 SQL 식과 유사하게 데이터에 대한 계산 및 비교를 수행합니다.
• 술어 는 쿼리 내에서 결과를 필터링하는 데 사용되는 불리언 값 표현식입니다
• 값 형식 은 처리하고 저장할 수 있는 값의 종류를 정의합니다.

그래프 데이터 이해

GQL을 효과적으로 사용하려면 그래프 데이터가 어떻게 구성되는지 이해해야 합니다. 이 기반을 통해 더 나은 쿼리를 작성하고 데이터를 효과적으로 모델링할 수 있습니다.

노드 및 가장자리: 구성 요소

GQL에서는 레이블이 지정된 속성 그래프를 사용합니다. 그래프는 다음 두 가지 유형의 요소로 구성됩니다.

노드는 일반적으로 사용자, 조직, 게시물 또는 제품과 같은 시스템의 엔터티("명사")를 나타냅니다. 도메인에 있는 독립적인 개체입니다. 노드를 꼭짓점이라고도 합니다.

에지는 엔터티 간의 관계("동사")를 나타내며, 엔터티가 연결되고 상호 작용하는 방식입니다. 예를 들어, 사람들이 서로 알고 있고(:knows), 특정 지역에서 활동하는 조직(:operates), 또는 제품을 구매한 고객(:purchased).
에지는 관계라고도 합니다.

모든 그래프 요소에는 다음과 같은 특징이 있습니다.

• 고유하게 식별하는 내부 ID
• 하나 이상의 레이블(예: Person 또는 knows.)을 설명하는 이름입니다. Microsoft Fabric에서는 그래프 간선이 항상 정확히 하나의 라벨을 가집니다.
• 속성—요소에 대한 데이터를 저장하는 이름-값 쌍(예: firstName: "Alice"birthday: "19730108"또는 ).

그래프의 구조화 방법

각 에지는 정확히 두 개의 노드( 원본 및 대상)를 연결합니다. 이 연결은 그래프의 구조를 만들고 엔터티가 서로 어떻게 관련되는지 보여줍니다. 가장자리의 방향이 중요 Person 합니다. 즉, 다른 follows 사람이 지시된 관계를 만드는 사람 Person 입니다.

비고

Microsoft Fabric의 그래프는 현재 방향성 없는 간선을 지원하지 않습니다.

Microsoft Fabric에서 지원하는 속성 그래프는 항상 잘 형성되어 있어 모든 간선이 두 개의 유효한 노드를 연결합니다. 그래프에 가장자리가 표시되면 두 엔드포인트가 동일한 그래프에 존재합니다.

그래프 모델 및 그래프 형식

Microsoft Fabric의 그래프 구조는 애플리케이션 도메인에 대한 데이터베이스 스키마처럼 작동되는 그래프 모델에 의해 설명됩니다. 그래프 모델은 다음을 정의합니다.

• 존재할 수 있는 노드 및 에지
• 가질 수 있는 레이블 및 속성
• 노드와 에지가 연결할 수 있는 방법

또한 그래프 모델은 제약 조건, 특히 각 노드를 고유하게 식별하는 속성을 지정하는 노드 키 제약 조건을 통해 데이터 무결성을 보장합니다.

비고

그래프 모델은 GQL 표준 구문을 사용하여 지정할 수 있으며, 이 경우 그래프 형식이라고 합니다.

실제 예: 소셜 네트워크

이 설명서 전체에서 소셜 네트워크 예제를 사용하여 GQL 개념을 설명합니다. 이 도메인을 이해하면 예제를 따르고 사용자 고유의 데이터에 유사한 패턴을 적용할 수 있습니다.

비고

소셜 네트워크는 GDC(그래프 데이터 위원회)가 게시한 LDBC SNB(LDBC 소셜 네트워크 벤치마크)에서 파생된 예제입니다. 자세한 내용은 "LDBC 소셜 네트워크 벤치마크" 문서를 참조하세요.

소셜 네트워크 엔터티

소셜 네트워크에는 도메인의 엔터티를 나타내는 다음과 같은 주요 종류의 노드가 포함됩니다.

사람들은 이름, 생일 및 성별과 같은 개인 정보를 가지고 있습니다. 그들은 도시에 살고 사회적 연결을 형성한다.

위치는 지리적 계층 구조를 형성합니다.

• "뉴욕" 또는 "런던"와 같은 도시
• "미국" 또는 "영국"와 같은 국가/지역
• "북아메리카" 또는 "유럽"과 같은 대륙

사람들이 시간을 보내는 조직:

• 사람들이 공부하는 대학
• 사람들이 일하는 회사

콘텐츠 및 토론:

• 게시물이 포함된 제목이 있는 포럼
• 콘텐츠, 언어 및 선택적 이미지가 있는 게시물
• 게시물 또는 기타 댓글에 회신하는 댓글
• 콘텐츠를 분류하고 관심사를 나타내는 태그

모든 항목이 연결되는 방법

엔터티 간의 연결은 네트워크를 흥미롭게 만듭니다.

• 사람들은 서로를 알고 있습니다 (우정, :knows)
• 사람들은 기업에서 일하거나 대학:workAt에서 공부합니다(:studyAt)
• 사람들은 게시물과 댓글을 작성합니다 (:hasCreator)
• 사람들이 게시물과 댓글에 좋아요를 눌러요 (:likes)
• 게시물, 포럼, 댓글에는 태그가 있을 수 있습니다 (:hasTag)
• 사람들은 특정 태그에 관심이 있습니다 (:hasInterest)
• 포럼에는 게시물():containerOf이 있으며, 회원(:hasMember)과 운영진()이 있습니다.:hasModerator

그래프 가장자리는 도메인 관계를 나타냅니다. 이 풍부한 네트워크는 흥미로운 쿼리 및 분석을 위한 많은 기회를 만듭니다.

전체 스키마 사양 보기

첫 번째 GQL 쿼리

그래프 기본 사항을 이해했으므로 이제 GQL을 사용하여 그래프 데이터를 쿼리하는 방법을 살펴보겠습니다. 이러한 예제는 GQL의 접근 방식을 통해 그래프 쿼리를 직관적이고 강력하게 만드는 방법을 보여 줍니다.

간단한 시작: 모든 사용자 찾기

가장 기본적인 쿼리부터 시작해 그래프 내 모든 사람들:Person의 이름(이름, 성)을 찾아봅시다.

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

이 쿼리는 다음과 같이 실행됩니다:

1. MATCH 레이블이 지정된 모든 노드를 찾습니다. Person
2. RETURN 이름과 성을 표시합니다.

필터링 추가: 특정 사용자 찾기

이제 특정한 특징을 가진 사람들을 찾아봅시다. 이 경우에는 모두 앨리스라는 이름을 가지고 이름과 생일을 보여주죠.

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

이 쿼리는 다음과 같이 실행됩니다:

1. MATCH Person으로 표시된 모든 노드 (p)를 찾습니다
2. FILTER 이름이 앨리스인 노드들(p)
3. RETURN 이름, 성, 생일을 표시한다

기본 쿼리 구조

기본 GQL 쿼리는 모두 일관된 패턴을 따릅니다. 데이터를 찾고, 필터링하고, 반환하기 위해 함께 작동하는 문 시퀀스입니다. 대부분의 쿼리는 그래프에서 패턴을 찾기 위해 시작 MATCH 해 출력을 지정하는 것으로 끝납니다 RETURN .

서로 알고 생일이 같은 사람들 쌍을 찾아 그 친구 쌍의 총 수를 반환하는 간단한 쿼리가 있습니다.

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

이 쿼리는 다음과 같이 실행됩니다:

1. MATCH 는 서로를 알고 있는 모든 노드 쌍 Person 을 찾습니다.
2. FILTER 는 두 사람이 같은 생일을 가진 쌍만 유지합니다.
3. RETURN 는 이러한 친구 쌍의 수를 계산합니다.

팁 (조언)

절을 추가하여 패턴의 일부로 직접 필터링을 수행할 수도 있습니다 WHERE . 예를 들어 MATCH (n:Person WHERE n.age > 23) 속성이 23보다 큰 노드 Person 만 일치 age 합니다.

비고

GQL은 C 스타일 // 줄 주석, SQL 스타일 -- 줄 주석 및 C 스타일 /* */ 블록 주석을 지원합니다.

일반적인 표현

• MATCH: 탐색할 그래프 패턴을 식별하며, 여기서 관심 있는 데이터의 구조를 정의합니다.
• LET: 매칭된 데이터를 기반으로 새로운 변수를 할당하거나 계산된 값을 할당하며, 결과에 파생 열을 추가합니다.
• FILTER조건을 적용하여 결과를 좁히며—기준에 부합하지 않는 행을 제거합니다.
• ORDER BY: 필터링된 데이터를 정렬하며, 하나 이상의 필드를 기반으로 출력을 정리하는 데 도움을 줍니다.
• OFFSET 그리고 LIMIT: 반환되는 행 수를 제한하여 페이지 지정이나 상위 k 쿼리에 유용합니다.
• RETURN: 최종 출력을 지정하며, 결과 집합에 포함해야 할 데이터를 정의하고 집계를 수행합니다.

문이 함께 작동하는 방법

GQL 문장은 파이프라인을 형성하며, 각 문장은 이전 문장의 출력을 처리합니다. 이 순차적 실행 덕분에 실행 순서가 읽기 순서와 일치하기 때문에 쿼리를 읽고 디버깅하기 쉽습니다.

주요 정보:

• 문장은 효과적으로 순차적으로 실행됩니다.
• 각 문장은 데이터를 변환하여 다음 문장으로 전달합니다.
• 이로 인해 복잡한 쿼리를 단순화하는 명확하고 예측 가능한 데이터 흐름이 생성됩니다.

중요합니다

내부적으로는 명령문 실행 순서를 재조정할 수 있고, 개별 명령문을 Microsoft Fabric에서 병렬로 실행하여 성능을 극대화할 수 있습니다. 하지만 이것이 결과의 정확성에는 영향을 미치지 않습니다.

예시

다음 GQL 쿼리는 이름에 "Air"가 포함된 회사에서 근무하는 첫 10명을 찾아 전체 이름으로 정렬한 후, 전체 이름과 회사 이름을 반환합니다.

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

이 쿼리는 다음과 같이 실행됩니다:

1. MATCH 이름에 'Air'가 들어간 회사에서 일하는 사람들을 찾습니다
2. LET 이름과 성을 합쳐 전체 이름을 만듭니다
3. FILTER 콘토소 직원만 남겨두었다
4. ORDER BY 전체 이름으로 정렬
5. LIMIT 처음 10개의 결과를 선택해
6. RETURN 신고서 이름 및 회사 위치

변수가 데이터를 연결합니다.

변수(예: pcfullName 이전 예제)는 문 간에 데이터를 전달합니다. 변수 이름을 다시 사용하면 GQL에서 동일한 데이터를 자동으로 참조하여 강력한 조인 조건을 만듭니다. 변수를 바인딩 변수라고도 합니다.

변수는 다음과 같은 다양한 방법으로 분류할 수 있습니다.

바인딩 소스별:

• 패턴 변수 - 일치하는 그래프 패턴에 의해 바인딩됨
• 일반 변수 - 다른 언어 구문에 의해 바인딩됨

패턴 변수 형식:

• 요소 변수 - 그래프 요소 참조 값에 바인딩
  • 노드 변수 - 개별 노드에 바인딩
  • 에지 변수 - 개별 에지에 바인딩
• 경로 변수 - 일치하는 경로를 나타내는 경로 값에 바인딩

참조 수준 기준:

• 싱글톤 변수 - 패턴의 개별 요소 참조 값에 바인딩
• 그룹 변수 - 가변 길이 패턴의 요소 참조 값 목록에 바인딩( 고급 집계 기술 참조)

실행 결과 및 결과

쿼리를 실행하면 다음으로 구성된 실행 결과를 다시 가져옵니다.

• 문의 데이터가 포함된 RETURN입니다.
• 쿼리의 성공 여부를 보여 주는 상태 정보입니다.

결과 테이블

결과 테이블(있는 경우)은 쿼리 실행의 실제 결과입니다.

결과 테이블에는 열의 이름과 형식, 결과를 표시하는 데 사용할 기본 열 이름 시퀀스, 테이블 순서 지정 여부 및 실제 행 자체에 대한 정보가 포함됩니다.

비고

실행 실패의 경우 결과 테이블은 실행 결과에 포함되지 않습니다.

상태 정보

쿼리를 실행하는 동안 다양한 중요한 조건(예: 오류 또는 경고)이 검색됩니다. 이러한 각 조건은 실행 결과의 상태 정보에 상태 개체에 의해 기록됩니다.

상태 정보는 기본 상태 개체와 추가 상태 개체의 (비어 있는) 목록으로 구성됩니다. 기본 상태 개체는 항상 존재하며 쿼리 실행이 성공했는지 실패했는지 여부를 나타냅니다.

모든 상태 개체에는 기록된 조건과 이를 설명하는 메시지를 식별하는 5자리 상태 코드(GQLSTATUS라고 함)가 포함됩니다.

성공 상태 코드:

GQLSTATUS	Message	언제
00000	참고: 성공적인 완료	하나 이상의 행을 사용하여 성공
00001	참고: 성공적인 완료 - 생략된 결과	테이블이 없는 성공(현재 사용되지 않음)
02000	참고: 데이터 없음	행이 0인 성공

다른 상태 코드는 쿼리 실행 중에 검색된 추가 오류 또는 경고를 나타냅니다.

전체 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

순환이 없는 순회에 대한 TRAIL 패턴:

패턴을 사용하여 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

가변 길이 에지 바인딩:

가변 길이 패턴에서 에지 변수는 컨텍스트에 따라 다른 정보를 캡처합니다.

-- 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 진술

Syntax:

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)

중요합니다

Microsoft Fabric의 그래프는 아직 임의 문 컴퍼지션을 지원하지 않습니다. 현재 제한 사항에 대한 문서를 참조하세요.

키 조인 동작:

데이터 조인을 처리하는 방법 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)

LET 진술

Syntax:

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 진술

Syntax:

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 - 유효한 ID
• 누락된 데이터 처리: NOT coalesce(p.locationIP, '127.0.0.1') STARTS WITH '127.0.0' - 로컬 네트워크에서 연결되지 않음
• 조건 결합: 복잡한 논리에 대한 명시적 null 검사와 함께 사용 AND/OR

주의

null 값과 관련된 조건이 반환 UNKNOWN되어 해당 행을 필터링합니다. null 포함 논리가 필요한 경우 명시적 IS NULL 검사를 사용합니다.

ORDER BY 진술

Syntax:

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 이해:

• 식 계산: 식이 각 행에 대해 계산된 다음 결과에서 행 순서를 결정합니다.
• 여러 정렬 키: 계층적 순서 만들기(기본, 보조, 3차 등)
• Null 처리: NULL 항상 비교에서 가장 작은 값으로 처리됩니다.
• 기본 순서: ASC (오름차순)은 기본값 DESC 이며(내림차순) 명시적으로 지정해야 합니다.
• 계산된 정렬: 저장된 속성뿐만 아니라 계산된 값을 기준으로 정렬할 수 있습니다.

주의

설정된 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 문장

Syntax:

  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: 기본 결과 프로젝션

Syntax:

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 with GROUP BY: 그룹화된 결과 프로젝션

Syntax:

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, UINT64, 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

주의

세 값 논리는 반환이 아니라 NULL = NULL반환UNKNOWN을 의미합니다TRUE. 이 동작은 필터링 및 조인에 영향을 줍니다. 항상 null 테스트에 사용합니다 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() 데이터 요약
• 문자열 함수: char_length(), upper(), lower()trim() 텍스트 처리
• 그래프 함수: nodes()- edges()labels() 그래프 구조 분석
• 일반 함수: coalesce() 정상적으로 null 값 처리

복합 식의 연산자 우선 순위:

1. 속성 액세스(.)
2. 곱하기/나누기(*, /)
3. 더하기/빼기(+, -)
4. 비교(=,, <>, <>, <=>=)
5. 논리적 부정(NOT)
6. 논리적 결합(AND)
7. 논리적 분리(OR)

위 목록에서 숫자가 낮은 연산자가 높은 숫자를 가진 연산자보다 "더 단단히 결합"됩니다. 예시: NOT n.prop OR m.prop is (NOT n.prop) OR m.prop 는 하지만 'NOT (n.prop 또는 m.prop)'는 아닙니다.

팁 (조언)

괄호를 사용하여 우선 순위를 명시적으로 지정합니다. 복잡한 식은 그룹화가 명확할 때 더 쉽게 읽고 디버그할 수 있습니다.

포괄적인 식 구문 및 모든 기본 제공 함수 알아보기

고급 쿼리 기술

이 섹션에서는 복잡하고 효율적인 그래프 쿼리를 빌드하기 위한 정교한 패턴과 기술에 대해 설명합니다. 이러한 패턴은 강력한 분석 쿼리를 작성하는 데 도움이 되는 기본 문 사용을 넘어선 것입니다.

복잡한 다중 문 컴퍼지션

중요합니다

Microsoft Fabric의 그래프는 아직 임의 문 컴퍼지션을 지원하지 않습니다. 현재 제한 사항에 대한 문서를 참조하세요.

복잡한 쿼리를 효율적으로 작성하는 방법을 이해하는 것은 고급 그래프 쿼리에 매우 중요합니다.

다단계 패턴 진행:

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

주의

동일한 문의 변수는 그래프 패턴을 제외하고 서로를 참조할 수 없습니다. 종속 변수를 만들려면 별도의 문을 사용합니다.

고급 집계 기술

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_
• 다중 단어 식별자의 경우 camelCase 또는 PascalCase를 :MyEntity:hasAttribute사용합니다.textColor

다음 단계

이제 GQL 기본 사항을 이해했으므로 권장되는 학습 경로는 다음과 같습니다.

GQL 기술 빌드 계속

초보자의 경우:

• 빠른 시작 시도 - 실습 자습서 를 따라 실습해 보세요.
• 기본 쿼리 연습 - 이 가이드의 예제를 사용자 고유의 데이터로 사용해 보세요.
• 그래프 패턴 알아보기 - 포괄적인 패턴 구문 마스터
• 데이터 형식 탐색 - GQL 값 및 값 형식 이해

숙련된 사용자의 경우:

• 고급 식 - Master GQL 식 및 함수
• 스키마 디자인 - GQL 그래프 형식 및 제약 조건 알아보기
• 데이터 형식 탐색 - GQL 값 및 값 형식 이해

참조 자료

빠른 조회를 위해 다음 참조를 편리하게 유지합니다.

• GQL 빠른 참조 - 구문 빠른 참조
• GQL 상태 코드 - 전체 오류 코드 참조
• GQL 예약어 - 예약된 키워드의 전체 목록

Microsoft Fabric 살펴보기

플랫폼에 대해 알아봅니다.

• 그래프 데이터 모델 - 그래프 개념 및 모델링 이해
• 그래프 및 관계형 데이터베이스 - 올바른 방법 선택
• 무료로 Microsoft Fabric 사용해 보기 - 실습 경험 얻기
• 엔드 투 엔드 자습서 - 전체 학습 시나리오

참여

• 피드백 공유 - 설명서 및 도구 개선
• 커뮤니티 가입 - 다른 그래프 데이터베이스 실무자와 연결
• 업데이트 유지 - 새 기능에 대한 Microsoft Fabric 공지 사항 따르기

팁 (조언)

학습을 선호하는 경우 빠른 시작 자습서 로 시작하거나 쿼리 언어를 먼저 마스터하려는 경우 그래프 패턴을 자세히 살펴봅니다.

관련 콘텐츠

주요 항목에 대한 자세한 내용:

• 소셜 네트워크 스키마 예제 - 그래프 스키마의 전체 작업 예제
• GQL 그래프 패턴 - 포괄적인 패턴 구문 및 고급 일치 기술
• GQL 식 및 함수 - 모든 식 형식 및 기본 제공 함수
• GQL 그래프 형식 - 그래프 형식 및 제약 조건
• GQL 값 및 값 형식 - 전체 형식 시스템 참조 및 값 처리

빠른 참조:

• GQL 요약 참조 - 구문 빠른 참조
• GQL 상태 코드 - 전체 오류 코드 참조
• GQL 예약어 - 예약된 키워드의 전체 목록

Microsoft Fabric의 그래프:

• 그래프 데이터 모델 - 그래프 개념 및 모델링 이해
• 그래프 및 관계형 데이터베이스 - 차이점 및 각 데이터베이스 사용 시기
• 무료로 Microsoft Fabric 사용해 보기
• Microsoft Fabric에서 종합 자습서