RDF term syntax

  • Syntax for IRI: PREFIX book: <http://example.org/book/book1

  • The general syntax for literals: language tag @ or datatype IRI ^^, 语言标识必须加，类型会自动生成

  • Syntax for query variables: 变量之前加 ? or $

  • Syntax for blank nodes: 一般可以用?variable代替

    1
    2
    3
    4
    5
    6
    SELECT ?a ?b
    WHERE
    {
        ?a :predicate ?variable .
        ?variable :otherPredicate ?b .
    }

Query Pattern

Triple Pattern

Triple patterns are similar to RDF triples, but any component can be a query variable?x foaf:mane ?name .

Basic Graph pattern

a set of triple patterns written as a sequence of triple patterns.

回答问题就是找 RDF terms 和 variables 匹配的项

1
2
3
4
5
6
PREFIX foaf:<http://xmlns.com/foaf/0.1/>
SELECT ?name ?mbox
WHERE{
    {?x foaf:name ?name .}
    {?x foaf:mbox ?mbox .}
}
1
2
3
PREFIX foaf:<http://xmlns.com/foaf/0.1/>
SELECT ?name ?mbox
WHERE{?x foaf:name ?name . ?x foaf:mbox ?mbox .}

Other graph pattern

  1. Group Graph Pattern FILTER + 需要的内容

    1
    2
    3
    {
        ?x foaf:name ?name . FILTER regex(?name, "Smith")
    }

  2. Optional Graph Pattern OPTIONAL 中的内容可以没有

    1
    2
    3
    4
    5
    6
    PREFIX foaf:<http://xmlns.com/foaf/0.1/>
    SELECT ?name ?mbox
    WHERE{
        {?x foaf:name ?name .}
        OPTIONAL{?x foaf:mbox ?mbox .}
    }

    | name | mbox |
    | :——-: | :————————————: |
    | “Alice” | alice@example.com |
    | “Bob” | |

    ☆ 两个OPTIONAL 第一个要加句号

    1
    2
    3
    4
    5
    6
    7
    PREFIX foaf:<http://xmlns.com/foaf/0.1/>
    SELECT ?name ?mbox
    WHERE{
        {?x foaf:name ?name .}
        OPTIONAL{?x foaf:mbox ?mbox .}.
        OPTIONAL{?x foaf:homepage ?hpage .}                              
    }

  3. Alternative Graph Pattern UNION 满足UNION前后的条件之一即可

    1
    2
    3
    4
    5
    6
    7
    8
    PREFIX dc10:<http://purl.org/dc/element/1.0/>
    PREFIX dc11:<http://purl.org/dc/element/1.1/>

    SELECT ?title
    WHERE{
        {?book dc10:title ?title .}
        UNION{?book dc11:title ?title .}
    }

