# DQL查询RDF格式的数据
{
  alice(func: eq(name, "Alice")) {
    uid
    name
  }
}

# 返回JSON格式的结果
{
  "alice": [
    {
      "uid": "0x1",
      "name": "Alice"
    }
  ]
}

# GraphQL查询（内部转换为DQL）
query {
  queryPerson(filter: { name: { eq: "Alice" } }) {
    id
    name
  }
}

# 单类型节点
_:alice <dgraph.type> "Person" .
_:alice <name> "Alice Johnson" .

# 多类型节点
_:bob <dgraph.type> "Person" .
_:bob <dgraph.type> "Employee" .
_:bob <dgraph.type> "Manager" .
_:bob <name> "Bob Smith" .

# 按类型查询
{
  persons(func: type(Person)) {
    uid
    name
  }
}

# 多类型查询
{
  employees(func: type(Person, Employee)) {
    uid
    name
    dgraph.type
  }
}

# 三元组示例
(人物A) - (居住在) - (城市B)  
(人物A) - (喜欢) - (电影C)  
(电影C) - (的类型是) - (科幻)

# ✅ 有效的谓词名称
name: string .
age: int .
user_name: string .
user123: string .
<姓名>: string .  # 中文谓词
<user-name>: string .  # 带连字符

# ❌ 无效的类型定义
dgraph.Student: string .  # 错误：不能以 dgraph. 开头

# ✅ 有效的命名示例
user_name: string @index(term) .
user-age: int @index(int) .
user_email: string @index(exact) .
user_123: string .
user.name: string .  # 点号是允许的
user@domain: string .  # @ 会被忽略，实际是 userdomain
<用户姓名>: string .  # 中文名称
<user-name>: string .  # 带连字符

