Neptune查询语言概述 #

查询语言：
├── Gremlin
│   ├── Apache TinkerPop项目
│   ├── 属性图查询语言
│   ├── 图遍历语言
│   └── 命令式查询
└── SPARQL
    ├── W3C标准
    ├── RDF图查询语言
    ├── 声明式查询
    └── 支持推理

Gremlin特点：
├── 图遍历语言
├── 函数式编程风格
├── 支持复杂遍历操作
├── 多语言驱动支持
└── 可扩展性强

// 获取所有顶点
g.V()

// 获取指定ID的顶点
g.V('1')

// 获取指定标签的顶点
g.V().hasLabel('person')

// 获取指定属性的顶点
g.V().has('name', 'Tom')

// 获取所有边
g.E()

// 获取指定标签的边
g.E().hasLabel('knows')

// 获取指定属性的边
g.E().has('since', 2020)

// 出边遍历
g.V('1').out('knows')

// 入边遍历
g.V('1').in('knows')

// 双向遍历
g.V('1').both('knows')

g.V().has('person', 'name', 'Tom').
  out('knows').
  values('name')

g.V().has('name', 'Tom').out('knows').
  where(out('knows').has('name', 'Jerry')).
  values('name')

g.V().has('name', 'Tom').
  repeat(out().simplePath()).
  until(has('name', 'Jerry')).
  path().
  limit(1)

遍历步骤分类：
├── 源步骤（Source Steps）
│   ├── V()：顶点源
│   └── E()：边源
├── 过滤步骤（Filter Steps）
│   ├── has()：属性过滤
│   ├── filter()：条件过滤
│   ├── where()：条件过滤
│   └── dedup()：去重
├── 变换步骤（Transform Steps）
│   ├── out()：出边遍历
│   ├── in()：入边遍历
│   ├── map()：映射
│   └── flatMap()：扁平映射
├── 侧效步骤（SideEffect Steps）
│   ├── aggregate()：聚合
│   ├── group()：分组
│   └── store()：存储
└── 终端步骤（Terminal Steps）
    ├── toList()：返回列表
    ├── next()：返回下一个
    ├── iterate()：执行遍历
    └── count()：计数

SPARQL特点：
├── W3C标准
├── 声明式查询
├── 模式匹配
├── 支持推理
├── 联邦查询
└── 多种查询形式

PREFIX ex: <http://example.org/>
PREFIX foaf: <http://xmlns.com/foaf/0.1/>

SELECT ?name ?age
WHERE {
  ?person a ex:Person .
  ?person foaf:name ?name .
  ?person ex:age ?age .
}

PREFIX ex: <http://example.org/>

ASK {
  ex:Tom ex:knows ex:Jerry .
}

PREFIX ex: <http://example.org/>

CONSTRUCT {
  ?person ex:friend ?friend .
}
WHERE {
  ?person ex:knows ?friend .
  ?friend ex:knows ?person .
}

PREFIX ex: <http://example.org/>

DESCRIBE ex:Tom

PREFIX ex: <http://example.org/>
PREFIX foaf: <http://xmlns.com/foaf/0.1/>

SELECT ?friendName
WHERE {
  ex:Tom foaf:name "Tom" .
  ex:Tom ex:knows ?friend .
  ?friend foaf:name ?friendName .
}

PREFIX ex: <http://example.org/>
PREFIX foaf: <http://xmlns.com/foaf/0.1/>

SELECT ?mutualFriend
WHERE {
  ex:Tom ex:knows ?mutualFriend .
  ex:Jerry ex:knows ?mutualFriend .
  ?mutualFriend foaf:name ?mutualFriend .
}

PREFIX ex: <http://example.org/>

SELECT ?path
WHERE {
  ex:Tom (ex:knows/ex:knows) ?target .
  ?target foaf:name ?path .
}

查询形式：
├── SELECT
│   └── 返回变量绑定结果
├── ASK
│   └── 返回布尔值
├── CONSTRUCT
│   └── 构建新的RDF图
└── DESCRIBE
    └── 描述资源

// 创建遍历源
g = traversal().withRemote(connection)

// 从顶点开始
g.V()

// 从边开始
g.E()

// 从指定顶点开始
g.V('1', '2', '3')

// has()过滤
g.V().has('name', 'Tom')
g.V().has('age', gt(25))
g.V().has('name', within('Tom', 'Jerry'))

// where()过滤
g.V().where(out('knows').count().is(gt(5)))

// filter()过滤
g.V().filter(outE().count().is(gt(0)))

// dedup()去重
g.V().out('knows').dedup()

// map()映射
g.V().map(values('name'))

// flatMap()扁平映射
g.V().flatMap(out('knows'))

// select()选择
g.V().as('a').out('knows').as('b').select('a', 'b')

// path()路径
g.V().out('knows').path()

// count()计数
g.V().count()

// group()分组
g.V().group().by('label').by(count())

