DEV Community: vultor-xyz

go(golang) ORM 찾기 #3 - ent

vultor-xyz — Fri, 10 Jun 2022 08:17:08 +0000

시리즈

Introduction

ent는 Facebook Open Source로 시작된 프로젝트이지만 현재는 Linux Foundation으로 이동한 프로젝트입니다. code first 전략을 취하고 있기 때문에 모델을 코드로 작성하면 그에 맞는 여러 가지 코드를 생성해 주는 방식을 취하고 있습니다.

Setting

Install Packages

패키지는 ORM인 ent와 마이그레이션을 담당하는 atlas 두 가지를 설치하겠습니다.

go get entgo.io/ent/cmd/ent@latest
go get ariga.io/atlas@latest

Create Models

아래의 명령어로 모델을 생성하면 ./ent/schema 에 모델의 기본이 되는 코드가 생성됩니다.

go run entgo.io/ent/cmd/ent init User

그 후 코드를 아래와 같이 작성하면 모델을 생성합니다. Fields에는 모델의 필드들에 대한 정의를 Edges에는 관계를 맺을 다른 모델에 대한 정의를 작성하게 됩니다.

package schema

import (
    "entgo.io/ent"
    "entgo.io/ent/dialect"
    "entgo.io/ent/schema/edge"
    "entgo.io/ent/schema/field"
    "time"
)

// User holds the schema definition for the User entity.
type User struct {
    ent.Schema
}

// Fields of the User.
func (User) Fields() []ent.Field {
    return []ent.Field{
        field.String("first_name"),
        field.String("last_name"),
        field.Time("birthday").
            Optional().
            SchemaType(map[string]string{
                dialect.Postgres: "DATE",
            }),
        field.Time("updated_at").
            Default(time.Now).
            UpdateDefault(time.Now),
        field.Time("created_at").
            Default(time.Now).
            Immutable(),
    }
}

// Edges of the User.
func (User) Edges() []ent.Edge {
    return []ent.Edge{
        edge.To("tasks", Task.Type),
    }
}

이 모델로부터 migration 코드가 생성되기 때문에 자세히 정의할수록 sql을 따로 조작할 필요성이 없게 됩니다. 그리고 SchemaType과 같은 기능을 이용하여 각각의 데이터베이스마다 특정 타입을 지정할 수 있다는 점도 긍정적으로 판단됩니다.

Migration

마이그레이션은 ent에서 직접 하는 것이 아니라 atlas라는 다른 패키지를 사용하여 진행하게 됩니다. 마이그레이션을 할 수 있는 방식은 declarative, versioned 방식을 지원하는데 declarative의 경우 자동으로 원하는 상태로 마이그레이션을 해주는 방식이기 때문에 개인적으로는 어떤 동작을 할 것인지 예상이 가지 않아서 좀 불안한 마음이 있습니다. 그래서 versioned migration으로 제작해 보았습니다.

Versioned으로 진행하게 되면 atlas에서는 sql 파일을 생성해 줍니다. 이 파일을 기반으로 실제 마이그레이션은 sqlboiler 예제에서도 사용한 golang-migrate를 사용하여 진행하였습니다. (다른 migration 툴도 지원하기 때문에 취향에 맞는 것을 사용하면 됩니다)

공식 문서를 보면 from client, from graph 방식을 지원하는데 테스트한 날(2022/06/10) 기준으로 from client 방식을 사용하려면 master branch를 기준으로 패키지를 설치해야지 정상적으로 작동했기 때문에 from graph 방식으로 진행해야 합니다.

아래와 같은 코드를 작성하면 마이그레이션을 위한 sql 파일을 생성할 수 있습니다.

func GenerateMigration() {
    basePath := "./example/ente"

    graphPath := basePath + "/ent/schema"
    graph, err := entc.LoadGraph(graphPath, &gen.Config{})
    if err != nil {
        log.Fatalln(err)
    }

    tbls, err := graph.Tables()
    if err != nil {
        log.Fatalln(err)
    }

    migrationPath := basePath + "/migrations"
    dir, err := migrate.NewLocalDir(migrationPath)
    if err != nil {
        log.Fatalln(err)
    }

    dlct, err := sql.Open(config.GetDBInfo())
    if err != nil {
        log.Fatalln(err)
    }

    m, err := schema.NewMigrate(dlct, schema.WithDir(dir))
    if err != nil {
        log.Fatalln(err)
    }

    if err := m.Diff(context.Background(), tbls...); err != nil {
        log.Fatalln(err)
    }
}

위의 내용을 실행하면 접속할 데이터베이스, migrations 폴더에 있는 sql 파일 내용, 작성된 모델을 비교하여 적절한 코드를 아래와 같은 파일을 생성해 줍니다.

-- create "users" table
CREATE TABLE "users"
(
    "id"         bigint            NOT NULL GENERATED BY DEFAULT AS IDENTITY,
    "first_name" character varying NOT NULL,
    "last_name"  character varying NOT NULL,
    "birthday"   date              NULL,
    "updated_at" timestamptz       NOT NULL,
    "created_at" timestamptz       NOT NULL,
    PRIMARY KEY ("id")
);

또한 many-to-many 관계의 경우 중간에 두 테이블을 연결해주는 테이블을 자동으로 migration에서 생성해 주게 됩니다.

Code Generation

아래의 명령어를 수행하면 각종 쿼리를 수행하기 위한 파일을 생성합니다. (생성되는 파일이 매우 많기 때문에 생성된 파일은 생략하겠습니다)

go generate ./ent

Usage

Connection

ent에서 connection을 맺을 때는 sqlboiler와 같이 기본 sql 패키지를 사용하지는 않습니다. 그렇다고 복잡하지는 않고 간단하게 연결됩니다.

func makeConnection() *ent.Client {
    conn, err := ent.Open(config.GetDBInfo())
    internal.LogFatal(err)

    return conn
}

CRUD

모델에 값을 설정할 때는 set함수를 이용하여 설정합니다. where 부분의 경우 각각의 연산에 대하여 미리 정의된 함수를 제공하여 type safe한 방식으로 작성이 가능합니다.

