728x90
반응형

계기

  • Go 로 사이드 프로젝트 개발을 하다, 동적 쿼리가 필요한 경우도 많았고 동일한 유틸/함수들을 다양한 프로젝트에서 동일하게 사용해야 하는 경우가 너무나 많았다.
  • 문득 내가 모든 프로젝트들에 사용하는, 내가 만든 함수들을 패키지화 시키고 간편하게 사용하면 어떨까 생각하게 되었다.
    • 그렇게 '동적 쿼리 유틸'과 'DB 연결 및 쿼리' 유틸들을 오픈소스 패키지화 하기로 결정하였다.

버전 릴리즈

  • 우선 깃허브에 퍼블릭 레포를 파고 패키지 소스코드를 푸시 하였다.
  • 패키지를 임포트 해 사용할 것이기 때문에, 메인 함수의 패키지명은 사용할 패키지 명으로 설정해야 한다.
package gqbd

// ... 코드
  • 테스트 코드들로 각 함수및 유틸들이 원하는 리턴값을 가져오는지 검증을 진행하였다.

    • 여담이지만 <>_test.go 파일들을 테스트 코드로 인식한다.
    • t *testing.T 타입을 인자로 넘겨주면 테스트 진행할 함수로 인식된다.
  • 완료된 후 버전을 릴리즈했다. 최초 베타 테스트이므로 v0.1.0 으로 잡았다.

git tag v0.1.0
git push origin v0.1.0
  • 위처럼 레포에 v0.1.0으로 푸시를 했다면, 이제 Go 쪽에 해당 패키지와 버전을 알려주면 배포가 완료된다.
GOPROXY=proxy.golang.org go list -m github.com/<repo_owner>/<repo_name>@<version>
  • 이렇게 하면 GoDoc에서 내가 배포한 레포를 확인할 수 있다.
    • 다만 배포했다고 GoDoc이 빠르게 반영되는건 아니라는 함정.
    • 그리고 레포의 README.md 파일은 GODOC의 메인 설명 페이지로 나온다는 것.

결과

  • 아래는 내가 배포한 두가지 패키지들이다. 지속적으로 유지보수하면서 버전업 시킬 예정이다.
  • GQBD : Go-Query-Builder
  • GDCT : Go-Database-ConnecT
728x90
반응형
728x90
반응형

개요

  • 로그인 시 발급되는 access token을 쿠키에 세팅
  • 미들웨어에서 쿠키의 access token 을 검증

Cookie 세팅

  • 생성된 토큰을 쿠키에 세팅한다
func Login(res http.ResponseWriter, req *http.Request) {

    /*
        로그인 로직
    */

    accessTokenCookie := http.Cookie{
        Name: "accessToken",
        Value: accessToken,
        Path: "/",
        Secure: true, // HTTPS 만
        HttpOnly: true, // 브라우저에서 쿠키 조작 불가하게 세팅
        SameSite: http.SameSiteNoneMode,
    }

    refreshTokenCookie := http.Cookie{
        Name: "refreshToken",
        Value: refreshToken,
        Path: "/",
        Secure: true, // HTTPS 만
        HttpOnly: true, // 브라우저에서 쿠키 조작 불가하게 세팅
        SameSite: http.SameSiteNoneMode,
    }

    http.SetCookie(res, &accessTokenCookie)
    http.SetCookie(res, &refreshTokenCookie)

    /*
        응답 보내기
    */
}

검증 미들웨어

  • 쿠키에서 토큰을 추출해서 컨텍스트에 담는다
  • 담은 컨텍스트의 정보를 컨트롤러에서 사용한다.
// 사용자 정의 키 타입을 사용하여 컨텍스트 충돌 방지

type contextKey string

const (
    // JWT 서명에 사용할 비밀 키 (환경 변수로 관리하는 것이 좋습니다)

    // jwtSecret = configs.GlobalConfig.JwtKey // 실제 배포 시 환경 변수로 관리

    // 컨텍스트에 사용자 정보를 저장할 키
    userContextKey = contextKey("user")
)

// 사용자 정보 구조체

type User struct {
    UserId string
    UserEmail string
    UserStatus string
}

var excludeRouteList = []string{
    "/", "/api", 
    "/user/signup", "/user/login",
}

