Cypher 매뉴얼 v4.2 체험기 조항부문 - sfjun/neo4j GitHub Wiki

Cypher 매뉴얼 v4.2 체험기 참조사이트: https://neo4j.com/docs/cypher-manual/current/clauses/ Neo4j Cypher 매뉴얼

MATCH

1.예제 생성 CREATE (a:Person {name: 'Oliver Stone'}), (b:Person {name: 'Michael Douglas'}), (c:Person {name: 'Charlie Sheen'}),(d:Person {name: 'Martin Sheen'}), (e:Person {name: 'Rob Reiner'}), (f:Movie {title: 'Wall Street'}), (g:Movie {title: 'The American President'}) CREATE (a) -[:DIRECTED]-> (f), (b) -[:ACTED_IN {role: 'Gordon Gekko'}]-> (f), (b) -[:ACTED_IN {role: 'President Andrew Shepherd'}]-> (g), (c) -[:ACTED_IN {role: 'Bud Fox'}]-> (f), (d) -[:ACTED_IN {role: 'Carl Fox'}]-> (f), (d) -[:ACTED_IN {role: 'A.J. Maclnerney'}]-> (g), (e) -[:DIRECTED]-> (g)

3.4. 여러 관계 유형에서 일치

여러관계 유형에서 match or 연결 MATCH (wallstreet { title: 'Wall Street' })<-[:ACTED_IN|:DIRECTED]-(person) RETURN person.name

4.3. 가변 길이 관계, 이해하는데 시간이 오래걸리네

MATCH (charlie { name: 'Charlie Sheen' })-[:ACTED_IN1..3]-(movie:Movie) RETURN movie.title -> MATCH P=(charlie { name: 'Charlie Sheen' })-[:ACTED_IN1..3]-(movie:Movie) RETURN movie.title, length(P) length를 넣어면 이해가 됨

MATCH P=(charlie { name: 'Charlie Sheen' })-[r:ACTED_IN*]-(person:Person) RETURN charlie.name, length(P),person.name

4.4. 여러 관계 유형이있는 가변 길이 관계

MATCH (charlie { name: 'Charlie Sheen' })-[:ACTED_IN|DIRECTED*2]-(person:Person) RETURN person.name ->acted_in 또는 directed 관계중 2홉으로 떨어진 노드추출 (acted_in, acted_in) or ( acted_in, directed) or (directed, directed) 조합시

4.5. 가변 길이 관계의 관계 변수

MATCH p =(actor { name: 'Charlie Sheen' })-[:ACTED_IN*2]-(co_actor) RETURN relationships(p) -> relationships 사용으로 타입 추출 가능

4.9. 바인딩 된 관계에서 일치

MATCH (a)-[r]-(b) WHERE id(r)= 0 RETURN a,b -> id 사용 지정으로 컨트롤 가능

5.1. 단일 최단 경로

shortestPath MATCH P=shortestPath((A:Person{name:'AA'}) -[*]-> (B:Person{name:'BB'})) RETURN P

6.1. ID 별 노드

MATCH (n) WHERE id(n)= 0 RETURN n ->id로 지정하여

6.3. ID 별 다중 노드

MATCH (n) WHERE id(n) IN [0, 3, 5] RETURN n

함수명 기능설명 사용예시 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

OPTIONAL MATCH

  1. 선택적 관계

MATCH (a:Movie { title: 'Wall Street' }) OPTIONAL MATCH (a)-->(x) RETURN x, x.name -> 관계가 있으면 반환됩니다. 그렇지 않은 경우 null 그 자리에 반환됩니다. 한줄이 생기는야 아니냐의 차이(vs. match로 하면 no changes, no records) x x.name null null

MATCH (a:Movie { title: 'Wall Street' }) OPTIONAL MATCH (a)-[r:ACTS_IN]->() RETURN a.title, r -> a.title r "Wall Street" null

RETURN

반환 예제 생성 CREATE (a { happy: 'Yes!', name: 'A', age: 55 }) -[:BLOCKS]-> (b { name: 'B' }), (a) -[:KNOWS]->(b)

노드 반환 MATCH (n { name: 'B' }) RETURN n

  1. 반환 관계 MATCH (n { name: 'A' })-[r:KNOWS]->(c) RETURN r

  2. 모든 요소 반환 MATCH p =(a { name: 'A' })-[r]->(b) RETURN *

  3. 열 별칭 MATCH (a { name: 'A' }) RETURN a.age AS SomethingTotallyDifferent

  4. 기타 표현 MATCH (a { name: 'A' }) RETURN a.age > 30, "I'm a literal",(a)-->()

  5. 독특한 결과 MATCH (a { name: 'A' })-->(b) RETURN DISTINCT b