# ❌ 无效的命名示例
^username: string .  # 错误：^ 不被支持
user}name: string .  # 错误：} 不被支持
{username: string .  # 错误：{ 不被支持
`username: string .  # 错误：` 不被支持
\username: string .  # 错误：\ 不被支持
~username: string .  # 错误：~ 不被支持
dgraph.user: string .  # 错误：dgraph. 是保留命名空间

# IRI 格式的谓词名称
<http://example.org/name>: string .
<https://schema.org/name>: string .
<urn:uuid:123e4567-e89b-12d3-a456-426614174000>: string .

# 使用 IRI 谓词
{
  set {
    _:user <http://example.org/name> "Alice" .
    _:user <https://schema.org/name> "Alice Smith" .
  }
}

{
  # 给返回结果字段命名
  user(func: eq(name, "Alice")) {
    uid
    name
    age
    friends: friend {  # 别名
      name
    }
  }
  
  # var 变量保存查询结果
  var(func: has(name)) {
    friends as friend  # 保存朋友关系
  }
  
  # 使用变量
  aliceFriends(func: uid(friends)) {
    name
    age
  }
}

# Schema 声明
name: string @index(term) .           # 属性
friend: [uid] @reverse .              # 多关系
worksFor: uid @reverse .              # 单关系
location: geo @index(geo) .           # 地理位置

# 节点类型定义
type User {
  name
  age
  friend
  worksFor
}

{
  stats(func: has(age)) {
    count(uid)        # 计数
    sum(age)          # 求和
    avg(age)          # 平均值
    min(age)          # 最小值
    max(age)          # 最大值
  }
}

{
  users(func: has(age)) {
    name
    age
    nextYear: math(age + 1)        # 数学计算
    friendsCount: count(friend)    # 朋友数量
  }
}

{
  # AND 逻辑
  adults(func: has(age)) @filter(ge(age, 18) AND le(age, 65)) {
    name
    age
  }
  
  # OR 逻辑
  youngOrOld(func: has(age)) @filter(lt(age, 18) OR gt(age, 65)) {
    name
    age
  }
  
  # NOT 逻辑
  noEmail(func: has(name)) @filter(NOT has(email)) {
    name
  }
}

{
  # 数值比较
  users(func: has(age)) @filter(age = 25) {
    name
    age
  }
  
  # 范围查询
  adults(func: has(age)) @filter(age > 18 AND age < 65) {
    name
    age
  }
}

{
  # 基本过滤
  users(func: has(name)) @filter(eq(name, "Alice")) {
    name
    age
  }
  
  # 复杂过滤
  adults(func: has(age)) @filter(ge(age, 18) AND has(email)) {
    name
    age
    email
  }
}

{
  # 结果裁剪 - 只返回有完整数据的节点
  users(func: has(name)) @cascade {
    name
    age
    friend {
      name
    }
  }
  
  # 结果扁平化 - 将嵌套结构扁平化
  users(func: has(name)) @normalize {
    name
    friend {
      name
    }
  }
  
  # 分页控制
  users(func: has(name), first: 10, offset: 20) {
    name
    age
  }
  
  # 排序
  users(func: has(age), orderasc: age) {
    name
    age
  }
}

network(func: eq(name, "Alice")) @recurse(depth: 3) {
  name
  friend {
    name
  }
}

# 启动 Alpha 节点时设置 --limit 参数
dgraph alpha --limit "mutations=strict; mutations-nquad=1000000" --my=<alpha-node-ip>:7080 --zero=<zero-node-ip>:5080

这会启用严格模式，只允许对已在 schema 中的谓词进行突变操作。在执行突变之前，需要先通过 alter 操作声明谓词及其 schema 类型。

# 关系谓词示例
friends: [uid] .
parent: uid .
children: [uid] @reverse .

pass: password .

{
  set {
    <0x123> <name> "Password Example" .
    <0x123> <pass> "ThePassword" .
  }
}

{
  check(func: uid(0x123)) {
    name
    checkpwd(pass, "ThePassword")
  }
}

{
  "data": {
    "check": [
      {
        "name": "Password Example",
        "checkpwd(pass)": true
      }
    ]
  }
}

{
  check(func: uid(0x123)) {
    name
    secret: checkpwd(pass, "ThePassword")
  }
}

# 不同字符串索引类型
name: string @index(term) .           # 词项索引，支持部分匹配
email: string @index(exact) .         # 精确匹配索引
description: string @index(trigram) . # 三元组索引，支持模糊搜索
content: string @index(fulltext) .    # 全文索引，支持语言分析
pattern: string @index(regexp) .      # 正则表达式索引

# 数值类型索引
age: int @index(int) .
score: float @index(float) .

# 日期时间索引
created_at: dateTime @index(year) .   # 按年索引
updated_at: dateTime @index(day) .    # 按天索引
event_time: dateTime @index(month) .  # 按月索引
log_time: dateTime @index(hour) .     # 按小时索引

# 地理位置索引
location: geo @index(geo) .

# 向量索引（用于机器学习）
embedding: float32vector @index(hnsw(metric: "cosine")) .
similarity: float32vector @index(hnsw(metric: "euclidean")) .

{
  users(func: type(User)) @cascade {
    name
    posts {
      title
      comments {
        content
      }
    }
  }
}

{
  users(func: type(User)) @normalize {
    name
    posts {
      title
    }
  }
}

mutation {
  set {
    _:u1 <name> "Alice" .
    _:u1 <age> "25" .
    _:u1 <dgraph.type> "User" .
  }
}

mutation {
  set {
    "uid": "_:u1",
    "name": "Alice",
    "age": 25,
    "dgraph.type": "User"
  }
}

delete {
  <0x123> * * .
}

{
  q(func: uid(0x123)) {
    expand(all)
  }
}

query {
  user(func: eq(name, "Alice")) {
    uid
    name
    age
  }
}

{
  # 使用 type() 函数
  users(func: type(User)) {
    uid
    name
    age
  }
  
  # 使用 @filter 过滤
  users(func: has(name)) @filter(eq(dgraph.type, "User")) {
    uid
    name
    age
  }
}

{
  # 无限层级递归
  network(func: eq(name, "Alice")) @recurse {
    name
    friend {
      name
    }
  }
  
  # 限制递归深度
  network(func: eq(name, "Alice")) @recurse(depth: 3) {
    name
    friend {
      name
    }
  }
}

{
  # 用户查询
  users(func: type(User)) {
    uid
    name
    age
  }
  
  # 电影查询
  movies(func: type(Movie)) {
    uid
    title
    year
  }
  
  # 关系查询
  relationships(func: has(friend)) {
    uid
    friend {
      name
    }
  }
}

query all($name: string, $minAge: int) {
  users(func: eq(name, $name)) @filter(ge(age, $minAge)) {
    uid
    name
    age
  }
}

{
  "name": "Alice",
  "minAge": 18
}

{
  stats(func: has(age)) {
    count(uid)        # 总数量
    sum(age)          # 年龄总和
    avg(age)          # 平均年龄
    min(age)          # 最小年龄
    max(age)          # 最大年龄
  }
}

{
  # 按年龄分组统计
  ageGroups(func: has(age)) @groupby(age) {
    count(uid)
  }
  
  # 按类型分组统计
  typeGroups(func: has(dgraph.type)) @groupby(dgraph.type) {
    count(uid)
  }
}

{
  users(func: has(name)) {
    name
    friend @facets(since, closeness) {  # 查询边的属性
      name
    }
  }
}

{
  # 展开所有字段
  users(func: eq(name, "Alice")) {
    expand(_all_) {
      expand(_all_)
    }
  }
  
  # 展开特定类型的所有字段
  users(func: type(User)) {
    expand(User)
  }
}

mutation {
  set {
    _:alice <name> "Alice Johnson" .
    _:alice <age> "30" .
    _:alice <email> "alice@example.com" .
    _:alice <dgraph.type> "User" .
  }
}

mutation {
  set {
    "uid": "_:alice",
    "dgraph.type": "User",
    "name": "Alice Johnson",
    "age": 30,
    "email": "alice@example.com"
  }
}

mutation {
  set {
    _:alice <name> "Alice" .
    _:alice <dgraph.type> "User" .
    
    _:bob <name> "Bob" .
    _:bob <dgraph.type> "User" .
    
    _:alice <friend> _:bob .
    _:bob <friend> _:alice .  # 双向关系
  }
}

mutation {
  set {
    <0x1> <age> "31" .
    <0x1> <email> "alice.new@example.com" .
    <0x1> <lastLogin> "2024-01-15T10:30:00Z" .
  }
}

mutation {
  set {
    <0x1> <dgraph.type> "Employee" .  # 添加新类型
    <0x1> <dgraph.type> "Manager" .   # 添加多个类型
  }
}

mutation {
  delete {
    <0x1> <email> * .                    # 删除email属性
    <0x1> <friend> <0x2> .              # 删除特定关系
    <0x1> <dgraph.type> "Manager" .     # 删除特定类型标签
  }
}

mutation {
  delete {
    <0x1> * * .  # 删除整个节点及其所有属性和关系
  }
}

# 立即提交事务
mutation {
  set {
    _:alice <name> "Alice" .
    _:alice <dgraph.type> "User" .
  }
  commitNow: true
}

# 指定事务开始时间戳
mutation {
  set {
    _:alice <name> "Alice" .
  }
  startTs: 1234567890
}

# 回滚事务
mutation {
  set {
    _:alice <name> "Alice" .
  }
  abort: true
}

mutation {
  set {
    _:person1 <name> "Alice" .
    _:person1 <age> "30" .
    _:person1 <dgraph.type> "User" .
    
    _:person2 <name> "Bob" .
    _:person2 <age> "28" .
    _:person2 <dgraph.type> "User" .
    
    _:person3 <name> "Charlie" .
    _:person3 <age> "32" .
    _:person3 <dgraph.type> "User" .
    
    # 建立关系网络
    _:person1 <friend> _:person2 .
    _:person2 <friend> _:person3 .
    _:person1 <friend> _:person3 .
  }
}

{
  # 先查询需要更新的节点
  var(func: eq(name, "Alice")) {
    alice as uid
  }
  
  # 然后更新
  mutation {
    set {
      uid(alice) <status> "active" .
      uid(alice) <lastLogin> "2024-01-15T10:30:00Z" .
    }
  }
}

mutation {
  set {
    <0x1> <dgraph.type> "Employee" .  # 给现有节点添加Employee类型
    <0x1> <dgraph.type> "Manager" .   # 同时添加Manager类型
    <0x1> <dgraph.type> "Admin" .     # 可以添加多个类型
  }
}

mutation {
  delete {
    <0x1> <dgraph.type> "Manager" .  # 删除Manager类型标签
  }
}

{
  # 查询所有Employee
  employees(func: type(Employee)) {
    uid
    name
    dgraph.type
  }
  
  # 查询既是Person又是Employee的节点
  personEmployees(func: type(Person, Employee)) {
    uid
    name
    dgraph.type
  }
  
  # 查询包含特定类型的所有节点
  allUsers(func: has(dgraph.type)) @filter(uid_in(dgraph.type, "User", "Employee")) {
    uid
    name
    dgraph.type
  }
}

{
  # 按类型分组统计
  typeStats(func: has(dgraph.type)) @groupby(dgraph.type) {
    count(uid)
  }
  
  # 统计特定类型的数量
  userCount(func: type(User)) {
    count(uid)
  }
}

{
  # 查询或创建
  var(func: eq(email, "alice@example.com")) {
    alice as uid
  }
  
  mutation {
    set {
      uid(alice) <name> "Alice" .
      uid(alice) <email> "alice@example.com" .
      uid(alice) <dgraph.type> "User" .
    }
  }
}

{
  # 查询朋友的朋友
  var(func: eq(name, "Alice")) {
    friends as friend
  }
  
  friendsOfFriends(func: uid(friends)) {
    name
    friend {
      name
    }
  }
}

{
  # 查询需要迁移的数据
  var(func: type(OldUser)) {
    oldUsers as uid
  }
  
  # 迁移数据
  mutation {
    set {
      uid(oldUsers) <dgraph.type> "User" .
    }
    delete {
      uid(oldUsers) <dgraph.type> "OldUser" .
    }
  }
}

# 错误：中文标识符没有尖括号
张三 <姓名> "张三" .
张三 <年龄> "25" .
张三 <朋友> 李四 .

# 正确：中文标识符使用尖括号
<张三> <姓名> "张三" .
<张三> <年龄> "25" .
<张三> <朋友> <李四> .

# 中文谓词定义
<姓名>: string @index(term) .
<年龄>: int @index(int) .
<职业>: string @index(term) .
<公司>: string @index(term) .
<朋友>: [uid] @reverse .
<同事>: [uid] @reverse .
<居住地>: string @index(term) .

# 中文类型定义
type 人员 {
  <姓名>
  <年龄>
  <职业>
  <公司>
  <朋友>
  <同事>
  <居住地>
}

mutation {
  set {
    <张三> <姓名> "张三" .
    <张三> <年龄> 28 .
    <张三> <职业> "软件工程师" .
    <张三> <公司> "阿里巴巴" .
    <张三> <居住地> "杭州" .
    <张三> <dgraph.type> "人员" .
    
    <李四> <姓名> "李四" .
    <李四> <年龄> 26 .
    <李四> <职业> "产品经理" .
    <李四> <公司> "腾讯" .
    <李四> <居住地> "深圳" .
    <李四> <dgraph.type> "人员" .
    
    <王五> <姓名> "王五" .
    <王五> <年龄> 30 .
    <王五> <职业> "设计师" .
    <王五> <公司> "字节跳动" .
    <王五> <居住地> "北京" .
    <王五> <dgraph.type> "人员" .
    
    # 建立关系
    <张三> <朋友> <李四> .
    <张三> <朋友> <王五> .
    <李四> <同事> <王五> .
  }
}

{
  # 查询所有人员
  所有人员(func: type(人员)) {
    <姓名>
    <年龄>
    <职业>
    <公司>
    <居住地>
  }
  
  # 查询张三的朋友
  张三的朋友(func: eq(<姓名>, "张三")) {
    <姓名>
    <朋友> {
      <姓名>
      <职业>
    }
  }
  
  # 查询在杭州的人员
  杭州人员(func: eq(<居住地>, "杭州")) {
    <姓名>
    <职业>
    <公司>
  }
}

# Schema 定义
<文章内容>: string @index(fulltext) @lang .

# 数据插入
{
  set {
    <article1> <文章内容> "人工智能正在改变世界"@zh .
    <article1> <文章内容> "Artificial Intelligence is changing the world"@en .
  }
}

# 中文全文搜索
{
  搜索结果(func: alloftext(<文章内容>@zh, "人工智能")) {
    <文章内容>@zh
  }
}

# Schema 定义
<标签>: [string] @index(term) .

# 数据插入
{
  set {
    <product1> <标签> "智能手机" .
    <product1> <标签> "5G" .
    <product1> <标签> "拍照" .
  }
}

# 词项搜索
{
  产品搜索(func: allofterms(<标签>, "智能手机 拍照")) {
    <标签>
  }
}