"Neo4j Tutorial"의 두 판 사이의 차이

2018년 1월 24일 (수) 22:07 기준 최신판

Neo4j 소개

Neo4j is the world's leading graph database.
그래프 데이터 베이스
Cypher, The Graph Query Language를 이용

Neo4j의 기본구조

The Labeled Property Graph Model을 기본 데이터 구조로 가짐.

노드Nodes

데이터 개체
Nodes are the main data elements
관계로 다른 노드들과 연결
Nodes are connected to other nodes via relationships
하나 이상의 속성을 지님
Nodes can have one or more properties (i.e., attributes stored as key/value pairs)
하나 이상의 라벨을 지님
Nodes have one or more labels that describes its role in the graph

관계Relationships

두 개의 노드를 연결
Relationships connect two nodes
직접적으로 연결
Relationships are directional
하나의 노드가 여러 개의 관계, 재귀적인 관계도 가질 수 있음
Nodes can have multiple, even recursive relationships
관계는 하나 이상의 속성을 가진다
Relationships can have one or more properties (i.e., attributes stored as key/value pairs)

속성Properties

문자로 정의된 값
Properties are named values where the name (or key) is a string
색인화되고, 제한될 수 있다.
Properties can be indexed and constrained
다양한 속성으로 복합적인 색인을 만들 수 있다
Composite indexes can be created from multiple properties

라벨Labels

노드를 묶는 단위
Labels are used to group nodes into sets
하나의 노드는 여러개의 라벨을 가질 수 있다
A node may have multiple labels
그래프에서 노드를 더 잘 찾을 수 있도록 색인화된다
Labels are indexed to accelerate finding nodes in the graph
기초 라벨 색인은 속도에 최적화되어 있다
Native label indexes are optimized for speed

Cypher, The Graph Query Language

Cyper의 기본 구조

MATCH <pattern> WHERE <conditions> RETURN <expressions>

변수

(변수:라벨{속성:속성값})
변수=(노드)-[관계]->(노드)

특정 관계나 값 등을 가진 형태를 가진 임의의 값. (중학생 때 배운 미지수 X와 같음)
불필요한 코드의 반복을 피하기 위해 코딩언어에서 사용.

Node/Property

(변수:라벨{속성:"속성값"})
변수.속성

(A:Person{name:"이혜영"}) : name 속성값이 "이혜영"이고, 라벨이 Person이 노드 A
A.name : 노드A의 name 속성

Relation

-[변수:릴레이션{속성:"속성값"}]->

A -[:Knows]-> B : Knows 관계를 가진 A와 B
A -[*]-> B : 관계를 가진 A와 B
A --> B : 관계를 가진 A와 B
A -[*1..3]-> B : 1~3의 거리를 가진 A와 B
A -[:Knows*1..3]-> B : Knows관계의 거리가 1~3인 A와 B
A -[:Knows{since:2009}]-> B : Knows관계를 가지고 since 속성이 2009값을 가지는 A와 B

Where

조건을 지정하기 위해 쓰임.
>,<,=, in, starts with, ends with, contains 등과 함께 쓰임.
Where A.name="ooo": name 속성의 값이 ooo인 노드 A
Where A.name in ["aaa", "bbb", "ccc"]: name 속성이 값이 aaa, bbb, ccc 중 하나의 값을 가지는 노드 A
Where A.name starts with "A": name 속성의 값이 A로 시작하는 노드 A (SQL의 where name like 'A%')
Where A.name ends with "A": name 속성의 값이 A로 끝나는 노드 A (SQL의 where name like '%A')
Where A.name contains "A": name 속성의 값에 A가 들어가는 노드 A (SQL의 where name like '%A%')

Create

노드 및 관계 생성

CREATE (변수:라벨 { 속성: "속성값", 속성: "속성값" })
CREATE (A:라벨 { 속성: "속성값", 속성: "속성값" }),  (B:라벨 { 속성: "속성값", 속성: "속성값" }), (A)-[:관계{속성:속성값}]->(B)

