README

GORM

The fantastic ORM library for Golang, aims to be developer friendly.

go report card wercker status Open Collective Backer Open Collective Sponsor MIT license GoDoc

Overview

  • Full-Featured ORM (almost)
  • Associations (Has One, Has Many, Belongs To, Many To Many, Polymorphism)
  • Hooks (Before/After Create/Save/Update/Delete/Find)
  • Preloading (eager loading)
  • Transactions
  • Composite Primary Key
  • SQL Builder
  • Auto Migrations
  • Logger
  • Extendable, write Plugins based on GORM callbacks
  • Every feature comes with tests
  • Developer Friendly

Getting Started

Contributing

You can help to deliver a better GORM, check out things you can do

License

© Jinzhu, 2013~time.Now

Released under the MIT License

Expand ▾ Collapse ▴

Documentation

Index

Constants

This section is empty.

Variables

View Source
var (
	// ErrRecordNotFound record not found error, happens when haven't find any matched data when looking up with a struct
	ErrRecordNotFound = errors.New("record not found")
	// ErrInvalidSQL invalid SQL error, happens when you passed invalid SQL
	ErrInvalidSQL = errors.New("invalid SQL")
	// ErrInvalidTransaction invalid transaction when you are trying to `Commit` or `Rollback`
	ErrInvalidTransaction = errors.New("no valid transaction")
	// ErrCantStartTransaction can't start transaction when you are trying to start one with `Begin`
	ErrCantStartTransaction = errors.New("can't start transaction")
	// ErrUnaddressable unaddressable value
	ErrUnaddressable = errors.New("using unaddressable value")
)
View Source
var DefaultCallback = &Callback{}

    DefaultCallback default callbacks defined by gorm

    View Source
    var DefaultTableNameHandler = func(db *DB, defaultTableName string) string {
    	return defaultTableName
    }

      DefaultTableNameHandler default table name handler

      View Source
      var LogFormatter = func(values ...interface{}) (messages []interface{}) {
      	if len(values) > 1 {
      		var (
      			sql             string
      			formattedValues []string
      			level           = values[0]
      			currentTime     = "\n\033[33m[" + NowFunc().Format("2006-01-02 15:04:05") + "]\033[0m"
      			source          = fmt.Sprintf("\033[35m(%v)\033[0m", values[1])
      		)
      
      		messages = []interface{}{source, currentTime}
      
      		if level == "sql" {
      
      			messages = append(messages, fmt.Sprintf(" \033[36;1m[%.2fms]\033[0m ", float64(values[2].(time.Duration).Nanoseconds()/1e4)/100.0))
      
      			for _, value := range values[4].([]interface{}) {
      				indirectValue := reflect.Indirect(reflect.ValueOf(value))
      				if indirectValue.IsValid() {
      					value = indirectValue.Interface()
      					if t, ok := value.(time.Time); ok {
      						formattedValues = append(formattedValues, fmt.Sprintf("'%v'", t.Format("2006-01-02 15:04:05")))
      					} else if b, ok := value.([]byte); ok {
      						if str := string(b); isPrintable(str) {
      							formattedValues = append(formattedValues, fmt.Sprintf("'%v'", str))
      						} else {
      							formattedValues = append(formattedValues, "'<binary>'")
      						}
      					} else if r, ok := value.(driver.Valuer); ok {
      						if value, err := r.Value(); err == nil && value != nil {
      							formattedValues = append(formattedValues, fmt.Sprintf("'%v'", value))
      						} else {
      							formattedValues = append(formattedValues, "NULL")
      						}
      					} else {
      						formattedValues = append(formattedValues, fmt.Sprintf("'%v'", value))
      					}
      				} else {
      					formattedValues = append(formattedValues, "NULL")
      				}
      			}
      
      			if numericPlaceHolderRegexp.MatchString(values[3].(string)) {
      				sql = values[3].(string)
      				for index, value := range formattedValues {
      					placeholder := fmt.Sprintf(`\$%d([^\d]|$)`, index+1)
      					sql = regexp.MustCompile(placeholder).ReplaceAllString(sql, value+"$1")
      				}
      			} else {
      				formattedValuesLength := len(formattedValues)
      				for index, value := range sqlRegexp.Split(values[3].(string), -1) {
      					sql += value
      					if index < formattedValuesLength {
      						sql += formattedValues[index]
      					}
      				}
      			}
      
      			messages = append(messages, sql)
      			messages = append(messages, fmt.Sprintf(" \n\033[36;31m[%v]\033[0m ", strconv.FormatInt(values[5].(int64), 10)+" rows affected or returned "))
      		} else {
      			messages = append(messages, "\033[31;1m")
      			messages = append(messages, values[2:]...)
      			messages = append(messages, "\033[0m")
      		}
      	}
      
      	return
      }
      View Source
      var NowFunc = func() time.Time {
      	return time.Now()
      }

        NowFunc returns current time, this function is exported in order to be able to give the flexibility to the developer to customize it according to their needs, e.g:

        gorm.NowFunc = func() time.Time {
          return time.Now().UTC()
        }
        
        View Source
        var ParseFieldStructForDialect = func(field *StructField, dialect Dialect) (fieldValue reflect.Value, sqlType string, size int, additionalType string) {
        	// Get redirected field type
        	var (
        		reflectType = field.Struct.Type
        		dataType    = field.TagSettings["TYPE"]
        	)
        
        	for reflectType.Kind() == reflect.Ptr {
        		reflectType = reflectType.Elem()
        	}
        
        	fieldValue = reflect.Indirect(reflect.New(reflectType))
        
        	if gormDataType, ok := fieldValue.Interface().(interface {
        		GormDataType(Dialect) string
        	}); ok {
        		dataType = gormDataType.GormDataType(dialect)
        	}
        
        	if dataType == "" {
        		var getScannerValue func(reflect.Value)
        		getScannerValue = func(value reflect.Value) {
        			fieldValue = value
        			if _, isScanner := reflect.New(fieldValue.Type()).Interface().(sql.Scanner); isScanner && fieldValue.Kind() == reflect.Struct {
        				getScannerValue(fieldValue.Field(0))
        			}
        		}
        		getScannerValue(fieldValue)
        	}
        
        	if num, ok := field.TagSettings["SIZE"]; ok {
        		size, _ = strconv.Atoi(num)
        	} else {
        		size = 255
        	}
        
        	additionalType = field.TagSettings["NOT NULL"] + " " + field.TagSettings["UNIQUE"]
        	if value, ok := field.TagSettings["DEFAULT"]; ok {
        		additionalType = additionalType + " DEFAULT " + value
        	}
        
        	return fieldValue, dataType, size, strings.TrimSpace(additionalType)
        }

          ParseFieldStructForDialect get field's sql data type

          Functions

          func Expr

          func Expr(expression string, args ...interface{}) *expr

            Expr generate raw SQL expression, for example:

            DB.Model(&product).Update("price", gorm.Expr("price * ? + ?", 2, 100))
            

            func IsByteArrayOrSlice

            func IsByteArrayOrSlice(value reflect.Value) bool

              IsByteArrayOrSlice returns true of the reflected value is an array or slice

              func IsRecordNotFoundError

              func IsRecordNotFoundError(err error) bool

                IsRecordNotFoundError returns current error has record not found error or not

                func RegisterDialect

                func RegisterDialect(name string, dialect Dialect)

                  RegisterDialect register new dialect

                  func ToDBName

                  func ToDBName(name string) string

                    ToDBName convert string to db name

                    Types

                    type Association

                    type Association struct {
                    	Error error
                    	// contains filtered or unexported fields
                    }

                      Association Mode contains some helper methods to handle relationship things easily.

                      func (*Association) Append

                      func (association *Association) Append(values ...interface{}) *Association

                        Append append new associations for many2many, has_many, replace current association for has_one, belongs_to

                        func (*Association) Clear

                        func (association *Association) Clear() *Association

                          Clear remove relationship between source & current associations, won't delete those associations

                          func (*Association) Count

                          func (association *Association) Count() int

                            Count return the count of current associations

                            func (*Association) Delete

                            func (association *Association) Delete(values ...interface{}) *Association

                              Delete remove relationship between source & passed arguments, but won't delete those arguments

                              func (*Association) Find

                              func (association *Association) Find(value interface{}) *Association

                                Find find out all related associations

                                func (*Association) Replace

                                func (association *Association) Replace(values ...interface{}) *Association

                                  Replace replace current associations with new one

                                  type Callback

                                  type Callback struct {
                                  	// contains filtered or unexported fields
                                  }

                                    Callback is a struct that contains all CRUD callbacks

                                    Field `creates` contains callbacks will be call when creating object
                                    Field `updates` contains callbacks will be call when updating object
                                    Field `deletes` contains callbacks will be call when deleting object
                                    Field `queries` contains callbacks will be call when querying object with query methods like Find, First, Related, Association...
                                    Field `rowQueries` contains callbacks will be call when querying object with Row, Rows...
                                    Field `processors` contains all callback processors, will be used to generate above callbacks in order
                                    

                                    func (*Callback) Create

                                    func (c *Callback) Create() *CallbackProcessor

                                      Create could be used to register callbacks for creating object

                                      db.Callback().Create().After("gorm:create").Register("plugin:run_after_create", func(*Scope) {
                                        // business logic
                                        ...
                                      
                                        // set error if some thing wrong happened, will rollback the creating
                                        scope.Err(errors.New("error"))
                                      })
                                      

                                      func (*Callback) Delete

                                      func (c *Callback) Delete() *CallbackProcessor

                                        Delete could be used to register callbacks for deleting object, refer `Create` for usage

                                        func (*Callback) Query

                                        func (c *Callback) Query() *CallbackProcessor

                                          Query could be used to register callbacks for querying objects with query methods like `Find`, `First`, `Related`, `Association`... Refer `Create` for usage

                                          func (*Callback) RowQuery

                                          func (c *Callback) RowQuery() *CallbackProcessor

                                            RowQuery could be used to register callbacks for querying objects with `Row`, `Rows`, refer `Create` for usage

                                            func (*Callback) Update

                                            func (c *Callback) Update() *CallbackProcessor

                                              Update could be used to register callbacks for updating object, refer `Create` for usage

                                              type CallbackProcessor

                                              type CallbackProcessor struct {
                                              	// contains filtered or unexported fields
                                              }

                                                CallbackProcessor contains callback informations

                                                func (*CallbackProcessor) After

                                                func (cp *CallbackProcessor) After(callbackName string) *CallbackProcessor

                                                  After insert a new callback after callback `callbackName`, refer `Callbacks.Create`

                                                  func (*CallbackProcessor) Before

                                                  func (cp *CallbackProcessor) Before(callbackName string) *CallbackProcessor

                                                    Before insert a new callback before callback `callbackName`, refer `Callbacks.Create`

                                                    func (*CallbackProcessor) Get

                                                    func (cp *CallbackProcessor) Get(callbackName string) (callback func(scope *Scope))

                                                      Get registered callback

                                                      db.Callback().Create().Get("gorm:create")
                                                      

                                                      func (*CallbackProcessor) Register

                                                      func (cp *CallbackProcessor) Register(callbackName string, callback func(scope *Scope))

                                                        Register a new callback, refer `Callbacks.Create`

                                                        func (*CallbackProcessor) Remove

                                                        func (cp *CallbackProcessor) Remove(callbackName string)

                                                          Remove a registered callback

                                                          db.Callback().Create().Remove("gorm:update_time_stamp_when_create")
                                                          

                                                          func (*CallbackProcessor) Replace

                                                          func (cp *CallbackProcessor) Replace(callbackName string, callback func(scope *Scope))

                                                            Replace a registered callback with new callback

                                                                db.Callback().Create().Replace("gorm:update_time_stamp_when_create", func(*Scope) {
                                                            		   scope.SetColumn("Created", now)
                                                            		   scope.SetColumn("Updated", now)
                                                                })
                                                            

                                                            type DB

                                                            type DB struct {
                                                            	Value        interface{}
                                                            	Error        error
                                                            	RowsAffected int64
                                                            	// contains filtered or unexported fields
                                                            }

                                                              DB contains information for current db connection

                                                              func Open

                                                              func Open(dialect string, args ...interface{}) (db *DB, err error)

                                                                Open initialize a new db connection, need to import driver first, e.g:

                                                                import _ "github.com/go-sql-driver/mysql"
                                                                func main() {
                                                                  db, err := gorm.Open("mysql", "user:password@/dbname?charset=utf8&parseTime=True&loc=Local")
                                                                }
                                                                

                                                                GORM has wrapped some drivers, for easier to remember driver's import path, so you could import the mysql driver with

                                                                import _ "github.com/jinzhu/gorm/dialects/mysql"
                                                                // import _ "github.com/jinzhu/gorm/dialects/postgres"
                                                                // import _ "github.com/jinzhu/gorm/dialects/sqlite"
                                                                // import _ "github.com/jinzhu/gorm/dialects/mssql"
                                                                

                                                                func (*DB) AddError

                                                                func (s *DB) AddError(err error) error

                                                                  AddError add error to the db

                                                                  func (*DB) AddForeignKey

                                                                  func (s *DB) AddForeignKey(field string, dest string, onDelete string, onUpdate string) *DB

                                                                    AddForeignKey Add foreign key to the given scope, e.g:

                                                                    db.Model(&User{}).AddForeignKey("city_id", "cities(id)", "RESTRICT", "RESTRICT")
                                                                    

                                                                    func (*DB) AddIndex

                                                                    func (s *DB) AddIndex(indexName string, columns ...string) *DB

                                                                      AddIndex add index for columns with given name

                                                                      func (*DB) AddUniqueIndex

                                                                      func (s *DB) AddUniqueIndex(indexName string, columns ...string) *DB

                                                                        AddUniqueIndex add unique index for columns with given name

                                                                        func (*DB) Assign

                                                                        func (s *DB) Assign(attrs ...interface{}) *DB

                                                                          Assign assign result with argument regardless it is found or not with `FirstOrInit` https://jinzhu.github.io/gorm/crud.html#firstorinit or `FirstOrCreate` https://jinzhu.github.io/gorm/crud.html#firstorcreate

                                                                          func (*DB) Association

                                                                          func (s *DB) Association(column string) *Association

                                                                            Association start `Association Mode` to handler relations things easir in that mode, refer: https://jinzhu.github.io/gorm/associations.html#association-mode

                                                                            func (*DB) Attrs

                                                                            func (s *DB) Attrs(attrs ...interface{}) *DB

                                                                              Attrs initialize struct with argument if record not found with `FirstOrInit` https://jinzhu.github.io/gorm/crud.html#firstorinit or `FirstOrCreate` https://jinzhu.github.io/gorm/crud.html#firstorcreate

                                                                              func (*DB) AutoMigrate

                                                                              func (s *DB) AutoMigrate(values ...interface{}) *DB

                                                                                AutoMigrate run auto migration for given models, will only add missing fields, won't delete/change current data

                                                                                func (*DB) Begin

                                                                                func (s *DB) Begin() *DB

                                                                                  Begin begin a transaction

                                                                                  func (*DB) BlockGlobalUpdate

                                                                                  func (s *DB) BlockGlobalUpdate(enable bool) *DB

                                                                                    BlockGlobalUpdate if true, generates an error on update/delete without where clause. This is to prevent eventual error with empty objects updates/deletions

                                                                                    func (*DB) Callback

                                                                                    func (s *DB) Callback() *Callback

                                                                                      Callback return `Callbacks` container, you could add/change/delete callbacks with it

                                                                                      db.Callback().Create().Register("update_created_at", updateCreated)
                                                                                      

                                                                                      Refer https://jinzhu.github.io/gorm/development.html#callbacks

                                                                                      func (*DB) Close

                                                                                      func (s *DB) Close() error

                                                                                        Close close current db connection. If database connection is not an io.Closer, returns an error.

                                                                                        func (*DB) Commit

                                                                                        func (s *DB) Commit() *DB

                                                                                          Commit commit a transaction

                                                                                          func (*DB) CommonDB

                                                                                          func (s *DB) CommonDB() SQLCommon

                                                                                            CommonDB return the underlying `*sql.DB` or `*sql.Tx` instance, mainly intended to allow coexistence with legacy non-GORM code.

                                                                                            func (*DB) Count

                                                                                            func (s *DB) Count(value interface{}) *DB

                                                                                              Count get how many records for a model

                                                                                              func (*DB) Create

                                                                                              func (s *DB) Create(value interface{}) *DB

                                                                                                Create insert the value into database

                                                                                                func (*DB) CreateTable

                                                                                                func (s *DB) CreateTable(models ...interface{}) *DB

                                                                                                  CreateTable create table for models

                                                                                                  func (*DB) DB

                                                                                                  func (s *DB) DB() *sql.DB

                                                                                                    DB get `*sql.DB` from current connection If the underlying database connection is not a *sql.DB, returns nil

                                                                                                    func (*DB) Debug

                                                                                                    func (s *DB) Debug() *DB

                                                                                                      Debug start debug mode

                                                                                                      func (*DB) Delete

                                                                                                      func (s *DB) Delete(value interface{}, where ...interface{}) *DB

                                                                                                        Delete delete value match given conditions, if the value has primary key, then will including the primary key as condition

                                                                                                        func (*DB) Dialect

                                                                                                        func (s *DB) Dialect() Dialect

                                                                                                          Dialect get dialect

                                                                                                          func (*DB) DropColumn

                                                                                                          func (s *DB) DropColumn(column string) *DB

                                                                                                            DropColumn drop a column

                                                                                                            func (*DB) DropTable

                                                                                                            func (s *DB) DropTable(values ...interface{}) *DB

                                                                                                              DropTable drop table for models

                                                                                                              func (*DB) DropTableIfExists

                                                                                                              func (s *DB) DropTableIfExists(values ...interface{}) *DB

                                                                                                                DropTableIfExists drop table if it is exist

                                                                                                                func (*DB) Exec

                                                                                                                func (s *DB) Exec(sql string, values ...interface{}) *DB

                                                                                                                  Exec execute raw sql

                                                                                                                  func (*DB) Find

                                                                                                                  func (s *DB) Find(out interface{}, where ...interface{}) *DB

                                                                                                                    Find find records that match given conditions

                                                                                                                    func (*DB) First

                                                                                                                    func (s *DB) First(out interface{}, where ...interface{}) *DB

                                                                                                                      First find first record that match given conditions, order by primary key

                                                                                                                      func (*DB) FirstOrCreate

                                                                                                                      func (s *DB) FirstOrCreate(out interface{}, where ...interface{}) *DB

                                                                                                                        FirstOrCreate find first matched record or create a new one with given conditions (only works with struct, map conditions) https://jinzhu.github.io/gorm/crud.html#firstorcreate

                                                                                                                        func (*DB) FirstOrInit

                                                                                                                        func (s *DB) FirstOrInit(out interface{}, where ...interface{}) *DB

                                                                                                                          FirstOrInit find first matched record or initialize a new one with given conditions (only works with struct, map conditions) https://jinzhu.github.io/gorm/crud.html#firstorinit

                                                                                                                          func (*DB) Get

                                                                                                                          func (s *DB) Get(name string) (value interface{}, ok bool)

                                                                                                                            Get get setting by name

                                                                                                                            func (*DB) GetErrors

                                                                                                                            func (s *DB) GetErrors() []error

                                                                                                                              GetErrors get happened errors from the db

                                                                                                                              func (*DB) Group

                                                                                                                              func (s *DB) Group(query string) *DB

                                                                                                                                Group specify the group method on the find

                                                                                                                                func (*DB) HasBlockGlobalUpdate

                                                                                                                                func (s *DB) HasBlockGlobalUpdate() bool

                                                                                                                                  HasBlockGlobalUpdate return state of block

                                                                                                                                  func (*DB) HasTable

                                                                                                                                  func (s *DB) HasTable(value interface{}) bool

                                                                                                                                    HasTable check has table or not

                                                                                                                                    func (*DB) Having

                                                                                                                                    func (s *DB) Having(query interface{}, values ...interface{}) *DB

                                                                                                                                      Having specify HAVING conditions for GROUP BY

                                                                                                                                      func (*DB) InstantSet

                                                                                                                                      func (s *DB) InstantSet(name string, value interface{}) *DB

                                                                                                                                        InstantSet instant set setting, will affect current db

                                                                                                                                        func (*DB) Joins

                                                                                                                                        func (s *DB) Joins(query string, args ...interface{}) *DB

                                                                                                                                          Joins specify Joins conditions

                                                                                                                                          db.Joins("JOIN emails ON emails.user_id = users.id AND emails.email = ?", "jinzhu@example.org").Find(&user)
                                                                                                                                          

                                                                                                                                          func (*DB) Last

                                                                                                                                          func (s *DB) Last(out interface{}, where ...interface{}) *DB

                                                                                                                                            Last find last record that match given conditions, order by primary key

                                                                                                                                            func (*DB) Limit

                                                                                                                                            func (s *DB) Limit(limit interface{}) *DB

                                                                                                                                              Limit specify the number of records to be retrieved

                                                                                                                                              func (*DB) LogMode

                                                                                                                                              func (s *DB) LogMode(enable bool) *DB

                                                                                                                                                LogMode set log mode, `true` for detailed logs, `false` for no log, default, will only print error logs

                                                                                                                                                func (*DB) Model

                                                                                                                                                func (s *DB) Model(value interface{}) *DB

                                                                                                                                                  Model specify the model you would like to run db operations

                                                                                                                                                  // update all users's name to `hello`
                                                                                                                                                  db.Model(&User{}).Update("name", "hello")
                                                                                                                                                  // if user's primary key is non-blank, will use it as condition, then will only update the user's name to `hello`
                                                                                                                                                  db.Model(&user).Update("name", "hello")
                                                                                                                                                  

                                                                                                                                                  func (*DB) ModifyColumn

                                                                                                                                                  func (s *DB) ModifyColumn(column string, typ string) *DB

                                                                                                                                                    ModifyColumn modify column to type

                                                                                                                                                    func (*DB) New

                                                                                                                                                    func (s *DB) New() *DB

                                                                                                                                                      New clone a new db connection without search conditions

                                                                                                                                                      func (*DB) NewRecord

                                                                                                                                                      func (s *DB) NewRecord(value interface{}) bool

                                                                                                                                                        NewRecord check if value's primary key is blank

                                                                                                                                                        func (*DB) NewScope

                                                                                                                                                        func (s *DB) NewScope(value interface{}) *Scope

                                                                                                                                                          NewScope create a scope for current operation

                                                                                                                                                          func (*DB) Not

                                                                                                                                                          func (s *DB) Not(query interface{}, args ...interface{}) *DB

                                                                                                                                                            Not filter records that don't match current conditions, similar to `Where`

                                                                                                                                                            func (*DB) Offset

                                                                                                                                                            func (s *DB) Offset(offset interface{}) *DB

                                                                                                                                                              Offset specify the number of records to skip before starting to return the records

                                                                                                                                                              func (*DB) Omit

                                                                                                                                                              func (s *DB) Omit(columns ...string) *DB

                                                                                                                                                                Omit specify fields that you want to ignore when saving to database for creating, updating

                                                                                                                                                                func (*DB) Or

                                                                                                                                                                func (s *DB) Or(query interface{}, args ...interface{}) *DB

                                                                                                                                                                  Or filter records that match before conditions or this one, similar to `Where`

                                                                                                                                                                  func (*DB) Order

                                                                                                                                                                  func (s *DB) Order(value interface{}, reorder ...bool) *DB

                                                                                                                                                                    Order specify order when retrieve records from database, set reorder to `true` to overwrite defined conditions

                                                                                                                                                                    db.Order("name DESC")
                                                                                                                                                                    db.Order("name DESC", true) // reorder
                                                                                                                                                                    db.Order(gorm.Expr("name = ? DESC", "first")) // sql expression
                                                                                                                                                                    

                                                                                                                                                                    func (*DB) Pluck

                                                                                                                                                                    func (s *DB) Pluck(column string, value interface{}) *DB

                                                                                                                                                                      Pluck used to query single column from a model as a map

                                                                                                                                                                      var ages []int64
                                                                                                                                                                      db.Find(&users).Pluck("age", &ages)
                                                                                                                                                                      

                                                                                                                                                                      func (*DB) Preload

                                                                                                                                                                      func (s *DB) Preload(column string, conditions ...interface{}) *DB

                                                                                                                                                                        Preload preload associations with given conditions

                                                                                                                                                                        db.Preload("Orders", "state NOT IN (?)", "cancelled").Find(&users)
                                                                                                                                                                        

                                                                                                                                                                        func (*DB) QueryExpr

                                                                                                                                                                        func (s *DB) QueryExpr() *expr

                                                                                                                                                                          QueryExpr returns the query as expr object

                                                                                                                                                                          func (*DB) Raw

                                                                                                                                                                          func (s *DB) Raw(sql string, values ...interface{}) *DB

                                                                                                                                                                            Raw use raw sql as conditions, won't run it unless invoked by other methods

                                                                                                                                                                            db.Raw("SELECT name, age FROM users WHERE name = ?", 3).Scan(&result)
                                                                                                                                                                            

                                                                                                                                                                            func (*DB) RecordNotFound

                                                                                                                                                                            func (s *DB) RecordNotFound() bool

                                                                                                                                                                              RecordNotFound check if returning ErrRecordNotFound error

                                                                                                                                                                              func (*DB) Related

                                                                                                                                                                              func (s *DB) Related(value interface{}, foreignKeys ...string) *DB

                                                                                                                                                                                Related get related associations

                                                                                                                                                                                func (*DB) RemoveForeignKey

                                                                                                                                                                                func (s *DB) RemoveForeignKey(field string, dest string) *DB

                                                                                                                                                                                  RemoveForeignKey Remove foreign key from the given scope, e.g:

                                                                                                                                                                                  db.Model(&User{}).RemoveForeignKey("city_id", "cities(id)")
                                                                                                                                                                                  

                                                                                                                                                                                  func (*DB) RemoveIndex

                                                                                                                                                                                  func (s *DB) RemoveIndex(indexName string) *DB

                                                                                                                                                                                    RemoveIndex remove index with name

                                                                                                                                                                                    func (*DB) Rollback

                                                                                                                                                                                    func (s *DB) Rollback() *DB

                                                                                                                                                                                      Rollback rollback a transaction

                                                                                                                                                                                      func (*DB) Row

                                                                                                                                                                                      func (s *DB) Row() *sql.Row

                                                                                                                                                                                        Row return `*sql.Row` with given conditions

                                                                                                                                                                                        func (*DB) Rows

                                                                                                                                                                                        func (s *DB) Rows() (*sql.Rows, error)

                                                                                                                                                                                          Rows return `*sql.Rows` with given conditions

                                                                                                                                                                                          func (*DB) Save

                                                                                                                                                                                          func (s *DB) Save(value interface{}) *DB

                                                                                                                                                                                            Save update value in database, if the value doesn't have primary key, will insert it

                                                                                                                                                                                            func (*DB) Scan

                                                                                                                                                                                            func (s *DB) Scan(dest interface{}) *DB

                                                                                                                                                                                              Scan scan value to a struct

                                                                                                                                                                                              func (*DB) ScanRows

                                                                                                                                                                                              func (s *DB) ScanRows(rows *sql.Rows, result interface{}) error

                                                                                                                                                                                                ScanRows scan `*sql.Rows` to give struct

                                                                                                                                                                                                func (*DB) Scopes

                                                                                                                                                                                                func (s *DB) Scopes(funcs ...func(*DB) *DB) *DB

                                                                                                                                                                                                  Scopes pass current database connection to arguments `func(*DB) *DB`, which could be used to add conditions dynamically

                                                                                                                                                                                                  func AmountGreaterThan1000(db *gorm.DB) *gorm.DB {
                                                                                                                                                                                                      return db.Where("amount > ?", 1000)
                                                                                                                                                                                                  }
                                                                                                                                                                                                  
                                                                                                                                                                                                  func OrderStatus(status []string) func (db *gorm.DB) *gorm.DB {
                                                                                                                                                                                                      return func (db *gorm.DB) *gorm.DB {
                                                                                                                                                                                                          return db.Scopes(AmountGreaterThan1000).Where("status in (?)", status)
                                                                                                                                                                                                      }
                                                                                                                                                                                                  }
                                                                                                                                                                                                  
                                                                                                                                                                                                  db.Scopes(AmountGreaterThan1000, OrderStatus([]string{"paid", "shipped"})).Find(&orders)
                                                                                                                                                                                                  

                                                                                                                                                                                                  Refer https://jinzhu.github.io/gorm/crud.html#scopes

                                                                                                                                                                                                  func (*DB) Select

                                                                                                                                                                                                  func (s *DB) Select(query interface{}, args ...interface{}) *DB

                                                                                                                                                                                                    Select specify fields that you want to retrieve from database when querying, by default, will select all fields; When creating/updating, specify fields that you want to save to database

                                                                                                                                                                                                    func (*DB) Set

                                                                                                                                                                                                    func (s *DB) Set(name string, value interface{}) *DB

                                                                                                                                                                                                      Set set setting by name, which could be used in callbacks, will clone a new db, and update its setting

                                                                                                                                                                                                      func (*DB) SetJoinTableHandler

                                                                                                                                                                                                      func (s *DB) SetJoinTableHandler(source interface{}, column string, handler JoinTableHandlerInterface)

                                                                                                                                                                                                        SetJoinTableHandler set a model's join table handler for a relation

                                                                                                                                                                                                        func (*DB) SetLogger

                                                                                                                                                                                                        func (s *DB) SetLogger(log logger)

                                                                                                                                                                                                          SetLogger replace default logger

                                                                                                                                                                                                          func (*DB) SingularTable

                                                                                                                                                                                                          func (s *DB) SingularTable(enable bool)

                                                                                                                                                                                                            SingularTable use singular table by default

                                                                                                                                                                                                            func (*DB) SubQuery

                                                                                                                                                                                                            func (s *DB) SubQuery() *expr

                                                                                                                                                                                                              SubQuery returns the query as sub query

                                                                                                                                                                                                              func (*DB) Table

                                                                                                                                                                                                              func (s *DB) Table(name string) *DB

                                                                                                                                                                                                                Table specify the table you would like to run db operations

                                                                                                                                                                                                                func (*DB) Take

                                                                                                                                                                                                                func (s *DB) Take(out interface{}, where ...interface{}) *DB

                                                                                                                                                                                                                  Take return a record that match given conditions, the order will depend on the database implementation

                                                                                                                                                                                                                  func (*DB) Unscoped

                                                                                                                                                                                                                  func (s *DB) Unscoped() *DB

                                                                                                                                                                                                                    Unscoped return all record including deleted record, refer Soft Delete https://jinzhu.github.io/gorm/crud.html#soft-delete

                                                                                                                                                                                                                    func (*DB) Update

                                                                                                                                                                                                                    func (s *DB) Update(attrs ...interface{}) *DB

                                                                                                                                                                                                                      Update update attributes with callbacks, refer: https://jinzhu.github.io/gorm/crud.html#update

                                                                                                                                                                                                                      func (*DB) UpdateColumn

                                                                                                                                                                                                                      func (s *DB) UpdateColumn(attrs ...interface{}) *DB

                                                                                                                                                                                                                        UpdateColumn update attributes without callbacks, refer: https://jinzhu.github.io/gorm/crud.html#update

                                                                                                                                                                                                                        func (*DB) UpdateColumns

                                                                                                                                                                                                                        func (s *DB) UpdateColumns(values interface{}) *DB

                                                                                                                                                                                                                          UpdateColumns update attributes without callbacks, refer: https://jinzhu.github.io/gorm/crud.html#update

                                                                                                                                                                                                                          func (*DB) Updates

                                                                                                                                                                                                                          func (s *DB) Updates(values interface{}, ignoreProtectedAttrs ...bool) *DB

                                                                                                                                                                                                                            Updates update attributes with callbacks, refer: https://jinzhu.github.io/gorm/crud.html#update

                                                                                                                                                                                                                            func (*DB) Where

                                                                                                                                                                                                                            func (s *DB) Where(query interface{}, args ...interface{}) *DB

                                                                                                                                                                                                                              Where return a new relation, filter records with given conditions, accepts `map`, `struct` or `string` as conditions, refer http://jinzhu.github.io/gorm/crud.html#query

                                                                                                                                                                                                                              type DefaultForeignKeyNamer

                                                                                                                                                                                                                              type DefaultForeignKeyNamer struct {
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                DefaultForeignKeyNamer contains the default foreign key name generator method

                                                                                                                                                                                                                                func (DefaultForeignKeyNamer) BuildKeyName

                                                                                                                                                                                                                                func (DefaultForeignKeyNamer) BuildKeyName(kind, tableName string, fields ...string) string

                                                                                                                                                                                                                                  BuildKeyName returns a valid key name (foreign key, index key) for the given table, field and reference

                                                                                                                                                                                                                                  type Dialect

                                                                                                                                                                                                                                  type Dialect interface {
                                                                                                                                                                                                                                  	// GetName get dialect's name
                                                                                                                                                                                                                                  	GetName() string
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// SetDB set db for dialect
                                                                                                                                                                                                                                  	SetDB(db SQLCommon)
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// BindVar return the placeholder for actual values in SQL statements, in many dbs it is "?", Postgres using $1
                                                                                                                                                                                                                                  	BindVar(i int) string
                                                                                                                                                                                                                                  	// Quote quotes field name to avoid SQL parsing exceptions by using a reserved word as a field name
                                                                                                                                                                                                                                  	Quote(key string) string
                                                                                                                                                                                                                                  	// DataTypeOf return data's sql type
                                                                                                                                                                                                                                  	DataTypeOf(field *StructField) string
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// HasIndex check has index or not
                                                                                                                                                                                                                                  	HasIndex(tableName string, indexName string) bool
                                                                                                                                                                                                                                  	// HasForeignKey check has foreign key or not
                                                                                                                                                                                                                                  	HasForeignKey(tableName string, foreignKeyName string) bool
                                                                                                                                                                                                                                  	// RemoveIndex remove index
                                                                                                                                                                                                                                  	RemoveIndex(tableName string, indexName string) error
                                                                                                                                                                                                                                  	// HasTable check has table or not
                                                                                                                                                                                                                                  	HasTable(tableName string) bool
                                                                                                                                                                                                                                  	// HasColumn check has column or not
                                                                                                                                                                                                                                  	HasColumn(tableName string, columnName string) bool
                                                                                                                                                                                                                                  	// ModifyColumn modify column's type
                                                                                                                                                                                                                                  	ModifyColumn(tableName string, columnName string, typ string) error
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// LimitAndOffsetSQL return generated SQL with Limit and Offset, as mssql has special case
                                                                                                                                                                                                                                  	LimitAndOffsetSQL(limit, offset interface{}) string
                                                                                                                                                                                                                                  	// SelectFromDummyTable return select values, for most dbs, `SELECT values` just works, mysql needs `SELECT value FROM DUAL`
                                                                                                                                                                                                                                  	SelectFromDummyTable() string
                                                                                                                                                                                                                                  	// LastInsertIdReturningSuffix most dbs support LastInsertId, but postgres needs to use `RETURNING`
                                                                                                                                                                                                                                  	LastInsertIDReturningSuffix(tableName, columnName string) string
                                                                                                                                                                                                                                  	// DefaultValueStr
                                                                                                                                                                                                                                  	DefaultValueStr() string
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// BuildKeyName returns a valid key name (foreign key, index key) for the given table, field and reference
                                                                                                                                                                                                                                  	BuildKeyName(kind, tableName string, fields ...string) string
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// CurrentDatabase return current database name
                                                                                                                                                                                                                                  	CurrentDatabase() string
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                    Dialect interface contains behaviors that differ across SQL database

                                                                                                                                                                                                                                    type Errors

                                                                                                                                                                                                                                    type Errors []error

                                                                                                                                                                                                                                      Errors contains all happened errors

                                                                                                                                                                                                                                      func (Errors) Add

                                                                                                                                                                                                                                      func (errs Errors) Add(newErrors ...error) Errors

                                                                                                                                                                                                                                        Add adds an error

                                                                                                                                                                                                                                        func (Errors) Error

                                                                                                                                                                                                                                        func (errs Errors) Error() string

                                                                                                                                                                                                                                          Error format happened errors

                                                                                                                                                                                                                                          func (Errors) GetErrors

                                                                                                                                                                                                                                          func (errs Errors) GetErrors() []error

                                                                                                                                                                                                                                            GetErrors gets all happened errors

                                                                                                                                                                                                                                            type Field

                                                                                                                                                                                                                                            type Field struct {
                                                                                                                                                                                                                                            	*StructField
                                                                                                                                                                                                                                            	IsBlank bool
                                                                                                                                                                                                                                            	Field   reflect.Value
                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                              Field model field definition

                                                                                                                                                                                                                                              func (*Field) Set

                                                                                                                                                                                                                                              func (field *Field) Set(value interface{}) (err error)

                                                                                                                                                                                                                                                Set set a value to the field

                                                                                                                                                                                                                                                type JoinTableForeignKey

                                                                                                                                                                                                                                                type JoinTableForeignKey struct {
                                                                                                                                                                                                                                                	DBName            string
                                                                                                                                                                                                                                                	AssociationDBName string
                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                  JoinTableForeignKey join table foreign key struct

                                                                                                                                                                                                                                                  type JoinTableHandler

                                                                                                                                                                                                                                                  type JoinTableHandler struct {
                                                                                                                                                                                                                                                  	TableName   string          `sql:"-"`
                                                                                                                                                                                                                                                  	Source      JoinTableSource `sql:"-"`
                                                                                                                                                                                                                                                  	Destination JoinTableSource `sql:"-"`
                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                    JoinTableHandler default join table handler

                                                                                                                                                                                                                                                    func (JoinTableHandler) Add

                                                                                                                                                                                                                                                    func (s JoinTableHandler) Add(handler JoinTableHandlerInterface, db *DB, source interface{}, destination interface{}) error

                                                                                                                                                                                                                                                      Add create relationship in join table for source and destination

                                                                                                                                                                                                                                                      func (JoinTableHandler) Delete

                                                                                                                                                                                                                                                      func (s JoinTableHandler) Delete(handler JoinTableHandlerInterface, db *DB, sources ...interface{}) error

                                                                                                                                                                                                                                                        Delete delete relationship in join table for sources

                                                                                                                                                                                                                                                        func (*JoinTableHandler) DestinationForeignKeys

                                                                                                                                                                                                                                                        func (s *JoinTableHandler) DestinationForeignKeys() []JoinTableForeignKey

                                                                                                                                                                                                                                                          DestinationForeignKeys return destination foreign keys

                                                                                                                                                                                                                                                          func (JoinTableHandler) JoinWith

                                                                                                                                                                                                                                                          func (s JoinTableHandler) JoinWith(handler JoinTableHandlerInterface, db *DB, source interface{}) *DB

                                                                                                                                                                                                                                                            JoinWith query with `Join` conditions

                                                                                                                                                                                                                                                            func (*JoinTableHandler) Setup

                                                                                                                                                                                                                                                            func (s *JoinTableHandler) Setup(relationship *Relationship, tableName string, source reflect.Type, destination reflect.Type)

                                                                                                                                                                                                                                                              Setup initialize a default join table handler

                                                                                                                                                                                                                                                              func (*JoinTableHandler) SourceForeignKeys

                                                                                                                                                                                                                                                              func (s *JoinTableHandler) SourceForeignKeys() []JoinTableForeignKey

                                                                                                                                                                                                                                                                SourceForeignKeys return source foreign keys

                                                                                                                                                                                                                                                                func (JoinTableHandler) Table

                                                                                                                                                                                                                                                                func (s JoinTableHandler) Table(db *DB) string

                                                                                                                                                                                                                                                                  Table return join table's table name

                                                                                                                                                                                                                                                                  type JoinTableHandlerInterface

                                                                                                                                                                                                                                                                  type JoinTableHandlerInterface interface {
                                                                                                                                                                                                                                                                  	// initialize join table handler
                                                                                                                                                                                                                                                                  	Setup(relationship *Relationship, tableName string, source reflect.Type, destination reflect.Type)
                                                                                                                                                                                                                                                                  	// Table return join table's table name
                                                                                                                                                                                                                                                                  	Table(db *DB) string
                                                                                                                                                                                                                                                                  	// Add create relationship in join table for source and destination
                                                                                                                                                                                                                                                                  	Add(handler JoinTableHandlerInterface, db *DB, source interface{}, destination interface{}) error
                                                                                                                                                                                                                                                                  	// Delete delete relationship in join table for sources
                                                                                                                                                                                                                                                                  	Delete(handler JoinTableHandlerInterface, db *DB, sources ...interface{}) error
                                                                                                                                                                                                                                                                  	// JoinWith query with `Join` conditions
                                                                                                                                                                                                                                                                  	JoinWith(handler JoinTableHandlerInterface, db *DB, source interface{}) *DB
                                                                                                                                                                                                                                                                  	// SourceForeignKeys return source foreign keys
                                                                                                                                                                                                                                                                  	SourceForeignKeys() []JoinTableForeignKey
                                                                                                                                                                                                                                                                  	// DestinationForeignKeys return destination foreign keys
                                                                                                                                                                                                                                                                  	DestinationForeignKeys() []JoinTableForeignKey
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                    JoinTableHandlerInterface is an interface for how to handle many2many relations

                                                                                                                                                                                                                                                                    type JoinTableSource

                                                                                                                                                                                                                                                                    type JoinTableSource struct {
                                                                                                                                                                                                                                                                    	ModelType   reflect.Type
                                                                                                                                                                                                                                                                    	ForeignKeys []JoinTableForeignKey
                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                      JoinTableSource is a struct that contains model type and foreign keys

                                                                                                                                                                                                                                                                      type LogWriter

                                                                                                                                                                                                                                                                      type LogWriter interface {
                                                                                                                                                                                                                                                                      	Println(v ...interface{})
                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                        LogWriter log writer interface

                                                                                                                                                                                                                                                                        type Logger

                                                                                                                                                                                                                                                                        type Logger struct {
                                                                                                                                                                                                                                                                        	LogWriter
                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                          Logger default logger

                                                                                                                                                                                                                                                                          func (Logger) Print

                                                                                                                                                                                                                                                                          func (logger Logger) Print(values ...interface{})

                                                                                                                                                                                                                                                                            Print format & print log

                                                                                                                                                                                                                                                                            type Model

                                                                                                                                                                                                                                                                            type Model struct {
                                                                                                                                                                                                                                                                            	ID        uint `gorm:"primary_key"`
                                                                                                                                                                                                                                                                            	CreatedAt time.Time
                                                                                                                                                                                                                                                                            	UpdatedAt time.Time
                                                                                                                                                                                                                                                                            	DeletedAt *time.Time `sql:"index"`
                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                              Model base model definition, including fields `ID`, `CreatedAt`, `UpdatedAt`, `DeletedAt`, which could be embedded in your models

                                                                                                                                                                                                                                                                              type User struct {
                                                                                                                                                                                                                                                                                gorm.Model
                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                              type ModelStruct

                                                                                                                                                                                                                                                                              type ModelStruct struct {
                                                                                                                                                                                                                                                                              	PrimaryFields []*StructField
                                                                                                                                                                                                                                                                              	StructFields  []*StructField
                                                                                                                                                                                                                                                                              	ModelType     reflect.Type
                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                ModelStruct model definition

                                                                                                                                                                                                                                                                                func (*ModelStruct) TableName

                                                                                                                                                                                                                                                                                func (s *ModelStruct) TableName(db *DB) string

                                                                                                                                                                                                                                                                                  TableName get model's table name

                                                                                                                                                                                                                                                                                  type Relationship

                                                                                                                                                                                                                                                                                  type Relationship struct {
                                                                                                                                                                                                                                                                                  	Kind                         string
                                                                                                                                                                                                                                                                                  	PolymorphicType              string
                                                                                                                                                                                                                                                                                  	PolymorphicDBName            string
                                                                                                                                                                                                                                                                                  	PolymorphicValue             string
                                                                                                                                                                                                                                                                                  	ForeignFieldNames            []string
                                                                                                                                                                                                                                                                                  	ForeignDBNames               []string
                                                                                                                                                                                                                                                                                  	AssociationForeignFieldNames []string
                                                                                                                                                                                                                                                                                  	AssociationForeignDBNames    []string
                                                                                                                                                                                                                                                                                  	JoinTableHandler             JoinTableHandlerInterface
                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                    Relationship described the relationship between models

                                                                                                                                                                                                                                                                                    type RowQueryResult

                                                                                                                                                                                                                                                                                    type RowQueryResult struct {
                                                                                                                                                                                                                                                                                    	Row *sql.Row
                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                    type RowsQueryResult

                                                                                                                                                                                                                                                                                    type RowsQueryResult struct {
                                                                                                                                                                                                                                                                                    	Rows  *sql.Rows
                                                                                                                                                                                                                                                                                    	Error error
                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                    type SQLCommon

                                                                                                                                                                                                                                                                                    type SQLCommon interface {
                                                                                                                                                                                                                                                                                    	Exec(query string, args ...interface{}) (sql.Result, error)
                                                                                                                                                                                                                                                                                    	Prepare(query string) (*sql.Stmt, error)
                                                                                                                                                                                                                                                                                    	Query(query string, args ...interface{}) (*sql.Rows, error)
                                                                                                                                                                                                                                                                                    	QueryRow(query string, args ...interface{}) *sql.Row
                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                      SQLCommon is the minimal database connection functionality gorm requires. Implemented by *sql.DB.

                                                                                                                                                                                                                                                                                      type Scope

                                                                                                                                                                                                                                                                                      type Scope struct {
                                                                                                                                                                                                                                                                                      	Search  *search
                                                                                                                                                                                                                                                                                      	Value   interface{}
                                                                                                                                                                                                                                                                                      	SQL     string
                                                                                                                                                                                                                                                                                      	SQLVars []interface{}
                                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                        Scope contain current operation's information when you perform any operation on the database

                                                                                                                                                                                                                                                                                        func (*Scope) AddToVars

                                                                                                                                                                                                                                                                                        func (scope *Scope) AddToVars(value interface{}) string

                                                                                                                                                                                                                                                                                          AddToVars add value as sql's vars, used to prevent SQL injection

                                                                                                                                                                                                                                                                                          func (*Scope) Begin

                                                                                                                                                                                                                                                                                          func (scope *Scope) Begin() *Scope

                                                                                                                                                                                                                                                                                            Begin start a transaction

                                                                                                                                                                                                                                                                                            func (*Scope) CallMethod

                                                                                                                                                                                                                                                                                            func (scope *Scope) CallMethod(methodName string)

                                                                                                                                                                                                                                                                                              CallMethod call scope value's method, if it is a slice, will call its element's method one by one

                                                                                                                                                                                                                                                                                              func (*Scope) CombinedConditionSql

                                                                                                                                                                                                                                                                                              func (scope *Scope) CombinedConditionSql() string

                                                                                                                                                                                                                                                                                                CombinedConditionSql return combined condition sql

                                                                                                                                                                                                                                                                                                func (*Scope) CommitOrRollback

                                                                                                                                                                                                                                                                                                func (scope *Scope) CommitOrRollback() *Scope

                                                                                                                                                                                                                                                                                                  CommitOrRollback commit current transaction if no error happened, otherwise will rollback it

                                                                                                                                                                                                                                                                                                  func (*Scope) DB

                                                                                                                                                                                                                                                                                                  func (scope *Scope) DB() *DB

                                                                                                                                                                                                                                                                                                    DB return scope's DB connection

                                                                                                                                                                                                                                                                                                    func (*Scope) Dialect

                                                                                                                                                                                                                                                                                                    func (scope *Scope) Dialect() Dialect

                                                                                                                                                                                                                                                                                                      Dialect get dialect

                                                                                                                                                                                                                                                                                                      func (*Scope) Err

                                                                                                                                                                                                                                                                                                      func (scope *Scope) Err(err error) error

                                                                                                                                                                                                                                                                                                        Err add error to Scope

                                                                                                                                                                                                                                                                                                        func (*Scope) Exec

                                                                                                                                                                                                                                                                                                        func (scope *Scope) Exec() *Scope

                                                                                                                                                                                                                                                                                                          Exec perform generated SQL

                                                                                                                                                                                                                                                                                                          func (*Scope) FieldByName

                                                                                                                                                                                                                                                                                                          func (scope *Scope) FieldByName(name string) (field *Field, ok bool)

                                                                                                                                                                                                                                                                                                            FieldByName find `gorm.Field` with field name or db name

                                                                                                                                                                                                                                                                                                            func (*Scope) Fields

                                                                                                                                                                                                                                                                                                            func (scope *Scope) Fields() []*Field

                                                                                                                                                                                                                                                                                                              Fields get value's fields

                                                                                                                                                                                                                                                                                                              func (*Scope) Get

                                                                                                                                                                                                                                                                                                              func (scope *Scope) Get(name string) (interface{}, bool)

                                                                                                                                                                                                                                                                                                                Get get setting by name

                                                                                                                                                                                                                                                                                                                func (*Scope) GetModelStruct

                                                                                                                                                                                                                                                                                                                func (scope *Scope) GetModelStruct() *ModelStruct

                                                                                                                                                                                                                                                                                                                  GetModelStruct get value's model struct, relationships based on struct and tag definition

                                                                                                                                                                                                                                                                                                                  func (*Scope) GetStructFields

                                                                                                                                                                                                                                                                                                                  func (scope *Scope) GetStructFields() (fields []*StructField)

                                                                                                                                                                                                                                                                                                                    GetStructFields get model's field structs

                                                                                                                                                                                                                                                                                                                    func (*Scope) HasColumn

                                                                                                                                                                                                                                                                                                                    func (scope *Scope) HasColumn(column string) bool

                                                                                                                                                                                                                                                                                                                      HasColumn to check if has column

                                                                                                                                                                                                                                                                                                                      func (*Scope) HasError

                                                                                                                                                                                                                                                                                                                      func (scope *Scope) HasError() bool

                                                                                                                                                                                                                                                                                                                        HasError check if there are any error

                                                                                                                                                                                                                                                                                                                        func (*Scope) IndirectValue

                                                                                                                                                                                                                                                                                                                        func (scope *Scope) IndirectValue() reflect.Value

                                                                                                                                                                                                                                                                                                                          IndirectValue return scope's reflect value's indirect value

                                                                                                                                                                                                                                                                                                                          func (*Scope) InstanceGet

                                                                                                                                                                                                                                                                                                                          func (scope *Scope) InstanceGet(name string) (interface{}, bool)

                                                                                                                                                                                                                                                                                                                            InstanceGet get instance setting from current operation

                                                                                                                                                                                                                                                                                                                            func (*Scope) InstanceID

                                                                                                                                                                                                                                                                                                                            func (scope *Scope) InstanceID() string

                                                                                                                                                                                                                                                                                                                              InstanceID get InstanceID for scope

                                                                                                                                                                                                                                                                                                                              func (*Scope) InstanceSet

                                                                                                                                                                                                                                                                                                                              func (scope *Scope) InstanceSet(name string, value interface{}) *Scope

                                                                                                                                                                                                                                                                                                                                InstanceSet set instance setting for current operation, but not for operations in callbacks, like saving associations callback

                                                                                                                                                                                                                                                                                                                                func (*Scope) Log

                                                                                                                                                                                                                                                                                                                                func (scope *Scope) Log(v ...interface{})

                                                                                                                                                                                                                                                                                                                                  Log print log message

                                                                                                                                                                                                                                                                                                                                  func (*Scope) New

                                                                                                                                                                                                                                                                                                                                  func (scope *Scope) New(value interface{}) *Scope

                                                                                                                                                                                                                                                                                                                                    New create a new Scope without search information

                                                                                                                                                                                                                                                                                                                                    func (*Scope) NewDB

                                                                                                                                                                                                                                                                                                                                    func (scope *Scope) NewDB() *DB

                                                                                                                                                                                                                                                                                                                                      NewDB create a new DB without search information

                                                                                                                                                                                                                                                                                                                                      func (*Scope) OmitAttrs

                                                                                                                                                                                                                                                                                                                                      func (scope *Scope) OmitAttrs() []string

                                                                                                                                                                                                                                                                                                                                        OmitAttrs return omitted attributes

                                                                                                                                                                                                                                                                                                                                        func (*Scope) PrimaryField

                                                                                                                                                                                                                                                                                                                                        func (scope *Scope) PrimaryField() *Field

                                                                                                                                                                                                                                                                                                                                          PrimaryField return scope's main primary field, if defined more that one primary fields, will return the one having column name `id` or the first one

                                                                                                                                                                                                                                                                                                                                          func (*Scope) PrimaryFields

                                                                                                                                                                                                                                                                                                                                          func (scope *Scope) PrimaryFields() (fields []*Field)

                                                                                                                                                                                                                                                                                                                                            PrimaryFields return scope's primary fields

                                                                                                                                                                                                                                                                                                                                            func (*Scope) PrimaryKey

                                                                                                                                                                                                                                                                                                                                            func (scope *Scope) PrimaryKey() string

                                                                                                                                                                                                                                                                                                                                              PrimaryKey get main primary field's db name

                                                                                                                                                                                                                                                                                                                                              func (*Scope) PrimaryKeyValue

                                                                                                                                                                                                                                                                                                                                              func (scope *Scope) PrimaryKeyValue() interface{}

                                                                                                                                                                                                                                                                                                                                                PrimaryKeyValue get the primary key's value

                                                                                                                                                                                                                                                                                                                                                func (*Scope) PrimaryKeyZero

                                                                                                                                                                                                                                                                                                                                                func (scope *Scope) PrimaryKeyZero() bool

                                                                                                                                                                                                                                                                                                                                                  PrimaryKeyZero check main primary field's value is blank or not

                                                                                                                                                                                                                                                                                                                                                  func (*Scope) Quote

                                                                                                                                                                                                                                                                                                                                                  func (scope *Scope) Quote(str string) string

                                                                                                                                                                                                                                                                                                                                                    Quote used to quote string to escape them for database

                                                                                                                                                                                                                                                                                                                                                    func (*Scope) QuotedTableName

                                                                                                                                                                                                                                                                                                                                                    func (scope *Scope) QuotedTableName() (name string)

                                                                                                                                                                                                                                                                                                                                                      QuotedTableName return quoted table name

                                                                                                                                                                                                                                                                                                                                                      func (*Scope) Raw

                                                                                                                                                                                                                                                                                                                                                      func (scope *Scope) Raw(sql string) *Scope

                                                                                                                                                                                                                                                                                                                                                        Raw set raw sql

                                                                                                                                                                                                                                                                                                                                                        func (*Scope) SQLDB

                                                                                                                                                                                                                                                                                                                                                        func (scope *Scope) SQLDB() SQLCommon

                                                                                                                                                                                                                                                                                                                                                          SQLDB return *sql.DB

                                                                                                                                                                                                                                                                                                                                                          func (*Scope) SelectAttrs

                                                                                                                                                                                                                                                                                                                                                          func (scope *Scope) SelectAttrs() []string

                                                                                                                                                                                                                                                                                                                                                            SelectAttrs return selected attributes

                                                                                                                                                                                                                                                                                                                                                            func (*Scope) Set

                                                                                                                                                                                                                                                                                                                                                            func (scope *Scope) Set(name string, value interface{}) *Scope

                                                                                                                                                                                                                                                                                                                                                              Set set value by name

                                                                                                                                                                                                                                                                                                                                                              func (*Scope) SetColumn

                                                                                                                                                                                                                                                                                                                                                              func (scope *Scope) SetColumn(column interface{}, value interface{}) error

                                                                                                                                                                                                                                                                                                                                                                SetColumn to set the column's value, column could be field or field's name/dbname

                                                                                                                                                                                                                                                                                                                                                                func (*Scope) SkipLeft

                                                                                                                                                                                                                                                                                                                                                                func (scope *Scope) SkipLeft()

                                                                                                                                                                                                                                                                                                                                                                  SkipLeft skip remaining callbacks

                                                                                                                                                                                                                                                                                                                                                                  func (*Scope) TableName

                                                                                                                                                                                                                                                                                                                                                                  func (scope *Scope) TableName() string

                                                                                                                                                                                                                                                                                                                                                                    TableName return table name

                                                                                                                                                                                                                                                                                                                                                                    type StructField

                                                                                                                                                                                                                                                                                                                                                                    type StructField struct {
                                                                                                                                                                                                                                                                                                                                                                    	DBName          string
                                                                                                                                                                                                                                                                                                                                                                    	Name            string
                                                                                                                                                                                                                                                                                                                                                                    	Names           []string
                                                                                                                                                                                                                                                                                                                                                                    	IsPrimaryKey    bool
                                                                                                                                                                                                                                                                                                                                                                    	IsNormal        bool
                                                                                                                                                                                                                                                                                                                                                                    	IsIgnored       bool
                                                                                                                                                                                                                                                                                                                                                                    	IsScanner       bool
                                                                                                                                                                                                                                                                                                                                                                    	HasDefaultValue bool
                                                                                                                                                                                                                                                                                                                                                                    	Tag             reflect.StructTag
                                                                                                                                                                                                                                                                                                                                                                    	TagSettings     map[string]string
                                                                                                                                                                                                                                                                                                                                                                    	Struct          reflect.StructField
                                                                                                                                                                                                                                                                                                                                                                    	IsForeignKey    bool
                                                                                                                                                                                                                                                                                                                                                                    	Relationship    *Relationship
                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                      StructField model field's struct definition

                                                                                                                                                                                                                                                                                                                                                                      Directories

                                                                                                                                                                                                                                                                                                                                                                      Path Synopsis
                                                                                                                                                                                                                                                                                                                                                                      dialects