func crud(ctx context.Context, c *ent.Client) {
    // Create
    newUser, err := c.User.Create().
        SetFirstName("Sample").
        SetLastName("User").
        SetBirthday(time.Now().AddDate(-30, 0, 0)).
        Save(ctx)
    internal.LogFatal(err)
    internal.PrintJSONLog(newUser)

    // Read
    gotUser, err := c.User.
        Query().
        Where(user.FirstNameEQ("Sample")).
        First(ctx)
    internal.LogFatal(err)
    internal.PrintJSONLog(gotUser)

    // Read List
    gotUsers, err := c.User.Query().
        Where(user.FirstNameEQ("Sample")).
        All(ctx)
    internal.LogFatal(err)
    internal.PrintJSONLog(gotUsers)

    // Update
    updateRowsAff, err := c.User.Update().
        Where(user.LastNameEQ("User")).
        SetLastName("Unknown").
        Save(ctx)
    internal.LogFatal(err)
    internal.PrintJSONLog(updateRowsAff)

    // Delete
    deleteRowsAff, err := c.User.Delete().
        Exec(ctx)
    internal.LogFatal(err)
    internal.PrintJSONLog(deleteRowsAff)
}

다른 ORM들과 크게 다르지 않고 type safe한 방식을 제공한다는 점을 긍정적으로 생각됩니다.

Relationship

모델 간 관계가 있는 경우에는 ent의 다른 필드들과 마찬가지로 set 함수를 이용하여 연결하고자 하는 모델을 지정하면 자동으로 연결해주기 때문에 손쉽게 사용이 가능하였습니다.

Eager loading의 경우 함수 형태로 어떤 관계를 불러올지 지정하면 출력하였을 때 불러온 관계를 함께 출력하는 부분은 간편하여 좋았습니다.

func queryWithRelation(ctx context.Context, c *ent.Client) {
    // Create with relationship
    newUser, err := c.User.Create().
        SetFirstName("Sample").
        SetLastName("User").
        SetBirthday(time.Now().AddDate(-30, 0, 0)).
        Save(ctx)
    internal.LogFatal(err)
    internal.PrintJSONLog(newUser)

    newTask, err := c.Task.Create().
        SetUser(newUser).
        SetTitle("task 1").
        SetNote("note 1").
        SetStatus(task.StatusTodo).
        Save(ctx)
    internal.LogFatal(err)
    internal.PrintJSONLog(newTask)

    // Read with relationship
    gotTask, err := c.Task.Get(ctx, newTask.ID)
    internal.LogFatal(err)
    internal.PrintJSONLog(gotTask)

    gotTaskUser, err := gotTask.QueryUser().First(ctx)
    internal.LogFatal(err)
    internal.PrintJSONLog(gotTaskUser)

    // Eager Loading
    tasks, err := c.Task.Query().
        WithUser().
        All(ctx)
    internal.LogFatal(err)
    internal.PrintJSONLog(tasks)
}

// Eager Loading Output
// {
//     "id": 5563,
//     "title": "task 1",
//     "note": "note 1",
//     "status": "todo",
//     "updated_at": "2022-06-10T07:44:50.994279Z",
//     "created_at": "2022-06-10T07:44:50.994279Z",
//     "edges": {
//         "user": {
//             "id": 5622,
//             "first_name": "Sample",
//             "last_name": "User",
//             "birthday": "1992-06-10T00:00:00Z",
//             "updated_at": "2022-06-10T07:44:50.992357Z",
//             "created_at": "2022-06-10T07:44:50.992358Z",
//             "edges": {}
//         }
//     }
// }

Seed

ent는 bulk insert를 지원합니다. 그래서 대량으로 모델을 추가할 때 유용하게 사용할 수 있습니다.

func seed(ctx context.Context, c *ent.Client, count int) {
    if count <= 0 {
        return
    }

    rand.Seed(time.Now().UnixNano())

    var bulkUsers []*ent.UserCreate
    for i := 0; i < count; i++ {
        bulkUsers = append(bulkUsers, c.User.Create().
            SetFirstName("Sample").
            SetLastName("User").
            SetBirthday(time.Now().AddDate(-30, 0, 0)),
        )
    }
    newUsers, err := c.User.CreateBulk(bulkUsers...).Save(ctx)
    internal.LogFatal(err)

    var bulkTasks []*ent.TaskCreate
    for i := 0; i < count; i++ {
        bulkTasks = append(bulkTasks, c.Task.Create().
            SetUser(newUsers[rand.Intn(len(newUsers))]).
            SetTitle(fmt.Sprintf("Task %d", i)).
            SetNote(fmt.Sprintf("Note %d", i)).
            SetStatus(task.StatusTodo),
        )
    }
    _, err = c.Task.CreateBulk(bulkTasks...).Save(ctx)
    internal.LogFatal(err)

    log.Println("Seed finished")
}

Aggregation

aggregation 쿼리도 큰 어려움 없이 손쉽게 구현 가능합니다. 디테일한 조작이 필요한 경우에는 func(s *sql.Selector) 를 제공하여 기본 sql 패키지를 이용한 조작도 가능합니다.

func aggregate(ctx context.Context, c *ent.Client) {
    var result []struct {
        Count     int `json:"count"`
        UserTasks int `json:"user_tasks"`
    }

    err := c.Task.Query().
        Order(func(s *sql.Selector) {
            s.OrderBy(sql.Desc("count"))
        }).
        Limit(5).
        GroupBy(task.UserColumn).
        Aggregate(ent.Count()).
        Scan(ctx, &result)

    internal.LogFatal(err)
    internal.PrintJSONLog(result)
}

Pagination

pagination에 대하여 ent에서 특별히 제공하는 기능은 없고 일반적인 수준의 기능을 제공합니다. 다만 limit, offset을 사용할 때 정렬 기준을 명시하지 않으면 뭔가 이상동작(?)을 하는 경우가 있어서 이 부분은 신경 써주어야 합니다.

func pagination(ctx context.Context, c *ent.Client) {
    // Limit & Offset
    // Must use order for id based pagination
    for i := 0; i < 5; i++ {
        users, err := c.User.Query().
            Limit(3).
            Offset(i * 3).
            Order(ent.Asc(user.FieldID)).
            All(ctx)
        internal.LogFatal(err)
        internal.PrintJSONLog(users)
    }

    // Cursor
    lastUserID := 0
    for i := 0; i < 5; i++ {
        users, err := c.User.Query().
            Where(user.IDGT(lastUserID)).
            Limit(3).
            All(ctx)
        internal.LogFatal(err)
        internal.PrintJSONLog(users)
        lastUserID = users[len(users)-1].ID
    }
}

Transform