CREATE (ee:Person { name: "Emil", from: "Sweden", klout: 99 })

이름이 Emil이고 출신이 Sweden, 영향력이 99인 Person 라벨의 개체를 만들어라.

CREATE (js:Person { name: "Johan", from: "Sweden", learn: "surfing" }), (ir:Person { name: "Ian", from: "England", title: "author" }), (js)-[:KNOWS {since: 2001}]->(ir)

이름이 johan이고 출신이 sweden이고 배우는 것이 surfing이고, 라벨이 person인 개체(js)와 이름이 lan이고 출신이 England이고 칭호가 작가이고 라벨이 Person인 개체(jr)을 만들어라. 그리고 js와 jr은 KNOWS라는 관계를 가지고, 그 관계의 since라는 속성은 2001이란 값을 가진다.

Delete

노드 및 관계 삭제

MATCH (A:Person) WHERE A.id="0000" DELETE A
MATCH (n { name: 'Andres' })-[r:KNOWS]->() DELETE r

SET / REMOVE

노드 수정

MATCH (n { name: 'Andres' }) SET n.position = 'Developer', n.surname = 'Taylor'
MATCH (n { name: 'Peter' }) REMOVE n:German RETURN n

UNION / Order by

Union : 합집합 / join

MATCH (n:Actor) RETURN n.name UNION MATCH (n:Movie) RETURN n.title

Order by : 보여줄 차순, 기본값 오름차순/ desc : 내림차순

MATCH (n:Actor) RETURN n.name, n.age ORDER BY n.age DESC

함수

특정 조건의 값(합계, 갯수, 최대값, true/false 등)를 나타내 주는 것을 도와줌.
함수 전체 보러가기

