go第三方库文档 数据库 *** 作gorm

// go第三方库文档 数据库 *** 作gorm
// https://pkg.go.dev/github.com/jinzhu/gorm

func AddNamingStrategy(ns *NamingStrategy)
func IsByteArrayOrSlice(value reflect.Value) bool
func IsRecordNotFoundError(err error) bool
func RegisterDialect(name string, dialect Dialect)
func ToColumnName(name string) string
func ToDBName(name string) string
func ToTableName(name string) string
type Association
func (association *Association) Append(values ...interface{}) *Association
func (association *Association) Clear() *Association
func (association *Association) Count() int
func (association *Association) Delete(values ...interface{}) *Association
func (association *Association) Find(value interface{}) *Association
func (association *Association) Replace(values ...interface{}) *Association
type Callback
func (c *Callback) Create() *CallbackProcessor
func (c *Callback) Delete() *CallbackProcessor
func (c *Callback) Query() *CallbackProcessor
func (c *Callback) RowQuery() *CallbackProcessor
func (c *Callback) Update() *CallbackProcessor
type CallbackProcessor
func (cp *CallbackProcessor) After(callbackName string) *CallbackProcessor
func (cp *CallbackProcessor) Before(callbackName string) *CallbackProcessor
func (cp *CallbackProcessor) Get(callbackName string) (callback func(scope *Scope))
func (cp *CallbackProcessor) Register(callbackName string, callback func(scope *Scope))
func (cp *CallbackProcessor) Remove(callbackName string)
func (cp *CallbackProcessor) Replace(callbackName string, callback func(scope *Scope))
type DB
func Open(dialect string, args ...interface{}) (db *DB, err error)
func (s *DB) AddError(err error) error
func (s *DB) AddForeignKey(field string, dest string, onDelete string, onUpdate string) *DB
func (s *DB) AddIndex(indexName string, columns ...string) *DB
func (s *DB) AddUniqueIndex(indexName string, columns ...string) *DB
func (s *DB) Assign(attrs ...interface{}) *DB
func (s *DB) Association(column string) *Association
func (s *DB) Attrs(attrs ...interface{}) *DB
func (s *DB) AutoMigrate(values ...interface{}) *DB
func (s *DB) Begin() *DB
func (s *DB) BeginTx(ctx context.Context, opts *sql.TxOptions) *DB
func (s *DB) BlockGlobalUpdate(enable bool) *DB
func (s *DB) Callback() *Callback
func (s *DB) Close() error
func (s *DB) Commit() *DB
func (s *DB) CommonDB() SQLCommon
func (s *DB) Count(value interface{}) *DB
func (s *DB) Create(value interface{}) *DB
func (s *DB) CreateTable(models ...interface{}) *DB
func (s *DB) DB() *sql.DB
func (s *DB) Debug() *DB
func (s *DB) Delete(value interface{}, where ...interface{}) *DB
func (s *DB) Dialect() Dialect
func (s *DB) DropColumn(column string) *DB
func (s *DB) DropTable(values ...interface{}) *DB
func (s *DB) DropTableIfExists(values ...interface{}) *DB
func (s *DB) Exec(sql string, values ...interface{}) *DB
func (s *DB) Find(out interface{}, where ...interface{}) *DB
func (s *DB) First(out interface{}, where ...interface{}) *DB
func (s *DB) FirstOrCreate(out interface{}, where ...interface{}) *DB
func (s *DB) FirstOrInit(out interface{}, where ...interface{}) *DB
func (s *DB) Get(name string) (value interface{}, ok bool)
func (s *DB) GetErrors() []error
func (s *DB) Group(query string) *DB
func (s *DB) HasBlockGlobalUpdate() bool
func (s *DB) HasTable(value interface{}) bool
func (s *DB) Having(query interface{}, values ...interface{}) *DB
func (s *DB) InstantSet(name string, value interface{}) *DB
func (s *DB) Joins(query string, args ...interface{}) *DB
func (s *DB) Last(out interface{}, where ...interface{}) *DB
func (s *DB) Limit(limit interface{}) *DB
func (s *DB) LogMode(enable bool) *DB
func (s *DB) Model(value interface{}) *DB
func (s *DB) ModifyColumn(column string, typ string) *DB
func (s *DB) New() *DB
func (s *DB) NewRecord(value interface{}) bool
func (s *DB) NewScope(value interface{}) *Scope
func (s *DB) Not(query interface{}, args ...interface{}) *DB
func (s *DB) Offset(offset interface{}) *DB
func (s *DB) Omit(columns ...string) *DB
func (s *DB) Or(query interface{}, args ...interface{}) *DB
func (s *DB) Order(value interface{}, reorder ...bool) *DB
func (s *DB) Pluck(column string, value interface{}) *DB
func (s *DB) Preload(column string, conditions ...interface{}) *DB
func (s *DB) Preloads(out interface{}) *DB
func (s *DB) QueryExpr() *SqlExpr
func (s *DB) Raw(sql string, values ...interface{}) *DB
func (s *DB) RecordNotFound() bool
func (s *DB) Related(value interface{}, foreignKeys ...string) *DB
func (s *DB) RemoveForeignKey(field string, dest string) *DB
func (s *DB) RemoveIndex(indexName string) *DB
func (s *DB) Rollback() *DB
func (s *DB) RollbackUnlessCommitted() *DB
func (s *DB) Row() *sql.Row
func (s *DB) Rows() (*sql.Rows, error)
func (s *DB) Save(value interface{}) *DB
func (s *DB) Scan(dest interface{}) *DB
func (s *DB) ScanRows(rows *sql.Rows, result interface{}) error
func (s *DB) Scopes(funcs ...func(*DB) *DB) *DB
func (s *DB) Select(query interface{}, args ...interface{}) *DB
func (s *DB) Set(name string, value interface{}) *DB
func (s *DB) SetJoinTableHandler(source interface{}, column string, handler JoinTableHandlerInterface)
func (s *DB) SetLogger(log logger)
func (s *DB) SetNowFuncOverride(nowFuncOverride func() time.Time) *DB
func (s *DB) SingularTable(enable bool)
func (s *DB) SubQuery() *SqlExpr
func (s *DB) Table(name string) *DB
func (s *DB) Take(out interface{}, where ...interface{}) *DB
func (s *DB) Transaction(fc func(tx *DB) error) (err error)
func (s *DB) Unscoped() *DB
func (s *DB) Update(attrs ...interface{}) *DB
func (s *DB) UpdateColumn(attrs ...interface{}) *DB
func (s *DB) UpdateColumns(values interface{}) *DB
func (s *DB) Updates(values interface{}, ignoreProtectedAttrs ...bool) *DB
func (s *DB) Where(query interface{}, args ...interface{}) *DB
type DefaultForeignKeyNamer
func (DefaultForeignKeyNamer) BuildKeyName(kind, tableName string, fields ...string) string
type Dialect
func GetDialect(name string) (dialect Dialect, ok bool)
type Errors
func (errs Errors) Add(newErrors ...error) Errors
func (errs Errors) Error() string
func (errs Errors) GetErrors() []error
type Field
func (field *Field) Set(value interface{}) (err error)
type JoinTableForeignKey
type JoinTableHandler
func (s JoinTableHandler) Add(handler JoinTableHandlerInterface, db *DB, source interface{}, ...) error
func (s JoinTableHandler) Delete(handler JoinTableHandlerInterface, db *DB, sources ...interface{}) error
func (s *JoinTableHandler) DestinationForeignKeys() []JoinTableForeignKey
func (s JoinTableHandler) JoinWith(handler JoinTableHandlerInterface, db *DB, source interface{}) *DB
func (s *JoinTableHandler) Setup(relationship *Relationship, tableName string, source reflect.Type, ...)
func (s *JoinTableHandler) SourceForeignKeys() []JoinTableForeignKey
func (s JoinTableHandler) Table(db *DB) string
type JoinTableHandlerInterface
type JoinTableSource
type LogWriter
type Logger
func (logger Logger) Print(values ...interface{})
type Model
type ModelStruct
func (s *ModelStruct) TableName(db *DB) string
type Namer
type NamingStrategy
func (ns *NamingStrategy) ColumnName(name string) string
func (ns *NamingStrategy) DBName(name string) string
func (ns *NamingStrategy) TableName(name string) string
type Relationship
type RowQueryResult
type RowsQueryResult
type SQLCommon
type Scope
func (scope *Scope) AddToVars(value interface{}) string
func (scope *Scope) Begin() *Scope
func (scope *Scope) CallMethod(methodName string)
func (scope *Scope) CombinedConditionSql() string
func (scope *Scope) CommitOrRollback() *Scope
func (scope *Scope) DB() *DB
func (scope *Scope) Dialect() Dialect
func (scope *Scope) Err(err error) error
func (scope *Scope) Exec() *Scope
func (scope *Scope) FieldByName(name string) (field *Field, ok bool)
func (scope *Scope) Fields() []*Field
func (scope *Scope) Get(name string) (interface{}, bool)
func (scope *Scope) GetModelStruct() *ModelStruct
func (scope *Scope) GetStructFields() (fields []*StructField)
func (scope *Scope) HasColumn(column string) bool
func (scope *Scope) HasError() bool
func (scope *Scope) IndirectValue() reflect.Value
func (scope *Scope) InstanceGet(name string) (interface{}, bool)
func (scope *Scope) InstanceID() string
func (scope *Scope) InstanceSet(name string, value interface{}) *Scope
func (scope *Scope) Log(v ...interface{})
func (scope *Scope) New(value interface{}) *Scope
func (scope *Scope) NewDB() *DB
func (scope *Scope) OmitAttrs() []string
func (scope *Scope) PrimaryField() *Field
func (scope *Scope) PrimaryFields() (fields []*Field)
func (scope *Scope) PrimaryKey() string
func (scope *Scope) PrimaryKeyValue() interface{}
func (scope *Scope) PrimaryKeyZero() bool
func (scope *Scope) Quote(str string) string
func (scope *Scope) QuotedTableName() (name string)
func (scope *Scope) Raw(sql string) *Scope
func (scope *Scope) SQLDB() SQLCommon
func (scope *Scope) SelectAttrs() []string
func (scope *Scope) Set(name string, value interface{}) *Scope
func (scope *Scope) SetColumn(column interface{}, value interface{}) error
func (scope *Scope) SkipLeft()
func (scope *Scope) TableName() string
type SqlExpr
func Expr(expression string, args ...interface{}) *SqlExpr
type StructField
func (sf *StructField) TagSettingsDelete(key string)
func (sf *StructField) TagSettingsGet(key string) (string, bool)
func (sf *StructField) TagSettingsSet(key, val string)