ent에서 column을 가리는 방식은 크게 두 가지가 있습니다. 1) 모델 정의 시 Sensitive를 넣어서 가리기 2) 모델 쿼리시 Select를 사용하여 필요한 칼럼만 표기, 제 생각에는 비밀번호와 같이 어떤 경우에도 아웃풋으로 나가면 안 되는 칼럼에 대하여 1번 방법을, 임시로 모델의 output을 조작할 때는 2번의 방법을 사용하면 좋을 것 같습니다.

아래 코드에서는 모델의 칼럼을 숨기는 두 가지 방식에 대한 예제 코드입니다.

// Hide column in model

func (Task) Fields() []ent.Field {
    return []ent.Field{
        field.String("title"),
        field.String("note").
            Sensitive(),
        field.Enum("status").
            Values(
                "todo",
                "in_progress",
                "done",
            ),
        field.Time("updated_at").
            Default(time.Now).
            UpdateDefault(time.Now),
        field.Time("created_at").
            Default(time.Now).
            Immutable(),
    }
}

// Hide column using select statement

func transform(ctx context.Context, c *ent.Client) {
    gotTask, err = c.Task.Query().
        Select(task.FieldID, task.FieldTitle).
        WithUser().
        First(ctx)
    internal.LogFatal(err)
    internal.PrintJSONLog(gotTask)
}

모델과 다른 모델의 관계를 출력할 때는 비교적 간단합니다. With{model} 구조로 호출해주면 자동으로 불러온 모델을 출력해 줍니다.

func transform(ctx context.Context, c *ent.Client) {
    // Print with relation
    gotTask, err := c.Task.Query().WithUser().First(ctx)
    internal.LogFatal(err)
    internal.PrintJSONLog(gotTask)
}

transform의 경우에는 제가 생각하는 기본 기능과 거의 동일하게 동작하기 때문에 개인적으로는 방향성이 동일하여 좋았습니다.

Raw Query

ent에서 raw 쿼리를 사용하기 위해서는 ent/generate.go 파일을 수정하여 sql/execquery, sql/modifier 기능을 활성화해줘야 합니다. 따라서 아래와 같이 내용을 추가 후 코드를 한 번 더 생성해 줍니다.

//go:generate go run -mod=mod entgo.io/ent/cmd/ent generate --feature sql/execquery,sql/modifier ./schema

위의 기능을 활성화해주면 QueryContext, ExecContext, Modifer 3가지 기능을 사용할 수 있게 됩니다. 이중 QueryContext, Contexture 는 기본 sql 패키지의 동일한 이름의 기능과 대응된다고 생각하시면 됩니다.

func rawQuery(ctx context.Context, c *ent.Client) {
    // QueryContext way
    rows, err := c.QueryContext(
        ctx,
        "SELECT id, title FROM tasks",
    )
    internal.LogFatal(err)
    for rows.Next() {
        var id int
        var title string
        if err := rows.Scan(&id, &title); err != nil {
            internal.LogFatal(err)
        }
        internal.PrintJSONLog(struct {
            ID    int    `json:"id"`
            Title string `json:"title"`
        }{
            id,
            title,
        })
    }
    err = rows.Close()
    internal.LogFatal(err)

    // Modifier way
    var result []struct {
        Count   string    `json:"count"`
        Created time.Time `json:"created"`
    }
    err = c.Task.Query().
        Modify(func(s *sql.Selector) {
            s.Select(
                sql.As(sql.Count("*"), "count"),
                sql.As("DATE(created_at)", "created"),
            ).GroupBy("DATE(created_at)")
        }).
        Scan(ctx, &result)
    internal.LogFatal(err)
    internal.PrintJSONLog(result)

    // ExecContext way
    _, err = c.ExecContext(ctx, "TRUNCATE TABLE  project_tasks, tasks, users")
    internal.LogFatal(err)
    log.Println("Truncate completed")
}

QueryContext는 raw query를 수행한 다음 어떤 결과를 받아와야 할 때 사용한다고 보면 쉽습니다. 다만 위의 예제처럼 사용하기 굉장히 번거롭기 때문에 결과를 받아와야 하는 종류의 raw query를 사용한다면 차라리 Modifer 기능을 사용하는 것이 조금 더 편해 보입니다.

Modifer는 ent 쿼리에서 기본 sql 패키지를 사용하여 더 다양한 조작이 가능하게 해주는 기능입니다. 따라서 위의 예제와 같이 완전 raw query는 아니더라도 그에 상응하는 기능을 구현할 수 있다고 보면 좋습니다.

마지막으로 ExecContext는 결과를 받아올 필요가 없는 raw query를 사용할 때 사용하는 기능이라고 볼 수 있습니다. 몇몇 특수한 경우에 사용될 수 있을 것 같네요.

ent의 raw query는 정말 특수한 경우를 제외하고 raw query를 사용할 생각은 안 하는 게 좋다고 말하는 것 같은 인상을 받았습니다. 사실 orm을 사용하면서 raw query를 작성할 경우는 드물기는 하지만 또 없으면 어떤 일이 생길지 모르기 때문에 일종의 보험 역할이라고 생각하여 이 정도 기능을 제공한다면 나쁘지는 않아 보입니다.

Hook

ent에서는 2가지 방식으로 hook을 설정할 수 있습니다. 1) 모델 정의 부분에서 hook에 대한 정의 2) ent.Client에 직접 훅을 설정, 각각의 용도에 맞게 사용할 수 있도록 다양한 옵션을 제공하는 점을 좋다고 봅니다.

// Define hook in model

// Hook of the Task.
func (Task) Hook() []ent.Hook {
    return []ent.Hook{
        hook.On(
            func(next ent.Mutator) ent.Mutator {
                return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
                    v, err := next.Mutate(ctx, m)
                    if err != nil {
                        return nil, err
                    }
                    internal.PrintJSONLog(v)
                    return v, err
                })
            },
            ent.OpCreate,
        ),
    }
}

// Define hook in ent.Client

import (
     entgo"entgo.io/ent"
    "project_path/ent"
)

func hook(ctx context.Context, c *ent.Client) {
    // You can do this in schema Hook() [].ent.Hook function
    c.Use(func(next entgo.Mutator) entgo.Mutator {
        return ent.MutateFunc(func(ctx context.Context, m entgo.Mutation) (entgo.Value, error) {
            v, err := next.Mutate(ctx, m)
            if err != nil {
                return nil, err
            }
            internal.PrintJSONLog(v)
            return v, err
        })
    })

    _, err := c.Task.Create().
        SetTitle("task 1").
        SetNote("note 1").
        SetStatus(task.StatusTodo).
        Save(ctx)
    internal.LogFatal(err)
}

