DH Developement

Centos9 에 Oracle 컨테이너 구동

• 공식 레포지토리 및 문서를 기본으로 진행
• Oracle 에서 파일 다운
  • 19c - Oracle Database 19c for Linux x86-64 ZIP 으로 다운 받음
  • https://www.oracle.com/database/technologies/oracle-database-software-downloads.html#db_free
• 깃허브에서 다운로드
  • 공식 깃허브
    • https://github.com/oracle/docker-images/tree/main/OracleDatabase/SingleInstance/dockerfiles
    • docker-images/OracleDatabase/SingleInstance/dockerfiles로 이동
  • 19.3.0 가 오라클 버전의 도커 이미지
  • 19.3.0 폴더 안에 위에서 받은 오라클 zip 파일 옮겨놓기
  • buildContainerImage.sh 스크립트 실행시키기

    # 필요한 버전을 -v 로 실행시키기
    ./buildContainerImage.sh -v 19.3.0 -e

• docker-compose.yml

services:
    oracle-db:
        shm_size: 8g
        image: oracle/database:19.3.0-ee
        container_name: oracle19c
        ports:
            - "1521:1521" # Oracle Listener Port
            - "5500:5500" # EM Express Port
        environment:
            ORACLE_SID: "ORCLCDB" # Replace with your SID
            ORACLE_PDB: "ORCLPDB1" # Replace with your PDB name
            INIT_SGA_SIZE: "1024" # Replace with your desired SGA size in MB
            INIT_PGA_SIZE: "256" # Replace with your desired PGA size in MB    
            INIT_CPU_COUNT: "2" # Replace with desired CPU count
            INIT_PROCESSES: "300" # Replace with processes init parameter
            ORACLE_EDITION: "standard"
            ORACLE_CHARACTERSET: "AL32UTF8" # Character set for the database
            ENABLE_ARCHIVELOG: "true" # Enable archive log
            ENABLE_FORCE_LOGGING: "true" # Enable force logging    
            ENABLE_TCPS: "true" # Enable TCPS protocol
        volumes:
            - oradata:/opt/oracle/oradata
        ulimits:
            nofile:
                soft: 1024
                hard: 65536
            nproc:
                soft: 2047
                hard: 16384
            stack:
                soft: 10485760
                hard: 33554432
            memlock:
                soft: 3221225472
                hard: 3221225472

volumes:
    oradata:
        external: true

• 이제 컨테이너 실행시키기
  • 생각보다 인스턴스 실행에 시간이 많이 소요됨
• 계정 생성
  • 컨테이너 내부 접속하면 패스워드 세팅 스크립트가 있음
  • 그걸로 일단 디폴트 유저 세팅 한 다음이 sqlplus로 유저 생성

    sudo docker exec -it oracle19c bash

    # 컨테이너 내부에서 sqlplus 사용
    sqlplus / as sysdba

• Identify Available Pluggable Databases (PDBs)

    SHOW PDBS;
    ALTER SESSION SET CONTAINER = <데이터베이스 명>;

• 필요한 유저 생성은 sqlplus에서 아래 쿼리문으로

  • SYSTEM 계정으로 실행

-- Create a user
CREATE USER youruser IDENTIFIED BY yourpassword;

--Grant permissions
GRANT CONNECT, RESOURCE, DBA TO demo;

• 유저 권한 부여를 위해서 세션 연결을 한 후에 하더라
• 사용자가 이미 존재할 때 테이블 생성 명령문

-- 테이블 생성 권한 부여
GRANT CREATE TABLE FROM user;

-- 모든 권한 부여
GRANT ALL PRIVILEGES TO user;

• 덤프는 뜬 거로 임포트 했는데 덤프 데이터에 대한 에러들이 발생함

imp userid=user/password file=./backup.dmp

imp user/password file=./backup.dmp

imp userid=user/password tables=TABLE1 file=./backup.dmp

imp user/password tables=TABLE1 file=./backup.dmp

imp userid=user/password tables=TABLE1,TABLE2,TABLE3 file=./backup.dmp

imp user/password tables=TABLE1,TABLE2,TABLE3  file=./backup.dmp

Standalone 이란

• 독립 / 자립 이라는 의미
• 파일 자체로 완전하게 독립적으로 구동된다는 의미
  • 다른 장비의 도움 없이, 그 자체로 구현이 가능한 것
    • 이건 네트워크도 해당될 수 있음. 즉 오프라인에서도 구동가능한 프로그램을 의미하기도 함
    • 어떤 소프트웨어 번들의 일부분이 아님