var (
    //ErrRecordNotFound返回“记录未找到错误”。仅在尝试使用结构查询数据库时发生；使用切片进行查询不会返回此错误
    ErrRecordNotFound = errors.New("record not found")
    //尝试使用无效SQL进行查询时，会出现ErrInvalidSQL
    ErrInvalidSQL = errors.New("invalid SQL")
    //当您尝试“提交”或“回滚”时，会发生ErrInvalidTransaction`
    ErrInvalidTransaction = errors.New("no valid transaction")
    //当您试图用“开始”启动事务时，ErrCantStartTransaction无法启动事务`
    ErrCantStartTransaction = errors.New("can't start transaction")
    //ErrUnaddressable unaddressable值
    ErrUnaddressable = errors.New("using unaddressable value")
)

var DefaultCallback = &Callback{logger: nopLogger{}}

// 默认回调gorm定义的默认回调
var DefaultTableNameHandler = func(db *DB, defaultTableName string) string {
	return defaultTableName
}

// 默认表名处理程序默认表名处理程序
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 len(values) == 2 {

			currentTime = currentTime[1:]

			source = fmt.Sprintf("\033[35m%v\033[0m", values[1])

			messages = []interface{}{currentTime, source}
		}

		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 {
						if t.IsZero() {
							formattedValues = append(formattedValues, fmt.Sprintf("'%v'", "0000-00-00 00:00:00"))
						} else {
							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, "''")
						}
					} 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 {
						switch value.(type) {
						case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64, bool:
							formattedValues = append(formattedValues, fmt.Sprintf("%v", value))
						default:
							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(" \n3[36;31m[%v]3[0m ", strconv.FormatInt(values[5].(int64), 10)+" rows affected or returned "))
		} else {
			messages = append(messages, "3[31;1m")
			messages = append(messages, values[2:]...)
			messages = append(messages, "3[0m")
		}
	}

	return
}