hook을 설정하면 모델이 실제로 데이터베이스에 접근하기 전에 조작할 수 있고 또 데이터베이스를 조작한 후의 결과를 조회할 수 있는 부분도 쉽게 구현할 수 있기 때문에 유용한 기능으로 보이네요.

Summary

개인적으로 ent는 code first 전략을 취하고 있기 때문에 성향과 잘 맞는 패키지입니다. 특히 다양한 데이터베이스를 지원하고 그에 대한 DDL을 습득할 필요 없이 패키지에서 생성해 준다는 점, 관계 데이터를 불러오고 출력할 때의 기본 행동이 제가 추구하는 방향과 비슷하다는 것들은 장점으로 볼 수 있습니다.

또한 여기에서는 소개하지 않았지만 정의된 모델에 몇 가지 설정하면 rest api + swagger, graphql, rpc 관련 기본 코드를 자동으로 생성해주는 기능이 있어서 사실 ORM뿐만 아니라 이를 기반으로 생태계를 확장하는 방향을 취하고 있습니다.

저는 비교적 간단한 기능들은 모두 자동화하고 조금 더 중요한 로직을 만드는데 시간을 사용하는 것을 추구하기 때문에 이런 생태계의 확장은 환영하는 입장입니다.

다만 이런 식의 다양한 기능을 제공하는 패키지에 관하여 거부감을 품고 계시는 분들도 있을 것 같은데요. 그렇다면 사실 사용하지 않을 옵션을 제공하기 때문에 ORM으로서 기능을 제한하여 사용하시면 될 것 같습니다.

go(golang) ORM 찾기 #2 - sqlboiler

vultor-xyz — Wed, 08 Jun 2022 07:39:47 +0000

시리즈

github 코드
go(golang) ORM 찾기 #1
go(golang) ORM 찾기 #2 - sqlboiler
go(golang) ORM 찾기 #3 - ent

기본설정

install packages

sqlboiler, sqlboiler postgresql driver 설치

go get github.com/volatiletech/sqlboiler/v4@latest
go get github.com/volatiletech/sqlboiler/v4/drivers/sqlboiler-psql@latest

database migration을 하기위한 golang-migrate 설치
```
go get github.com/golang-migrate/migrate/v4
```
명령어 형태로 실행을 하기 위한 cobra 설치
```
go get github.com/spf13/cobra@latest
```

Create Model

sqlboiler는 데이터베이스에 접속하여 모델 코드를 만드는 형식이기 때문에 1) 데이터베이스 구성 2) migration 파일 제작 후 마이그레이션 실행 3) sqlboiler code generator 실행의 순으로 진행합니다.

docker-compose로 postgre 설정

version: '3.9'
services:
  postgres:
    container_name: postgres
    image: postgres
    volumes:
      - go-orm-example:/var/lib/go-orm-example/data
    environment:
      POSTGRES_USER: 'user'
      POSTGRES_PASSWORD: 'pass'
      POSTGRES_DB: 'postgres'
    ports:
      - "5432:5432"

volumes:
  go-orm-example:

docker-compose up

docker-compose -f docker-compose.yml up -d

golang-migrate로 migration file 제작

migrate create -ext sql -dir examples/boiler/migrations -seq init_tables

데이터베이스 마이그레이션을 위한 DDL 작성 (link)

golang-migrate로 마이그레이션 up을 실행하기 위한 코드 작성

func makeMigrate(migrationPath string) *migrate.Migrate {
    db, err := sql.Open(config.GetDBInfo())
    if err != nil {
        log.Fatal(err)
    }

    driver, err := postgres.WithInstance(db, &postgres.Config{})
    if err != nil {
        log.Fatal(err)
    }

    m, err := migrate.NewWithDatabaseInstance(
        migrationPath,
        "postgres",
        driver,
    )
    if err != nil {
        log.Fatal(err)
    }

    return m
}

func UpMigration(migrationPath string) {
    log.Println("Up Migration")
    m := makeMigrate(migrationPath)
    err := m.Up()
    if err != nil {
        log.Fatal(err)
    }
    log.Println("Complete Up Migration")
}

sqlboiler 기본 접속 설정

output = "examples/boiler/models" # 생성된 파일 저장 위치
wipe = true
add-enum-types = true 

[auto-columns] # create, update 이벤트시 자동 업데이트를 위한 설정
created = "created_at"
updated = "updated_at"

[psql]
dbname = "postgres"
host = "localhost"
port = 5432
user = "user"
pass = "pass"
sslmode = "disable"

sqlboiler 로 모델 생성하기

sqlboiler psql --config examples/boiler/sqlboiler.toml

여기까지 진행하게 되면 아래와 같이 다양한 파일들이 생성됩니다. sqlboiler의 생성한 모델의 기본적인 테스트 코드를 작성해 줍니다.

기본적인 워크플로우는 migration을 sql로 작성한 후에 이를 기반으로 모델 코드를 생성한 다음 필요한 작업을 수행하게 됩니다. database first를 지향하기 때문에 DDL을 작성한 후 코드가 생성되는데 코드를 작성하다가 sql을 작성하는 것에 대하여 큰 부담이 없다면 쉽게 사용하실 수 있을 것 같네요.

Usage

Connection

func GetDBInfo() (string, string) {
    return "postgres", fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",
        "localhost", 5432, "user", "pass", "postgres")
}

conn, err := sql.Open(config.GetDBInfo())

기본 sql 패키지를 사용하여 connection을 만들기 때문에 뭔가 다른 orm을 사용할 수 있다는 장점을 가지고 있습니다.

CRUD

// 편의를 위하여 error 처리 부분은 제외하였습니다
// Create
newUser := &models.User{
    FirstName: "Sample",
    LastName:  "User",
    Birthday:  time.Now().AddDate(-30, 0, 0),
}
err := newUser.Insert(ctx, conn, boil.Infer())

// Read One
gotUser, err := models.Users(
    models.UserWhere.FirstName.EQ("Sample"),
).One(ctx, conn)

// Read List
gotUsers, err := models.Users(
    models.UserWhere.FirstName.EQ("Sample"),
).All(ctx, conn)

// Update
updateRowsAff, err := models.Users(
    models.UserWhere.LastName.EQ("User"),
).UpdateAll(
    ctx,
    conn,
    models.M{models.UserColumns.LastName: "Unknown"},
)

// Delete
deleteRowsAff, err := models.Users().DeleteAll(ctx, conn)