// AuthMiddleware는 accessToken 쿠키를 추출하고 JWT를 검증하는 미들웨어입니다.
func AuthMiddleware(next http.Handler) http.Handler {

    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

        // 제외할 경로는 바로 다음 핸들러로 넘김
        for _, route := range excludeRouteList {
            if r.URL.Path == route {
                log.Printf("Found Match Route: %s", route)
                next.ServeHTTP(w, r)
                return
            }
        }

        // accessToken 쿠키 추출
        cookie, err := r.Cookie("accessToken")

        log.Printf("Cookie: %s", cookie)

        if err != nil {
            log.Printf("Get Cookie Error :%v", err)  

            if err == http.ErrNoCookie {
                response.Response(w, response.CommonResponseWithMessage{
                    Status: http.StatusUnauthorized,
                    Code: "AUTH001",
                    Message: "No access token provided",    
                })

                return
            }

            // 다른 쿠키 에러 처리

            response.Response(w, response.CommonResponseWithMessage{
                Status: http.StatusUnauthorized,
                Code: "AUTH002",
                Message: "Invalid cookie format",
            })

            return
        }

        accessToken := cookie.Value

        userId, userEmail, userStatus, validateErr := auth.ValidateJwtTokenFromString(accessToken)


        if validateErr != nil {
            log.Printf("ValidateErr Cookie Error :%v", validateErr)

            // 토큰 만료에 대한 응답
            if strings.Contains(validateErr.Error(), "token expired") {
                response.Response(w, response.CommonResponseWithMessage{
                    Status: http.StatusUnauthorized,
                    Code: "AUTH003",
                    Message: "Token expired",
                })

                return
            }

            // 일반적인 JWT 검증 실패 응답
            response.Response(w, response.CommonResponseWithMessage{
                Status: http.StatusUnauthorized,
                Code: "AUTH004",
                Message: "Invalid token",
            })

            return        
        }

        // 사용자 정보를 구조체로 생성

        user := User{
            UserId: userId,
            UserEmail: userEmail,
            UserStatus: userStatus,
        }

        // 사용자 정보를 컨텍스트에 추가
        ctx := context.WithValue(r.Context(), userContextKey, user)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}



// 사용자 정보를 핸들러 및 컨트롤러에서 가져오는 헬퍼 함수
func GetUserFromContext(ctx context.Context) (User, bool) {
    user, ok := ctx.Value(userContextKey).(User)
    return user, ok
}

컨트롤러에서 추출된 정보들 사용


func SampleController(res http.ResponseWriter, req *http.Request) {
    user, ok := middlewares.GetUserFromContext(req.Context())

    if !ok {    
        dto.SetErrorResponse(res, 401, "01", "JWT Verifying Error", nil)

        return
    }
    /*
        이후 로직
    */

    dto.SetResponse(res, 200, "01")
}
728x90
반응형
728x90
반응형

기존

  • 기존에는 직접 CORS 체크 미들웨어를 작성해 사용했다.
func CorsMiddlewares(next http.Handler) http.Handler {
    return http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {

        origin := req.Header.Get("Origin")

        if origin == "" {
            origin = "unknown"
        }

        for _, o := range originList {
            if o == origin {    
                log.Printf("Allowed Origin: %s", origin)
                res.Header().Set("Access-Control-Allow-Origin", origin)
                res.Header().Set("Access-Control-Max-Age", "86400")
                res.Header().Set("Access-Control-Allow-Methods", "POST, GET, OPTIONS")
                res.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
                res.Header().Set("Access-Control-Allow-Credentials", "true")
                break
            }
        }

        // Handle preflight request
        if req.Method == http.MethodOptions {
            res.WriteHeader(http.StatusOK)
            return
        }

        next.ServeHTTP(res, req)
    })
}

변경

  • 그러나 조금 더 심플하고 편하게 설정할 수 있는 패키지가 있어 가져와 사용했다.
get -u github.com/rs/cors
  • 이후 세팅은 이렇게 된다.
func CorsHanlder() *cors.Cors {
    corHandler := cors.New(cors.Options{
        AllowedOrigins: originList,
        AllowedMethods: []string{http.MethodGet, http.MethodPost, http.MethodOptions},
        AllowedHeaders: []string{"Origin", "Accept", "Content-Type", "Authorization"},
        AllowCredentials: true,
        MaxAge: 86400,        
        Debug: false,
    })

    return corHandler
}

미들웨어 등록하기

  • 현재 표준 라이브러리인 net/http 에서 gorilla/mux 로 변경한 상태이다.
func OpenServer() *http.Server {
    router := mux.NewRouter()

    routers.DefaultRouter(router)

    routers.UploadImageController(router)

    routers.AdminUserRouter(router)

    routers.AdminPostRouter(router)

    routers.UserRouter(router)

    routers.PostRouter(router)

    router.Use(middlewares.AuthMiddleware)

    // CORS 핸들러
    handler := middlewares.CorsHanlder().Handler(router)

    // 기존 방식  
    // handler := middlewares.CorsMiddlewares(router)

    serving := &http.Server{
        Handler: handler,
        Addr: configs.GlobalConfig.AppHost,
        WriteTimeout: 30 * time.Second,
        ReadTimeout: 30 * time.Second,
    }

    return serving
}
728x90
반응형
728x90
반응형