var NowFunc = func() time.Time {
	return time.Now()
}

// NowFunc返回当前时间，导出此函数是为了使开发人员能够灵活地根据自己的需要进行自定义，例如：
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.TagSettingsGet("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.TagSettingsGet("SIZE"); ok {
		size, _ = strconv.Atoi(num)
	} else {
		size = 255
	}

	notNull, _ := field.TagSettingsGet("NOT NULL")
	unique, _ := field.TagSettingsGet("UNIQUE")
	additionalType = notNull + " " + unique
	if value, ok := field.TagSettingsGet("DEFAULT"); ok {
		additionalType = additionalType + " DEFAULT " + value
	}

	if value, ok := field.TagSettingsGet("COMMENT"); ok {
		additionalType = additionalType + " COMMENT " + value
	}

	return fieldValue, dataType, size, strings.TrimSpace(additionalType)
}

// ParseFieldStructForDialect获取字段的sql数据类型
var TheNamingStrategy = &NamingStrategy{
	DB:     defaultNamer,
	Table:  defaultNamer,
	Column: defaultNamer,
}
// 正在使用defaultNamingStrategy初始化NamingStrategy

// 功能
func AddNamingStrategy 
func AddNamingStrategy(ns *NamingStrategy)
// AddNamingStrategy设置命名策略

func IsByteArrayOrSlice 
func IsByteArrayOrSlice(value reflect.Value) bool
// IsByteArrayOrSlice返回反射值为数组或切片的真值

func IsRecordNotFoundError 
func IsRecordNotFoundError(err error) bool
// 如果错误包含RecordNotFound错误，IsRecordNotFoundError将返回true

func RegisterDialect 
func RegisterDialect(name string, dialect Dialect)
// RegisterDialect注册新方言

func ToColumnName 
func ToColumnName(name string) string
// ToColumnName将字符串转换为db名称

func ToDBName 
func ToDBName(name string) string
// ToDBName将字符串转换为数据库名称

func ToTableName 
func ToTableName(name string) string
// ToTableName将字符串转换为表名

// 类型
type Association 
type Association struct {
    Error error
    //包含已过滤或未报告的字段
}
// 关联模式包含一些帮助器方法，可以轻松处理关系事务。

func (*Association) Append 
func (association *Association) Append(values ...interface{}) *Association
// 为多个添加新关联，为多个添加新关联，为多个替换当前关联，属于

func (*Association) Clear 
func (association *Association) Clear() *Association
// 清除“删除源关联和当前关联之间的关系”，不会删除这些关联

func (*Association) Count 
func (association *Association) Count() int
// Count返回当前关联的计数

func (*Association) Delete 
func (association *Association) Delete(values ...interface{}) *Association
// 删除删除源参数和传递参数之间的关系，但不会删除这些参数

func (*Association) Find 
func (association *Association) Find(value interface{}) *Association
// 找出所有相关的关联

func (*Association) Replace 
func (association *Association) Replace(values ...interface{}) *Association
// 用新关联替换当前关联

type Callback 
type Callback struct {
    //包含已过滤或未报告的字段
}
// 回调是包含所有CRUD回调的结构
// 字段“creates”包含在创建对象时将调用的回调
// 字段“updates”包含更新对象时将调用的回调
// 字段“deletes”包含删除对象时将调用的回调
// 字段“queries”包含回调，当使用诸如Find、First、Related、Association等查询方法查询对象时，将调用回调。。。
// 字段“rowQueries”包含在查询具有行的对象时将调用的回调。。。
// 字段“processors”包含所有回调处理器，将用于按顺序生成上述回调

func (*Callback) Create 
func (c *Callback) Create() *CallbackProcessor
// Create可用于注册用于创建对象的回调
db.Callback().Create().After("gorm:create").Register("plugin:run_after_create", func(*Scope) {
    //业务逻辑
    ...
    //设置错误如果发生错误，将回滚创建
    scope.Err(errors.New("error"))
})

func (*Callback) Delete 
func (c *Callback) Delete() *CallbackProcessor
// Delete可用于注册用于删除对象的回调，有关用法，请参阅“创建”

func (*Callback) Query 
func (c *Callback) Query() *CallbackProcessor
// 查询可用于注册回调，以便使用诸如“Find”、“First”、“Related”、“Association”等查询方法查询对象。。。有关用法，请参阅“创建”

func (*Callback) RowQuery 
func (c *Callback) RowQuery() *CallbackProcessor
// RowQuery可用于注册回调以查询具有“Row”和“Rows”的对象，有关用法，请参阅“Create”

func (*Callback) Update 
func (c *Callback) Update() *CallbackProcessor
// Update可用于注册用于更新对象的回调，有关用法，请参阅“创建”

type CallbackProcessor 
type CallbackProcessor struct {
    /包含已过滤或未报告的字段
}
// CallbackProcessor包含回调信息

func (*CallbackProcessor) After 
func (cp *CallbackProcessor) After(callbackName string) *CallbackProcessor
// 在回调“callbackName”之后插入新回调后，请参阅“Callbacks.Create”`

func (*CallbackProcessor) Before 
func (cp *CallbackProcessor) Before(callbackName string) *CallbackProcessor
// 在回调“callbackName”之前插入新回调之前，请参阅“Callbacks.Create”`

func (*CallbackProcessor) Get 
func (cp *CallbackProcessor) Get(callbackName string) (callback func(scope *Scope))
// 获取注册回调
db.Callback().Create().Get("gorm:create")

func (*CallbackProcessor) Register 
func (cp *CallbackProcessor) Register(callbackName string, callback func(scope *Scope))
// 注册新回调，请参阅“Callbacks.Create”`