CRUD를 수행하는 건 비교적 간단하다. 함수들이 굉장히 raw query 같은 느낌을 주고 있기 때문에 큰 학습곡선 없이 쉽게 익힐 수 있습니다. 위 코드와 같이 connection을 매번 넣어 줄 수도 있지만 global로 설정하기 때문에 이런 부분은 각자 니즈에 맞게 진행하면 되겠습니다.

특히 where 구문, column 이름 등을 string을 이용하여 작성할 수도 있지만 자동으로 생성된 코드에서 정의된 내용을 불러서 쓸 수 있기 때문에 취향껏 사용할 수 있다.

Relationship

// 편의를 위하여 error 처리 부분은 제외하였습니다

// Create with relationship
newUser := &models.User{
    FirstName: "Sample",
    LastName:  "User",
    Birthday:  time.Now().AddDate(-30, 0, 0),
}
err := newUser.Insert(ctx, conn, boil.Infer())

newTask := &models.Task{
    UserID: null.Int64{Int64: newUser.ID, Valid: true},
    Title:  "task 1",
    Note:   "note 1",
    Status: models.TaskStatusTodo,
}
err = newTask.Insert(ctx, conn, boil.Infer())

// Read with relationship
gotTask, err := models.FindTask(ctx, conn, newTask.ID)
gotTaskUser, err := gotTask.User().One(ctx, conn)

// Eager Loading
gotTask, err = models.Tasks(qm.Load(models.TaskRels.User)).One(ctx, conn)

Create : 직접 sql 쿼리를 작성하여 insert 하는 방식과 동일합니다. Set{Relation}과 같은 형식의 함수를 이용하여 할 수 있는 방법이 존재하지만, 이는 각각의 고유 아이디가 생성된 후에 진행할 수 있기 때문에 총 쿼리의 개수가 늘어나서 위와 같은 방법으로 작성하는 것이 총 쿠리의 수를 줄이는 방향으로 구현하였습니다.
Read : 이미 조회한 모델에서 관계 모델을 불러서 이를 따로 where 문 없이 쿼리를 할 수 있습니다.
Eager Loading : 모델을 조회할 때 Load 구문을 통하여 불러올 수 있으며 이는 recursively하게 불러올 수 있습니다. 또한 {Model}Rels라는 형태로 string 값이 아닌 생성된 코드 정의 값을 사용할 수 있기 때문에 유연하게 사용할 수 있습니다.

Seed

// 편의를 위하여 error 처리 부분은 제외하였습니다

rand.Seed(time.Now().UnixNano())

var newUsers []*models.User
for i := 0; i < count; i++ {
    newUser := &models.User{
        FirstName: "Sample",
        LastName:  "User",
        Birthday:  time.Now().AddDate(-30, 0, 0),
    }
    err := newUser.Insert(ctx, conn, boil.Infer())

    newUsers = append(newUsers, newUser)
}

var newTasks []*models.Task
for i := 0; i < count; i++ {
    num := i + 1
    newTask := &models.Task{
        UserID: null.Int64{Int64: newUsers[rand.Intn(len(newUsers))].ID, Valid: true},
        Title:  fmt.Sprintf("Task %d", num),
        Note:   fmt.Sprintf("Note %d", num),
        Status: models.TaskStatusTodo,
    }
    err := newTask.Insert(ctx, conn, boil.Infer())

    newTasks = append(newTasks, newTask)
}

각각 insert 하는 것으로 구현해 두었는데 여기의 내용을 보면 bulk insert는 지원하지 않는 것으로 보입니다. 사실 이 부분은 직접 구현해도 사용할 수 있지만 내가 생각하기에는 굉장히 많이 사용되는 기능임에도 불구하고 지원하지 않는다는 부분은 굉장히 아쉽게 다가옵니다.

Aggregation

// 편의를 위하여 error 처리 부분은 제외하였습니다

var result []struct {
    UserID int64 `boil:"user_id"`
    Count  int64 `boil:"count"`
}

err := models.Tasks(
    qm.Select("count(*) as count", models.TaskColumns.UserID),
    qm.GroupBy(models.TaskColumns.UserID),
    qm.OrderBy("count DESC"),
    qm.Limit(10),
).Bind(ctx, conn, &result)

계속 말을 하지만 sqlboiler가 SQL문을 알고 있는 분에게는 굉장히 코드 작성이 직관적이기 때문에 그냥 SQL문 작성하듯 작성하면 원하는 결과를 알 수 있습니다. 다만 go언어 특성상 result struct와 같은 방식으로 응답을 bind할 struct를 만들어서 사용해야 합니다. 다만 bind를 위한 tag를 작성해야 하는데 이건 조금 더 쉬운 방법이 있으면 좋을 것 같네요.

Pagination

// 편의를 위하여 error 처리 부분은 제외하였습니다

// Limit & Offset
for i := 0; i < 5; i++ {
    users, err := models.Users(
        qm.Limit(3),
        qm.Offset(i*3),
    ).All(ctx, conn)
}

// Cursor
lastUserID := int64(0)
for i := 0; i < 5; i++ {
    users, err := models.Users(
        models.UserWhere.ID.GT(lastUserID),
        qm.Limit(3),
    ).All(ctx, conn)
    lastUserID = users[len(users)-1].ID
}

offset, cusor paging 두 가지 방식으로 구현해보았습니다. 뭔가 편하게 작동할 방법은 없는 것 같고 직접 구현이기 때문에 특별히 신경 써야 하는 부분은 없어 보이네요.

Transform

개발하다 보면 조회한 모델을 여러 가지 형태로 조작할 필요가 있는데 그럴 때 어떻게 할 수 있는지 알아보았습니다.

Struct way

// 편의를 위하여 error 처리 부분은 제외하였습니다

task, err := models.Tasks(
    models.TaskWhere.UserID.IsNotNull(),
    qm.Load(models.TaskRels.User),
).One(ctx, conn)

// Struct way
internal.PrintJSONLog(
    struct {
        *models.Task
        R interface{}
    }{
        task,
        task.R,
    },
)

// Struct way output
// {
//     "id": 710,
//     "user_id": 786,
//     "child_id": null,
//     "title": "Task 1",
//     "note": "Note 1",
//     "status": "todo",
//     "updated_at": "2022-06-08T06:37:57.787242Z",
//     "created_at": "2022-06-08T06:37:57.787242Z",
//     "R": {
//         "Child": null,
//         "User": {
//             "id": 786,
//             "first_name": "Sample",
//             "last_name": "User",
//             "birthday": "1992-06-08T00:00:00Z",
//             "updated_at": "2022-06-08T06:37:57.749966Z",
//             "created_at": "2022-06-08T06:37:57.749966Z"
//         },
//         "ProjectTasks": null,
//         "ChildTasks": null
//     }
// }

