2014-01-26 08:41:37 +04:00
|
|
|
package gorm
|
|
|
|
|
2014-01-26 09:51:23 +04:00
|
|
|
import (
|
|
|
|
"errors"
|
|
|
|
"fmt"
|
2014-01-26 15:34:06 +04:00
|
|
|
"go/ast"
|
2014-01-26 10:18:21 +04:00
|
|
|
"strings"
|
2014-01-26 13:10:33 +04:00
|
|
|
"time"
|
2014-01-26 09:51:23 +04:00
|
|
|
|
|
|
|
"reflect"
|
2014-01-26 10:18:21 +04:00
|
|
|
"regexp"
|
2014-01-26 09:51:23 +04:00
|
|
|
)
|
2014-01-26 08:41:37 +04:00
|
|
|
|
|
|
|
type Scope struct {
|
2014-07-30 10:58:00 +04:00
|
|
|
Value interface{}
|
|
|
|
indirectValue *reflect.Value
|
|
|
|
Search *search
|
|
|
|
Sql string
|
|
|
|
SqlVars []interface{}
|
|
|
|
db *DB
|
|
|
|
skipLeft bool
|
|
|
|
primaryKey string
|
2014-08-20 13:05:02 +04:00
|
|
|
instanceId string
|
2014-07-30 10:58:00 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
func (scope *Scope) IndirectValue() reflect.Value {
|
|
|
|
if scope.indirectValue == nil {
|
|
|
|
value := reflect.Indirect(reflect.ValueOf(scope.Value))
|
|
|
|
scope.indirectValue = &value
|
|
|
|
}
|
|
|
|
return *scope.indirectValue
|
2014-01-26 08:41:37 +04:00
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// NewScope create scope for callbacks, including DB's search information
|
2014-01-27 04:26:59 +04:00
|
|
|
func (db *DB) NewScope(value interface{}) *Scope {
|
2014-01-27 07:06:13 +04:00
|
|
|
db.Value = value
|
2014-08-20 12:25:01 +04:00
|
|
|
return &Scope{db: db, Search: db.search, Value: value}
|
2014-01-26 09:51:23 +04:00
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// New create a new Scope without search information
|
2014-01-27 04:26:59 +04:00
|
|
|
func (scope *Scope) New(value interface{}) *Scope {
|
|
|
|
return &Scope{db: scope.db.parent, Search: &search{}, Value: value}
|
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// NewDB create a new DB without search information
|
2014-01-27 04:26:59 +04:00
|
|
|
func (scope *Scope) NewDB() *DB {
|
2014-01-27 06:47:37 +04:00
|
|
|
return scope.db.new()
|
2014-01-27 04:26:59 +04:00
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// DB get *sql.DB
|
2014-01-26 08:41:37 +04:00
|
|
|
func (scope *Scope) DB() sqlCommon {
|
|
|
|
return scope.db.db
|
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// SkipLeft skip remaining callbacks
|
2014-01-29 08:00:57 +04:00
|
|
|
func (scope *Scope) SkipLeft() {
|
|
|
|
scope.skipLeft = true
|
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// Quote used to quote database column name according to database dialect
|
2014-01-29 08:00:57 +04:00
|
|
|
func (scope *Scope) Quote(str string) string {
|
|
|
|
return scope.Dialect().Quote(str)
|
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// Dialect get dialect
|
2014-04-25 03:20:23 +04:00
|
|
|
func (scope *Scope) Dialect() Dialect {
|
2014-01-26 08:41:37 +04:00
|
|
|
return scope.db.parent.dialect
|
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// Err write error
|
2014-01-26 08:41:37 +04:00
|
|
|
func (scope *Scope) Err(err error) error {
|
|
|
|
if err != nil {
|
|
|
|
scope.db.err(err)
|
|
|
|
}
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// Log print log message
|
2014-01-28 04:27:12 +04:00
|
|
|
func (scope *Scope) Log(v ...interface{}) {
|
|
|
|
scope.db.log(v...)
|
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// HasError check if there are any error
|
2014-01-26 08:41:37 +04:00
|
|
|
func (scope *Scope) HasError() bool {
|
2014-01-28 12:29:42 +04:00
|
|
|
return scope.db.Error != nil
|
2014-01-26 08:41:37 +04:00
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// PrimaryKey get the primary key's column name
|
2014-01-26 08:41:37 +04:00
|
|
|
func (scope *Scope) PrimaryKey() string {
|
2014-04-02 12:59:07 +04:00
|
|
|
if scope.primaryKey != "" {
|
|
|
|
return scope.primaryKey
|
|
|
|
}
|
|
|
|
|
2014-07-25 12:51:54 +04:00
|
|
|
scope.primaryKey = ToSnake(GetPrimaryKey(scope.Value))
|
2014-04-02 12:59:07 +04:00
|
|
|
return scope.primaryKey
|
2014-01-26 08:41:37 +04:00
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// PrimaryKeyZero check the primary key is blank or not
|
2014-01-26 13:10:33 +04:00
|
|
|
func (scope *Scope) PrimaryKeyZero() bool {
|
|
|
|
return isBlank(reflect.ValueOf(scope.PrimaryKeyValue()))
|
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// PrimaryKeyValue get the primary key's value
|
2014-01-26 13:10:33 +04:00
|
|
|
func (scope *Scope) PrimaryKeyValue() interface{} {
|
2014-07-30 10:58:00 +04:00
|
|
|
if scope.IndirectValue().Kind() == reflect.Struct {
|
|
|
|
if field := scope.IndirectValue().FieldByName(SnakeToUpperCamel(scope.PrimaryKey())); field.IsValid() {
|
2014-01-26 13:10:33 +04:00
|
|
|
return field.Interface()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// HasColumn to check if has column
|
2014-01-26 08:41:37 +04:00
|
|
|
func (scope *Scope) HasColumn(name string) bool {
|
2014-07-31 07:08:26 +04:00
|
|
|
_, result := scope.FieldValueByName(name)
|
2014-01-28 08:28:44 +04:00
|
|
|
return result
|
|
|
|
}
|
|
|
|
|
2014-07-31 07:08:26 +04:00
|
|
|
// FieldValueByName to get column's value and existence
|
|
|
|
func (scope *Scope) FieldValueByName(name string) (interface{}, bool) {
|
|
|
|
return FieldValueByName(name, scope.Value)
|
2014-01-26 08:41:37 +04:00
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// SetColumn to set the column's value
|
2014-07-30 16:48:36 +04:00
|
|
|
func (scope *Scope) SetColumn(column string, value interface{}) bool {
|
2014-01-27 18:36:08 +04:00
|
|
|
if scope.Value == nil {
|
2014-07-30 16:48:36 +04:00
|
|
|
return false
|
2014-01-27 18:36:08 +04:00
|
|
|
}
|
|
|
|
|
2014-07-30 16:48:36 +04:00
|
|
|
return setFieldValue(scope.IndirectValue().FieldByName(SnakeToUpperCamel(column)), value)
|
2014-01-26 08:41:37 +04:00
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// CallMethod invoke method with necessary argument
|
2014-01-26 08:41:37 +04:00
|
|
|
func (scope *Scope) CallMethod(name string) {
|
2014-01-27 18:36:08 +04:00
|
|
|
if scope.Value == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-01-28 05:25:30 +04:00
|
|
|
call := func(value interface{}) {
|
|
|
|
if fm := reflect.ValueOf(value).MethodByName(name); fm.IsValid() {
|
|
|
|
fi := fm.Interface()
|
|
|
|
if f, ok := fi.(func()); ok {
|
|
|
|
f()
|
|
|
|
} else if f, ok := fi.(func(s *Scope)); ok {
|
|
|
|
f(scope)
|
|
|
|
} else if f, ok := fi.(func(s *DB)); ok {
|
|
|
|
f(scope.db.new())
|
|
|
|
} else if f, ok := fi.(func() error); ok {
|
|
|
|
scope.Err(f())
|
|
|
|
} else if f, ok := fi.(func(s *Scope) error); ok {
|
|
|
|
scope.Err(f(scope))
|
|
|
|
} else if f, ok := fi.(func(s *DB) error); ok {
|
|
|
|
scope.Err(f(scope.db.new()))
|
|
|
|
} else {
|
|
|
|
scope.Err(errors.New(fmt.Sprintf("unsupported function %v", name)))
|
|
|
|
}
|
2014-01-26 09:51:23 +04:00
|
|
|
}
|
|
|
|
}
|
2014-01-28 05:25:30 +04:00
|
|
|
|
2014-07-30 10:58:00 +04:00
|
|
|
if values := scope.IndirectValue(); values.Kind() == reflect.Slice {
|
2014-01-28 05:25:30 +04:00
|
|
|
for i := 0; i < values.Len(); i++ {
|
|
|
|
call(values.Index(i).Addr().Interface())
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
call(scope.Value)
|
|
|
|
}
|
2014-01-26 08:41:37 +04:00
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// AddToVars add value as sql's vars, gorm will escape them
|
2014-01-26 08:41:37 +04:00
|
|
|
func (scope *Scope) AddToVars(value interface{}) string {
|
2014-01-26 10:18:21 +04:00
|
|
|
scope.SqlVars = append(scope.SqlVars, value)
|
|
|
|
return scope.Dialect().BinVar(len(scope.SqlVars))
|
2014-01-26 08:41:37 +04:00
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// TableName get table name
|
2014-07-02 07:56:37 +04:00
|
|
|
var pluralMapKeys = []*regexp.Regexp{regexp.MustCompile("ch$"), regexp.MustCompile("ss$"), regexp.MustCompile("sh$"), regexp.MustCompile("day$"), regexp.MustCompile("y$"), regexp.MustCompile("x$"), regexp.MustCompile("([^s])s?$")}
|
|
|
|
var pluralMapValues = []string{"ches", "sses", "shes", "days", "ies", "xes", "${1}s"}
|
|
|
|
|
2014-01-26 08:41:37 +04:00
|
|
|
func (scope *Scope) TableName() string {
|
2014-01-28 12:56:51 +04:00
|
|
|
if scope.Search != nil && len(scope.Search.TableName) > 0 {
|
|
|
|
return scope.Search.TableName
|
2014-01-26 10:18:21 +04:00
|
|
|
} else {
|
2014-01-28 07:37:32 +04:00
|
|
|
if scope.Value == nil {
|
|
|
|
scope.Err(errors.New("can't get table name"))
|
|
|
|
return ""
|
|
|
|
}
|
2014-01-26 10:18:21 +04:00
|
|
|
|
2014-07-30 10:58:00 +04:00
|
|
|
data := scope.IndirectValue()
|
2014-01-26 10:18:21 +04:00
|
|
|
if data.Kind() == reflect.Slice {
|
2014-07-08 06:45:31 +04:00
|
|
|
elem := data.Type().Elem()
|
|
|
|
if elem.Kind() == reflect.Ptr {
|
|
|
|
elem = elem.Elem()
|
|
|
|
}
|
|
|
|
data = reflect.New(elem).Elem()
|
2014-01-26 10:18:21 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if fm := data.MethodByName("TableName"); fm.IsValid() {
|
|
|
|
if v := fm.Call([]reflect.Value{}); len(v) > 0 {
|
|
|
|
if result, ok := v[0].Interface().(string); ok {
|
|
|
|
return result
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-21 10:06:54 +04:00
|
|
|
str := ToSnake(data.Type().Name())
|
2014-01-26 10:18:21 +04:00
|
|
|
|
2014-08-20 09:46:10 +04:00
|
|
|
if scope.db == nil || !scope.db.parent.singularTable {
|
2014-07-02 07:56:37 +04:00
|
|
|
for index, reg := range pluralMapKeys {
|
2014-01-26 10:18:21 +04:00
|
|
|
if reg.MatchString(str) {
|
2014-07-02 07:56:37 +04:00
|
|
|
return reg.ReplaceAllString(str, pluralMapValues[index])
|
2014-01-26 10:18:21 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return str
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-03 13:15:05 +04:00
|
|
|
func (scope *Scope) QuotedTableName() string {
|
|
|
|
if scope.Search != nil && len(scope.Search.TableName) > 0 {
|
|
|
|
return scope.Search.TableName
|
|
|
|
} else {
|
2014-06-10 09:08:19 +04:00
|
|
|
keys := strings.Split(scope.TableName(), ".")
|
|
|
|
for i, v := range keys {
|
|
|
|
keys[i] = scope.Quote(v)
|
|
|
|
}
|
|
|
|
return strings.Join(keys, ".")
|
2014-06-03 13:15:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// CombinedConditionSql get combined condition sql
|
2014-01-29 04:55:45 +04:00
|
|
|
func (scope *Scope) CombinedConditionSql() string {
|
|
|
|
return scope.joinsSql() + scope.whereSql() + scope.groupSql() +
|
|
|
|
scope.havingSql() + scope.orderSql() + scope.limitSql() + scope.offsetSql()
|
2014-01-26 10:55:41 +04:00
|
|
|
}
|
|
|
|
|
2014-07-31 07:08:26 +04:00
|
|
|
func (scope *Scope) FieldByName(name string) (field *Field, ok bool) {
|
|
|
|
var f reflect.StructField
|
|
|
|
if scope.Value != nil {
|
|
|
|
if scope.IndirectValue().Kind() == reflect.Struct {
|
|
|
|
if f, ok = scope.IndirectValue().Type().FieldByName(SnakeToUpperCamel(name)); ok {
|
|
|
|
field = scope.fieldFromStruct(f)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2014-07-30 10:58:00 +04:00
|
|
|
func (scope *Scope) fieldFromStruct(fieldStruct reflect.StructField) *Field {
|
|
|
|
var field Field
|
|
|
|
field.Name = fieldStruct.Name
|
|
|
|
field.DBName = ToSnake(fieldStruct.Name)
|
2014-01-26 15:34:06 +04:00
|
|
|
|
2014-07-30 10:58:00 +04:00
|
|
|
value := scope.IndirectValue().FieldByName(fieldStruct.Name)
|
|
|
|
indirectValue := reflect.Indirect(value)
|
|
|
|
field.Value = value.Interface()
|
|
|
|
field.IsBlank = isBlank(value)
|
2014-01-26 15:34:06 +04:00
|
|
|
|
2014-07-30 10:58:00 +04:00
|
|
|
// Search for primary key tag identifier
|
|
|
|
settings := parseTagSetting(fieldStruct.Tag.Get("gorm"))
|
2014-07-31 07:08:26 +04:00
|
|
|
if scope.PrimaryKey() == field.DBName {
|
|
|
|
field.IsPrimaryKey = true
|
2014-07-30 10:58:00 +04:00
|
|
|
}
|
2014-01-26 15:34:06 +04:00
|
|
|
|
2014-07-31 07:08:26 +04:00
|
|
|
field.Tag = fieldStruct.Tag
|
|
|
|
field.SqlTag = scope.sqlTagForField(&field)
|
2014-04-02 12:59:07 +04:00
|
|
|
|
2014-08-14 17:45:42 +04:00
|
|
|
if !field.IsIgnored {
|
|
|
|
// parse association
|
2014-08-15 07:14:33 +04:00
|
|
|
if !indirectValue.IsValid() {
|
|
|
|
indirectValue = reflect.New(value.Type())
|
|
|
|
}
|
2014-08-14 17:45:42 +04:00
|
|
|
typ := indirectValue.Type()
|
|
|
|
foreignKey := SnakeToUpperCamel(settings["FOREIGNKEY"])
|
|
|
|
associationForeignKey := SnakeToUpperCamel(settings["ASSOCIATIONFOREIGNKEY"])
|
|
|
|
many2many := settings["MANY2MANY"]
|
|
|
|
scopeTyp := scope.IndirectValue().Type()
|
2014-01-27 06:47:37 +04:00
|
|
|
|
2014-08-14 17:45:42 +04:00
|
|
|
switch indirectValue.Kind() {
|
|
|
|
case reflect.Slice:
|
|
|
|
typ = typ.Elem()
|
2014-07-30 17:14:10 +04:00
|
|
|
|
2014-08-14 17:45:42 +04:00
|
|
|
if typ.Kind() == reflect.Struct {
|
2014-07-31 07:08:26 +04:00
|
|
|
if foreignKey == "" {
|
|
|
|
foreignKey = scopeTyp.Name() + "Id"
|
|
|
|
}
|
2014-08-14 17:45:42 +04:00
|
|
|
if associationForeignKey == "" {
|
|
|
|
associationForeignKey = typ.Name() + "Id"
|
|
|
|
}
|
|
|
|
|
|
|
|
// if not many to many, foreign key could be null
|
|
|
|
if many2many == "" {
|
|
|
|
if !reflect.New(typ).Elem().FieldByName(foreignKey).IsValid() {
|
|
|
|
foreignKey = ""
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
field.Relationship = &relationship{
|
|
|
|
JoinTable: many2many,
|
|
|
|
ForeignKey: foreignKey,
|
|
|
|
AssociationForeignKey: associationForeignKey,
|
|
|
|
Kind: "has_many",
|
|
|
|
}
|
|
|
|
|
|
|
|
if many2many != "" {
|
|
|
|
field.Relationship.Kind = "many_to_many"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
case reflect.Struct:
|
|
|
|
if !field.IsTime() && !field.IsScanner() {
|
|
|
|
if foreignKey == "" && scope.HasColumn(field.Name+"Id") {
|
|
|
|
field.Relationship = &relationship{ForeignKey: field.Name + "Id", Kind: "belongs_to"}
|
|
|
|
} else if scope.HasColumn(foreignKey) {
|
|
|
|
field.Relationship = &relationship{ForeignKey: foreignKey, Kind: "belongs_to"}
|
|
|
|
} else {
|
|
|
|
if foreignKey == "" {
|
|
|
|
foreignKey = scopeTyp.Name() + "Id"
|
|
|
|
}
|
|
|
|
if reflect.New(typ).Elem().FieldByName(foreignKey).IsValid() {
|
|
|
|
field.Relationship = &relationship{ForeignKey: foreignKey, Kind: "has_one"}
|
|
|
|
}
|
2014-01-27 18:36:08 +04:00
|
|
|
}
|
2014-01-27 06:47:37 +04:00
|
|
|
}
|
|
|
|
}
|
2014-07-30 10:58:00 +04:00
|
|
|
}
|
|
|
|
return &field
|
|
|
|
}
|
|
|
|
|
|
|
|
// Fields get value's fields
|
2014-07-30 11:15:23 +04:00
|
|
|
func (scope *Scope) Fields() (fields []*Field) {
|
|
|
|
if scope.IndirectValue().IsValid() {
|
|
|
|
scopeTyp := scope.IndirectValue().Type()
|
|
|
|
for i := 0; i < scopeTyp.NumField(); i++ {
|
|
|
|
fieldStruct := scopeTyp.Field(i)
|
|
|
|
if !ast.IsExported(fieldStruct.Name) {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
fields = append(fields, scope.fieldFromStruct(fieldStruct))
|
2014-07-30 10:58:00 +04:00
|
|
|
}
|
2014-01-26 15:34:06 +04:00
|
|
|
}
|
2014-07-30 11:15:23 +04:00
|
|
|
return
|
2014-01-26 08:41:37 +04:00
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// Raw set sql
|
2014-01-28 11:54:19 +04:00
|
|
|
func (scope *Scope) Raw(sql string) *Scope {
|
2014-01-26 10:18:21 +04:00
|
|
|
scope.Sql = strings.Replace(sql, "$$", "?", -1)
|
2014-01-28 11:54:19 +04:00
|
|
|
return scope
|
2014-01-26 08:41:37 +04:00
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// Exec invoke sql
|
2014-01-28 06:23:31 +04:00
|
|
|
func (scope *Scope) Exec() *Scope {
|
2014-08-23 12:00:04 +04:00
|
|
|
defer scope.Trace(NowFunc())
|
2014-01-28 11:54:19 +04:00
|
|
|
|
2014-01-26 10:18:21 +04:00
|
|
|
if !scope.HasError() {
|
2014-06-05 13:58:14 +04:00
|
|
|
result, err := scope.DB().Exec(scope.Sql, scope.SqlVars...)
|
|
|
|
if scope.Err(err) == nil {
|
|
|
|
if count, err := result.RowsAffected(); err == nil {
|
|
|
|
scope.db.RowsAffected = count
|
|
|
|
}
|
|
|
|
}
|
2014-01-26 10:18:21 +04:00
|
|
|
}
|
2014-01-28 06:23:31 +04:00
|
|
|
return scope
|
2014-01-26 08:41:37 +04:00
|
|
|
}
|
2014-01-26 13:10:33 +04:00
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// Set set value by name
|
2014-08-20 13:05:02 +04:00
|
|
|
func (scope *Scope) Set(name string, value interface{}) *Scope {
|
|
|
|
scope.db.set(name, value)
|
|
|
|
return scope
|
2014-01-27 07:56:04 +04:00
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// Get get value by name
|
2014-08-20 12:25:01 +04:00
|
|
|
func (scope *Scope) Get(name string) (interface{}, bool) {
|
|
|
|
return scope.db.Get(name)
|
2014-01-29 15:14:37 +04:00
|
|
|
}
|
|
|
|
|
2014-08-20 13:05:02 +04:00
|
|
|
// InstanceId get InstanceId for scope
|
|
|
|
func (scope *Scope) InstanceId() string {
|
|
|
|
if scope.instanceId == "" {
|
|
|
|
scope.instanceId = fmt.Sprintf("%v", &scope)
|
|
|
|
}
|
|
|
|
return scope.instanceId
|
|
|
|
}
|
|
|
|
|
|
|
|
func (scope *Scope) InstanceSet(name string, value interface{}) *Scope {
|
|
|
|
return scope.Set(name+scope.InstanceId(), value)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (scope *Scope) InstanceGet(name string) (interface{}, bool) {
|
|
|
|
return scope.Get(name + scope.InstanceId())
|
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// Trace print sql log
|
2014-01-26 13:10:33 +04:00
|
|
|
func (scope *Scope) Trace(t time.Time) {
|
|
|
|
if len(scope.Sql) > 0 {
|
|
|
|
scope.db.slog(scope.Sql, t, scope.SqlVars...)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// Begin start a transaction
|
2014-01-26 13:10:33 +04:00
|
|
|
func (scope *Scope) Begin() *Scope {
|
2014-01-27 06:47:37 +04:00
|
|
|
if db, ok := scope.DB().(sqlDb); ok {
|
|
|
|
if tx, err := db.Begin(); err == nil {
|
|
|
|
scope.db.db = interface{}(tx).(sqlCommon)
|
2014-08-20 13:05:02 +04:00
|
|
|
scope.InstanceSet("gorm:started_transaction", true)
|
2014-01-27 06:47:37 +04:00
|
|
|
}
|
2014-01-26 13:10:33 +04:00
|
|
|
}
|
|
|
|
return scope
|
|
|
|
}
|
|
|
|
|
2014-01-29 15:14:37 +04:00
|
|
|
// CommitOrRollback commit current transaction if there is no error, otherwise rollback it
|
2014-01-26 13:10:33 +04:00
|
|
|
func (scope *Scope) CommitOrRollback() *Scope {
|
2014-08-20 13:05:02 +04:00
|
|
|
if _, ok := scope.InstanceGet("gorm:started_transaction"); ok {
|
2014-01-26 13:10:33 +04:00
|
|
|
if db, ok := scope.db.db.(sqlTx); ok {
|
|
|
|
if scope.HasError() {
|
|
|
|
db.Rollback()
|
|
|
|
} else {
|
|
|
|
db.Commit()
|
|
|
|
}
|
|
|
|
scope.db.db = scope.db.parent.db
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return scope
|
|
|
|
}
|