func (*CallbackProcessor) Remove 
func (cp *CallbackProcessor) Remove(callbackName string)
// 删除已注册的回调
db.Callback().Create().Remove("gorm:update_time_stamp_when_create")

func (*CallbackProcessor) Replace 
func (cp *CallbackProcessor) Replace(callbackName string, callback func(scope *Scope))
// 用新的回调函数替换已注册的回调函数
    db.Callback().Create().Replace("gorm:update_time_stamp_when_create", func(*Scope) {
		   scope.SetColumn("CreatedAt", now)
		   scope.SetColumn("UpdatedAt", now)
    })

type DB 
type DB struct {
	sync.RWMutex
	Value        interface{}
	Error        error
	RowsAffected int64
    //包含已过滤或未报告的字段
}
// 数据库包含当前数据库连接的信息

func Open 
func Open(dialect string, args ...interface{}) (db *DB, err error)
// 打开初始化新的数据库连接，需要先导入驱动程序，例如：
import _ "github.com/go-sql-driver/mysql"
func main() {
  db, err := gorm.Open("mysql", "user:password@/dbname?charset=utf8&parseTime=True&loc=Local")
}
// GORM包装了一些驱动程序，以便更容易记住驱动程序的导入路径，因此您可以使用
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
// 加法器将错误添加到数据库

func (*DB) AddForeignKey 
func (s *DB) AddForeignKey(field string, dest string, onDelete string, onUpdate string) *DB
// AddForeignKey将外键添加到给定范围，例如：
db.Model(&User{}).AddForeignKey("city_id", "cities(id)", "RESTRICT", "RESTRICT")

func (*DB) AddIndex 
func (s *DB) AddIndex(indexName string, columns ...string) *DB
// AddIndex为具有给定名称的列添加索引

func (*DB) AddUniqueIndex 
func (s *DB) AddUniqueIndex(indexName string, columns ...string) *DB
// AddUniqueIndex为具有给定名称的列添加唯一索引

func (*DB) Assign 
func (s *DB) Assign(attrs ...interface{}) *DB
// 无论是否使用'FirstOrInit'找到带参数的赋值结果https://jinzhu.github.io/gorm/crud.html#firstorinit 或“第一个或创建”https://jinzhu.github.io/gorm/crud.html#firstorcreate

func (*DB) Association 
func (s *DB) Association(column string) *Association
// 关联启动“关联模式”要在该模式下启动easir，请参阅：https://jinzhu.github.io/gorm/associations.html#association-模式

func (*DB) Attrs 
func (s *DB) Attrs(attrs ...interface{}) *DB
// 如果找不到带有“FirstOrInit”的记录，则Attrs将使用参数初始化结构https://jinzhu.github.io/gorm/crud.html#firstorinit 或“第一个或创建”https://jinzhu.github.io/gorm/crud.html#firstorcreate

func (*DB) AutoMigrate 
func (s *DB) AutoMigrate(values ...interface{}) *DB
// 自动迁移为给定模型运行自动迁移，只会添加缺少的字段，不会删除/更改当前数据

func (*DB) Begin 
func (s *DB) Begin() *DB
// 开始一项交易

func (*DB) BeginTx 
func (s *DB) BeginTx(ctx context.Context, opts *sql.TxOptions) *DB
// BeginTx使用选项开始事务

func (*DB) BlockGlobalUpdate 
func (s *DB) BlockGlobalUpdate(enable bool) *DB
// BlockGlobalUpdate如果为true，则在更新/删除时生成一个错误，而不包含where子句。这是为了防止更新/删除空对象时出现最终错误

func (*DB) Callback 
func (s *DB) Callback() *Callback
// 回调返回`Callbacks`容器，您可以使用它添加/更改/删除回调
db.Callback().Create().Register("update_created_at", updateCreated)
// 参考https://jinzhu.github.io/gorm/development.html#callbacks

func (*DB) Close 
func (s *DB) Close() error
// 关闭当前数据库连接。如果数据库连接不是io.Closer，则返回错误。

func (*DB) Commit 
func (s *DB) Commit() *DB
// 提交事务

func (*DB) CommonDB 
func (s *DB) CommonDB() SQLCommon
// CommonDB返回底层的“*sql.DB”或“*sql.Tx”实例，主要用于允许与遗留的非GORM代码共存。

func (*DB) Count 
func (s *DB) Count(value interface{}) *DB
// 计数获取一个模型的记录数

func (*DB) Create 
func (s *DB) Create(value interface{}) *DB
// 创建并将值插入数据库

func (*DB) CreateTable 
func (s *DB) CreateTable(models ...interface{}) *DB
// CreateTable为模型创建表格

func (*DB) DB 
func (s *DB) DB() *sql.DB
// DB get`*sql.DB`从当前连接如果基础数据库连接不是*sql.DB，则返回nil

func (*DB) Debug 
func (s *DB) Debug() *DB
// 调试启动调试模式

func (*DB) Delete 
func (s *DB) Delete(value interface{}, where ...interface{}) *DB
// 删除与给定条件匹配的删除值，如果该值具有主键，则将包含主键作为条件警告。如果模型具有DeletedAt字段，GORM将仅将字段DeletedAt的值设置为当前时间

func (*DB) Dialect 
func (s *DB) Dialect() Dialect
// 方言得到方言

func (*DB) DropColumn 
func (s *DB) DropColumn(column string) *DB
// 删除列删除列

func (*DB) DropTable 
func (s *DB) DropTable(values ...interface{}) *DB
// DropTable用于模型的DropTable

func (*DB) DropTableIfExists 
func (s *DB) DropTableIfExists(values ...interface{}) *DB
// DropTableIfExists如果存在DropTable

func (*DB) Exec 
func (s *DB) Exec(sql string, values ...interface{}) *DB
// 执行原始sql

func (*DB) Find 
func (s *DB) Find(out interface{}, where ...interface{}) *DB
// 查找与给定条件匹配的记录

func (*DB) First 
func (s *DB) First(out interface{}, where ...interface{}) *DB
// 首先查找符合给定条件的第一条记录，按主键排序

