gorm의 DeletedAt에 대해 얘기해 보겠습니다.

순서

본고는 주로 gorm의 DeletedAt을 연구합니다.

DeletedAt

gorm.io/[email protected]/soft_delete.go

type DeletedAt sql.NullTime

// Scan implements the Scanner interface.
func (n *DeletedAt) Scan(value interface{}) error {
    return (*sql.NullTime)(n).Scan(value)
}

// Value implements the driver Valuer interface.
func (n DeletedAt) Value() (driver.Value, error) {
    if !n.Valid {
        return nil, nil
    }
    return n.Time, nil
}

func (n DeletedAt) MarshalJSON() ([]byte, error) {
    if n.Valid {
        return json.Marshal(n.Time)
    }
    return json.Marshal(nil)
}

func (n *DeletedAt) UnmarshalJSON(b []byte) error {
    if string(b) == "null" {
        n.Valid = false
        return nil
    }
    err := json.Unmarshal(b, &n.Time)
    if err == nil {
        n.Valid = true
    }
    return err
}

func (DeletedAt) QueryClauses(f *schema.Field) []clause.Interface {
    return []clause.Interface{SoftDeleteQueryClause{Field: f}}
}

func (DeletedAt) DeleteClauses(f *schema.Field) []clause.Interface {
    return []clause.Interface{SoftDeleteDeleteClause{Field: f}}
}

DeletedAt은 sql입니다.NullTime 유형은 Scanner 인터페이스의 Scan 방법을 실현하고 Valuer 인터페이스의 Value 방법을 실현한다.또한 MarshalJSON, UnmarshalJSON 방법을 정의하고QueryClauses 방법을 정의했으며 SoftDeleteQueryClause를 사용했다.DeleteClauses 메서드는 SoftDeleteDeleteClause를 사용합니다.

SoftDeleteQueryClause

gorm.io/[email protected]/soft_delete.go

type SoftDeleteQueryClause struct {
    Field *schema.Field
}

func (sd SoftDeleteQueryClause) Name() string {
    return ""
}

func (sd SoftDeleteQueryClause) Build(clause.Builder) {
}

func (sd SoftDeleteQueryClause) MergeClause(*clause.Clause) {
}

func (sd SoftDeleteQueryClause) ModifyStatement(stmt *Statement) {
    if _, ok := stmt.Clauses["soft_delete_enabled"]; !ok {
        if c, ok := stmt.Clauses["WHERE"]; ok {
            if where, ok := c.Expression.(clause.Where); ok && len(where.Exprs) > 1 {
                for _, expr := range where.Exprs {
                    if orCond, ok := expr.(clause.OrConditions); ok && len(orCond.Exprs) == 1 {
                        where.Exprs = []clause.Expression{clause.And(where.Exprs...)}
                        c.Expression = where
                        stmt.Clauses["WHERE"] = c
                        break
                    }
                }
            }
        }

        stmt.AddClause(clause.Where{Exprs: []clause.Expression{
            clause.Eq{Column: clause.Column{Table: clause.CurrentTable, Name: sd.Field.DBName}, Value: nil},
        }})
        stmt.Clauses["soft_delete_enabled"] = clause.Clause{}
    }
}

SoftDeleteQueryClause의 ModifyStatement 메서드는 nil의 조회 조건으로 DeletedAt을 추가합니다.

SoftDeleteDeleteClause

gorm.io/[email protected]/soft_delete.go

type SoftDeleteDeleteClause struct {
    Field *schema.Field
}

func (sd SoftDeleteDeleteClause) Name() string {
    return ""
}

func (sd SoftDeleteDeleteClause) Build(clause.Builder) {
}

func (sd SoftDeleteDeleteClause) MergeClause(*clause.Clause) {
}

func (sd SoftDeleteDeleteClause) ModifyStatement(stmt *Statement) {
    if stmt.SQL.String() == "" {
        curTime := stmt.DB.NowFunc()
        stmt.AddClause(clause.Set{{Column: clause.Column{Name: sd.Field.DBName}, Value: curTime}})
        stmt.SetColumn(sd.Field.DBName, curTime, true)

        if stmt.Schema != nil {
            _, queryValues := schema.GetIdentityFieldValuesMap(stmt.ReflectValue, stmt.Schema.PrimaryFields)
            column, values := schema.ToQueryValues(stmt.Table, stmt.Schema.PrimaryFieldDBNames, queryValues)

            if len(values) > 0 {
                stmt.AddClause(clause.Where{Exprs: []clause.Expression{clause.IN{Column: column, Values: values}}})
            }

            if stmt.ReflectValue.CanAddr() && stmt.Dest != stmt.Model && stmt.Model != nil {
                _, queryValues = schema.GetIdentityFieldValuesMap(reflect.ValueOf(stmt.Model), stmt.Schema.PrimaryFields)
                column, values = schema.ToQueryValues(stmt.Table, stmt.Schema.PrimaryFieldDBNames, queryValues)

                if len(values) > 0 {
                    stmt.AddClause(clause.Where{Exprs: []clause.Expression{clause.IN{Column: column, Values: values}}})
                }
            }
        }

        if _, ok := stmt.Clauses["WHERE"]; !stmt.DB.AllowGlobalUpdate && !ok {
            stmt.DB.AddError(ErrMissingWhereClause)
        } else {
            SoftDeleteQueryClause{Field: sd.Field}.ModifyStatement(stmt)
        }

        stmt.AddClauseIfNotExists(clause.Update{})
        stmt.Build("UPDATE", "SET", "WHERE")
    }
}

SoftDeleteDeleteClause의 ModifyStatement 메서드는 DeletedAt을 현재 시간으로 설정합니다.

interfaces

gorm.io/[email protected]/schema/interfaces.go

type GormDataTypeInterface interface {
    GormDataType() string
}

type CreateClausesInterface interface {
    CreateClauses(*Field) []clause.Interface
}

type QueryClausesInterface interface {
    QueryClauses(*Field) []clause.Interface
}

type UpdateClausesInterface interface {
    UpdateClauses(*Field) []clause.Interface
}

type DeleteClausesInterface interface {
    DeleteClauses(*Field) []clause.Interface
}

인터페이스 패키지는QueryClausesInterface, DeleteClausesInterface 인터페이스를 정의합니다.schema의 Parse 방법은 이 인터페이스의 대응 방법을 리셋합니다.

작은 매듭

gorm의 DeletedAt은 sql입니다.NullTime 유형은QueryClauses 방법을 정의하고 SoftDeleteQueryClause를 사용하며 ModifyStatement 방법은nil의 조회 조건으로 DeletedAt을 추가합니다.DeleteClauses 방법은 SoftDeleteDeleteClause를 사용하며, ModifyStatement 방법은 DeletedAt을 현재 시간으로 설정합니다.

doc

gorm