WITH

MATCH (n) DETACH DELETE n -> 기존자료 삭제

WITH, 예제생성 CREATE (a:Person {name: 'Anders'}, (b:Person {name: 'Ceaser'}, (c:Person {name: 'Bossman'}, (d:Person {name: 'Georage'}, (e:Person {name: 'David'} CREATE (a)-[:BLOCKS]->(b), (c)-[:BLOCKS]->(e), (a)-[:KNOWS]->(c), (c)-[:KNOWS]->(d), (b)-[:KNOWS]->(d), (e)-[:KNOWS]->(a) RETURN *

WITH절을 사용하면 쿼리 부분을 함께 연결하여 하나의 결과를 다음 시작점 또는 기준으로 사용할 수 있습니다. WITH범위의 변수에 영향을 미친다 는 점에 유의하는 것이 중요합니다 . WITH절에 포함되지 않은 변수는 나머지 쿼리로 전달되지 않습니다.

  1. 집계 함수 결과 필터링

MATCH (david { name: 'David' })--(otherPerson)-->() WITH otherPerson, count(*) AS foaf WHERE foaf > 1 RETURN otherPerson.name

  1. 수집을 사용하기 전에 결과 정렬

MATCH (n) WITH n ORDER BY n.name DESC LIMIT 3 RETURN collect(n.name) -> collect 목록으로 반환

MATCH (n) WITH n ORDER BY n.name DESC LIMIT 3 RETURN collect(id(n)) -> id 목록으로 반환 -> collect --> 리스트로 , 반대개념 : unwind

MATCH (n { name: 'Anders' })--(m) WITH m ORDER BY m.name DESC LIMIT 1 MATCH (m)--(o) RETURN o.name --> o.name "Bossman" "Anders"

UNWIND

UNWIND 목록을 일련의 행으로 확장합니다. UNWIND 를 사용하면 모든 목록을 개별 행으로 다시 변환 할 수 있습니다. 이 목록은 전달된 매개 변수, 이전에 collect작성된 결과 또는 기타 목록 표현식 일 수 있습니다.

  1. UNWIND목록을 반환하는 표현식과 함께 사용

WITH [1, 2] AS a,[3, 4] AS b UNWIND (a + b) AS x RETURN x --> x 1 2 3 4

  1. UNWIND목록 목록과 함께 사용

WITH [[1, 2],[3, 4], 5] AS nested UNWIND nested AS x UNWIND x AS y RETURN y

  1. UNWIND빈 목록으로 사용

UNWIND와 함께 빈 목록을 사용하면 행이 미리 존재했는지 여부 또는 다른 값이 프로젝션되는지 여부에 관계없이 행이 생성되지 않습니다

UNWIND [] AS empty RETURN empty, 'literal_that_is_not_returned' -> (no changes, no records)

UNWIND빈 목록에서 실수로 사용 하는 것을 방지하기 위해 빈 목록 CASE을 다음으로 대체하는 데 사용할 수 있습니다 WITH [] AS list UNWIND CASE WHEN list = [] THEN [null] ELSE list END AS emptylist RETURN emptylist

  1. UNWIND목록이 아닌 표현식과 함께 사용

UNWIND NULL AS x RETURN x, 'some_literal'

UNWIND [] AS x RETURN x, 'some_literal' -> 위 두개 같은 의미

MATCH (n { name: 'Anders' })--(m) WITH m ORDER BY m.name DESC LIMIT 1 MATCH (m)--(o) WITH collect(o.name) AS BB UNWIND BB AS CC RETURN CC -> 목록으로 갔다가 개별행으로 갔다가 -> RETURN을 대신에 WITH로 받아서 재활용??

WHERE

예제생성 CREATE (a:Swedish:Person { belt: 'white', name: 'Andy', age: 36 })-[:HAS_DOG { since: 2016 }]->(b:Dog { name: 'Andy' }), (a)-[:KNOWS { since: 1999 }]->(c:Person { email: '[email protected]', name: 'Peter', age: 35 })-[d:HAS_DOG { since: 2010 }]->(e:Dog { name: 'Fido' })-[:HAS_TOY]->(f:Toy { name: 'Banana' }), (c)-[g:HAS_DOG { since: 2018 }]->(h:Dog { name: 'Ozzy' }),(a)-[:KNOWS { since: 2012 }]->(i:Person { address: 'Sweden/Malmo', name: 'Timothy', age: 25 }) ->이중라벨은 붙여서 표기해야 한참 찾았네

2.1. 부울 연산 MATCH (n:Person) WHERE n.name = 'Peter' XOR (n.age < 30 AND n.name = 'Timothy') OR NOT (n.name = 'Timothy' OR n.name = 'Peter') RETURN n.name, n.age -> XOR, OR NOT 헤갈리지만

2.2. 노드 레이블에서 필터링 MATCH (n) WHERE n:Swedish RETURN n.name, n.age -> where 절에 n:Swedish =을 사용하는게 아니고...특이하네 n.name n.age "Andy" 36

2.4. 관계 속성에 대한 필터링 MATCH (n:Person)-[k:KNOWS]->(f) WHERE k.since < 2000 RETURN f.name, f.age, f.email -> f.name f.age f.email "Peter" 35 "[email protected]"

2.5. 동적으로 계산 된 노드 속성에 대한 필터링 WITH 'AGE' AS propname MATCH (n:Person) WHERE n[toLower(propname)]< 30 RETURN n.name, n.age -> n.name n.age "Timothy" 25 ->변수($~~)와는 다른 with로 동적 노드 속성 지정

2.6. 속성 유무 확인 MATCH (n:Person) WHERE EXISTS (n.belt) RETURN n.name, n.belt -> n.name n.belt "Andy" "white" exists 없으면 (no changes, no records)

3.1. 다음을 사용하여 접두사 문자열 검색STARTS WITH MATCH (n:Person) WHERE n.name STARTS WITH 'Pet' RETURN n.name, n.age

3.2. 다음을 사용하여 접미사 문자열 검색ENDS WITH MATCH (n:Person) WHERE n.name ENDS WITH 'ter' RETURN n.name, n.age

3.3. 다음을 사용하여 하위 문자열 검색CONTAINS MATCH (n:Person) WHERE n.name CONTAINS 'ete' RETURN n.name, n.age

4.1. 정규식을 사용한 일치 MATCH (n:Person) WHERE n.name =~ 'Tim.*' RETURN n.name, n.age ->.이 중요 n.name n.age "Timothy" 25

MATCH (n:Person) WHERE n.email =~ '.*\.com' RETURN n.name, n.age, n.email ->왜 2개 이스케이프를 사용하는지?? .을 위한 한개만 있으면 되는거 아닌가?

4.3. 대소 문자를 구분하지 않는 정규식 MATCH (n:Person) WHERE n.name =~ '(?i)AND.*' RETURN n.name, n.age 정규식 앞에를 추가 (?i)하면 전체식이 대소 문자를 구분하지 않습니다.

5.1. 패턴 필터링 MATCH (timothy:Person { name: 'Timothy' }),(other:Person) WHERE other.name IN ['Andy', 'Peter'] AND (timothy)<--(other) RETURN other.name, other.age ->match에 한해서 other.name other.age "Andy" 36

5.2. 다음을 사용하여 패턴 필터링NOT MATCH (person:Person),(peter:Person { name: 'Peter' }) WHERE NOT (person)-->(peter) RETURN person.name, person.age -> match 에서 대상 지정됨 person.name person.age "Peter" 35 "Timothy" 25

5.3. 속성이있는 패턴 필터링 MATCH (n:Person) WHERE (n)-[:KNOWS]-({ name: 'Timothy' }) RETURN n.name, n.age -> n.name n.age "Andy" 36

5.4. 관계 유형 필터링 MATCH (n:Person)-[r]->() WHERE n.name='Andy' AND type(r)=~ 'K.*' RETURN type(r), r.since -> 관계레이블을 찾는 함수는 type type(r) r.since "KNOWS" 1999 "KNOWS" 2012

6.1. 단순 존재 하위 쿼리 MATCH (person:Person) WHERE EXISTS { MATCH (person)-[:HAS_DOG]->(:Dog) } RETURN person.name as name -> name "Andy" "Peter"

6.3. 존재하는 하위 쿼리 중첩 MATCH (person:Person) WHERE EXISTS { MATCH (person)-[:HAS_DOG]->(dog:Dog) WHERE EXISTS { MATCH (dog)-[:HAS_TOY]->(toy:Toy) WHERE toy.name = 'Banana' } } RETURN person.name as name ->그림처럼 그냥 쭉 써면 쿼리가 되네

7.1. IN운영자 MATCH (a:Person) WHERE a.name IN ['Peter', 'Timothy'] RETURN a.name, a.age

8.2. true속성이 누락 된 경우 기본값 MATCH (n:Person) WHERE n.belt = 'white' OR n.belt IS NULL RETURN n.name, n.age, n.belt ORDER BY n.name ->belt 속성이 없는경우 NULL 사용,

8.3. 필터링null MATCH (person:Person) WHERE person.name = 'Peter' AND person.belt IS NULL RETURN person.name, person.age, person.belt -> person.name person.age person.belt "Peter" 35 null

9.1. 간단한 범위 MATCH (a:Person) WHERE a.name >= 'Peter' RETURN a.name, a.age ->알파벳으로 비교 a.name a.age "Peter" 35 "Timothy" 25 -> 부등호를 바꾸면(<) Andy만 나옴

9.2. 복합 범위 MATCH (a:Person) WHERE a.name > 'Andy' AND a.name < 'Timothy' RETURN a.name, a.age -> a.name a.age "Peter" 35

ORDER

예시생성 CREATE (a:A {name: 'A', length: 185, age: 34}) -[:KNOWS]-> (b:B {name:'B', age: 36}) -[:KNOWS]-> (c:C {name: 'C', length: 185, age: 32})

  1. WITH조항의 주문 MATCH (n) WITH n ORDER BY n.age RETURN collect(n.name) AS names ->with 있어야만 없으면 에러 names ["C", "A", "B"]

SKIP

예제생성 CREATE (a:A {name: 'A'}) -[:KNOWS]-> (b:B {name: 'B'}), (a) -[:KNOWS]-> (c:C {name: 'C'}), (a) -[:KNOWS]-> (d:D {name: 'D'}), (a) -[:KNOWS]-> (e:E {name: 'E'})

  1. 가운데 두 행 반환 MATCH (n) RETURN n.name ORDER BY n.name SKIP 1 LIMIT 2 -> n.name "B" "C"
  1. 표현식을 사용 SKIP하여 행의 하위 집합 반환 MATCH (n) RETURN n.name ORDER BY n.name SKIP toInteger(3*rand())+ 1 ->매뉴얼 결과가 이상함, 수정이 필요 n.name "D" "E"

CREATE

예제생성 CREATE (a:Person { name: 'A' }), (b:Person { name: 'B' })

2.1. 두 노드 간의 관계 생성 MATCH (a:Person),(b:Person) WHERE a.name = 'A' AND b.name = 'B' CREATE (a)-[r:RELTYPE]->(b) RETURN type(r) -> type(r) "RELTYPE"

중복 관계중 id 2번 지우기 전체 보기로 id 확인 후 MATCH (n { name: 'A' })-[r:RELTYPE]->() WHERE id(r) = 2 DELETE r

2.2. 관계 생성 및 속성 설정 MATCH (a:Person),(b:Person) WHERE a.name = 'A' AND b.name = 'B' CREATE (a)-[r:RELTYPE { name: a.name + '<->' + b.name }]->(b) RETURN type(r), r.name

  1. 전체 경로 만들기 CREATE p =(andy { name:'Andy' })-[:WORKS_AT]->(neo)<-[:WORKS_AT]-(michael { name: 'Michael' }) RETURN p ->이 쿼리는 한 번에 세개의 노드와 두개의 관계를 만들고 경로 변수에 할당 한 다음 반환합니다.

DELETE

예제생성 CREATE (a:Person { name: 'Andy' })-[:KNOWS]->(b:Person { name: 'Timothy', age: 25 }), (a)-[:KNOWS]->(c:Person { name: 'Peter', age: 34 }), (d:Person { name: 'UNKNOWN' }) RETURN *

  1. 단일 노드 삭제 MATCH (n:Person { name: 'UNKNOWN' }) DELETE n
  1. 모든 노드 및 관계 삭제 MATCH (n) DETACH DELETE n
  1. 모든 관계가있는 노드 삭제 MATCH (n { name: 'Andy' }) DETACH DELETE n
  1. 관계만 삭제 MATCH (n { name: 'Andy' })-[r:KNOWS]->() DELETE r

SET

CREATE ({name: 'Stefan'})-[:KNOWS]->(:Swedish {hungry: true, name: 'Andy', age: 36})-[:KNOWS]->({name: 'Peter', age: 34})<-[:KNOWS]-({name: 'George'})

  1. 속성 설정 MATCH (n { name: 'Andy' }) SET n.surname = 'Taylor' RETURN n.name, n.surname

MATCH (n { name: 'Andy' }) SET ( CASE WHEN n.age = 36 THEN n END ).worksIn = 'Malmo' RETURN n.name, n.worksIn

  1. 속성 업데이트 MATCH (n { name: 'Andy' }) SET n.age = toString(n.age) RETURN n.name, n.age
  1. 속성 제거 REMOVE일반적으로 속성을 제거하는 데 사용 되지만 SET명령을 사용하여 수행하는 것이 편리한 경우가 있습니다 . 적절한 경우는 속성이 매개 변수에 의해 제공되는 경우입니다.

이름 제거 MATCH (n { name: 'Andy' }) SET n.name = NULL RETURN n.name, n.age

이름복구 MATCH (n { surname: 'Taylor' }) SET n.name = 'Andy' RETURN n.name, n.age

  1. 노드와 관계간에 속성 복사 MATCH (at { name: 'Andy' }),(pn { name: 'Peter' }) SET at = pn RETURN at.name, at.age, at.hungry, pn.name, pn.age

6.지도를 사용하여 모든 속성을 교체하고 = MATCH (p { name: 'Peter' }) SET p = { name: 'Peter Smith', position: 'Entrepreneur' } RETURN p.name, p.age, p.position -> p.name p.age p.position "Peter Smith" null "Entrepreneur"

  1. 빈지도를 사용하여 모든 속성을 제거하고 = MATCH (p { name: 'Peter Smith' }) SET p = { } RETURN p.name, p.age

8.지도를 사용하여 특정 속성을 변경하고 += MATCH (p { name: 'Peter' }) SET p += { age: 38, hungry: TRUE , position: 'Entrepreneur' } RETURN p.name, p.age, p.hungry, p.position

속성 대체 연산자와 달리= 빈지도를 오른쪽 피연산자로 제공하면 +=노드 또는 관계에서 기존 속성이 제거되지 않습니다. 위에 설명 된 의미에 따라 빈 맵을 +=전달해도 효과가 없습니다. MATCH (p { name: 'Peter' }) SET p += { } RETURN p.name, p.age

  1. 하나의 SET절을 사용하여 여러 속성 설정 MATCH (n { name: 'Andy' }) SET n.position = 'Developer', n.surname = 'Taylor'
  1. 매개 변수를 사용하여 속성 설정 매개변수를 설정이 안되어 with 사용

with { surname: "sfjun" } AS aa MATCH (n { name: 'Andy' }) SET n.surname = aa.surname RETURN n.name, n.surname -> n.name n.surname "Andy" "sfjun"

  1. 매개 변수를 사용하여 모든 속성 설정 WITH { props : { name: "Andy", position : "Developer" } }AS bb MATCH (n { name: 'Andy' }) SET n = bb.props RETURN n.name, n.position, n.age, n.hungry -> n.name n.position n.age n.hungry "Andy" "Developer" null null
  1. 노드에 레이블 설정 MATCH (n { name: 'Stefan' }) SET n:German RETURN n.name, labels(n) AS labels -> 특이하게 리스트로 나오네.. 중복이 될수 있으니... n.name labels "Stefan" ["German"]
  1. 노드에 여러 레이블 설정 MATCH (n { name: 'George' }) SET n:Swedish:Bossman RETURN n.name, labels(n) AS labels -> n.name labels "George" ["Swedish", "Bossman"]

REMOVE

이 REMOVE절은 노드 및 관계에서 속성을 제거하고 노드에서 레이블을 제거하는 데 사용됩니다.

예제생성 CREATE (a:Swedish { name: 'Andy', age: 36})-[:KNOWS]->(b:Swedish:German { name: 'Peter', age: 34}), (a)-[:KNOWS]->(c:Swedish { name: 'Timothy', age: 25})

  1. 속성 제거

MATCH (a { name: 'Andy' }) REMOVE a.age RETURN a.name, a.age

-> 아래 동일한 효과 차이는 REMOVE냐 SET이냐 Neo4j는 null속성에 저장할 수 없습니다 .

MATCH (a { name: 'Andy' }) SET a.age = null RETURN a.name, a.age

  1. 모든 속성 제거 REMOVE는 노드 또는 관계에서 모든 기존 속성을 제거하는데 사용할 수 없습니다. 대신 SET 및 with = { }을 오른쪽 피연산자 로 사용하면 노드 또는 관계에서 모든 속성이 지워 집니다.

전체 노드의 전체 속성을 삭제

MATCH (p) SET p = { } RETURN p.name, p.age

  1. 노드에서 레이블 제거 MATCH (n { name: 'Peter' }) REMOVE n:German RETURN n.name, labels(n) -> n.name labels(n) "Peter" ["Swedish"]
  1. 노드에서 여러 레이블 제거 MATCH (n { name: 'Peter' }) REMOVE n:German:Swedish RETURN n.name, labels(n) -> n.name labels(n) "Peter" []

FOREACH

이 FOREACH절은 경로의 구성 요소 또는 집계 결과에 관계없이 목록 내의 데이터를 업데이트하는 데 사용됩니다. 예제생성 CREATE (a:Person { name: 'A'})-[:KNOWS]->(b:Person { name: 'B'})-[:KNOWS]->(c:Person { name: 'C'})-[:KNOWS]->(d:Person { name: 'D'}

  1. 경로를 따라 모든 노드 표시 각 노드에 속성추가 반복 MATCH p =(begin)-[*]->(END ) WHERE begin.name = 'A' AND END .name = 'D' FOREACH (n IN nodes(p) | SET n.marked = TRUE )

MERGE ->update and create??

CREATE (a:Person { bornIn: 'New York', name: 'Charlie Sheen', chauffeurName: 'John Brown' }), (b:Person { bornIn: 'New York', name: 'Oliver Stone', chauffeurName: 'Bill White' }),(c:Person { chauffeurName: 'John Brown', bornIn: 'New Jersey', name: 'Michael Douglas' }), (d:Person { bornIn: 'Ohio', name: 'Martin Sheen', chauffeurName: 'Bob Brown' }), (e:Person { bornIn: 'New York', name: 'Rob Reiner', chauffeurName: 'Ted Green' }), (m1:Movie { title: 'Wall Street'}), (m2:Movie { title: 'The American President' }) CREATE (a)-[:ACTED_IN]->(m1), (a)-[:FATHER]->(d),(b)-[:ACTED_IN]->(m1),(c)-[:ACTED_IN]->(m1), (d)-[:ACTED_IN]->(m1),(d)-[:ACTED_IN]->(m2), (e)-[:ACTED_IN]->(m2)

2.1. 단일 노드를 레이블과 병합 ->단일노드 병합(없으면 생성) MERGE (robert:Critic) RETURN robert, labels(robert) ->Critic데이터베이스에 레이블이 지정된 노드가 없기 때문에 새 노드가 생성 됩니다.

2.2. 단일 노드를 속성과 병합 MERGE (charlie { name: 'Charlie Sheen', age: 10 }) RETURN charlie ->모든 속성이 기존 'Charlie Sheen' 노드 와 일치하는 것은 아니므로 즉 age: 10이 안맞아 이름이 'Charlie Sheen'인 새 노드 가 생성됩니다 .

2.3. 레이블과 속성을 모두 지정하는 단일 노드 병합 MERGE (michael:Person { name: 'Michael Douglas' }) RETURN michael.name, michael.bornIn ->MATCH (michael:Person { name: 'Michael Douglas' }) 하면 값이 나오므로 신규생성이 아니고 머지로 진행

앞서 언급했듯이 MERGE쿼리는 스키마 인덱스의 이점을 크게 활용할 수 있습니다. 이 예에서 다음은 MERGE절의 성능을 크게 향상시킵니다 . CREATE INDEX PersonIndex FOR (n:Person) ON (n.name)

2.4. 기존 노드 속성에서 파생된 단일 노드 병합 MATCH (person:Person) MERGE (city:City { name: person.bornIn }) RETURN person.name, person.bornIn, city ->3개 city 노드 생성됨, New York는 data가 3개이지만 Merge로 한개의 노드만 생성

3.1. 와 합치다ON CREATE MERGE (keanu:Person { name: 'Keanu Reeves' }) ON CREATE SET keanu.created = timestamp() RETURN keanu.name, keanu.created

3.2. 와 합치다ON MATCH MERGE (person:Person) ON MATCH SET person.found = TRUE RETURN person.name, person.found

-> ON CREATE SET, ON MATCH SET 생성과 업데이트의 차이? 노드생성할 경우는 on create set을 사용하고 기존 존재하는거면 on match set으로 속성지정 (기존 존재하는 노드에 on create set을 하면 반영이 안됨)

3.3. 와 병합 ON CREATE및ON MATCH MERGE (keanu:Person { name: 'Keanu Reeves' }) ON CREATE SET keanu.created = timestamp() ON MATCH SET keanu.lastSeen = timestamp() RETURN keanu.name, keanu.created, keanu.lastSeen -> on create set으로 생성하고 on match set으로 업데이트로 가능 속성이 중요한것이 아니고 노드가 있고 없고가 기준

3.4. ON MATCH여러 속성 을 설정 하여 병합 MERGE (person:Person) ON MATCH SET person.found = TRUE , person.lastAccessed = timestamp() RETURN person.name, person.found, person.lastAccessed

4.1. 관계에 병합 MATCH (charlie:Person { name: 'Charlie Sheen' }),(wallStreet:Movie { title: 'Wall Street' }) MERGE (charlie)-[r:ACTED_IN]->(wallStreet) RETURN charlie.name, type(r), wallStreet.title

4.2. 여러 관계에서 병합 MATCH (oliver:Person { name: 'Oliver Stone' }),(reiner:Person { name: 'Rob Reiner' }) MERGE (oliver)-[:DIRECTED]->(movie:Movie)<-[:ACTED_IN]-(reiner) RETURN movie ---> 예제 그래프에서 'Oliver Stone' 과 'Rob Reiner' 는 함께 작동 한 적이 없습니다. MERGE"그들 사이의 영화"를 시도 할 때 Neo4j는 이미 두 사람에게 연결된 기존 영화를 사용하지 않고 대신 새로운 'movie' 노드가 생성됩니다.

4.3. 방향이없는 관계에 병합 MATCH (charlie:Person { name: 'Charlie Sheen' }),(oliver:Person { name: 'Oliver Stone' }) MERGE (charlie)-[r:KNOWS]-(oliver) RETURN r -> As 'Charlie Sheen' and 'Oliver Stone' do not know each other this MERGE query will create a KNOWS relationship between them. The direction of the created relationship is arbitrary.

4.4. 두 개의 기존 노드 간의 관계에 병합

에러 데이터 삭제 MATCH (n) WHERE id(n) = 19 DELETE n

MATCH (person:Person) MERGE (city:City { name: person.bornIn }) MERGE (person)-[r:BORN_IN]->(city) RETURN person.name, person.bornIn, city --> 반드시 person에는 born_in 값이 있어야 에러가 안남 그래서 정리가 필요

4.5. 기존 노드와 노드 속성에서 파생 된 병합 된 노드 간의 관계에서 병합 MATCH (person:Person) MERGE (person)-[r:HAS_CHAUFFEUR]->(chauffeur:Chauffeur { name: person.chauffeurName }) RETURN person.name, person.chauffeurName, chauffeur

  1. 고유 한 제약 조건 사용 MERGE CREATE CONSTRAINT ON (n:Person) ASSERT n.name IS UNIQUE; CREATE CONSTRAINT ON (n:Person) ASSERT n.role IS UNIQUE;

5.1. 고유 한 제약 조건을 사용하여 병합하면 노드가 없으면 새 노드가 생성됩니다. MERGE (laurence:Person { name: 'Laurence Fishburne' }) RETURN laurence.name

5.2. 고유 한 제약 조건을 사용하여 병합은 기존 노드와 일치합니다. MERGE (oliver:Person { name: 'Oliver Stone' }) RETURN oliver.name, oliver.bornIn

5.3. 고유 한 제약 조건 및 부분 일치와 병합 MERGE (michael:Person { name: 'Michael Douglas', role: 'Gordon Gekko' }) RETURN michael ->Merge did not find a matching node michael and can not create a new node due to conflicts with existing unique nodes

role 업데이트 하는 법

MERGE (michael:Person { name: 'Michael Douglas' }) SET michael.role = 'Gordon Gekko'

5.5. 지도 매개 변수 사용MERGE WITH { param : { name : "Keanu Reeves", role : "Neo" } } AS aa MERGE (person:Person { name: aa.param.name, role: aa.param.role }) RETURN person.name, person.role ->매개변수를 사용할 수 없어 with로 대체하여 학습

CALL {} Subquery

CREATE (a:Person:Child { name: 'Alice', age: 20 }) -[:CHILD_OF]-> (b:Person:Parent { name: 'Charlie', age: 65 }), (a)-[:FRIEND_OF]->(c:Person { name: 'Bob', age: 27}), (d:Person { name: 'Dora', age: 30 })

  1. 하위 쿼리로 변수 가져 오기

UNWIND [0, 1, 2] AS x CALL { WITH x RETURN x * 10 AS y } RETURN x, y

  1. 노조 후 처리 CALL { MATCH (p:Person) RETURN p ORDER BY p.age ASC LIMIT 1 UNION MATCH (p:Person) RETURN p ORDER BY p.age DESC LIMIT 1 } RETURN p.name, p.age ORDER BY p.name

MATCH (p:Person) CALL { WITH p OPTIONAL MATCH (p)-[:FRIEND_OF]->(other:Person) RETURN other UNION WITH p OPTIONAL MATCH (p)-[:CHILD_OF]->(other:Parent) RETURN other } RETURN DISTINCT p.name, count(other) -> p.name count(other) "Bob" 0 "Alice" 2 "Charlie" 0 "Dora" 0

  1. 집계 및 부작용 MATCH (p:Person) CALL { UNWIND range(1, 5) AS i CREATE (c:Clone) RETURN count(c) AS numberOfClones } RETURN p.name, numberOfClones -> p.name numberOfClones "Bob" 5 "Alice" 5 "Charlie" 5 "Dora" 5
  1. 가져온 변수에 대한 집계 MATCH (p:Person) CALL { WITH p MATCH (other:Person) WHERE other.age < p.age RETURN count(other) AS youngerPersonsCount } RETURN p.name, youngerPersonsCount -> p.name youngerPersonsCount "Bob" 1 "Alice" 0 "Charlie" 3 "Dora" 2

call procedure

CALL db.labels

UNION

예제생성 CREATE (a:Actor { name: 'Anthony Hopkins' })-[:KNOWS]->(b:Actor { name: 'Helen Mirren' })-[:ACT_IN]->(c:Movie { title: 'Hitchcock' }), (a)-[:ACT_IN]->(c), (d:Actor { name: 'Hitchcock' }) --> 반복되는 relationship을 변수로 사용할려고 하다가 실패,,,, apoc....으로 해야되는듯 당장은 사용할 수 없음.

  1. 두 쿼리를 결합하고 중복 유지 두 쿼리의 결과를 결합하려면 UNION ALL. MATCH (n:Actor) RETURN n.name AS name UNION ALL MATCH (n:Movie) RETURN n.title AS name
  1. 두 쿼리를 결합하고 중복 제거

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

CSV로드

메모장으로 artist.csv 생성 생성위치는 C:\neo\neo4jDatabases\database-16496f68-8979-4526-b858-1562a6fcd3e4\installation-4.1.0\import 1,ABBA,1992 2,Roxette,1986 3,Europe,1979 4,The Cardigans,1992

->(오류)교재엔 artists.csv로 's'가 붙어 있음 파일생성은 's'없이 하고 로드할때는 s가 붙어 있음 조심

  1. CSV 파일에서 데이터 가져 오기 LOAD CSV FROM 'File:///artist.csv' AS line CREATE (:Artist { name: line[1], year: toInteger(line[2])}) -> Added 4 labels, created 4 nodes, set 8 properties, completed after 82 ms.
  1. 헤더가 포함 된 CSV 파일에서 데이터 가져 오기

LOAD CSV WITH HEADERS FROM 'File:///artist-with-headers.csv' AS line CREATE (:Artist { name: line.Name, year: toInteger(line.Year)}) ->Added 4 labels, created 4 nodes, set 8 properties, completed after 14 ms. LOAD CSV WITH HEADERS FROM 으로 표기해야

  1. 사용자 정의 필드 구분 기호를 사용하여 CSV 파일에서 데이터 가져 오기

LOAD CSV FROM 'File:///artists-fieldterminator.csv' AS line FIELDTERMINATOR ';' CREATE (:Artist { name: line[1], year: toInteger(line[2])})

  1. 많은 양의 데이터 가져 오기

:auto USING PERIODIC COMMIT LOAD CSV FROM 'File:///artist.csv' AS line CREATE (:Artist { name: line[1], year: toInteger(line[2])}) ->:auto 추가하여 사용

  1. 주기적 커밋 비율 설정 :auto USING PERIODIC COMMIT 500 LOAD CSV FROM 'File:///artist.csv' AS line CREATE (:Artist { name: line[1], year: toInteger(line[2])}) -> 500개 단위로 자동 저장하면서...
  1. 이스케이프 된 문자가 포함 된 데이터 가져 오기 LOAD CSV FROM 'File:///artists-with-escaped-char.csv' AS line CREATE (a:Artist { name: line[1], year: toInteger(line[2])}) RETURN a.name AS name, a.year AS year, size(a.name) AS size ->그냥 가져올때와 차이가 없는데...

LOAD CSV FROM 'File:///artist.csv' AS line CREATE (:Artist { name: line[1], year: toInteger(line[2])})

  1. LOAD CSV와 함께 linenumber () 사용

LOAD CSV FROM 'File:///artist.csv' AS line CREATE (a:Artist { name: line[1], year: toInteger(line[2])}) RETURN linenumber() AS number, a.name, a.year -> number a.name a.year 1 "ABBA" 1992 2 "Roxette" 1986 3 "Europe" 1979 4 "The Cardigans" 1992

  1. LOAD CSV와 함께 file () 사용

LOAD CSV FROM 'File:///artist.csv' AS line RETURN DISTINCT file() AS path ->뭐지...path를 알려구