func (*DB) FirstOrCreate 
func (s *DB) FirstOrCreate(out interface{}, where ...interface{}) *DB
// first或创建查找第一个匹配的记录或创建具有给定条件的新记录（仅适用于结构、映射条件）https://jinzhu.github.io/gorm/crud.html#firstorcreate

func (*DB) FirstOrInit 
func (s *DB) FirstOrInit(out interface{}, where ...interface{}) *DB
// FirstOrInit查找第一个匹配的记录或使用给定条件初始化新记录（仅适用于结构、映射条件）https://jinzhu.github.io/gorm/crud.html#firstorinit

func (*DB) Get 
func (s *DB) Get(name string) (value interface{}, ok bool)
// 按名称获取设置

func (*DB) GetErrors 
func (s *DB) GetErrors() []error
// GetErrors从数据库中获取发生的错误

func (*DB) Group 
func (s *DB) Group(query string) *DB
// 组指定查找上的组方法

func (*DB) HasBlockGlobalUpdate 
func (s *DB) HasBlockGlobalUpdate() bool
// HasBlockGlobalUpdate块的返回状态

func (*DB) HasTable 
func (s *DB) HasTable(value interface{}) bool
// HasTable检查是否有表

func (*DB) Having 
func (s *DB) Having(query interface{}, values ...interface{}) *DB
// 规定了分组的条件

func (*DB) InstantSet 
func (s *DB) InstantSet(name string, value interface{}) *DB
// InstantSet instant set设置，将影响当前数据库

func (*DB) Joins 
func (s *DB) Joins(query string, args ...interface{}) *DB
// 联接指定联接条件
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
// 最后查找与给定条件匹配的最后一条记录，按主键排序

func (*DB) Limit 
func (s *DB) Limit(limit interface{}) *DB
// 限制指定要检索的记录数

func (*DB) LogMode 
func (s *DB) LogMode(enable bool) *DB
// LogMode设置日志模式，对于详细日志为'true'，对于无日志为'false'，默认情况下，将只打印错误日志

func (*DB) Model 
func (s *DB) Model(value interface{}) *DB
// 模型指定要运行db操作的模型
//将所有用户的名称更新为“hello”`
db.Model(&User{}).Update("name", "hello")
//如果用户的主键为非空，则将其用作条件，然后仅将用户名更新为“hello”`
db.Model(&user).Update("name", "hello")

func (*DB) ModifyColumn 
func (s *DB) ModifyColumn(column string, typ string) *DB
// ModifyColumn将列修改为类型

func (*DB) New 
func (s *DB) New() *DB
// 新建克隆不带搜索条件的新数据库连接

func (*DB) NewRecord 
func (s *DB) NewRecord(value interface{}) bool
// NewRecord检查值的主键是否为空

func (*DB) NewScope 
func (s *DB) NewScope(value interface{}) *Scope
// NewScope为当前操作创建作用域

func (*DB) Not 
func (s *DB) Not(query interface{}, args ...interface{}) *DB
// 不筛选与当前条件不匹配的记录，类似于“Where”`

func (*DB) Offset 
func (s *DB) Offset(offset interface{}) *DB
// 偏移量指定开始返回记录之前要跳过的记录数

func (*DB) Omit 
func (s *DB) Omit(columns ...string) *DB
// 忽略指定在保存到数据库以进行创建、更新时要忽略的字段

func (*DB) Or 
func (s *DB) Or(query interface{}, args ...interface{}) *DB
// 或筛选与条件或此条件匹配的记录，类似于“Where”`

func (*DB) Order 
func (s *DB) Order(value interface{}, reorder ...bool) *DB
// 顺序指定从数据库检索记录时的顺序，将reorder设置为“true”以覆盖定义的条件
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
// 用于将模型中的单个列作为映射查询的Pull
var ages []int64
db.Find(&users).Pluck("age", &ages)

func (*DB) Preload 
func (s *DB) Preload(column string, conditions ...interface{}) *DB
// 预加载与给定条件的预加载关联
db.Preload("Orders", "state NOT IN (?)", "cancelled").Find(&users)

func (*DB) Preloads 
func (s *DB) Preloads(out interface{}) *DB
// 预加载预加载关系，不接触

func (*DB) QueryExpr 
func (s *DB) QueryExpr() *SqlExpr
// QueryExpr将查询作为SqlExpr对象返回

func (*DB) Raw 
func (s *DB) Raw(sql string, values ...interface{}) *DB
// Raw使用Raw sql作为条件，除非被其他方法调用，否则不会运行它
db.Raw("SELECT name, age FROM users WHERE name = ?", 3).Scan(&result)

func (*DB) RecordNotFound 
func (s *DB) RecordNotFound() bool
// RecordNotFound检查是否返回ErrRecordNotFound错误

func (*DB) Related 
func (s *DB) Related(value interface{}, foreignKeys ...string) *DB
// 关联得到关联关联

func (*DB) RemoveForeignKey 
func (s *DB) RemoveForeignKey(field string, dest string) *DB
// RemoveForeignKey从给定范围中删除外键，例如：

// db.Model（&User{}）.RemoveForeignKey（“city_id”，“cities（id）”）
func (*DB) RemoveIndex 
func (s *DB) RemoveIndex(indexName string) *DB
// RemoveIndex删除名为的索引

func (*DB) Rollback 
func (s *DB) Rollback() *DB
// 回滚回滚事务

func (*DB) RollbackUnlessCommitted 
func (s *DB) RollbackUnlessCommitted() *DB
// 回滚未提交回滚尚未提交的事务。

func (*DB) Row 
func (s *DB) Row() *sql.Row
// 行返回带有给定条件的“*sql.Row”

func (*DB) Rows 
func (s *DB) Rows() (*sql.Rows, error)
// 行返回带有给定条件的“*sql.Rows”

func (*DB) Save 
func (s *DB) Save(value interface{}) *DB
// 将更新值保存在数据库中，如果该值没有主键，将插入它

func (*DB) Scan 
func (s *DB) Scan(dest interface{}) *DB
// 将扫描值扫描到结构