예시

• 예시로 자바의 war 파일을 그 자체로 서버로서 사용하는 것
• 혹은 Go 의 빌드된 바이너리 파일을 구동시켜 서버로 사용하는 것
• 도커를 이용한 서버 구동은 stand alone이라 하기 어려움

리눅스 Standalone 네트워크 서비스

• 리눅스 서버에서의 standalone 방식 네트워크 서비스 제공 방식
  • 서버 부팅 시 데몬을 작동시켜 백그라운드에서 대기 시킴
  • 요청 들어올 때 혼자서 처리하는 프로그램
  • 항상 서비스 가능하며, 다른 의존성 없이 바로 네트워크 서비스 데몬이 클라이언트 요청을 처리
• 항상 메모리에 상주해야 하기 때문에 메모리 점유율이 높음

번외 inetd

• 서비스 요청이 있을 때 마다 데몬을 실행시키는 방식
  • 요청이 없을 때에는 대기(잠자는 중)
• 적은 시스템 리소스로 여러가지 서비스를 돌릴수 있다
• 대신 요청이 들어올 때 데몬이 프로그램을 실행시켜야 하므로 속도가 느리다.

예시

• Standalone: Apache 웹서버
• inetd: telnet

• 본 글은 데보션 글을 기반으로 정리 형식에서 작성되었습니다. (해당 링크는 하단에)

gRPC 란?

• 구글에서 개발한 고성능 RPC 프레임워크
• HTTP/2 에서 동작하며 양방향 스트리밍 및 흐름 제어 제공
• 원경으로 호출할 수 있는 메서드 지정하여 서비스 정의하는 개념 기반
  • 클라이언트 어플리케이션이 로컬 객체처럼 다른 컴퓨터의 서버 어플리케이션의 메서드를 직접 호출 가능 -> 분산 어플리케이션 및 서비스 개발에 용이함
• protobuf(IDL로 사용)를 기본 메세지 형식으로 사용
  • IDL (Interface Definition Language)

gRPC 특징

• 언어 독립성: 다양한 언어 지원. 클라이언트와 서버가 다른 언어로 작성되어도 상호작용 가능
• 양방향 스트리밍: HTTP/2를 기반으로 하는 클라이언트 - 서버 간 양방향 스트리밍 지원
• 강력한 타입 체크: 메세지 형식으로 protobufs로 정의하면, gRPC는 Type 체크 제공
• 높은 성능: HTTP/2와 protobufs 를 활용한 높은 성능 제공
• 구글 API 연동: 구글 API 인터페이스에 gRPC가 제공되므로 연동에 용이함

gRPC 4가지 서비스 정의 방법

1. 단항 RPC: 클라이언트가 서버에 단일 요청 전송 후 일반 함수 호출처럼 단일 응답

rpc SayHello(HelloRequest) returns (HelloResponse);

2. 서버 스트리밍 RPC: 클라이언트가 서버에 요청 보내고, 일련의 메시지 읽을 수 있는 스트림을 다시 받는 방식

rpc LotsOfReplies(HelloRequest) returns (stream HelloResponse);

3. 클라이언트 스트리밍 RPC: 클라이언트가 일련의 메시지 작성하고 제공된 스트림을 사용하여 다시 서버로 보내는 방식

rpc LotsOfGreetings(stream HelloRequest) returns (HelloResponse);

4. 양방향 스트리밍 RPC: 양쪽이 읽기-쓰기 스트림을 사용해 일련의 메시지를 보내는 방식

rpc LotsOfGreetings(stream HelloRequest) returns (HelloResponse);

protobuf

• 프로토콜 버퍼 데이터
• 개발 언어, 플랫폼과 상관 없이 직렬화 가능하게 하는 데이터 구조
  • 메시지로 구조화 됨
  • 각 메세지는 필드라고 하는 일련의 이름-값 쌍을 포함함
• 서로 다른 시스템끼리 데이터 공유, 저장하기 위해 사용
• xml, json 보다 더 효율적인 방식으로 데이터 관리
  • 때문에 전송 및 저장 시 데이터를 더 적게 사용할 수 있다.
• 파일 확장자는 .proto로 정의된다

코드 작성해 보기

• proto 파일 생성

// https://github.com/grpc/grpc-go

syntax = "proto3";