Nullable 데이터

  • DB의 필드 중에 NULL 값이 들어갈 수 있는 값들이 있다. 이 값들을 쿼리해서 코드단에서 처리할 때 어떻게 해야 할까?
  • 다른 언어들은 그냥 쿼리해서 사용하면 null 값으로 처리되던데...

Struct 정의

  • 우선 쿼리된 결과를 원하는 값들에 할당해준다. 아래는 기존에 사용하던 코드
type SampleQueryItem struct {
  UserId string `json:"userId"`
  UserName string `json:"userName"`
  UserEmail string `json:"userEmail"`
}
  • 이렇게 하면 받아오는 데이터 세개 전부 값이 있다고 가능하는 셈이다.
    • 이렇게 된다면 null 값들은 처리할 수 없다.

포인터 사용하기

type SampleQueryItem struct {
  UserId string `json:"userId"`
  UserName string `json:"userName"`
  UserEmail *string `json:"userEmail"` // 포인터 사용
}
  • 이렇게 처리하면 userEmail 값은 null 로 받아올 수 있다.

번외; 단건 조회 데이터가 없을 때

  • 한 건 조회할 때, 쿼리 데이터가 없다면?
  • golang은 심플함을 강조하기 때문에, 이러한 상황들을 직접 핸들링 해 줘야 한다.

기존 코드

var dataItem SampleQueryItem

if scanErr := queryResult.Scan(&dataItem.UserId, &dataItem.UserName, &dataItem.UserEmail);
    scanErr != nil {
        log.Printf("Scan Error: %v", scanErr)
        return scanErr
    }
  • 이렇게 해 주면 scan 에러가 발생한다. 그 이유는 쿼리된 데이터가 없다는 것

수정된 코드

var dataItem SampleQueryItem

if scanErr := queryResult.Scan(&dataItem.UserId, &dataItem.UserName, &dataItem.UserEmail);
    scanErr != nil {
        // 데이터가 없는 에러는 error 에러를 리턴하지 않게 해서 에러로 빠지지 않게 한다.
        if scanErr == sql.NoRowError {
            return SampleQueryItem{}, nil
        }

        log.Printf("Scan Error: %v", scanErr)
        return SampleQueryItem{}, scanErr
    }
  • 조회된 데이터가 없는 것은 에러로 처리된다. scan 할 데이터가 없기 때문
    • 위 처럼 쿼리 후 에러 핸들링을 하면, 에러 처리로 넘기지 않고 빈 데이터를 넘길 수 있다.
728x90
반응형
728x90
반응형

Centos9 에 Oracle 컨테이너 구동

    # 필요한 버전을 -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
728x90
반응형
728x90
반응형
  • 본 글은 데보션 글을 기반으로 정리 형식에서 작성되었습니다. (해당 링크는 하단에)

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);
  1. 서버 스트리밍 RPC: 클라이언트가 서버에 요청 보내고, 일련의 메시지 읽을 수 있는 스트림을 다시 받는 방식
rpc LotsOfReplies(HelloRequest) returns (stream HelloResponse);
  1. 클라이언트 스트리밍 RPC: 클라이언트가 일련의 메시지 작성하고 제공된 스트림을 사용하여 다시 서버로 보내는 방식
rpc LotsOfGreetings(stream HelloRequest) returns (HelloResponse);
  1. 양방향 스트리밍 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

728x90
반응형
728x90
반응형

이미지

기본 설정 및 포트

  • 기본 포트는 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
728x90
반응형
728x90
반응형

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
`
728x90
반응형
728x90
반응형

계속 적을 글

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

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!
        }
    }
728x90
반응형

'백엔드 Backend > Golang' 카테고리의 다른 글

[gRPC] Go 언어로 gRPC 사용해보기  (2) 2024.12.24
[Neo4J] 데이터 핸들링하기  (1) 2024.12.09
[Neo4j] Golang으로 Neo4j 연동  (0) 2024.12.05
[GO] Ubuntu 서버에 설치  (1) 2024.10.30
[GO] Goroutine이란?  (0) 2024.10.02
728x90
반응형

공식 문서

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())
}
728x90
반응형

'백엔드 Backend > Golang' 카테고리의 다른 글

[gRPC] Go 언어로 gRPC 사용해보기  (2) 2024.12.24
[Neo4J] 데이터 핸들링하기  (1) 2024.12.09
[Neo4j] Golang 으로 쿼리 핸들링  (0) 2024.12.06
[GO] Ubuntu 서버에 설치  (1) 2024.10.30
[GO] Goroutine이란?  (0) 2024.10.02

+ Recent posts