Eager loading을 하였을 때 sqlboiler에서는 기본적으로 load한 관계를 보여주지 않는 것으로 보입니다. 그렇기 때문에 위와 같이 struct를 하나 생성하여 binding을 해줄 수 있습니다. 예제에서는 모든 관계를 가지고 오기 위하여 R을 넣어 주었지만, User만 넣는지 하는 것은 그렇게 어렵지 않아 보입니다.

Functional way

// 편의를 위하여 error 처리 부분은 제외하였습니다

// Functional way
buildTaskOutput := func(t *models.Task) map[string]interface{} {
    output := map[string]interface{}{
        "id":         t.ID,
        "user_id":    t.UserID,
        "child_id":   t.ChildID,
        "title":      t.Title,
        "note":       t.Note,
        "status":     t.Status,
        "updated_at": t.UpdatedAt,
        "created_at": t.CreatedAt,
        "R":          t.R,
    }
    return output
}
internal.PrintJSONLog(buildTaskOutput(task))

// Functional way output
// {
//     "R": {
//         "Child": null,
//         "User": {
//             "id": 786,
//             "first_name": "Sample",
//             "last_name": "User",
//             "birthday": "1992-06-08T00:00:00Z",
//             "updated_at": "2022-06-08T06:37:57.749966Z",
//             "created_at": "2022-06-08T06:37:57.749966Z"
//         },
//         "ProjectTasks": null,
//         "ChildTasks": null
//     },
//     "child_id": null,
//     "created_at": "2022-06-08T06:37:57.787242Z",
//     "id": 710,
//     "note": "Note 1",
//     "status": "todo",
//     "title": "Task 1",
//     "updated_at": "2022-06-08T06:37:57.787242Z",
//     "user_id": 786
// }

1번에서 구현한 방법을 functional 하게 구현해 보았습니다. 위와 같이 구현하면 output 구조에 대하여 완전한 컨트롤을 할 수 있어서 좋은 것 같네요.

Hide column

// 편의를 위하여 error 처리 부분은 제외하였습니다

// Hide column
convertSelectStatement := func(target []string) string {
    return strings.Join(target, ", ")
}
taskDefaultColumns := []string{
    models.TaskColumns.Title,
    models.TaskColumns.Note,
    models.TaskColumns.Status,
}
task, err = models.Tasks(
    qm.Select(convertSelectStatement(taskDefaultColumns)),
).One(ctx, conn)
internal.PrintJSONLog(task)

// Hide column output
// {
//     "id": 0,
//     "user_id": null,
//     "child_id": null,
//     "title": "Task 1",
//     "note": "Note 1",
//     "status": "todo",
//     "updated_at": "0001-01-01T00:00:00Z",
//     "created_at": "0001-01-01T00:00:00Z"
// }

2번까지 구현하고 나서는 매번 output에서 가려야 하는 칼럼이 있을 때 조금 더 간단한 방법을 찾다가 구현하였습니다. 차라리 select 구문에 몇 가지 세트를 만들어서 쿼리시 사용하게 만들어 보았습니다. 다만 마지막 아웃풋에서 칼럼을 완전히 가려버릴 것인지는 output을 만드는 함수에서 조작하면 좋을 것 같습니다.

제가 못 찾은 것일 수도 있지만 transforming을 하는 것은 조금은 직접 구현해야 하는 양이 많아 보였습니다. ORM의 역할을 어디까지인지에 대하여 각자 의견이 다를 수 있겠지만 저의 경우 많이 사용하는 기능 그리고 공통적이라고 생각하는 기능은 어느 정도 커버해주면 편하다는 생각이 들어서 transforming 관련 기능은 조금은 아쉬웠습니다.

Raw Query

// 편의를 위하여 error 처리 부분은 제외하였습니다

var task struct {
    ID    int64  `json:"id"`
    Title string `json:"title"`
}
err := queries.Raw(
    "SELECT * FROM tasks WHERE title LIKE '%Task%'",
).Bind(ctx, conn, &task)

기본 sqlboiler의 쿼리 작성 방식이 직관적이기 때문에 raw query지원은 굉장히 간편하게 사용할 수 있지만 사용하는 경우는 몇몇 특수한 쿼리를 제외하면 매우 한정적일 것으로 생각되네요.

Hook

// 편의를 위하여 error 처리 부분은 제외하였습니다

taskInsertHook := func(ctx context.Context, exec boil.ContextExecutor, t *models.Task) error {
    log.Println("Insert into task :", t.Title)
    return nil
}
models.AddTaskHook(boil.BeforeInsertHook, taskInsertHook)

newTask := &models.Task{
    Title:  "task 1",
    Note:   "note 1",
    Status: models.TaskStatusTodo,
}
err := newTask.Insert(ctx, conn, boil.Infer())

// Output
// Insert into task : task 1

hook 기능도 굉장히 간단하게 구현할 수 있습니다. 함수 하나만 작성하여 붙여주면 사용 가능 때문에 쉽게 사용할 수 있습니다.

Summary

sqlboiler로 구현하면서 직접적으로 데이터베이스에 액세스해야 하는 경우는 지원이 확실하기 때문에 쉽게 사용 가능하다고 생각되었습니다. 반면 조금 부가적인 기능은 지원하지 않기 때문에 이런 경우 다른 라이브러리와 조합하여 사용하는 것이 좋을 것 같습니다.

데이터베이스도 mysql, postgresql, mssql, sqlite3, cockroachDB를 지원하기 때문에 크게 미달한다는 느낌은 없었습니다. 다만 migration을 직접 제작하는 건 저의 경우에는 다른 데이터베이스와의 호환까지 생각하다 보면 조금은 불편하다는 생각이 들었습니다.

ORM을 사용하지만, SQL과 조금 더 가까웠으면 좋겠다고 생각하는 분들에게는 좋은 옵션일 것 같네요.

go(golang) ORM 찾기 #1

vultor-xyz — Fri, 03 Jun 2022 03:54:28 +0000

시리즈

서론

어떤 ORM을 사용하는가에 따라 백엔드 개발에서의 생산성이 크게 영향받는다고 생각합니다. 그래서 go 언어에서 여러 가지 ORM을 살펴보면서 추후 백엔드 개발에서 사용할 ORM을 찾아보겠습니다. 후보 중에서는 ORM이라고 부르기 어려운 기술들도 있는데 여기에서는 데이터베이스에 접근하는 라이브러리를 탐색한다는 생각으로 접근해보려고 합니다.