// 패키지로 생성하기 위해 추가
option go_package = "grpc/helloworld";

// 패키지로 생성하기 위해 추가
package helloworld;

// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}

• .proto 파일 생성 후, protoc 을 이용해 각 언어에 맞는 코드 생성

protoc --go\_out=. --go\_opt=paths=source\_relative --go-grpc\_out=. --go-grpc\_opt=paths=source\_relative helloworld/helloworld.proto

• go 서버 코드 작성

package main

import (
    "context"
    "flag"
    "fmt"
    pb "grpc/helloworld" // protoc 로 생성된 코드
    "log"
    "net"

    "google.golang.org/grpc"
)

var (
    port = flag.Int("port", 50051, "The server port")
)

// helloworld.GreeterServer 구현체 시용하는 서버
type server struct {
    pb.UnimplementedGreeterServer // 이부분은 안하면 에러가 발생한다. protobuf generate시 생성됨
}

type GreeterServer struct {
    SayHello(context.Context, *HelloRequest) (*HelloReply, error)
    // protobuf 빌드 시 생성되는 메서드
    mustEmbedUnimplementedGreeterServer()
}

func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
    log.Printf("Received: %v", in.GetName())
    return &pb.HelloReply{Message: "Hello " + in.GetName()}, nil
}

func main() {
    flag.Parse()
    lis, err := net.Listen("tcp", fmt.Sprintf(":%d", *port))
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer()
    pb.RegisterGreeterServer(s, &server{}) //client가 사용할 수 있도록 등록
    log.Printf("server listening at %v", lis.Addr())
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

REFERENCE

• 데보션: https://devocean.sk.com/blog/techBoardDetail.do?ID=165058

빌드 시 디렉토리 지정

• script 안에 dir 을 선언해서 빌드 할 소스 상에서의 위치를 정의할 수 있다.

stage('도커 이미지 빌드') {
    steps {
        script {
            dir("api") {
                    // 브랜치에 따라 이미지 이름 변경
                    DOCKER_IMAGE = docker.build(DOCKER_IMAGE_NAME)
                }
            }
        echo "Built: ${DOCKER_IMAGE_NAME}"
    }
}

Golang 빌드

• Go를 빌드하여 컴파일 된 바이너리 파일을 배포하고자 한다.
  • 때문에 빌드 시에 go 언어 컴파일이 가능하게끔 시도하였다.
    • 때문에 go 언어 도커 이미지를 받아와 빌드하려고 한다.
    • 이 때 golang 이미지는 go.mod 에 명시된 go 버전을 사용해야만 한다.

stage('도커 이미지 빌드') {
    agent {
        docker {
            image 'golang:1.23.4' // go.mod 의 버전과 동일하게
            args '-v /tmp:/tmp' // 권한 문제로 인해, 쓰기 권한이 있는 디렉토리 설정
        }
    }
    steps {
        script {
            dir("backup") {
                sh '''
                    export GOCACHE=/tmp/go-build-cache
                    mkdir -p $GOCACHE
                    GO111MODULE=on CGO_ENABLED=1 GOOS=linux GOARCH=amd64 go build -o backup .
                '''
            }
            echo "Built Backup Binary"
        }
    }
}

Jmeter란?

• Apache에서 자바로 만든 웹 애플리케이션 성능 테스트 오픈 소스입니다.
• 위의 그림과 같은 GUI를 지원합니다.

테스트 용어

• Thread Group : 테스트에 사용될 스레드 개수, 스레드 1개당 사용자 1명
• Sampler : 사용자의 액션 (예: 로그인, 게시물 작성, 게시물 조회 등)
• Listener : 응답을 받아 리포팅, 검증, 그래프 등 다양한 처리
• Configuration : Sampler 또는 Listener가 사용할 설정 값 (쿠키, JDBC 커넥션 등)
• Assertion : 응답 확인 방법 (응답 코드, 본문 내용 비교 등)

예시

• Thread 개수가 1000 개이고, Ramp-up Period가 60, Loop Count가 10이면
  • 1000명의 유저가 60초 동안 10번 반복해서 요청 보낸다는 의미
• Sampler - 사용자의 액션
  • 프로토콜, IP, 포트, HTTP, PATH 등을 지정 가능
  • Parameter와 Body 도 넘길 수 있음

설치 (MAC)

Homebrew 로 설치

• MAC 기준 설치 및 실행

brew install jmeter

• 실행

  open /opt/homebrew/bin/jmeter

소스 다운로드로 설치

• Archive 로 설치
  • url :https://jmeter.apache.org/download_jmeter.cgi

cd apache-jmeter-5.6.2 

./bin/jmeter.sh

HTML 보고서 만들기 (Mac - Homebrew)

• Graph 차트로 만든 보고서를 csv로 저장한 후에 HTML로 보고서를 생성할 수 있다.

그래프 보고서 생성

• 결과 파일 csv 저장하기 위해 경로 설정
  • Wirte result to file/Read from file
• 설정 시 뜨는 오류는 무시해도 됨

HTML 보고서 생성

• 보고서 설정
  • 상단의 Tool - Generate HTML 선택
    • csv: 그래프 차트 저장으로 생성된 CSV
    • properties: /bin/jmeter/jmeter.properties 선택
  • homebrew
    • properties: /opt/homebrew/Cellar/jmeter/버전/libexec/bin/jmeter.properties 선택
  • 결과 html 저장 경로
    • 빈 디렉토리어야 함. 따라서 새로운 폴더 생성

Jmeter란?

• Apache에서 자바로 만든 웹 애플리케이션 성능 테스트 오픈 소스입니다.
• 위의 그림과 같은 GUI를 지원합니다.

테스트 용어

• Thread Group : 테스트에 사용될 스레드 개수, 스레드 1개당 사용자 1명
• Sampler : 사용자의 액션 (예: 로그인, 게시물 작성, 게시물 조회 등)
• Listener : 응답을 받아 리포팅, 검증, 그래프 등 다양한 처리
• Configuration : Sampler 또는 Listener가 사용할 설정 값 (쿠키, JDBC 커넥션 등)
• Assertion : 응답 확인 방법 (응답 코드, 본문 내용 비교 등)

예시

• Thread 개수가 1000 개이고, Ramp-up Period가 60, Loop Count가 10이면
  • 1000명의 유저가 60초 동안 10번 반복해서 요청 보낸다는 의미
• Sampler - 사용자의 액션
  • 프로토콜, IP, 포트, HTTP, PATH 등을 지정 가능
  • Parameter와 Body 도 넘길 수 있음

테스트 수행

• 아래처럼 생각하면 좋다
  • Thread Group 추가 - 테스트 설정
  • Sampler 추가 - 요청 관련 설정
  • Listener 추가 - 테스트 결과 확인

Add Thread Group

• 테스트 세팅
  • Thread, Ramp up, Loop Count

Add Sampler - HTTP Request

• 요청 세팅
  • 프로토콜, url, port, body 등 세팅

Add Listener - Summary Report

• 상단 초록색 실행 아이콘 눌렀을 때, 그. 테스트 결과 확인
  • samplers: 표본 수
  • Average: 응답 시간 (ms)
  • Min: 응답 시간 (ms)
  • Max: 응답 시간 (ms)
  • Error: 400 / 500 번대 응답 코드 비율
  • Throughput: TPS(Transaction Per Second) 초당 처리량
  • 

rsync

• remote sync의 약자
• unix 및 linux 시스템에서 파일을 효율적으로 전송 및 동기화 하기 위한 유틸리티
• 로컬/원격지 모두 동기화 가능
• 변경된 사항만 빠르게 동기화가 가능
• scp보다 빠르고 효율적

옵션 정리

-v: verbosity를 높이는 방법으로, 과정을 더 상세히 출력
-z: compress를 주는 옵션으로, 파일을 압축해서 복사. 용량이 큰 파일에 대해 사용
-h: 인간이 읽을 수 있는 형태로 복사 결과 출력
-a: Archive 모드로, symlink, 권한등의 속성을 그대로 복사. 항상 넣어 주는게 좋음
-l: symlink 형태로 복사
-p: 파일과 디렉토리들의 권한을 유지
-g: 그룹 속성을 유지
-o: 소유자 속성을 유지
-r: 디렉토리를 복사할 때 사용하는 옵션. -a 옵션을 사용할 경우 -a 안에 포함되어 있으므로 사용하지 않아도 됨

로컬에서 로컬로 파일 복사하기

• 모든 속성 유지, 전송 과정 로그 상세화, 복사 결과 출력
  • 파일 용량이 적은 파일일 경우 -z 옵션 생략

rsync -avh <file_path> <target_path>

• 특정 파일 제외

rsync -avh --exclude <제외할_파일_path> <file_path> <target_path>

# txt 확장자 파일만 제외할 때
rsync -avh --exclude '*.txt' <file_path> <target_path>

# 복수개의 확장자에 대해 제외할 때
rsync -avh --exclude={'*.txt', '*.iso'} <file_path> <target_path>

서버에 파일 보내기

• scp 이용

scp -rp <file_path> <server_user>@<server_host>:<target_directory>

• rsync 이용
  • 전송하는 파일 크기가 너무 클 때 대신해서 사용

rsync --avz <file_path> <server_user>@<server_host>:<target_directory>

이미지

• https://hub.docker.com/_/neo4j

기본 설정 및 포트

• 기본 포트는 7474와 7687
  • http 포트: 7474
  • bolt 포트: 7687
• 컨테이너 기본 데이터 저장 위치 경로: /data
• 컨테이너 기본 로그 저장 위치 경로: /logs
• 컨테이너 설정 저장 위치 경로: /conf
• 컨테이너 기본 플러그인 위치 경로: /plugins
• 기본 유저 정보는
  • 관리자 계정은 반드시 유저 이름이 neo4j이어야 하며, password는 8글자 이상이어야 한다.
    • user: neo4j
    • passwd: 1231231212
  • 환경변수로 넣는 방법
    • NEO4J_AUTH=username/password
  • 인증 파일을 넣어주는 방법
    • NEO4J_AUTH_FILE=/run/secrets/neo4j_auth_file
  • 인증을 개발용 목적으로 끄고 싶다면
    • env에서 NEO4J_AUTH=none으로 설정

예시

• docker-compose 파일

services:
  neo4j:
    image: neo4j:5.25.1-community-bullseye
    container_name: graphdb
    restart: always
    ports:
      - 7687:7687
      - 7474:7474
    volumes:
      - ./data:/data
      - ./logs:/logs
      - ./plugins:/plugins
    env_file:
      - .env
    networks:
      - proxy
networks:
  proxy:
    external: true

• .env 파일

NEO4J_AUTH=username/password

Graph DB 핸들링

• MATCH 로 조회한 데이터는 전부 Map으로 매핑된 데이터들
  • 따라서 쿼리한 데이터를 가져올 때 GET 메서드로 데이터를 가져와야 함
  • 아래는 처음에 짰던 코드
    • 코드가 길고 가독성도 별로라서 다른 방안 고민 중 - 아래에 수정 내용 추가

result, queryErr := dbCon.Query(GetWordAndRelatedWord, map[string]interface{}{"word": word})

if queryErr != nil {
    log.Printf("[SEARCH] Query Word Error: %v", queryErr)
    return []SearchWordResult{}, queryErr
}

var queryResult []SearchWordResult

for _, data := range result {

    name, isName := data.Get("name")

    if !isName {
        log.Printf("[SEARCH] No Name Found. Ignore. Word: %s", word)
        continue
    }

    description, isDescription := data.Get("description")

    if !isDescription {
        log.Printf("[SEARCH] No Description Found. Ignore. Word: %s", word)
        continue
    }

    createdAt, isCreatedAt := data.Get("created_at")

    if !isCreatedAt {
        log.Printf("[SEARCH] No CreatedAt Found. Ignore. Word: %s", word)
        continue
    }

    updatedAt, isUpdatedAt := data.Get("updated_at")  

    if !isUpdatedAt {
        log.Printf("[SEARCH] No UpdatedAt Found. Ignore. Word: %s", word)
        continue
    }

    category, isCategory := data.Get("category")  

    if !isCategory {

        log.Printf("[SEARCH] No Category Found. Ignore. Word: %s", word)

        continue

    }

    createdBy, isCreatedBy := data.Get("created_by")

    if !isCreatedBy {
        log.Printf("[SEARCH] No CreatedBy Found. Ignore. Word: %s", word)
        continue
    }

    var node = SearchWordResult{
        Name: name.(string),
        Category: category.(string),
        Description: description.(string),
        CreatedBy: createdBy.(string),
        CreatedAt: createdAt.(string),
        UpdatedAt: updatedAt.(string),
    }
    queryResult = append(queryResult, node)

}

데이터 핸들링 수정

• 처음에는 위처럼 데이터를 핸들링 했지만, 읽는 노드 개수가 여러개가 됨에 따라 그 데이터 형태가 달라졌다.
  • 따라서 쿼리 방식을 바꿔야 했고, 데이터 형태 파악부터 해야 했다.
    • 데이터는 배열 안에 각각 노드 Label에 따라 노드들이 배열에 담겨있었다.
    • 따라서 쿼리 결과를 iteration 하며, 각각 label과 함께 나온 데이터를 핸들링하게 끔 수정했다.
  • 쿼리 결과를 GET해서 가져왔을 때, 그 타입이 any 였다.
    • 때문에 이를 dbtype.Node로 캐스팅하고, Node의 Properties를 뽑아와 사용했다.
      • dbType은 neo4j에서 제공하는 노드 타입
      • properties는 map[string]any 타입

responseMap := make(map[string]*SearchWordResult)

for _, data := range result {
    wNode, isNode := data.Get("word")

    if !isNode {
        log.Printf("[SEARCH] No Node Found")
        continue
    }

    targetNode := wNode.(dbtype.Node)

    rNode, isRelated := data.Get("related")

    if !isRelated {
        log.Printf("[SEARCH] No Related Node Found")
        continue    
    }

    relatedNodeList := rNode.(dbtype.Node)

    wordeNode := SearchWordItem{
        Name: targetNode.GetProperties()["name"].(string),
        Category: targetNode.GetProperties()["category"].(string),
        Description: targetNode.GetProperties()["description"].(string),
        CreatedBy: targetNode.GetProperties()["created_by"].(string),
        CreatedAt: targetNode.GetProperties()["created_at"].(string),
        UpdatedAt: targetNode.GetProperties()["updated_at"].(string),
    }

    relatedNode := SearchWordItem{
        Name: relatedNodeList.GetProperties()["name"].(string),
        Category: relatedNodeList.GetProperties()["category"].(string),
        Description: relatedNodeList.GetProperties()["description"].(string),
        CreatedBy: relatedNodeList.GetProperties()["created_by"].(string),
        CreatedAt: relatedNodeList.GetProperties()["created_at"].(string),
        UpdatedAt: relatedNodeList.GetProperties()["updated_at"].(string),
    }

    if _, exists := responseMap[wordeNode.Name]; !exists {
        responseMap[wordeNode.Name] = &SearchWordResult{
            Word: wordeNode,
            Related: []SearchWordItem{},
        }
    }

    responseMap[wordeNode.Name].Related = append(responseMap[wordeNode.Name].Related, relatedNode)

}

var responseList []SearchWordResult

for _, response := range responseMap {
    responseList = append(responseList, *response)
}

노드 및 관계 읽기

• 아래 쿼리 방식은 관계를 통한 조회이다.
  • relations가 RELATED 혹은 PARENT 인 노드 관계들을 조회하고
  • 1..2 는 hop에 관한 내용이다
    • 1 은 직접적으로 연관된 노드들
    • 2는 중간에 노드가 하나 있는 노드들
  • 조회에 성공한 노드들 정보를 리턴한다
    • SQL과 동일하게 DISTINCT 해서 리턴
    • word의 경우 name 프로퍼티에 대한 조건 쿼리랑 동일하기 때문에 하나 혹은 동일한 이름을 가진 노드들 리턴
    • related의 경우, 특정 이름을 가진 노드와 1홉 혹은 2홉의 관계를 가진 모든 노드들

MATCH (w:Word {name: $word})-[:RELATED|PARENT*1..2]-(related:Word)
RETURN DISTINCT word, related

관계 property 설정

• 실제 짜서 사용중인 코드이다. 아래처럼 관계를 설정한다.
  • 방향이 설정되지 않은 관계는 RELATED
  • 부모/자식 노드들의 관계를 PARENT / CHILDREN이라는 관계로 정의함

// Create Relations
var CreateWordRelatinon = `
    MATCH (w1:Word{name: $name1}), (w2:Word{name: $name2})
    MERGE (w1)-[r:RELATED]-(w2)
    SET r.weight = $weight
`

// Create Relations; w1 is Parent, w2 is Children
var CreateWordParent = `
    MATCH (w1:Word{name: $name1}), (w2:Word{name: $name2})
    MERGE (w1)-[r:PARENT]->(w2)
    SET r.weight = $weight
`

// Create Relations; w2 is Parent, w1 is Children
var CreateWordChildren = `
    MATCH (w1:Word{name: $name1}), (w2:Word{name: $name2})
    MERGE (w1)-[r:CHILDREN]->(w2)
    SET r.weight = $weight
`