// order()排序
g.V().order().by('name', asc)

// sum()求和
g.V().values('age').sum()

// 添加顶点
g.addV('person').property('name', 'Tom')

// 添加边
g.addE('knows').from(V('1')).to(V('2'))

// 设置属性
g.V('1').property('age', 30)

// 删除顶点
g.V('1').drop()

// 删除属性
g.V('1').properties('age').drop()

# 简单三元组模式
SELECT ?s ?p ?o
WHERE {
  ?s ?p ?o .
}

# 多三元组模式
SELECT ?name ?email
WHERE {
  ?person foaf:name ?name .
  ?person foaf:mbox ?email .
}

# 数值过滤
SELECT ?name ?age
WHERE {
  ?person foaf:name ?name .
  ?person ex:age ?age .
  FILTER (?age > 25)
}

# 字符串过滤
SELECT ?name
WHERE {
  ?person foaf:name ?name .
  FILTER (STRSTARTS(?name, "T"))
}

# 正则过滤
SELECT ?name
WHERE {
  ?person foaf:name ?name .
  FILTER (REGEX(?name, "^T", "i"))
}

# OPTIONAL
SELECT ?name ?email
WHERE {
  ?person foaf:name ?name .
  OPTIONAL { ?person foaf:mbox ?email }
}

# UNION
SELECT ?name
WHERE {
  {
    ?person foaf:firstName ?name .
  }
  UNION
  {
    ?person foaf:lastName ?name .
  }
}

# 路径表达式
SELECT ?friend
WHERE {
  ex:Tom foaf:knows+ ?friend .
}

# 路径操作符
# * : 零次或多次
# + : 一次或多次
# ? : 零次或一次
# / : 路径序列
# | : 路径选择
# ^ : 反向路径

# INSERT DATA
INSERT DATA {
  ex:Tom foaf:name "Tom" .
  ex:Tom ex:age 30 .
}

# DELETE DATA
DELETE DATA {
  ex:Tom ex:age 30 .
}

# DELETE/INSERT
DELETE {
  ex:Tom ex:age ?oldAge .
}
INSERT {
  ex:Tom ex:age 31 .
}
WHERE {
  ex:Tom ex:age ?oldAge .
}

属性图 → RDF转换：
├── 顶点 → URI资源
├── 标签 → rdf:type
├── 属性 → 谓语
└── 边 → 三元组

g.V().has('name', 'Tom').out('knows').values('name')

SELECT ?friendName
WHERE {
  ?tom foaf:name "Tom" .
  ?tom ex:knows ?friend .
  ?friend foaf:name ?friendName .
}

// 使用索引过滤
g.V().hasLabel('person').has('name', 'Tom')

// 限制遍历深度
g.V().repeat(out()).times(3)

// 使用limit()
g.V().limit(100)

# 使用FILTER减少中间结果
SELECT ?name
WHERE {
  ?person a ex:Person .
  ?person foaf:name ?name .
  FILTER (STRSTARTS(?name, "T"))
}

# 使用BIND预计算
SELECT ?fullName
WHERE {
  ?person foaf:firstName ?first .
  ?person foaf:lastName ?last .
  BIND(CONCAT(?first, " ", ?last) AS ?fullName)
}

from gremlin_python.driver.driver_remote_connection import DriverRemoteConnection
from gremlin_python.process.anonymous_traversal import traversal

connection = DriverRemoteConnection('wss://endpoint:8182/gremlin', 'g')
g = traversal().withRemote(connection)

const gremlin = require('gremlin');
const DriverRemoteConnection = gremlin.driver.DriverRemoteConnection;
const traversal = gremlin.process.AnonymousTraversalSource.traversal;

const connection = new DriverRemoteConnection('wss://endpoint:8182/gremlin');
const g = traversal().withRemote(connection);

import org.apache.tinkerpop.gremlin.driver.Cluster;
import org.apache.tinkerpop.gremlin.driver.remote.DriverRemoteConnection;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import static org.apache.tinkerpop.gremlin.process.traversal.AnonymousTraversalSource.traversal;

Cluster cluster = Cluster.build("endpoint").port(8182).create();
GraphTraversalSource g = traversal().withRemote(DriverRemoteConnection.using(cluster));

from SPARQLWrapper import SPARQLWrapper, JSON

sparql = SPARQLWrapper('https://endpoint:8182/sparql')
sparql.setQuery('SELECT ?s WHERE { ?s ?p ?o } LIMIT 10')
sparql.setReturnFormat(JSON)
results = sparql.query().convert()

const fetch = require('node-fetch');

const endpoint = 'https://endpoint:8182/sparql';
const query = 'SELECT ?s WHERE { ?s ?p ?o } LIMIT 10';

const response = await fetch(`${endpoint}?query=${encodeURIComponent(query)}`, {
  headers: { 'Accept': 'application/sparql-results+json' }
});
const results = await response.json();