func (*DB) ScanRows 
func (s *DB) ScanRows(rows *sql.Rows, result interface{}) error
// ScanRows扫描“*sql.Rows”以给出结构

func (*DB) Scopes 
func (s *DB) Scopes(funcs ...func(*DB) *DB) *DB
// 作用域将当前数据库连接传递给参数“func（*DB）*DB”，该参数可用于动态添加条件
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)
// 参考https://jinzhu.github.io/gorm/crud.html#scopes

func (*DB) Select 
func (s *DB) Select(query interface{}, args ...interface{}) *DB
// 选择“指定查询时要从数据库检索的字段”，默认情况下，将选择所有字段；创建/更新时，指定要保存到数据库的字段

func (*DB) Set 
func (s *DB) Set(name string, value interface{}) *DB
// 可以在回调中使用的“按名称设置”将克隆一个新数据库，并更新其设置

func (*DB) SetJoinTableHandler 
func (s *DB) SetJoinTableHandler(source interface{}, column string, handler JoinTableHandlerInterface)
// SetJoinTableHandler为关系设置模型的联接表处理程序

func (*DB) SetLogger 
func (s *DB) SetLogger(log logger)
// 设置记录器替换默认记录器

func (*DB) SetNowFuncOverride 
func (s *DB) SetNowFuncOverride(nowFuncOverride func() time.Time) *DB
// SetNowFuncOverride设置创建新时间戳时要使用的函数

func (*DB) SingularTable 
func (s *DB) SingularTable(enable bool)
// 默认情况下，SingularTable使用singular表

func (*DB) SubQuery 
func (s *DB) SubQuery() *SqlExpr
// 子查询将查询作为子查询返回

func (*DB) Table 
func (s *DB) Table(name string) *DB
// 表指定要运行db *** 作的表

func (*DB) Take 
func (s *DB) Take(out interface{}, where ...interface{}) *DB
// 获取并返回与给定条件匹配的记录，顺序将取决于数据库实现

func (*DB) Transaction 
func (s *DB) Transaction(fc func(tx *DB) error) (err error)
// 事务以块的形式启动事务，返回错误将回滚，否则提交。

func (*DB) Unscoped 
func (s *DB) Unscoped() *DB
// 非范围返回所有记录，包括已删除的记录，参见软删除https://jinzhu.github.io/gorm/crud.html#soft-删除

func (*DB) Update 
func (s *DB) Update(attrs ...interface{}) *DB
// 使用回调更新属性，请参阅：https://jinzhu.github.io/gorm/crud.html#update 警告：当使用struct更新时，GORM不会更新值为零值的字段

func (*DB) UpdateColumn 
func (s *DB) UpdateColumn(attrs ...interface{}) *DB
// UpdateColumn不带回调的更新属性，请参阅：https://jinzhu.github.io/gorm/crud.html#update

func (*DB) UpdateColumns 
func (s *DB) UpdateColumns(values interface{}) *DB
// UpdateColumns不带回调的更新属性，请参阅：https://jinzhu.github.io/gorm/crud.html#update

func (*DB) Updates 
func (s *DB) Updates(values interface{}, ignoreProtectedAttrs ...bool) *DB
// 使用回调更新属性，请参阅：https://jinzhu.github.io/gorm/crud.html#update

func (*DB) Where 
func (s *DB) Where(query interface{}, args ...interface{}) *DB
// 如果返回一个新的关系，过滤具有给定条件的记录，接受'map'、'struct'或'string'作为条件，请参阅http://jinzhu.github.io/gorm/crud.html#query

