DH Developement

계속 적을 글

• 본 글은 계속해서 적어갈 예정

Create

• 메서드 설명
  • CREATE: 동일한 내용의 노드가 있더라도 생성함
  • MERGE: 동일한 노드가 있다면 무시하고 진행함
• 쿼리 문에 들어갈 파라미터들은 Prepared 하게 런타임에서 주입
  • Golang에서는 map 에 담아서 사용

CREATE 
(p:Person {name: $name, age: $age, languages: $languages})-[l:LIKES]->(t:Technology {name: $tech})

MERGE 
(p:Person {name: $name, age: $age, languages: $languages})-[l:LIKES]->(t:Technology {name: $tech})

// 각각 노드 생성하고 관계 추가
MERGE (a:Person {name: $name})
MERGE (b:Person {name: $friend})
MERGE (a)-[friendship:KNOWS {since: $friendsSince}]->(b)

// Golang
queryArguments := map[string]interface{}{
    "name": name,
    "age": age,
    "languages": languageList,
    "tech": techName,
}

queryErr := dbCon.Insert(CreatePersonQuery, queryArguments)

Select(Match)

• ExecuteQuery 로 쿼리 수행하고, 나온 데이터를 핸들링한다.
  • []*db.Record 타입으로 리턴됨

내가 핸들링한 방법

• dbtype.node 의 Props로 감싸고, 키 값으로 처리
• 공식문서는 AsMap()으로 처리

// ============== 내가 한 방식 ==============
for _, record := range result {
    person, isPersonExist := record.Get("p")

    if !isPersonExist {
        log.Printf("[SINGLE_PERSON] No Person Data Found: %v", isPersonExist)
        continue
    }

    log.Printf("[SINGLE_PERSON] Get single person: %v", person)

    personProperties := person.(dbtype.Node).Props

    personData := Person{
        Name: personProperties["name"].(string),
        Age: personProperties["age"].(string),
        Languages: personProperties["languages"].([]string),
    }

    personList = append(personList, personData)
}

// ============== 공식문서 ==============
 if employeesN := org.AsMap()["employeesN"].(int64);
       employeesN < employeeThreshold {
        err = addPersonToOrganization(ctx, tx, name, orgId)

        if err != nil {
            return nil, err
            // Transaction will roll back
            // -> not even Person is created!
        }
    }

공식 문서

• 공식 문서: https://neo4j.com/docs/go-manual/current/

Golang으로 연결

• neo4j 드라이버 설치
  • 연결의 인증은 여러 방식이 있음; BasicAuth, BearerAuth, AuthToken, CustomAuth, ...
  • 본 예시는 유저 이름과 패스워드로 인증하는 방식

go get -u github.com/neo4j/neo4j-go-driver/v5/neo4j

• 드라이버 인스턴스 생성

import (
    "github.com/neo4j/neo4j-go-driver/v5/neo4j"
    "github.com/neo4j/neo4j-go-driver/v5/neo4j/db"
)

func main() {
    driver, err := neo4j.NewDriverWithContext(
        "neoj4://<DATABASE_URI>:<DATABASE_PORT>,
        neo4j.BasicAuth(<USER>, <PASSWD>, ""),
    )
}

• 연결 체크

import (
    "context"

    "github.com/neo4j/neo4j-go-driver/v5/neo4j"
    "github.com/neo4j/neo4j-go-driver/v5/neo4j/db"
)

func main() {
    driver, err := neo4j.NewDriverWithContext(
        "neoj4://<DATABASE_URI>:<DATABASE_PORT>,
        neo4j.BasicAuth(<USER>, <PASSWD>, ""),
    )

    ctx := context.Background()

    err := driver.VerifyConnectivity(ctx)

    if err != nil {
        log.Printf("[GRAPH_DB] Check Connection Error: %v", err)
        return err
    }

    defer driver.Close(ctx)

    return nil
}

Golang으로 쿼리

• 쿼리 실행
  • ExecuteQuery 메서드로 쿼리 실행

import (
    "context"

    "github.com/neo4j/neo4j-go-driver/v5/neo4j"
    "github.com/neo4j/neo4j-go-driver/v5/neo4j/db"
)

func main() {
    driver, err := neo4j.NewDriverWithContext(
        "neoj4://<DATABASE_URI>:<DATABASE_PORT>,
        neo4j.BasicAuth("<USER>", "<PASSWD>", ""),
    )

    ctx := context.Background()

    // 쿼리 실행
    result, queryErr := neo4j.ExecuteQuery(
        ctx, 
        driver, 
        "MERGE (n:Node {name:"$nodeName"})", // Node라는 유니크 노드 생성
        []map[string]interface{ // 파라미터 생성. nodeName에 들어갈 값
            nodeName: "New Node"
        }, 
        neo4j.EagerResultTransformer, // 쿼리 결과 변환
        neo4j.ExecuteQueryWithDatabase("neo4j"),
    )

    if queryErr != nil {
        return nil, queryErr
    }

    defer db.Close(ctx)

    for _, record := range result.Records {
        log.Printf("[GRAPH_DB] Query Result: %v", record.Values...)
    }

    // 쿼리 결과에 대한 요약
    log.Printf("The query `%v` returned %v records in %+v.\n",
        result.Summary.Query().Text(), len(result.Records),
        result.Summary.ResultAvailableAfter())
}