함수명	기능설명	사용예시
collect()	특정 조건으로 노드를 그룹화하고 그 한 그룹에 속하는 노드의 목록을 보여줌.	MATCH (n:person) RETURN collect(n.sex), n.name
count()	노드의 갯수, (SQL의 count)	MATCH (n:person) return n.sex ,count(n)
exist()	()안의 특정 값이 있는 경우 (SQL의 where is not null)	MATCH (p:Person) WHERE exists(p.firstname) RETURN p
none()	()안의 특정 값이 없는 경우 (SQL의 where is null)	MATCH (p:Person) WHERE none(p.firstname) RETURN p
min(), max(), sum()	()안의 값의 최소값, 최대값, 합계
length()	노드와 노드 사이의 거리 (관계를 정의할때 를 적어주어야 함. 그렇지 않으면 length의 값이 모두 1로 나옴(관계정의의 기본 단계값이 1이기 때문에 여러 단계의 관계를 보고 싶을때는 를 써줌).	MATCH P=(A:Person) -[:Knows*]-> (B:Person) RETURN length(P)
shortestPath()	노드와 노드 사이의 가장 빠른 길	MATCH P=shortestPath((A:Person{name:'AA'}) -[*]-> (B:Person{name:'BB'})) RETURN P

Cypher 실습

Neo4j 샘플:DH 프로젝트
클래스 Actor만 보여라

match (n:Actor) return n

클래스가 Actor인 개체의 한글이름과 한자이름을 보여라.

match (n:Actor) return n.name, n.chname

프로젝트가 워커힐인 개체를 모두 보여라 (아무거나 25개만 보여라)

MATCH (n) where n.project="워커힐" RETURN n (LIMIT 25)

방문했다(visits)라는 관계를 개체를 모두 보여라.

MATCH p=()-[r:visits]->() RETURN p

아버지와 아들(hasSon)의 관계를 가진 인물들의 이름과 거리를 보여라.

match p=(A:Actor)-[:hasSon*]->(B:Actor) return A.name,B.name, length(p)

이벤트의 이름과 이벤트에 참여한 행위자의 수를 내림차순으로 보여라.

match (e:Event)<-[:Creates]-(a:Actor) return e.name as eventName, count(a) as 참여인원 order by 참여인원 desc

이벤트와 그 이벤트가 열린 장소를 모두 보여라.

match (n:Place)<-[:isHeldAt]-(o) return n,o

과거 프로젝트 : 강세윤과 두단계까지만 연결된 인물들을 보여라

match (a1:Actor{name:"강세윤"}) -[*1..2]- (a2:Actor) where a1.project="과거" and a2.project="과거" return a1, a2

포미닛과 외화벌이(개념)을 연결하는 가장 빠른 길은?

match (포미닛{name:"포미닛"}), (외화벌이{name:"외화벌이"}), 빠른길= shortestPath((포미닛)-[*]-(외화벌이)) return 포미닛, 외화벌이, 빠른길

워커힐 프로젝트의 actor를 group 속성으로 분류하고, 각 속성에 속하는 개체의 이름을 보여라.

match (n:Actor) where n.project="워커힐" return n.group, count(n) as 분류, collect(n.name)

@@ 32번째 줄: / 32번째 줄: @@
 ===Cyper의 기본 구조===
   MATCH <pattern> WHERE <conditions> RETURN <expressions>
+===변수===
+ (변수:라벨{속성:속성값})
+ 변수=(노드)-[관계]->(노드)
+*특정 관계나 값 등을 가진 형태를 가진 임의의 값. (중학생 때 배운 미지수 X와 같음)
+*불필요한 코드의 반복을 피하기 위해 코딩언어에서 사용.
+===Node/Property===
+ (변수:라벨{속성:"속성값"})
+ 변수.속성
+*<SPAN STYLE="COLOR:LightSeaGreen ">(A:Person{name:"이혜영"})</span> : name 속성값이 "이혜영"이고, 라벨이 Person이 노드 A
+*<SPAN STYLE="COLOR:LightSeaGreen ">A.name</span> : 노드A의 name 속성
 ===Relation===
   -[변수:릴레이션{속성:"속성값"}]->
-ex)
+*<SPAN STYLE="COLOR:LightSeaGreen ">A -[:Knows]-> B </span>: Knows 관계를 가진 A와 B
-*A -[:Knows]-> B: Knows 관계를 가진 A와 B
+*<SPAN STYLE="COLOR:LightSeaGreen ">A -[*]-> B </SPAN>: 관계를 가진 A와 B
-*A -[*]-> B : 관계를 가진 A와 B
+*<SPAN STYLE="COLOR:LightSeaGreen ">A --> B </SPAN>: 관계를 가진 A와 B
-*A --> B : 관계를 가진 A와 B
+*<SPAN STYLE="COLOR:LightSeaGreen ">A -[*1..3]-> B </SPAN>: 1~3의 거리를 가진 A와 B
-*A -[*1..3]-> B : 1~3의 거리를 가진 A와 B
+*<SPAN STYLE="COLOR:LightSeaGreen ">A -[:Knows*1..3]-> B </SPAN>: Knows관계의 거리가 1~3인 A와 B
-*A -[:Knows*1..3]-> B : Knows관계의 거리가 1~3인 A와 B
+*<SPAN STYLE="COLOR:LightSeaGreen ">A -[:Knows{since:2009}]-> B </SPAN>: Knows관계를 가지고 since 속성이 2009값을 가지는 A와 B
+===Where===
+*조건을 지정하기 위해 쓰임.
+*>,<,=, in, starts with, ends with, contains 등과 함께 쓰임.
+*<SPAN STYLE="COLOR:LightSeaGreen ">Where A.name="ooo"</span>: name 속성의 값이 ooo인 노드 A
+*<SPAN STYLE="COLOR:LightSeaGreen ">Where A.name in ["aaa", "bbb", "ccc"]</span>: name 속성이 값이 aaa, bbb, ccc 중 하나의 값을 가지는 노드 A
+*<SPAN STYLE="COLOR:LightSeaGreen ">Where A.name starts with "A"</span>: name 속성의 값이 A로 시작하는 노드 A (SQL의 where name like 'A%')
+*<SPAN STYLE="COLOR:LightSeaGreen ">Where A.name ends with "A"</span>: name 속성의 값이 A로 끝나는 노드 A (SQL의 where name like '%A')
+*<SPAN STYLE="COLOR:LightSeaGreen ">Where A.name contains "A"</span>: name 속성의 값에 A가 들어가는 노드 A (SQL의 where name like '%A%')
 ===Create===
