gorm: github.com/jinzhu/gorm Index | Files | Directories

package gorm

import "github.com/jinzhu/gorm"

Index

Package Files

association.go callback.go callback_create.go callback_delete.go callback_query.go callback_query_preload.go callback_row_query.go callback_save.go callback_update.go dialect.go dialect_common.go dialect_mysql.go dialect_postgres.go dialect_sqlite3.go errors.go field.go interface.go join_table_handler.go logger.go main.go model.go model_struct.go scope.go search.go utils.go

Variables

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")
)
var DefaultCallback = &Callback{}

DefaultCallback default callbacks defined by gorm

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

DefaultTableNameHandler default table name handler

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`, index+1)
                    sql = regexp.MustCompile(placeholder).ReplaceAllString(sql, value)
                }
            } 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)
        } else {
            messages = append(messages, "\033[31;1m")
            messages = append(messages, values[2:]...)
            messages = append(messages, "\033[0m")
        }
    }

    return
}
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()
}
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)
    }

    // Get scanner's real value
    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

func Expr Uses

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 RegisterDialect Uses

func RegisterDialect(name string, dialect Dialect)

RegisterDialect register new dialect

func ToDBName Uses

func ToDBName(name string) string

ToDBName convert string to db name

type Association Uses

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

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

func (*Association) Append Uses

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 Uses

func (association *Association) Clear() *Association

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

func (*Association) Count Uses

func (association *Association) Count() int

Count return the count of current associations

func (*Association) Delete Uses

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

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

func (*Association) Find Uses

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

Find find out all related associations

func (*Association) Replace Uses

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

Replace replace current associations with new one

type Callback Uses

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 Uses

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 Uses

func (c *Callback) Delete() *CallbackProcessor

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

func (*Callback) Query Uses

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 Uses

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 Uses

func (c *Callback) Update() *CallbackProcessor

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

type CallbackProcessor Uses

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

CallbackProcessor contains callback informations

func (*CallbackProcessor) After Uses

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

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

func (*CallbackProcessor) Before Uses

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

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

func (*CallbackProcessor) Get Uses

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

Get registered callback

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

func (*CallbackProcessor) Register Uses

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

Register a new callback, refer `Callbacks.Create`

func (*CallbackProcessor) Remove Uses

func (cp *CallbackProcessor) Remove(callbackName string)

Remove a registered callback

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

func (*CallbackProcessor) Replace Uses

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 Uses

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

DB contains information for current db connection

func Open Uses

func Open(dialect string, args ...interface{}) (*DB, 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 Uses

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

AddError add error to the db

func (*DB) AddForeignKey Uses

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 Uses

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

AddIndex add index for columns with given name

func (*DB) AddUniqueIndex Uses

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

AddUniqueIndex add unique index for columns with given name

func (*DB) Assign Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (s *DB) Begin() *DB

Begin begin a transaction

func (*DB) BlockGlobalUpdate Uses

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 Uses

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 Uses

func (s *DB) Close() error

Close close current db connection

func (*DB) Commit Uses

func (s *DB) Commit() *DB

Commit commit a transaction

func (*DB) CommonDB Uses

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 Uses

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

Count get how many records for a model

func (*DB) Create Uses

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

Create insert the value into database

func (*DB) CreateTable Uses

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

CreateTable create table for models

func (*DB) DB Uses

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

DB get `*sql.DB` from current connection

func (*DB) Debug Uses

func (s *DB) Debug() *DB

Debug start debug mode

func (*DB) Delete Uses

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 Uses

func (s *DB) Dialect() Dialect

Dialect get dialect

func (*DB) DropColumn Uses

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

DropColumn drop a column

func (*DB) DropTable Uses

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

DropTable drop table for models

func (*DB) DropTableIfExists Uses

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

DropTableIfExists drop table if it is exist

func (*DB) Exec Uses

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

Exec execute raw sql

func (*DB) Find Uses

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

Find find records that match given conditions

func (*DB) First Uses

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

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

func (*DB) FirstOrCreate Uses

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 Uses

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 Uses

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

Get get setting by name

func (*DB) GetErrors Uses

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

GetErrors get happened errors from the db

func (*DB) Group Uses

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

Group specify the group method on the find

func (*DB) HasBlockGlobalUpdate Uses

func (s *DB) HasBlockGlobalUpdate() bool

HasBlockGlobalUpdate return state of block

func (*DB) HasTable Uses

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

HasTable check has table or not

func (*DB) Having Uses

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

Having specify HAVING conditions for GROUP BY

func (*DB) InstantSet Uses

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

InstantSet instant set setting, will affect current db

func (*DB) Joins Uses

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 Uses

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

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

func (*DB) Limit Uses

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

Limit specify the number of records to be retrieved

func (*DB) LogMode Uses

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 Uses

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 Uses

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

ModifyColumn modify column to type

func (*DB) New Uses

func (s *DB) New() *DB

New clone a new db connection without search conditions

func (*DB) NewRecord Uses

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

NewRecord check if value's primary key is blank

func (*DB) NewScope Uses

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

NewScope create a scope for current operation

func (*DB) Not Uses

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

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

func (*DB) Offset Uses

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

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

func (*DB) Omit Uses

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 Uses

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 Uses

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 Uses

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 Uses

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) Raw Uses

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 Uses

func (s *DB) RecordNotFound() bool

RecordNotFound check if returning ErrRecordNotFound error

func (*DB) Related Uses

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

Related get related associations

func (*DB) RemoveIndex Uses

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

RemoveIndex remove index with name

func (*DB) Rollback Uses

func (s *DB) Rollback() *DB

Rollback rollback a transaction

func (*DB) Row Uses

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

Row return `*sql.Row` with given conditions

func (*DB) Rows Uses

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

Rows return `*sql.Rows` with given conditions

func (*DB) Save Uses

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 Uses

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

Scan scan value to a struct

func (*DB) ScanRows Uses

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

ScanRows scan `*sql.Rows` to give struct

func (*DB) Scopes Uses

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 Uses

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 Uses

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 Uses

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

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

func (*DB) SetLogger Uses

func (s *DB) SetLogger(log logger)

SetLogger replace default logger

func (*DB) SingularTable Uses

func (s *DB) SingularTable(enable bool)

SingularTable use singular table by default

func (*DB) Table Uses

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

Table specify the table you would like to run db operations

func (*DB) Unscoped Uses

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 Uses

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

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

func (*DB) UpdateColumn Uses

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

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

func (*DB) UpdateColumns Uses

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

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

func (*DB) Updates Uses

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 Uses

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 Uses

type DefaultForeignKeyNamer struct {
}

DefaultForeignKeyNamer contains the default foreign key name generator method

func (DefaultForeignKeyNamer) BuildForeignKeyName Uses

func (DefaultForeignKeyNamer) BuildForeignKeyName(tableName, field, dest string) string

type Dialect Uses

type Dialect interface {
    // GetName get dialect's name
    GetName() string

    // SetDB set db for dialect
    SetDB(db *sql.DB)

    // 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

    // 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

    // BuildForeignKeyName returns a foreign key name for the given table, field and reference
    BuildForeignKeyName(tableName, field, dest string) string

    // CurrentDatabase return current database name
    CurrentDatabase() string
}

Dialect interface contains behaviors that differ across SQL database

type Errors Uses

type Errors []error

Errors contains all happened errors

func (Errors) Add Uses

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

Add adds an error

func (Errors) Error Uses

func (errs Errors) Error() string

Error format happened errors

func (Errors) GetErrors Uses

func (errs Errors) GetErrors() []error

GetErrors gets all happened errors

type Field Uses

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

Field model field definition

func (*Field) Set Uses

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

Set set a value to the field

type JoinTableForeignKey Uses

type JoinTableForeignKey struct {
    DBName            string
    AssociationDBName string
}

JoinTableForeignKey join table foreign key struct

type JoinTableHandler Uses

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

JoinTableHandler default join table handler

func (JoinTableHandler) Add Uses

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 Uses

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

Delete delete relationship in join table for sources

func (*JoinTableHandler) DestinationForeignKeys Uses

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

DestinationForeignKeys return destination foreign keys

func (JoinTableHandler) JoinWith Uses

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

JoinWith query with `Join` conditions

func (*JoinTableHandler) Setup Uses

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

Setup initialize a default join table handler

func (*JoinTableHandler) SourceForeignKeys Uses

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

SourceForeignKeys return source foreign keys

func (JoinTableHandler) Table Uses

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

Table return join table's table name

type JoinTableHandlerInterface Uses

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 Uses

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

JoinTableSource is a struct that contains model type and foreign keys

type LogWriter Uses

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

LogWriter log writer interface

type Logger Uses

type Logger struct {
    LogWriter
}

Logger default logger

func (Logger) Print Uses

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

Print format & print log

type Model Uses

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 Uses

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

ModelStruct model definition

func (*ModelStruct) TableName Uses

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

TableName get model's table name

type Relationship Uses

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 Uses

type RowQueryResult struct {
    Row *sql.Row
}

type RowsQueryResult Uses

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

type Scope Uses

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 Uses

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

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

func (*Scope) Begin Uses

func (scope *Scope) Begin() *Scope

Begin start a transaction

func (*Scope) CallMethod Uses

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 Uses

func (scope *Scope) CombinedConditionSql() string

CombinedConditionSql return combined condition sql

func (*Scope) CommitOrRollback Uses

func (scope *Scope) CommitOrRollback() *Scope

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

func (*Scope) DB Uses

func (scope *Scope) DB() *DB

DB return scope's DB connection

func (*Scope) Dialect Uses

func (scope *Scope) Dialect() Dialect

Dialect get dialect

func (*Scope) Err Uses

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

Err add error to Scope

func (*Scope) Exec Uses

func (scope *Scope) Exec() *Scope

Exec perform generated SQL

func (*Scope) FieldByName Uses

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

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

func (*Scope) Fields Uses

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

Fields get value's fields

func (*Scope) Get Uses

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

Get get setting by name

func (*Scope) GetModelStruct Uses

func (scope *Scope) GetModelStruct() *ModelStruct

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

func (*Scope) GetStructFields Uses

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

GetStructFields get model's field structs

func (*Scope) HasColumn Uses

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

HasColumn to check if has column

func (*Scope) HasError Uses

func (scope *Scope) HasError() bool

HasError check if there are any error

func (*Scope) IndirectValue Uses

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

IndirectValue return scope's reflect value's indirect value

func (*Scope) InstanceGet Uses

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

InstanceGet get instance setting from current operation

func (*Scope) InstanceID Uses

func (scope *Scope) InstanceID() string

InstanceID get InstanceID for scope

func (*Scope) InstanceSet Uses

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 Uses

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

Log print log message

func (*Scope) New Uses

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

New create a new Scope without search information

func (*Scope) NewDB Uses

func (scope *Scope) NewDB() *DB

NewDB create a new DB without search information

func (*Scope) OmitAttrs Uses

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

OmitAttrs return omitted attributes

func (*Scope) PrimaryField Uses

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 Uses

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

PrimaryFields return scope's primary fields

func (*Scope) PrimaryKey Uses

func (scope *Scope) PrimaryKey() string

PrimaryKey get main primary field's db name

func (*Scope) PrimaryKeyValue Uses

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

PrimaryKeyValue get the primary key's value

func (*Scope) PrimaryKeyZero Uses

func (scope *Scope) PrimaryKeyZero() bool

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

func (*Scope) Quote Uses

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

Quote used to quote string to escape them for database

func (*Scope) QuotedTableName Uses

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

QuotedTableName return quoted table name

func (*Scope) Raw Uses

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

Raw set raw sql

func (*Scope) SQLDB Uses

func (scope *Scope) SQLDB() sqlCommon

SQLDB return *sql.DB

func (*Scope) SelectAttrs Uses

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

SelectAttrs return selected attributes

func (*Scope) Set Uses

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

Set set value by name

func (*Scope) SetColumn Uses

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 Uses

func (scope *Scope) SkipLeft()

SkipLeft skip remaining callbacks

func (*Scope) TableName Uses

func (scope *Scope) TableName() string

TableName return table name

type StructField Uses

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

PathSynopsis
dialects/mssql
dialects/mysql
dialects/postgres
dialects/sqlite

Package gorm imports 19 packages (graph) and is imported by 596 packages. Updated 2017-01-16. Refresh now. Tools for package owners.