• 아래는 쿼리문이 아니라 표현식이다.

(:nodes)-[:ARE_CONNECTED_TO]->(:otherNodes)

• () 기호는 노드를 의미함
• -[]-> 는 노드 간의 관계를 의미함
• 각 노드와 관계에 대해 properties를 할당함
• 노드들은 특정 라벨에 의해 그룹화 될 수 있음
  • 라벨은 테이블, 노드는 레코드라고 생각할 수 있음

노드 변수

• SQL의 Alias라고 생각하면 됨.
  • 즉 쿼리에서의 변수 선언
• 노드 앞에 : 가 없다면 그 자체가 변수가 되어버림
  • 이건 관계에서도 동일함

// 변수 없을 때
MATCH (:Person)
Return Person


// 변수 있을 때
MATCH (p:Person)
RETURN p

// 변수만 돌려줌
MATCH (Person)
RETURN Person

관계

• 관계는 언제나 화살표로 방향을 가지고 있음
• 방향이 선언되지 않은 경우 MATCH 구문을 사용함
  • 방향이 특정되지 않았다는 것은, 어느 방향으로든 가능하다는 의미
• 아래 예시는 쿼리문이 아니라 설명임
• // 오른쪽 방향 [p:Person]-[:LIKES]->(t:Technology)

// 왼쪽방향
[p:Person]<-[:LIKES]-(t:Technology)

// 방향 없을 때
(p:Person)-[:LIKES]-(t:Technology)

### 관계 타입
* 관계 타입은 자연어 처럼 노드들이 서로 관계하는지를 알려준다
* 관계 타입은 **관계들을 카테고리 화** 시킨다.
    * 이는 라벨이 노드들을 하나로 묶는것과 비슷한 역할
* 또한 노드들이 서로 어떻게 관계하는지를 설명한다

```cypher
MATCH (p:Person)-[r:LIKES]->(t:Technology)
RETURN p,r,t

다양한 관계들

• 관계라는게 매개 테이블 처럼 생각하면 될 것 같다.

CREATE
  (alice:Person {name:'Alice', age: 38, eyes: 'brown'}),
  (bob:Person {name: 'Bob', age: 25, eyes: 'blue'}),
  (charlie:Person {name: 'Charlie', age: 53, eyes: 'green'}),
  (daniel:Person {name: 'Daniel', eyes: 'brown'}),
  (eskil:Person {name: 'Eskil', age: 41, eyes: 'blue'}),
  (alice)-[:KNOWS]->(bob),
  (alice)-[:KNOWS]->(charlie),
  (bob)-[:KNOWS]->(daniel),
  (charlie)-[:KNOWS]->(daniel),
  (bob)-[:MARRIED]->(eskil)

Properties

• 노드와 관계 모두에 추가될 수 있는 데이터 타입들
• properties는 {key: 'value'} 로 담는다

// 프로퍼티 생성
CREATE (p:Person {name:'Sally'})-[r:IS_FRIENDS_WITH]->(p:Person {name:'John'})
RETURN p, r

// 이건 쿼리가 아님
(p:Person {name: "Sally"})-[r:LIKES]->(g:Technology {type: "Graphs"})

쿼리문

// 생성
CREATE (p:Person {name: "Sally"})-[r:LIKES]->(t:Technology {type: "Graphs"})

// 조회
MATCH (p:Person {name: "Sally"})-[r:LIKES]->(t:Technology {type: "Graphs"})
RETURN p,r,t

// 조회
MATCH (p:Product)
RETURN p.productName, p.unitPrice
ORDER BY p.unitPrice DESC
LIMIT 10;

// WHERE 문 이용한 조회
MATCH (p:Product)
WHERE p.productName = 'Chocolade'
RETURN p.productName, p.unitPrice;

// properties 조회
MATCH (p:Product {productName:'Chocolade'})
RETURN p.productName, p.unitPrice;

// IN 이용한 조회
MATCH (p:Product)
WHERE p.productName IN ['Chocolade','Chai']
RETURN p.productName, p.unitPrice;

// LIKE 이용한 조회
MATCH (p:Product)
WHERE p.productName STARTS WITH 'C' AND p.unitPrice > 100
RETURN p.productName, p.unitPrice;

// 정규식을 이용한 조회
MATCH (p:Product)
WHERE p.productName =~ '^C.*'
RETURN p.productName, p.unitPrice

// JOIN 을 이용한 조회
MATCH (p:Product {productName:'Chocolade'})<-[:ORDERS]-(:Order)<-[:PURCHASED]-(c:Customer)
RETURN DISTINCT c.companyName;

OPTIONAL MATCH

• optional match는 OUTER JOIN 과 같음
• MATCH (c:Customer {companyName:'Drachenblut Delikatessen'}) OPTIONAL MATCH (p:Product)<-[o:ORDERS]-(:Order)<-[:PURCHASED]-(c) RETURN p.productName, toInteger(sum(o.unitPrice * o.quantity)) AS volume ORDER BY volume DESC;

인덱싱

CREATE INDEX Product_productName IF NOT EXISTS FOR (p:Product) ON p.productName;
CREATE INDEX Product_unitPrice IF NOT EXISTS FOR (p:Product) ON p.unitPrice;