+*노드 및 관계 생성
   CREATE (변수:라벨 { 속성: "속성값", 속성: "속성값" })
-ex)
+ CREATE (A:라벨 { 속성: "속성값", 속성: "속성값" }),  (B:라벨 { 속성: "속성값", 속성: "속성값" }), (A)-[:관계{속성:속성값}]->(B)
-*CREATE (ee:Person { name: "Emil", from: "Sweden", klout: 99 }) : 이름이 Emil이고 출신이 Sweden, 영향력이 99인 Person 라벨의 개체를 만들어라.
+*<SPAN STYLE="COLOR:LightSeaGreen ">CREATE (ee:Person { name: "Emil", from: "Sweden", klout: 99 }) </span>
-*CREATE (js:Person { name: "Johan", from: "Sweden", learn: "surfing" }), (ir:Person { name: "Ian", from: "England", title: "author" }), (js)-[:KNOWS {since: 2001}]->(ir) :
+: 이름이 Emil이고 출신이 Sweden, 영향력이 99인 Person 라벨의 개체를 만들어라.
-''이름이 johan이고 출신이 sweden이고 배우는 것이 surfing이고, 라벨이 person인 개체(js)와 이름이 lan이고 출신이 England이고 칭호가 작가이고 라벨이 Person인 개체(jr)을 만들어라. 그리고 js와 jr은 KNOWS라는 관계를 가지고, 그 관계의 since라는 속성은 2001이란 값을 가진다.
+*<SPAN STYLE="COLOR:LightSeaGreen ">CREATE (js:Person { name: "Johan", from: "Sweden", learn: "surfing" }), (ir:Person { name: "Ian", from: "England", title: "author" }), (js)-[:KNOWS {since: 2001}]->(ir) </span>
-<!--
+: 이름이 johan이고 출신이 sweden이고 배우는 것이 surfing이고, 라벨이 person인 개체(js)와 이름이 lan이고 출신이 England이고 칭호가 작가이고 라벨이 Person인 개체(jr)을 만들어라. 그리고 js와 jr은 KNOWS라는 관계를 가지고, 그 관계의 since라는 속성은 2001이란 값을 가진다.
- CREATE (ee:Person { name: "Emil", from: "Sweden", klout: 99 })
-''이름이 Emil이고 출신이 Sweden, 영향력이 99인 Person 라벨의 개체를 만들어라.''
+===Delete===
- CREATE (js:Person { name: "Johan", from: "Sweden", learn: "surfing" }), (ir:Person { name: "Ian", from: "England", title: "author" }), (js)-[:KNOWS {since: 2001}]->(ir)
+*노드 및 관계 삭제
-''이름이 johan이고 출신이 sweden이고 배우는 것이 surfing이고, 라벨이 person인 개체(js)와 이름이 lan이고 출신이 England이고 칭호가 작가이고 라벨이 Person인 개체(jr)을 만들어라. 그리고 js와 jr은 KNOWS라는 관계를 가지고, 그 관계의 since라는 속성은 2001이란 값을 가진다.
+  MATCH (A:Person) WHERE A.id="0000" DELETE A
-*Match : finding Nodes
+ MATCH (n { name: 'Andres' })-[r:KNOWS]->() DELETE r
-  MATCH (ee:Person) WHERE ee.name = "Emil" RETURN ee;
+===SET / REMOVE ===
-''라벨이 Person인 개체 중에 이름 속성이 emil인 것의 그 개체 자체(모든 것)를 보여라.''
+*노드 수정
-*Pattern Matching
+ MATCH (n { name: 'Andres' }) SET n.position = 'Developer', n.surname = 'Taylor'
-  MATCH (ee:Person)-[:KNOWS]-(friends) WHERE ee.name = "Emil" RETURN ee, friends
+ MATCH (n { name: 'Peter' }) REMOVE n:German RETURN n
-''라벨이 Person인 개체 중에 이름이 에밀이란 개체와 KNOWS란 관계를 가진 것을 friends라 한다. 그 에밀이란 개체(ee)와 friends을 보여라.''
+===UNION / Order by===
-*Using Pattern
+*Union : 합집합 / join
- MATCH (js:Person)-[:KNOWS]-()-[:KNOWS]-(surfer) WHERE js.name = "Johan" AND surfer.hobby = "surfing" RETURN DISTINCT surfer
+  MATCH (n:Actor) RETURN n.name UNION MATCH (n:Movie) RETURN n.title
-''라벨이 Person인 개체(js) 중 KNOWS와 KNOWS가 두번 연결된 관계에 있는 것을 surfer라 한다. 이름이 johan인 개체(js) surfer의 취미가 surfing인 것들 중 surfer들의 고유값을 보여줘라.
+*Order by : 보여줄 차순, 기본값 오름차순/ desc : 내림차순
--->
+ MATCH (n:Actor) RETURN n.name, n.age ORDER BY n.age DESC
+===함수===
+*특정 조건의 값(합계, 갯수, 최대값, true/false 등)를 나타내 주는 것을 도와줌.
+*[https://neo4j.com/docs/developer-manual/current/cypher/functions/ 함수 전체 보러가기]
+{|class="wikitable"
+!함수명!!기능설명 !! 사용예시
+|-
+| collect() || 특정 조건으로 노드를 그룹화하고 그 한 그룹에 속하는 노드의 목록을 보여줌. || MATCH (n:person) RETURN collect(n.sex), n.name
+|-
+| count() || 노드의 갯수, (SQL의 count) || MATCH (n:person) return n.sex ,count(n)
+|-
+| exist() || ()안의 특정 값이 있는 경우 (SQL의 where is not null) || MATCH (p:Person) WHERE exists(p.firstname) RETURN p
+|-
+| none() || ()안의 특정 값이 없는 경우 (SQL의 where is null) || MATCH (p:Person) WHERE none(p.firstname) RETURN p
+|-
+| min(), max(), sum() || ()안의 값의 최소값, 최대값, 합계 ||
+|-
+| length() || 노드와 노드 사이의 거리<br/>(관계를 정의할때 *를 적어주어야 함. 그렇지 않으면 length의 값이 모두 1로 나옴(관계정의의 기본 단계값이 1이기 때문에 여러 단계의 관계를 보고 싶을때는 *를 써줌). || MATCH P=(A:Person) -[:Knows*]-> (B:Person) RETURN length(P)
+|-
+| shortestPath() || 노드와 노드 사이의 가장 빠른 길 || MATCH P=shortestPath((A:Person{name:'AA'}) -[*]-> (B:Person{name:'BB'})) RETURN P
+|-
+|}
 ==Cypher 실습==
-*[http://dh.aks.ac.kr:7474/browser/ Neo4j 샘플:워커힐 프로젝트]
+*[http://dh.aks.ac.kr:7474/browser/ Neo4j 샘플:DH 프로젝트]
 *클래스 Actor만 보여라
   match (n:Actor) return n
@@ 73번째 줄: / 116번째 줄: @@
 *방문했다(visits)라는 관계를 개체를 모두 보여라.
   MATCH p=()-[r:visits]->() RETURN p
+*아버지와 아들(hasSon)의 관계를 가진 인물들의 이름과 거리를 보여라.
+ match p=(A:Actor)-[:hasSon*]->(B:Actor) return A.name,B.name, length(p)
 *이벤트의 이름과 이벤트에 참여한 행위자의 수를 내림차순으로 보여라.
   match (e:Event)<-[:Creates]-(a:Actor) return e.name as eventName, count(a) as 참여인원 order by 참여인원 desc