type DefaultForeignKeyNamer 
type DefaultForeignKeyNamer struct {
// }
// DefaultForeignKeyNamer包含默认外键名生成器方法

func (DefaultForeignKeyNamer) BuildKeyName 
func (DefaultForeignKeyNamer) BuildKeyName(kind, tableName string, fields ...string) string
// BuildKeyName返回给定表、字段和引用的有效键名（外键、索引键）


type Dialect 
type Dialect interface {
    //获取方言的名称
    GetName() string

    //SetDB为方言设置db
    SetDB(db SQLCommon)

    //BindVar返回SQL语句中实际值的占位符，在许多数据库中它是“”，Postgres使用$1
    BindVar(i int) string
    //Quote quotes字段名，通过使用保留字作为字段名来避免SQL解析异常
    Quote(key string) string
    //返回数据的sql类型的DataTypeOf
    DataTypeOf(field *StructField) string

    //HasIndex检查是否有索引
    HasIndex(tableName string, indexName string) bool
    //HasForeignKey检查是否有外键
    HasForeignKey(tableName string, foreignKeyName string) bool
    //删除索引删除索引
    RemoveIndex(tableName string, indexName string) error
    //HasTable检查是否有表
    HasTable(tableName string) bool
    //HasColumn检查是否有列
    HasColumn(tableName string, columnName string) bool
    //ModifyColumn修改列的类型
    ModifyColumn(tableName string, columnName string, typ string) error

    //LimitAndOffsetSQL返回生成的带有Limit和Offset的SQL，因为mssql有特殊情况
    LimitAndOffsetSQL(limit, offset interface{}) (string, error)
    //SelectFromDummyTable返回select值，对于大多数数据库，`select values`只起作用，mysql需要`select value FROM DUAL`
    SelectFromDummyTable() string
    //大多数数据库支持LastInsertId，但mssql需要使用`输出'`
    LastInsertIDOutputInterstitial(tableName, columnName string, columns []string) string
    //LastInsertdReturningSuffix大多数数据库支持LastInsertId，但postgres需要使用'RETURNING'`
    LastInsertIDReturningSuffix(tableName, columnName string) string
    //DefaultValueStr
    DefaultValueStr() string

    //BuildKeyName返回给定表、字段和引用的有效键名（外键、索引键）
    BuildKeyName(kind, tableName string, fields ...string) string

    //NormalizeIndexAndColumn根据每种方言返回有效的索引名和列名
    NormalizeIndexAndColumn(indexName, columnName string) (string, string)

    //CurrentDatabase返回当前数据库名称
    CurrentDatabase() string
}
// 方言接口包含不同于SQL数据库的行为


func GetDialect 
func GetDialect(name string) (dialect Dialect, ok bool)
// 获取指定方言名称的方言

type Errors 
type Errors []error
// 错误包含所有发生的错误

func (Errors) Add 
func (errs Errors) Add(newErrors ...error) Errors
// 添加将错误添加到给定的错误片段中

func (Errors) Error 
func (errs Errors) Error() string
// Error获取已发生的所有错误的片段，并将其作为格式化字符串返回

func (Errors) GetErrors 
func (errs Errors) GetErrors() []error
// GetErrors获取已发生的所有错误，并返回错误片段（错误类型）

type Field 
type Field struct {
	*StructField
	IsBlank bool
	Field   reflect.Value
}
// 字段模型字段定义

func (*Field) Set 
func (field *Field) Set(value interface{}) (err error)
// 为字段设置一个值

type JoinTableForeignKey 
type JoinTableForeignKey struct {
	DBName            string
	AssociationDBName string
}
// JoinTableForeignKey连接表外键结构

type JoinTableHandler 
type JoinTableHandler struct {
	TableName   string          `sql:"-"`
	Source      JoinTableSource `sql:"-"`
	Destination JoinTableSource `sql:"-"`
}
// JoinTableHandler默认联接表处理程序

func (JoinTableHandler) Add 
func (s JoinTableHandler) Add(handler JoinTableHandlerInterface, db *DB, source interface{}, destination interface{}) error
// 在源和目标的联接表中添加创建关系

func (JoinTableHandler) Delete 
func (s JoinTableHandler) Delete(handler JoinTableHandlerInterface, db *DB, sources ...interface{}) error
// 删除源的联接表中的删除关系

func (*JoinTableHandler) DestinationForeignKeys 
func (s *JoinTableHandler) DestinationForeignKeys() []JoinTableForeignKey
// DestinationForeignKeys返回目标外键

func (JoinTableHandler) JoinWith 
func (s JoinTableHandler) JoinWith(handler JoinTableHandlerInterface, db *DB, source interface{}) *DB
// 带有“Join”条件的JoinWith查询

func (*JoinTableHandler) Setup 
func (s *JoinTableHandler) Setup(relationship *Relationship, tableName string, source reflect.Type, destination reflect.Type)
// 安装程序初始化默认联接表处理程序

func (*JoinTableHandler) SourceForeignKeys 
func (s *JoinTableHandler) SourceForeignKeys() []JoinTableForeignKey
// SourceForeignKeys返回源外键

func (JoinTableHandler) Table 
func (s JoinTableHandler) Table(db *DB) string
// 表返回联接表的表名

type JoinTableHandlerInterface 
type JoinTableHandlerInterface interface {
    //初始化联接表处理程序
    Setup(relationship *Relationship, tableName string, source reflect.Type, destination reflect.Type)
    //表返回联接表的表名
    Table(db *DB) string
    //在源和目标的联接表中添加创建关系
    Add(handler JoinTableHandlerInterface, db *DB, source interface{}, destination interface{}) error
    //删除源的联接表中的删除关系
    Delete(handler JoinTableHandlerInterface, db *DB, sources ...interface{}) error
    //带有“Join”条件的JoinWith查询
    JoinWith(handler JoinTableHandlerInterface, db *DB, source interface{}) *DB
    //SourceForeignKeys返回源外键
    SourceForeignKeys() []JoinTableForeignKey
    //DestinationForeignKeys返回目标外键
    DestinationForeignKeys() []JoinTableForeignKey
}
// JoinTableHandlerInterface是一个用于处理许多关系的接口

type JoinTableSource 
type JoinTableSource struct {
	ModelType   reflect.Type
	ForeignKeys []JoinTableForeignKey
}
// JoinTableSource是一个包含模型类型和外键的结构

type LogWriter 
type LogWriter interface {
	Println(v ...interface{})
}
// 日志编写器日志编写器接口

type Logger 
type Logger struct {
	LogWriter
}
// 记录器默认记录器

func (Logger) Print 
func (logger Logger) Print(values ...interface{})
// 打印格式和打印日志

type Model 
type Model struct {
	ID        uint `gorm:"primary_key"`
	CreatedAt time.Time
	UpdatedAt time.Time
	DeletedAt *time.Time `sql:"index"`
}
// 模型基础模型定义，包括可以嵌入到模型中的字段`ID`、`CreatedAt`、`UpdatedAt`、`DeletedAt`

type User struct {
  gorm.Model
}

type ModelStruct 
type ModelStruct struct {
	PrimaryFields []*StructField
	StructFields  []*StructField
	ModelType     reflect.Type
    //包含已过滤或未报告的字段
}
// ModelStruct模型定义

func (*ModelStruct) TableName 
func (s *ModelStruct) TableName(db *DB) string
// TableName返回模型的表名

type Namer 
type Namer func(string) string
// Namer是一种函数类型，它被赋予一个字符串并返回一个字符串

type NamingStrategy 
type NamingStrategy struct {
	DB     Namer
	Table  Namer
	Column Namer
}
// NamingStrategy代表命名策略

func (*NamingStrategy) ColumnName 
func (ns *NamingStrategy) ColumnName(name string) string
// ColumnName按列更改给定名称

func (*NamingStrategy) DBName 
func (ns *NamingStrategy) DBName(name string) string
// DBName通过DB更改给定的名称

func (*NamingStrategy) TableName 
func (ns *NamingStrategy) TableName(name string) string
// TableName按表更改给定的名称

type Relationship 
type Relationship struct {
	Kind                         string
	PolymorphicType              string
	PolymorphicDBName            string
	PolymorphicValue             string
	ForeignFieldNames            []string
	ForeignDBNames               []string
	AssociationForeignFieldNames []string
	AssociationForeignDBNames    []string
	JoinTableHandler             JoinTableHandlerInterface
}
// 关系描述了模型之间的关系

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是gorm所需的最小数据库连接功能。由*sql.DB实现。

type Scope 
type Scope struct {
	Search  *search
	Value   interface{}
	SQL     string
	SQLVars []interface{}
    //包含已过滤或未报告的字段
}
// 在数据库上执行任何 *** 作时，作用域包含当前 *** 作的信息

func (*Scope) AddToVars 
func (scope *Scope) AddToVars(value interface{}) string
// AddToVars作为sql的变量添加值，用于防止sql注入

func (*Scope) Begin 
func (scope *Scope) Begin() *Scope
// 开始交易

func (*Scope) CallMethod 
func (scope *Scope) CallMethod(methodName string)
// CallMethod调用范围值的方法，如果它是一个切片，将逐个调用其元素的方法

func (*Scope) CombinedConditionSql 
func (scope *Scope) CombinedConditionSql() string
// 组合条件sql返回组合条件sql

func (*Scope) CommitOrRollback 
func (scope *Scope) CommitOrRollback() *Scope
// CommitterRollback如果没有发生错误，则提交当前事务，否则将回滚它

func (*Scope) DB 
func (scope *Scope) DB() *DB
// DB返回作用域的DB连接

func (*Scope) Dialect 
func (scope *Scope) Dialect() Dialect
// 方言得到方言

func (*Scope) Err 
func (scope *Scope) Err(err error) error
// Err将错误添加到范围

func (*Scope) Exec 
func (scope *Scope) Exec() *Scope
// 执行生成的SQL

func (*Scope) FieldByName 
func (scope *Scope) FieldByName(name string) (field *Field, ok bool)
// FieldByName使用字段名或db名称查找'gorm.Field'

func (*Scope) Fields 
func (scope *Scope) Fields() []*Field
// 字段获取值的字段

func (*Scope) Get 
func (scope *Scope) Get(name string) (interface{}, bool)
// 按名称获取设置

func (*Scope) GetModelStruct 
func (scope *Scope) GetModelStruct() *ModelStruct
// GetModelStruct获取值的模型结构，基于结构和标记定义的关系

func (*Scope) GetStructFields 
func (scope *Scope) GetStructFields() (fields []*StructField)
// GetStructFields获取模型的字段结构

func (*Scope) HasColumn 
func (scope *Scope) HasColumn(column string) bool
// HasColumn检查是否有列

func (*Scope) HasError 
func (scope *Scope) HasError() bool
// HasError检查是否有任何错误

func (*Scope) IndirectValue 
func (scope *Scope) IndirectValue() reflect.Value
// IndirectValue返回范围的反射值的间接值

func (*Scope) InstanceGet 
func (scope *Scope) InstanceGet(name string) (interface{}, bool)
// InstanceGet从当前 *** 作获取实例设置

func (*Scope) InstanceID 
func (scope *Scope) InstanceID() string
// InstanceID获取作用域的InstanceID

func (*Scope) InstanceSet 
func (scope *Scope) InstanceSet(name string, value interface{}) *Scope
// InstanceSet为当前 *** 作设置实例设置，但不为回调中的 *** 作设置实例设置，如保存回调关联

func (*Scope) Log 
func (scope *Scope) Log(v ...interface{})
// 日志打印日志消息

func (*Scope) New 
func (scope *Scope) New(value interface{}) *Scope
// 新建创建不包含搜索信息的新范围

func (*Scope) NewDB 
func (scope *Scope) NewDB() *DB
// 新建数据库创建一个没有搜索信息的新数据库

func (*Scope) OmitAttrs 
func (scope *Scope) OmitAttrs() []string
// OmitAttrs返回省略的属性

func (*Scope) PrimaryField 
func (scope *Scope) PrimaryField() *Field
// PrimaryField返回作用域的主主字段（如果定义了多个主字段），将返回列名为'id'的字段或第一个字段

func (*Scope) PrimaryFields 
func (scope *Scope) PrimaryFields() (fields []*Field)
// PrimaryFields返回作用域的主字段

func (*Scope) PrimaryKey 
func (scope *Scope) PrimaryKey() string
// PrimaryKey获取主字段的db名称

func (*Scope) PrimaryKeyValue 
func (scope *Scope) PrimaryKeyValue() interface{}
// PrimaryKeyValue获取主键的值

func (*Scope) PrimaryKeyZero 
func (scope *Scope) PrimaryKeyZero() bool
// PrimaryKeyZero检查主主字段的值是否为空

func (*Scope) Quote 
func (scope *Scope) Quote(str string) string
// Quote用于引用字符串以对数据库进行转义

func (*Scope) QuotedTableName 
func (scope *Scope) QuotedTableName() (name string)
// QuotedTableName返回带引号的表名

func (*Scope) Raw 
func (scope *Scope) Raw(sql string) *Scope
// 原始集原始sql

func (*Scope) SQLDB 
func (scope *Scope) SQLDB() SQLCommon
// SQLDB return*sql.DB

func (*Scope) SelectAttrs 
func (scope *Scope) SelectAttrs() []string
// SelectAttrs返回所选属性

func (*Scope) Set 
func (scope *Scope) Set(name string, value interface{}) *Scope
// 按名称设置值

func (*Scope) SetColumn 
func (scope *Scope) SetColumn(column interface{}, value interface{}) error
// SetColumn要设置列的值，列可以是字段或字段的名称/dbname

func (*Scope) SkipLeft 
func (scope *Scope) SkipLeft()
// SkipLeft跳过剩余的回调

func (*Scope) TableName 
func (scope *Scope) TableName() string
// TableName返回表名

type SqlExpr 
type SqlExpr struct {
    //包含已过滤或未报告的字段
}
// SQL 表达式

func Expr 
func Expr(expression string, args ...interface{}) *SqlExpr
// Expr生成原始SQL表达式，例如：
DB.Model(&product).Update("price", gorm.Expr("price * ? + ?", 2, 100))

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模型字段的结构定义

func (*StructField) TagSettingsDelete 
func (sf *StructField) TagSettingsDelete(key string)
// 标记设置删除删除标记

func (*StructField) TagSettingsGet 
func (sf *StructField) TagSettingsGet(key string) (string, bool)
// TagSettingsGet从标记设置返回标记

func (*StructField) TagSettingsSet 
func (sf *StructField) TagSettingsSet(key, val string)
// 标记设置设置在标记设置映射中设置标记