Dataset specification

  • SPARQL queries are executed over an RDF dataset:

    • One default graph
    • Zero or more named graphs (identified by an IRI)

    image-20230208230531360

    1
    2
    3
    4
    SELECT ?v
    WHERE{
        GRAPH ?g {?v rdf:type umbel-sc:Volcano .}
    }
    1
    2
    3
    4
    5
    SELECT ?v
    WHERE{
        _:x rdfs:seeAlso ?g . 
        GRAPH ?g {?v rdf:type umbel-sc:Volcano .}
    }

    Query Forms

    1. SELECT

      1
      2
      3
      4
      5
      PREFIX foaf:<http://xmlns.com/foaf/0.1/>

      SELECT ?name
      FROM <http://example.org/foaf/aliceFoaf>
      WHERE{?x foaf:name ?name.}

      返回一系列搜索结果（一般以表格呈现）

      • DISTINCT (去除重复结果)

        1
        2
        3
        4
        SELECT DISTINCT ?type
        WHERE{
            _:x rdf:type ?type .
        }

      • ORDER BY (以某种顺序显示结果)

        1
        2
        3
        4
        5
        SELECT ?v
        WHERE{
            ?v rdf:type umbel:Volcano;
               rdfs:label ?name.
        }ORDER BY ?name

      • BINDINGS(筛选时生成新变量)

        1
        2
        3
        4
        5
        6
        7
        SELECT ?title ?price
        WHERE{
            ?b ex:title ?title;
               ex:price ?p;
               ex:discount ?r.
            BIND((?p- ?r) AS ?price)
        }
        1
        2
        3
        4
        5
        6
        7
        SELECT ?title (?p- ?r) AS ?price
        WHERE{
            ?b ex:title ?title;
               ex:price ?p;
               ex:discount ?r.
            
        }

      • VALUES 缩小范围的

        1
        2
        3
        4
        5
        SELECT ?title 
        WHERE{
            ?b ex:title ?title.
            VALUES ?b {(ex:Book1)(ex:Book2)}
        }

  1. DESCRIBE

    1
    2
    PREFIX ent:<http://org.example.com/employees#>
    DESCRIBE ?x WHERE {?x ent:employeeID "1234".}

    返回 ?x 所有有关内容

  2. CONSTRUCT

    1
    2
    3
    4
    5
    PREFIX foaf:<http://xmlns.com/foaf/0.1/>
    PREFIX org:<tttp://example.com/ns#>

    CONSTRUCT{?x foaf:name ?name.}
    WHERE{?x org:employeeName ?name.}

    返回新构建的triple，blank node 后面的词可以改变

  3. BOUND

    1
    2
    OPTIONAL{?v p:location ?l .FILTER(?l=dbpedia:United_States)
            }FILTER(!BOUND(?l))

    if ?l has value, BOUND(?l)=true

  4. ASK

    1
    2
    PREFIX foaf:<http://xmlns.com/foaf/0.1/>
    ASK{?x foaf:name "Alice".}

    返回 T or F , 查看是否有至少一个符合条件。

  5. INSERT

    1
    2
    3
    4
    5
    6
    7
    PREFIX foaf:<http://xmlns.com/foaf/0.1/>
    PREFIX org:<tttp://example.com/ns#>

    INSERT DATA{
        _c: org:employeeName "John";
            org:employeeID 13579.
    }

    返回原有 RDF Graph中增加新的 RDF triples。

  6. DELETE

    1
    2
    3
    4
    PREFIX foaf:<http://xmlns.com/foaf/0.1/>
    PREFIX org:<tttp://example.com/ns#>

    DELETE DATA{_:a foaf:name "Alice".}

    返回删除后的新graph

  7. DELETE/INSERT 连用（替换）

    1
    2
    3
    4
    5
    PREFIX foaf:<http://xmlns.com/foaf/0.1/>
    WITH <http://example/addresses> 
    DELETE { ?person foaf:givenName 'Bill' .} 
    INSERT { ?person foaf:givenName 'William' .} 
    WHERE { ?person foaf:givenName 'Bill' .}

    返回替换后的graph

  8. CLEAR

    1
    2
    3
    4
    PREFIX foaf:<http://xmlns.com/foaf/0.1/>
    WITH <http://example/addresses> 

    CLEAR GRAPH {GRAPH<http://person>}

    返回空Graph

  9. MOVE

    1
    2
    3
    4
    PREFIX foaf:<http://xmlns.com/foaf/0.1/>
    WITH <http://example/addresses>

    MOVE {GRAPH<http://person>} To {GRAPH<http://person2>}

    将一个graph的内容覆盖移动到另一个。

Graph Database

Neo4j

open source graph database

Cypher

declarative graph query language

Create

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
CREATE(
	<node-name>:<label-name>{
        <Property1-name>:<Property1-value>
    	......
    	<Propertyn-name>:<Propertyn-Value>
    }
)

e.g.
CREATE(
	node:Person
	{
        name:"Emil"
        from:"Sweden"
    }
)

relationship

1
2
3
4
5
6
7
CREATE
	(<node1-name>:<node1-label-name>{<define-properties-list>})-[<relationship-name>:<ralationship-label-name>{<define-properties-list>}]->(<node2-name>:<node2-label-name>{<define-properties-list>})

e.g.
CREATE
	(n1:Person{name:"OLiver"})-[r:DIRECTED]->(n2:Movie{title:"Wall Street"})

Match+return 查询

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
MATCH (n)
RETURN n

MATCH(movie:Movie)
RETURN movie.title
      
MATCH (director{name:'Oliver'})--(movie)
RETURN movie.title             
                                  
MATCH(:Person{name:'OLiver'})--(movie:Movie)    
RETURN movie.title
                                
MATCH(:Person{name:'OLiver'})-[r]->(movie)                                   
RETURN type(r)    ##也就是relationship-label-name

MATCH(wallstreet:Movie{title:'Wall Street'})<-[:ACTED_IN]-(actor)            
RETURN actor.name            

MATCH(wallstreet:Movie{title:'Wall Street'})<-[:ACTED_IN|:DIRECTED]-(person:Person)       
RETURN person.name                                                           
 
MATCH(wallstreet:Movie{title:'Wall Street'})<-[r:ACTED_IN]-(actor)      
RETURN r.role

Match+Create 创建关系

1
2
MATCH(charlie:Person{name:'Charlie'}),(rob:Person{name:'Bob'})
CREATE (rob)-[:'TYPE INCLUDING A SPACE']->(charlie)

DELETE

1
2
3
4
5
6
7
8
9
10
11
# delete single node
MATCH (n:Person{name:'UNKNOWN'}) DELETE n

# delete all nodes and relationships                 
MATCH(n) DETACH DELETE n                 
                 
# delete a node with all its relationship                 
MATCH(n{name;'Andy'}) DATACH DELETE n                 
                 
#delete relationship only                 
MARCH (n{name:'Andy'})-[r:KNOWS]->() DELETE r

Match+Set 更新

1
2
3
4
5
6
7
8
9
10
11
12
13
# update a property
MATCH (n{name;'Andy'})
SET n.age = toString(n.age)
RETURN n.name, n.age

#Multiple properties
MATCH(n{name:'Andy'})
SET n.position = 'Developer', n.surname = 'Taylor'

#replace all properties
MATCH (p{name:'Peter'})
SET p={name:'Peter', position:'Entrepreneur'}
RETURN p.name, p.age, p.position