ORM을 비교할 기준을 먼저 정해보자면 아래와 같습니다.

1. 모델 정의 방법

Code first, Database first 전략이 대표적인데 개인적으로는 코드만 작성하면 나머지는 라이브러리가 알아서 해주는 Code first를 좀 더 선호합니다. SQL을 따로 작성하기보다는 항상 다루는 코드를 작성하는 것이 더 편하다고 생각하기 때문입니다. 그리고 저에게는 사용하기만 편하다면 Active record인지 Data mapper인지는 큰 상관이 없을 것 같습니다.

2. 관계 데이터를 다루는 방법

관계 데이터를 다루는 방법은 정답이 있기보다는 데이터 간 관계를 정의하는 방식이 작성하기 쉽게 되어있는지를 또 쿼리를 할 때 얼마나 쉽게 관계를 불러올 수 있는지를 중점적으로 볼 예정입니다. 부모-자식, many to many와 같은 관계들 그리고 Eager Loading과 같은 기능을 지원하는지가 자세히 봐야 할 것 같습니다.

3. 마이그레이션 처리 방법

데이터베이스의 구조를 변경하기 위한 마이그레이션이 어떤 식으로 처리되는지를 주요하게 볼 예정입니다. 사실 지원하지 않는 ORM들도 상당수 있는데 그 경우 ORM의 모델과 Migration을 따로 작성하는 불편함이 있기 때문에 어떤 툴을 사용하여 마이그레이션을 수행할 수 있는지 그리고 마이그레이션의 롤백은 어떤 식으로 동작하는지를 중점적으로 살펴볼 예정입니다.

4. 이벤트 지원

ORM을 사용하다 보면 어떤 모델이 수정되면 그에 대한 이벤트를 받아야 할 때가 있습니다. 이런 기능을 지원하는지 또한 중점적으로 살펴볼 예정입니다.

5. 지원 데이터베이스

어떤 데이터베이스를 지원하는지 살펴볼 예정입니다. ORM의 장점 중 하나는 여러 가지 데이터베이스에 대하여 동일한 코드로 접근을 할 수 있다는 것인데 과연 이것들이 잘 지원하는지 살펴보면 좋을 것 같네요.

6. 기타 기능들

pagination 관련 기능, 모델 transform 관련 기능, raw query 기능들 등 있으면 좋겠다고 생각하는 기능들에 대하여도 살펴볼 예정입니다.

검증용 데이터베이스 모델

위의 내용들을 검증하기 위한 모델을 작성하였습니다. 모델은 아래와 같습니다.

후보

최근까지 업데이트 되고 있는지 github star가 적절한지에 따라 후보들을 추려보았습니다.

sqlc : database first 전략을 사용하며 각각의 쿼리도 sql로 작성하면 code를 만들어주는 방법을 사용하고 있습니다.
sqlboiler : Rails에서 영감을 받은 것으로 보이고 database first 전략을 취하고 있습니다. 데이터베이스 테이블을 읽어서 모델을 만드는 형태이기 때문에 미리 테이블들을 만들고 이를 기반으로 코드를 생성해야 합니다.
ent : code first 전략을 사용하며 모델 코드를 작성하면 이를 기반으로 다른 필요한 구성요소를 생성하는 형태를 취하고 있습니다.
gorm : code first 전략을 취하고 있고 go 언어 orm을 찾으면 가장 많이 나오는 orm 중 하나입니다.

다음 포스팅부터는 각각의 후보들을 실제로 구현해 보면서 살펴볼 예정입니다.

macOS 개발 환경 설정

vultor-xyz — Wed, 25 May 2022 02:48:09 +0000

새롭게 맥을 설정할 때 어떻게 개발환경을 설정하는지 공유하는 글입니다. 주로 언어별 설정을 제외한 개발 환경을 다룰 것이고 또 개발환경 설정뿐만 아니라 몇 가지 유용한 유틸리티도 함께 소개할 예정입니다. 여기에 공유된 내용이 쓸만한 레퍼런스가 좋겠네요.

Homebrew

많이 알려진 프로그램입니다. 여러 가지 다른 프로그램을 설치하기 위하여 설치해야 하는 프로그램이기 때문에 가장 먼저 설치해 주면 좋습니다.

설치

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile
eval "$(/opt/homebrew/bin/brew shellenv)"

mas-cli

Mac App Store에 있는 프로그램을 명령어로 설치할 수 있게 해주는 프로그램입니다. 나중에 새로 맥을 설정하는 스크립트를 제작할 때 유용합니다.

설치

brew install mas

사용

mas를 사용하여 설치하고자 하는 프로그램을 찾고 그 결과로 나오는 고유 숫자를 사용하여 실제로 프로그램을 설치할 수 있습니다.

# Search
$ mas search $NAME
00000000 $NAME

# Install
$ mas install 00000000

Terminal

다양한 터미널 후보가 있지만 결국 iterm2를 사용하게 되네요. 혹시 다른 옵션을 찾는 분들을 위하여 후보들과 느낀 점을 간단하게 남겨 둡니다.

kitty : 단축키가 손에 잘 익지 않고 변경할 수 있지만 기본 아이콘이 별로네요.
alacritty : 빠릿하여 좋기는 하지만 설정 가이드가 그다지 친절하지 않았습니다.
tabby : 테스트할때 버벅임이 있어서 제외하였습니다.
warp : 첫 화면에서 회원가입이 있어서 제외하였습니다. 회원가입후 사용하면 사실 좋은점도 많은 터미널인데 아쉽네요.

설치

brew install --cask iterm2

상세 설정

테마 설정 : Preference → Appearance → General → Theme → Minimal
키 맵핑 설정 : Preference → Profiles → Keys → Key Mappings → Presets… → Natural Text Editing
컬럼 테마 설정 : Preference → Profiles → Colors → Color Presets → 마음에 드는 것으로

oh my zsh & powerlevel10k

다양한 shell들이 있지만 oh my zsh, powerleve10k 조합은 커뮤니티가 비교적 크다고 생각하여 계속 사용하고 있습니다.

그리고 powerlevel9k를 사용하시던 분들은 그 프로젝트가 read-only로 변환되었기 때문에 powerlevel10k 사용을 권장합니다.

플러그인은 명령어 히스토리의 내용들을 커멘드 입력 시 힌트로 나오게 해주는 zsh-autosuggestions 이외에 필요성을 느끼지 못하여 zsh-autosuggestions만 설치하여 사용하고 있습니다.

설치

sh -c "$(curl -fsSL https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"
git clone https://github.com/zsh-users/zsh-autosuggestions ~/.zsh/zsh-autosuggestions
git clone --depth=1 https://github.com/romkatv/powerlevel10k.git ${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/themes/powerlevel10k

p10k 설정 및 플러그인 관련 `~/.zshrc` 구성

if [[ -r "${XDG_CACHE_HOME:-$HOME/.cache}/p10k-instant-prompt-${(%):-%n}.zsh" ]]; then
  source "${XDG_CACHE_HOME:-$HOME/.cache}/p10k-instant-prompt-${(%):-%n}.zsh"
fi

export ZSH="$HOME/.oh-my-zsh"
ZSH_THEME="powerlevel10k/powerlevel10k"

source $ZSH/oh-my-zsh.sh
source ~/.zsh/zsh-autosuggestions/zsh-autosuggestions.zsh

# To customize prompt, run `p10k configure` or edit ~/.p10k.zsh.
[[ ! -f ~/.p10k.zsh ]] || source ~/.p10k.zsh

lsd

ls를 좀 더 가독성 좋게 할 목적으로 만들어진 프로그램입니다. exa이라는 프로그램도 있지만 개인적으로는 아이콘과 파일명 사이의 공백 처리가 lsd가 더 깔끔하다고 생각하여 lsd를 사용합니다.

설치

brew install lsd

`~/.zshrc` alias 추가 (`ls`와 동일하게 사용하기 위하여)

alias ls='lsd'
alias ll='ls -alhF'

bat

cat에서 문법 하이라이트를 추가한 프로그램입니다. 별거 아닌 것 같지만, 많이 유용한 프로그램 중 하나입니다.

다만 아무런 옵션을 사용하지 않으면 파일 용량 이름 등의 부가 정보를 표시해주기 때문에 >, >> 등 redirection을 할 때 불편한 점이 있어서 -p 옵션을 함께 사용합니다.

설치

brew install bat

`~/.zshrc` alias 추가 (`cat`와 동일하게 사용하기 위하여)

alias cat='bat -p'

peco

grep와 비슷한 필터링 툴입니다. 다만 peco는 interactive하기 때문에 grep와 다르게 검색 목적으로 사용하면 좋은 툴입니다.

설치

brew install peco

sd

sed를 대체하는 툴입니다. sed 보다 문법이 간결하고 속도도 빠르다고 하네요.

설치

brew install sd

Editor

jetbrains-toolbox : jetbrain 제품은 toolbox로 관리하는 게 더 공식적인 느낌이라 toolbox를 설치하여 사용합니다

brew install --cask jetbrains-toolbox

visual-studio-code : 보조 에디터로 많이 사용합니다.

brew install --cask visual-studio-code

spf13-vim : 보조 에디터로 사용합니다. 다만 여러 가지 설정에 신경 쓰고 싶지 않아서 best practice가 잘 되어있는 distribution을 사용합니다.

curl https://j.mp/spf13-vim3 -L > spf13-vim.sh && sh spf13-vim.sh
rm -rf spf13-vim.sh

Xcode : 가끔 iOS 개발을 하므로 설치해두고 사용합니다.

mas install 497799835

Lazydocker

로컬머신에서 돌아가는 docker의 리소스, 로그 등을 모니터링하고 간단한 명령어를 container에 줄 수 있는 프로그램입니다.

설치

brew install lazydocker

bottom

터미널에서 시스템 리소스를 볼 수 있는 툴입니다. 다른 옵션도 많지만, 개인적으로는 다른 옵션에 비하면 안정적이고 리소스마다 상세 뷰 등을 제공합니다.

설치

brew install bottom

다른 옵션

vtop
gtop

ETC

rectangle : 윈도우의 이동과 리사이징을 할 수 있는 프로그램, 다양한 프로그램들이 있지만 오픈소스 기반이고 불필요한 UI들이 없어서 사용하는 프로그램입니다.

brew install --cask rectangle

iina : 오픈소스 동영상 플레이어, 대부분의 단축키가 특별한 학습 없이 생각한 것 같이 적용되어 사용합니다.

brew install --cask iina

keepingyouawake : 맥이 잠자는 것을 막아주는 프로그램입니다.

brew install --cask keepingyouawake

vimari safari에서 vim 단축키 기반 브라우징이 가능하게 해주는 프로그램입니다. 키보드만 사용하고 싶을 때 유용하네요.

mas install 1480933944

지금까지 맥을 새로 설치하였을 때 유용할만한 설정을 알아보았습니다. 각 프로그래밍 언어별 설정들도 있을 것 같은데요. 그건 커버할 범위가 넓을 수 있기 때문에 다른 글에서 알아보도록 하겠습니다. 여기에 나온 설치 명령어들을 모아서 한 번에 프로그램이 설치할 수 있는 스크립트를 만들어 봐도 좋을 것 같네요.

DEV Community: vultor-xyz

go(golang) ORM 찾기 #3 - ent

시리즈

Introduction

Setting

Install Packages

Create Models

Migration

Code Generation

Usage

Connection

CRUD

Relationship

Seed

Aggregation

Pagination

Transform

Raw Query

Hook

Summary

go(golang) ORM 찾기 #2 - sqlboiler

시리즈

기본설정

install packages

Create Model

Usage

Connection

CRUD

Relationship

Seed

Aggregation

Pagination

Transform

Raw Query

Hook

Summary

go(golang) ORM 찾기 #1

시리즈

서론

1. 모델 정의 방법

2. 관계 데이터를 다루는 방법

3. 마이그레이션 처리 방법

4. 이벤트 지원

5. 지원 데이터베이스

6. 기타 기능들

검증용 데이터베이스 모델

후보

macOS 개발 환경 설정

설치

설치

사용

Terminal

설치

상세 설정

oh my zsh & powerlevel10k

설치

p10k 설정 및 플러그인 관련 ~/.zshrc 구성

설치

~/.zshrc alias 추가 (ls와 동일하게 사용하기 위하여)

설치

~/.zshrc alias 추가 (cat와 동일하게 사용하기 위하여)

설치

설치

Editor

설치

설치

다른 옵션

ETC

p10k 설정 및 플러그인 관련 `~/.zshrc` 구성

`~/.zshrc` alias 추가 (`ls`와 동일하게 사용하기 위하여)

`~/.zshrc` alias 추가 (`cat`와 동일하게 사용하기 위하여)