123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419 |
- package gorm
- import (
- "bytes"
- "database/sql"
- "database/sql/driver"
- "errors"
- "fmt"
- "reflect"
- "regexp"
- "strings"
- "time"
- )
- // Scope contain current operation's information when you perform any operation on the database
- type Scope struct {
- Search *search
- Value interface{}
- SQL string
- SQLVars []interface{}
- db *DB
- instanceID string
- primaryKeyField *Field
- skipLeft bool
- fields *[]*Field
- selectAttrs *[]string
- }
- // IndirectValue return scope's reflect value's indirect value
- func (scope *Scope) IndirectValue() reflect.Value {
- return indirect(reflect.ValueOf(scope.Value))
- }
- // New create a new Scope without search information
- func (scope *Scope) New(value interface{}) *Scope {
- return &Scope{db: scope.NewDB(), Search: &search{}, Value: value}
- }
- ////////////////////////////////////////////////////////////////////////////////
- // Scope DB
- ////////////////////////////////////////////////////////////////////////////////
- // DB return scope's DB connection
- func (scope *Scope) DB() *DB {
- return scope.db
- }
- // NewDB create a new DB without search information
- func (scope *Scope) NewDB() *DB {
- if scope.db != nil {
- db := scope.db.clone()
- db.search = nil
- db.Value = nil
- return db
- }
- return nil
- }
- // SQLDB return *sql.DB
- func (scope *Scope) SQLDB() SQLCommon {
- return scope.db.db
- }
- // Dialect get dialect
- func (scope *Scope) Dialect() Dialect {
- return scope.db.dialect
- }
- // Quote used to quote string to escape them for database
- func (scope *Scope) Quote(str string) string {
- if strings.Contains(str, ".") {
- newStrs := []string{}
- for _, str := range strings.Split(str, ".") {
- newStrs = append(newStrs, scope.Dialect().Quote(str))
- }
- return strings.Join(newStrs, ".")
- }
- return scope.Dialect().Quote(str)
- }
- // Err add error to Scope
- func (scope *Scope) Err(err error) error {
- if err != nil {
- scope.db.AddError(err)
- }
- return err
- }
- // HasError check if there are any error
- func (scope *Scope) HasError() bool {
- return scope.db.Error != nil
- }
- // Log print log message
- func (scope *Scope) Log(v ...interface{}) {
- scope.db.log(v...)
- }
- // SkipLeft skip remaining callbacks
- func (scope *Scope) SkipLeft() {
- scope.skipLeft = true
- }
- // Fields get value's fields
- func (scope *Scope) Fields() []*Field {
- if scope.fields == nil {
- var (
- fields []*Field
- indirectScopeValue = scope.IndirectValue()
- isStruct = indirectScopeValue.Kind() == reflect.Struct
- )
- for _, structField := range scope.GetModelStruct().StructFields {
- if isStruct {
- fieldValue := indirectScopeValue
- for _, name := range structField.Names {
- if fieldValue.Kind() == reflect.Ptr && fieldValue.IsNil() {
- fieldValue.Set(reflect.New(fieldValue.Type().Elem()))
- }
- fieldValue = reflect.Indirect(fieldValue).FieldByName(name)
- }
- fields = append(fields, &Field{StructField: structField, Field: fieldValue, IsBlank: isBlank(fieldValue)})
- } else {
- fields = append(fields, &Field{StructField: structField, IsBlank: true})
- }
- }
- scope.fields = &fields
- }
- return *scope.fields
- }
- // FieldByName find `gorm.Field` with field name or db name
- func (scope *Scope) FieldByName(name string) (field *Field, ok bool) {
- var (
- dbName = ToColumnName(name)
- mostMatchedField *Field
- )
- for _, field := range scope.Fields() {
- if field.Name == name || field.DBName == name {
- return field, true
- }
- if field.DBName == dbName {
- mostMatchedField = field
- }
- }
- return mostMatchedField, mostMatchedField != nil
- }
- // PrimaryFields return scope's primary fields
- func (scope *Scope) PrimaryFields() (fields []*Field) {
- for _, field := range scope.Fields() {
- if field.IsPrimaryKey {
- fields = append(fields, field)
- }
- }
- return fields
- }
- // 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 *Scope) PrimaryField() *Field {
- if primaryFields := scope.GetModelStruct().PrimaryFields; len(primaryFields) > 0 {
- if len(primaryFields) > 1 {
- if field, ok := scope.FieldByName("id"); ok {
- return field
- }
- }
- return scope.PrimaryFields()[0]
- }
- return nil
- }
- // PrimaryKey get main primary field's db name
- func (scope *Scope) PrimaryKey() string {
- if field := scope.PrimaryField(); field != nil {
- return field.DBName
- }
- return ""
- }
- // PrimaryKeyZero check main primary field's value is blank or not
- func (scope *Scope) PrimaryKeyZero() bool {
- field := scope.PrimaryField()
- return field == nil || field.IsBlank
- }
- // PrimaryKeyValue get the primary key's value
- func (scope *Scope) PrimaryKeyValue() interface{} {
- if field := scope.PrimaryField(); field != nil && field.Field.IsValid() {
- return field.Field.Interface()
- }
- return 0
- }
- // HasColumn to check if has column
- func (scope *Scope) HasColumn(column string) bool {
- for _, field := range scope.GetStructFields() {
- if field.IsNormal && (field.Name == column || field.DBName == column) {
- return true
- }
- }
- return false
- }
- // SetColumn to set the column's value, column could be field or field's name/dbname
- func (scope *Scope) SetColumn(column interface{}, value interface{}) error {
- var updateAttrs = map[string]interface{}{}
- if attrs, ok := scope.InstanceGet("gorm:update_attrs"); ok {
- updateAttrs = attrs.(map[string]interface{})
- defer scope.InstanceSet("gorm:update_attrs", updateAttrs)
- }
- if field, ok := column.(*Field); ok {
- updateAttrs[field.DBName] = value
- return field.Set(value)
- } else if name, ok := column.(string); ok {
- var (
- dbName = ToDBName(name)
- mostMatchedField *Field
- )
- for _, field := range scope.Fields() {
- if field.DBName == value {
- updateAttrs[field.DBName] = value
- return field.Set(value)
- }
- if (field.DBName == dbName) || (field.Name == name && mostMatchedField == nil) {
- mostMatchedField = field
- }
- }
- if mostMatchedField != nil {
- updateAttrs[mostMatchedField.DBName] = value
- return mostMatchedField.Set(value)
- }
- }
- return errors.New("could not convert column to field")
- }
- // CallMethod call scope value's method, if it is a slice, will call its element's method one by one
- func (scope *Scope) CallMethod(methodName string) {
- if scope.Value == nil {
- return
- }
- if indirectScopeValue := scope.IndirectValue(); indirectScopeValue.Kind() == reflect.Slice {
- for i := 0; i < indirectScopeValue.Len(); i++ {
- scope.callMethod(methodName, indirectScopeValue.Index(i))
- }
- } else {
- scope.callMethod(methodName, indirectScopeValue)
- }
- }
- // AddToVars add value as sql's vars, used to prevent SQL injection
- func (scope *Scope) AddToVars(value interface{}) string {
- _, skipBindVar := scope.InstanceGet("skip_bindvar")
- if expr, ok := value.(*expr); ok {
- exp := expr.expr
- for _, arg := range expr.args {
- if skipBindVar {
- scope.AddToVars(arg)
- } else {
- exp = strings.Replace(exp, "?", scope.AddToVars(arg), 1)
- }
- }
- return exp
- }
- scope.SQLVars = append(scope.SQLVars, value)
- if skipBindVar {
- return "?"
- }
- return scope.Dialect().BindVar(len(scope.SQLVars))
- }
- // SelectAttrs return selected attributes
- func (scope *Scope) SelectAttrs() []string {
- if scope.selectAttrs == nil {
- attrs := []string{}
- for _, value := range scope.Search.selects {
- if str, ok := value.(string); ok {
- attrs = append(attrs, str)
- } else if strs, ok := value.([]string); ok {
- attrs = append(attrs, strs...)
- } else if strs, ok := value.([]interface{}); ok {
- for _, str := range strs {
- attrs = append(attrs, fmt.Sprintf("%v", str))
- }
- }
- }
- scope.selectAttrs = &attrs
- }
- return *scope.selectAttrs
- }
- // OmitAttrs return omitted attributes
- func (scope *Scope) OmitAttrs() []string {
- return scope.Search.omits
- }
- type tabler interface {
- TableName() string
- }
- type dbTabler interface {
- TableName(*DB) string
- }
- // TableName return table name
- func (scope *Scope) TableName() string {
- if scope.Search != nil && len(scope.Search.tableName) > 0 {
- return scope.Search.tableName
- }
- if tabler, ok := scope.Value.(tabler); ok {
- return tabler.TableName()
- }
- if tabler, ok := scope.Value.(dbTabler); ok {
- return tabler.TableName(scope.db)
- }
- return scope.GetModelStruct().TableName(scope.db.Model(scope.Value))
- }
- // QuotedTableName return quoted table name
- func (scope *Scope) QuotedTableName() (name string) {
- if scope.Search != nil && len(scope.Search.tableName) > 0 {
- if strings.Contains(scope.Search.tableName, " ") {
- return scope.Search.tableName
- }
- return scope.Quote(scope.Search.tableName)
- }
- return scope.Quote(scope.TableName())
- }
- // CombinedConditionSql return combined condition sql
- func (scope *Scope) CombinedConditionSql() string {
- joinSQL := scope.joinsSQL()
- whereSQL := scope.whereSQL()
- if scope.Search.raw {
- whereSQL = strings.TrimSuffix(strings.TrimPrefix(whereSQL, "WHERE ("), ")")
- }
- return joinSQL + whereSQL + scope.groupSQL() +
- scope.havingSQL() + scope.orderSQL() + scope.limitAndOffsetSQL()
- }
- // Raw set raw sql
- func (scope *Scope) Raw(sql string) *Scope {
- scope.SQL = strings.Replace(sql, "$$$", "?", -1)
- return scope
- }
- // Exec perform generated SQL
- func (scope *Scope) Exec() *Scope {
- defer scope.trace(NowFunc())
- if !scope.HasError() {
- if result, err := scope.SQLDB().Exec(scope.SQL, scope.SQLVars...); scope.Err(err) == nil {
- if count, err := result.RowsAffected(); scope.Err(err) == nil {
- scope.db.RowsAffected = count
- }
- }
- }
- return scope
- }
- // Set set value by name
- func (scope *Scope) Set(name string, value interface{}) *Scope {
- scope.db.InstantSet(name, value)
- return scope
- }
- // Get get setting by name
- func (scope *Scope) Get(name string) (interface{}, bool) {
- return scope.db.Get(name)
- }
- // InstanceID get InstanceID for scope
- func (scope *Scope) InstanceID() string {
- if scope.instanceID == "" {
- scope.instanceID = fmt.Sprintf("%v%v", &scope, &scope.db)
- }
- return scope.instanceID
- }
- // InstanceSet set instance setting for current operation, but not for operations in callbacks, like saving associations callback
- func (scope *Scope) InstanceSet(name string, value interface{}) *Scope {
- return scope.Set(name+scope.InstanceID(), value)
- }
- // InstanceGet get instance setting from current operation
- func (scope *Scope) InstanceGet(name string) (interface{}, bool) {
- return scope.Get(name + scope.InstanceID())
- }
- // Begin start a transaction
- func (scope *Scope) Begin() *Scope {
- if db, ok := scope.SQLDB().(sqlDb); ok {
- if tx, err := db.Begin(); err == nil {
- scope.db.db = interface{}(tx).(SQLCommon)
- scope.InstanceSet("gorm:started_transaction", true)
- }
- }
- return scope
- }
- // CommitOrRollback commit current transaction if no error happened, otherwise will rollback it
- func (scope *Scope) CommitOrRollback() *Scope {
- if _, ok := scope.InstanceGet("gorm:started_transaction"); ok {
- if db, ok := scope.db.db.(sqlTx); ok {
- if scope.HasError() {
- db.Rollback()
- } else {
- scope.Err(db.Commit())
- }
- scope.db.db = scope.db.parent.db
- }
- }
- return scope
- }
- ////////////////////////////////////////////////////////////////////////////////
- // Private Methods For *gorm.Scope
- ////////////////////////////////////////////////////////////////////////////////
- func (scope *Scope) callMethod(methodName string, reflectValue reflect.Value) {
- // Only get address from non-pointer
- if reflectValue.CanAddr() && reflectValue.Kind() != reflect.Ptr {
- reflectValue = reflectValue.Addr()
- }
- if methodValue := reflectValue.MethodByName(methodName); methodValue.IsValid() {
- switch method := methodValue.Interface().(type) {
- case func():
- method()
- case func(*Scope):
- method(scope)
- case func(*DB):
- newDB := scope.NewDB()
- method(newDB)
- scope.Err(newDB.Error)
- case func() error:
- scope.Err(method())
- case func(*Scope) error:
- scope.Err(method(scope))
- case func(*DB) error:
- newDB := scope.NewDB()
- scope.Err(method(newDB))
- scope.Err(newDB.Error)
- default:
- scope.Err(fmt.Errorf("unsupported function %v", methodName))
- }
- }
- }
- var (
- columnRegexp = regexp.MustCompile("^[a-zA-Z\\d]+(\\.[a-zA-Z\\d]+)*$") // only match string like `name`, `users.name`
- isNumberRegexp = regexp.MustCompile("^\\s*\\d+\\s*$") // match if string is number
- comparisonRegexp = regexp.MustCompile("(?i) (=|<>|(>|<)(=?)|LIKE|IS|IN) ")
- countingQueryRegexp = regexp.MustCompile("(?i)^count(.+)$")
- )
- func (scope *Scope) quoteIfPossible(str string) string {
- if columnRegexp.MatchString(str) {
- return scope.Quote(str)
- }
- return str
- }
- func (scope *Scope) scan(rows *sql.Rows, columns []string, fields []*Field) {
- var (
- ignored interface{}
- values = make([]interface{}, len(columns))
- selectFields []*Field
- selectedColumnsMap = map[string]int{}
- resetFields = map[int]*Field{}
- )
- for index, column := range columns {
- values[index] = &ignored
- selectFields = fields
- offset := 0
- if idx, ok := selectedColumnsMap[column]; ok {
- offset = idx + 1
- selectFields = selectFields[offset:]
- }
- for fieldIndex, field := range selectFields {
- if field.DBName == column {
- if field.Field.Kind() == reflect.Ptr {
- values[index] = field.Field.Addr().Interface()
- } else {
- reflectValue := reflect.New(reflect.PtrTo(field.Struct.Type))
- reflectValue.Elem().Set(field.Field.Addr())
- values[index] = reflectValue.Interface()
- resetFields[index] = field
- }
- selectedColumnsMap[column] = offset + fieldIndex
- if field.IsNormal {
- break
- }
- }
- }
- }
- scope.Err(rows.Scan(values...))
- for index, field := range resetFields {
- if v := reflect.ValueOf(values[index]).Elem().Elem(); v.IsValid() {
- field.Field.Set(v)
- }
- }
- }
- func (scope *Scope) primaryCondition(value interface{}) string {
- return fmt.Sprintf("(%v.%v = %v)", scope.QuotedTableName(), scope.Quote(scope.PrimaryKey()), value)
- }
- func (scope *Scope) buildCondition(clause map[string]interface{}, include bool) (str string) {
- var (
- quotedTableName = scope.QuotedTableName()
- quotedPrimaryKey = scope.Quote(scope.PrimaryKey())
- equalSQL = "="
- inSQL = "IN"
- )
- // If building not conditions
- if !include {
- equalSQL = "<>"
- inSQL = "NOT IN"
- }
- switch value := clause["query"].(type) {
- case sql.NullInt64:
- return fmt.Sprintf("(%v.%v %s %v)", quotedTableName, quotedPrimaryKey, equalSQL, value.Int64)
- case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
- return fmt.Sprintf("(%v.%v %s %v)", quotedTableName, quotedPrimaryKey, equalSQL, value)
- case []int, []int8, []int16, []int32, []int64, []uint, []uint8, []uint16, []uint32, []uint64, []string, []interface{}:
- if !include && reflect.ValueOf(value).Len() == 0 {
- return
- }
- str = fmt.Sprintf("(%v.%v %s (?))", quotedTableName, quotedPrimaryKey, inSQL)
- clause["args"] = []interface{}{value}
- case string:
- if isNumberRegexp.MatchString(value) {
- return fmt.Sprintf("(%v.%v %s %v)", quotedTableName, quotedPrimaryKey, equalSQL, scope.AddToVars(value))
- }
- if value != "" {
- if !include {
- if comparisonRegexp.MatchString(value) {
- str = fmt.Sprintf("NOT (%v)", value)
- } else {
- str = fmt.Sprintf("(%v.%v NOT IN (?))", quotedTableName, scope.Quote(value))
- }
- } else {
- str = fmt.Sprintf("(%v)", value)
- }
- }
- case map[string]interface{}:
- var sqls []string
- for key, value := range value {
- if value != nil {
- sqls = append(sqls, fmt.Sprintf("(%v.%v %s %v)", quotedTableName, scope.Quote(key), equalSQL, scope.AddToVars(value)))
- } else {
- if !include {
- sqls = append(sqls, fmt.Sprintf("(%v.%v IS NOT NULL)", quotedTableName, scope.Quote(key)))
- } else {
- sqls = append(sqls, fmt.Sprintf("(%v.%v IS NULL)", quotedTableName, scope.Quote(key)))
- }
- }
- }
- return strings.Join(sqls, " AND ")
- case interface{}:
- var sqls []string
- newScope := scope.New(value)
- if len(newScope.Fields()) == 0 {
- scope.Err(fmt.Errorf("invalid query condition: %v", value))
- return
- }
- scopeQuotedTableName := newScope.QuotedTableName()
- for _, field := range newScope.Fields() {
- if !field.IsIgnored && !field.IsBlank {
- sqls = append(sqls, fmt.Sprintf("(%v.%v %s %v)", scopeQuotedTableName, scope.Quote(field.DBName), equalSQL, scope.AddToVars(field.Field.Interface())))
- }
- }
- return strings.Join(sqls, " AND ")
- default:
- scope.Err(fmt.Errorf("invalid query condition: %v", value))
- return
- }
- replacements := []string{}
- args := clause["args"].([]interface{})
- for _, arg := range args {
- var err error
- switch reflect.ValueOf(arg).Kind() {
- case reflect.Slice: // For where("id in (?)", []int64{1,2})
- if scanner, ok := interface{}(arg).(driver.Valuer); ok {
- arg, err = scanner.Value()
- replacements = append(replacements, scope.AddToVars(arg))
- } else if b, ok := arg.([]byte); ok {
- replacements = append(replacements, scope.AddToVars(b))
- } else if as, ok := arg.([][]interface{}); ok {
- var tempMarks []string
- for _, a := range as {
- var arrayMarks []string
- for _, v := range a {
- arrayMarks = append(arrayMarks, scope.AddToVars(v))
- }
- if len(arrayMarks) > 0 {
- tempMarks = append(tempMarks, fmt.Sprintf("(%v)", strings.Join(arrayMarks, ",")))
- }
- }
- if len(tempMarks) > 0 {
- replacements = append(replacements, strings.Join(tempMarks, ","))
- }
- } else if values := reflect.ValueOf(arg); values.Len() > 0 {
- var tempMarks []string
- for i := 0; i < values.Len(); i++ {
- tempMarks = append(tempMarks, scope.AddToVars(values.Index(i).Interface()))
- }
- replacements = append(replacements, strings.Join(tempMarks, ","))
- } else {
- replacements = append(replacements, scope.AddToVars(Expr("NULL")))
- }
- default:
- if valuer, ok := interface{}(arg).(driver.Valuer); ok {
- arg, err = valuer.Value()
- }
- replacements = append(replacements, scope.AddToVars(arg))
- }
- if err != nil {
- scope.Err(err)
- }
- }
- buff := bytes.NewBuffer([]byte{})
- i := 0
- for _, s := range str {
- if s == '?' && len(replacements) > i {
- buff.WriteString(replacements[i])
- i++
- } else {
- buff.WriteRune(s)
- }
- }
- str = buff.String()
- return
- }
- func (scope *Scope) buildSelectQuery(clause map[string]interface{}) (str string) {
- switch value := clause["query"].(type) {
- case string:
- str = value
- case []string:
- str = strings.Join(value, ", ")
- }
- args := clause["args"].([]interface{})
- replacements := []string{}
- for _, arg := range args {
- switch reflect.ValueOf(arg).Kind() {
- case reflect.Slice:
- values := reflect.ValueOf(arg)
- var tempMarks []string
- for i := 0; i < values.Len(); i++ {
- tempMarks = append(tempMarks, scope.AddToVars(values.Index(i).Interface()))
- }
- replacements = append(replacements, strings.Join(tempMarks, ","))
- default:
- if valuer, ok := interface{}(arg).(driver.Valuer); ok {
- arg, _ = valuer.Value()
- }
- replacements = append(replacements, scope.AddToVars(arg))
- }
- }
- buff := bytes.NewBuffer([]byte{})
- i := 0
- for pos, char := range str {
- if str[pos] == '?' {
- buff.WriteString(replacements[i])
- i++
- } else {
- buff.WriteRune(char)
- }
- }
- str = buff.String()
- return
- }
- func (scope *Scope) whereSQL() (sql string) {
- var (
- quotedTableName = scope.QuotedTableName()
- deletedAtField, hasDeletedAtField = scope.FieldByName("DeletedAt")
- primaryConditions, andConditions, orConditions []string
- )
- if !scope.Search.Unscoped && hasDeletedAtField {
- sql := fmt.Sprintf("%v.%v IS NULL", quotedTableName, scope.Quote(deletedAtField.DBName))
- primaryConditions = append(primaryConditions, sql)
- }
- if !scope.PrimaryKeyZero() {
- for _, field := range scope.PrimaryFields() {
- sql := fmt.Sprintf("%v.%v = %v", quotedTableName, scope.Quote(field.DBName), scope.AddToVars(field.Field.Interface()))
- primaryConditions = append(primaryConditions, sql)
- }
- }
- for _, clause := range scope.Search.whereConditions {
- if sql := scope.buildCondition(clause, true); sql != "" {
- andConditions = append(andConditions, sql)
- }
- }
- for _, clause := range scope.Search.orConditions {
- if sql := scope.buildCondition(clause, true); sql != "" {
- orConditions = append(orConditions, sql)
- }
- }
- for _, clause := range scope.Search.notConditions {
- if sql := scope.buildCondition(clause, false); sql != "" {
- andConditions = append(andConditions, sql)
- }
- }
- orSQL := strings.Join(orConditions, " OR ")
- combinedSQL := strings.Join(andConditions, " AND ")
- if len(combinedSQL) > 0 {
- if len(orSQL) > 0 {
- combinedSQL = combinedSQL + " OR " + orSQL
- }
- } else {
- combinedSQL = orSQL
- }
- if len(primaryConditions) > 0 {
- sql = "WHERE " + strings.Join(primaryConditions, " AND ")
- if len(combinedSQL) > 0 {
- sql = sql + " AND (" + combinedSQL + ")"
- }
- } else if len(combinedSQL) > 0 {
- sql = "WHERE " + combinedSQL
- }
- return
- }
- func (scope *Scope) selectSQL() string {
- if len(scope.Search.selects) == 0 {
- if len(scope.Search.joinConditions) > 0 {
- return fmt.Sprintf("%v.*", scope.QuotedTableName())
- }
- return "*"
- }
- return scope.buildSelectQuery(scope.Search.selects)
- }
- func (scope *Scope) orderSQL() string {
- if len(scope.Search.orders) == 0 || scope.Search.ignoreOrderQuery {
- return ""
- }
- var orders []string
- for _, order := range scope.Search.orders {
- if str, ok := order.(string); ok {
- orders = append(orders, scope.quoteIfPossible(str))
- } else if expr, ok := order.(*expr); ok {
- exp := expr.expr
- for _, arg := range expr.args {
- exp = strings.Replace(exp, "?", scope.AddToVars(arg), 1)
- }
- orders = append(orders, exp)
- }
- }
- return " ORDER BY " + strings.Join(orders, ",")
- }
- func (scope *Scope) limitAndOffsetSQL() string {
- return scope.Dialect().LimitAndOffsetSQL(scope.Search.limit, scope.Search.offset)
- }
- func (scope *Scope) groupSQL() string {
- if len(scope.Search.group) == 0 {
- return ""
- }
- return " GROUP BY " + scope.Search.group
- }
- func (scope *Scope) havingSQL() string {
- if len(scope.Search.havingConditions) == 0 {
- return ""
- }
- var andConditions []string
- for _, clause := range scope.Search.havingConditions {
- if sql := scope.buildCondition(clause, true); sql != "" {
- andConditions = append(andConditions, sql)
- }
- }
- combinedSQL := strings.Join(andConditions, " AND ")
- if len(combinedSQL) == 0 {
- return ""
- }
- return " HAVING " + combinedSQL
- }
- func (scope *Scope) joinsSQL() string {
- var joinConditions []string
- for _, clause := range scope.Search.joinConditions {
- if sql := scope.buildCondition(clause, true); sql != "" {
- joinConditions = append(joinConditions, strings.TrimSuffix(strings.TrimPrefix(sql, "("), ")"))
- }
- }
- return strings.Join(joinConditions, " ") + " "
- }
- func (scope *Scope) prepareQuerySQL() {
- if scope.Search.raw {
- scope.Raw(scope.CombinedConditionSql())
- } else {
- scope.Raw(fmt.Sprintf("SELECT %v FROM %v %v", scope.selectSQL(), scope.QuotedTableName(), scope.CombinedConditionSql()))
- }
- return
- }
- func (scope *Scope) inlineCondition(values ...interface{}) *Scope {
- if len(values) > 0 {
- scope.Search.Where(values[0], values[1:]...)
- }
- return scope
- }
- func (scope *Scope) callCallbacks(funcs []*func(s *Scope)) *Scope {
- defer func() {
- if err := recover(); err != nil {
- if db, ok := scope.db.db.(sqlTx); ok {
- db.Rollback()
- }
- panic(err)
- }
- }()
- for _, f := range funcs {
- (*f)(scope)
- if scope.skipLeft {
- break
- }
- }
- return scope
- }
- func convertInterfaceToMap(values interface{}, withIgnoredField bool, db *DB) map[string]interface{} {
- var attrs = map[string]interface{}{}
- switch value := values.(type) {
- case map[string]interface{}:
- return value
- case []interface{}:
- for _, v := range value {
- for key, value := range convertInterfaceToMap(v, withIgnoredField, db) {
- attrs[key] = value
- }
- }
- case interface{}:
- reflectValue := reflect.ValueOf(values)
- switch reflectValue.Kind() {
- case reflect.Map:
- for _, key := range reflectValue.MapKeys() {
- attrs[ToColumnName(key.Interface().(string))] = reflectValue.MapIndex(key).Interface()
- }
- default:
- for _, field := range (&Scope{Value: values, db: db}).Fields() {
- if !field.IsBlank && (withIgnoredField || !field.IsIgnored) {
- attrs[field.DBName] = field.Field.Interface()
- }
- }
- }
- }
- return attrs
- }
- func (scope *Scope) updatedAttrsWithValues(value interface{}) (results map[string]interface{}, hasUpdate bool) {
- if scope.IndirectValue().Kind() != reflect.Struct {
- return convertInterfaceToMap(value, false, scope.db), true
- }
- results = map[string]interface{}{}
- for key, value := range convertInterfaceToMap(value, true, scope.db) {
- if field, ok := scope.FieldByName(key); ok && scope.changeableField(field) {
- if _, ok := value.(*expr); ok {
- hasUpdate = true
- results[field.DBName] = value
- } else {
- err := field.Set(value)
- if field.IsNormal && !field.IsIgnored {
- hasUpdate = true
- if err == ErrUnaddressable {
- results[field.DBName] = value
- } else {
- results[field.DBName] = field.Field.Interface()
- }
- }
- }
- }
- }
- return
- }
- func (scope *Scope) row() *sql.Row {
- defer scope.trace(NowFunc())
- result := &RowQueryResult{}
- scope.InstanceSet("row_query_result", result)
- scope.callCallbacks(scope.db.parent.callbacks.rowQueries)
- return result.Row
- }
- func (scope *Scope) rows() (*sql.Rows, error) {
- defer scope.trace(NowFunc())
- result := &RowsQueryResult{}
- scope.InstanceSet("row_query_result", result)
- scope.callCallbacks(scope.db.parent.callbacks.rowQueries)
- return result.Rows, result.Error
- }
- func (scope *Scope) initialize() *Scope {
- for _, clause := range scope.Search.whereConditions {
- scope.updatedAttrsWithValues(clause["query"])
- }
- scope.updatedAttrsWithValues(scope.Search.initAttrs)
- scope.updatedAttrsWithValues(scope.Search.assignAttrs)
- return scope
- }
- func (scope *Scope) isQueryForColumn(query interface{}, column string) bool {
- queryStr := strings.ToLower(fmt.Sprint(query))
- if queryStr == column {
- return true
- }
- if strings.HasSuffix(queryStr, "as "+column) {
- return true
- }
- if strings.HasSuffix(queryStr, "as "+scope.Quote(column)) {
- return true
- }
- return false
- }
- func (scope *Scope) pluck(column string, value interface{}) *Scope {
- dest := reflect.Indirect(reflect.ValueOf(value))
- if dest.Kind() != reflect.Slice {
- scope.Err(fmt.Errorf("results should be a slice, not %s", dest.Kind()))
- return scope
- }
- if dest.Len() > 0 {
- dest.Set(reflect.Zero(dest.Type()))
- }
- if query, ok := scope.Search.selects["query"]; !ok || !scope.isQueryForColumn(query, column) {
- scope.Search.Select(column)
- }
- rows, err := scope.rows()
- if scope.Err(err) == nil {
- defer rows.Close()
- for rows.Next() {
- elem := reflect.New(dest.Type().Elem()).Interface()
- scope.Err(rows.Scan(elem))
- dest.Set(reflect.Append(dest, reflect.ValueOf(elem).Elem()))
- }
- if err := rows.Err(); err != nil {
- scope.Err(err)
- }
- }
- return scope
- }
- func (scope *Scope) count(value interface{}) *Scope {
- if query, ok := scope.Search.selects["query"]; !ok || !countingQueryRegexp.MatchString(fmt.Sprint(query)) {
- if len(scope.Search.group) != 0 {
- if len(scope.Search.havingConditions) != 0 {
- scope.prepareQuerySQL()
- scope.Search = &search{}
- scope.Search.Select("count(*)")
- scope.Search.Table(fmt.Sprintf("( %s ) AS count_table", scope.SQL))
- } else {
- scope.Search.Select("count(*) FROM ( SELECT count(*) as name ")
- scope.Search.group += " ) AS count_table"
- }
- } else {
- scope.Search.Select("count(*)")
- }
- }
- scope.Search.ignoreOrderQuery = true
- scope.Err(scope.row().Scan(value))
- return scope
- }
- func (scope *Scope) typeName() string {
- typ := scope.IndirectValue().Type()
- for typ.Kind() == reflect.Slice || typ.Kind() == reflect.Ptr {
- typ = typ.Elem()
- }
- return typ.Name()
- }
- // trace print sql log
- func (scope *Scope) trace(t time.Time) {
- if len(scope.SQL) > 0 {
- scope.db.slog(scope.SQL, t, scope.SQLVars...)
- }
- }
- func (scope *Scope) changeableField(field *Field) bool {
- if selectAttrs := scope.SelectAttrs(); len(selectAttrs) > 0 {
- for _, attr := range selectAttrs {
- if field.Name == attr || field.DBName == attr {
- return true
- }
- }
- return false
- }
- for _, attr := range scope.OmitAttrs() {
- if field.Name == attr || field.DBName == attr {
- return false
- }
- }
- return true
- }
- func (scope *Scope) related(value interface{}, foreignKeys ...string) *Scope {
- toScope := scope.db.NewScope(value)
- tx := scope.db.Set("gorm:association:source", scope.Value)
- for _, foreignKey := range append(foreignKeys, toScope.typeName()+"Id", scope.typeName()+"Id") {
- fromField, _ := scope.FieldByName(foreignKey)
- toField, _ := toScope.FieldByName(foreignKey)
- if fromField != nil {
- if relationship := fromField.Relationship; relationship != nil {
- if relationship.Kind == "many_to_many" {
- joinTableHandler := relationship.JoinTableHandler
- scope.Err(joinTableHandler.JoinWith(joinTableHandler, tx, scope.Value).Find(value).Error)
- } else if relationship.Kind == "belongs_to" {
- for idx, foreignKey := range relationship.ForeignDBNames {
- if field, ok := scope.FieldByName(foreignKey); ok {
- tx = tx.Where(fmt.Sprintf("%v = ?", scope.Quote(relationship.AssociationForeignDBNames[idx])), field.Field.Interface())
- }
- }
- scope.Err(tx.Find(value).Error)
- } else if relationship.Kind == "has_many" || relationship.Kind == "has_one" {
- for idx, foreignKey := range relationship.ForeignDBNames {
- if field, ok := scope.FieldByName(relationship.AssociationForeignDBNames[idx]); ok {
- tx = tx.Where(fmt.Sprintf("%v = ?", scope.Quote(foreignKey)), field.Field.Interface())
- }
- }
- if relationship.PolymorphicType != "" {
- tx = tx.Where(fmt.Sprintf("%v = ?", scope.Quote(relationship.PolymorphicDBName)), relationship.PolymorphicValue)
- }
- scope.Err(tx.Find(value).Error)
- }
- } else {
- sql := fmt.Sprintf("%v = ?", scope.Quote(toScope.PrimaryKey()))
- scope.Err(tx.Where(sql, fromField.Field.Interface()).Find(value).Error)
- }
- return scope
- } else if toField != nil {
- sql := fmt.Sprintf("%v = ?", scope.Quote(toField.DBName))
- scope.Err(tx.Where(sql, scope.PrimaryKeyValue()).Find(value).Error)
- return scope
- }
- }
- scope.Err(fmt.Errorf("invalid association %v", foreignKeys))
- return scope
- }
- // getTableOptions return the table options string or an empty string if the table options does not exist
- func (scope *Scope) getTableOptions() string {
- tableOptions, ok := scope.Get("gorm:table_options")
- if !ok {
- return ""
- }
- return " " + tableOptions.(string)
- }
- func (scope *Scope) createJoinTable(field *StructField) {
- if relationship := field.Relationship; relationship != nil && relationship.JoinTableHandler != nil {
- joinTableHandler := relationship.JoinTableHandler
- joinTable := joinTableHandler.Table(scope.db)
- if !scope.Dialect().HasTable(joinTable) {
- toScope := &Scope{Value: reflect.New(field.Struct.Type).Interface()}
- var sqlTypes, primaryKeys []string
- for idx, fieldName := range relationship.ForeignFieldNames {
- if field, ok := scope.FieldByName(fieldName); ok {
- foreignKeyStruct := field.clone()
- foreignKeyStruct.IsPrimaryKey = false
- foreignKeyStruct.TagSettingsSet("IS_JOINTABLE_FOREIGNKEY", "true")
- foreignKeyStruct.TagSettingsDelete("AUTO_INCREMENT")
- sqlTypes = append(sqlTypes, scope.Quote(relationship.ForeignDBNames[idx])+" "+scope.Dialect().DataTypeOf(foreignKeyStruct))
- primaryKeys = append(primaryKeys, scope.Quote(relationship.ForeignDBNames[idx]))
- }
- }
- for idx, fieldName := range relationship.AssociationForeignFieldNames {
- if field, ok := toScope.FieldByName(fieldName); ok {
- foreignKeyStruct := field.clone()
- foreignKeyStruct.IsPrimaryKey = false
- foreignKeyStruct.TagSettingsSet("IS_JOINTABLE_FOREIGNKEY", "true")
- foreignKeyStruct.TagSettingsDelete("AUTO_INCREMENT")
- sqlTypes = append(sqlTypes, scope.Quote(relationship.AssociationForeignDBNames[idx])+" "+scope.Dialect().DataTypeOf(foreignKeyStruct))
- primaryKeys = append(primaryKeys, scope.Quote(relationship.AssociationForeignDBNames[idx]))
- }
- }
- scope.Err(scope.NewDB().Exec(fmt.Sprintf("CREATE TABLE %v (%v, PRIMARY KEY (%v))%s", scope.Quote(joinTable), strings.Join(sqlTypes, ","), strings.Join(primaryKeys, ","), scope.getTableOptions())).Error)
- }
- scope.NewDB().Table(joinTable).AutoMigrate(joinTableHandler)
- }
- }
- func (scope *Scope) createTable() *Scope {
- var tags []string
- var primaryKeys []string
- var primaryKeyInColumnType = false
- for _, field := range scope.GetModelStruct().StructFields {
- if field.IsNormal {
- sqlTag := scope.Dialect().DataTypeOf(field)
- // Check if the primary key constraint was specified as
- // part of the column type. If so, we can only support
- // one column as the primary key.
- if strings.Contains(strings.ToLower(sqlTag), "primary key") {
- primaryKeyInColumnType = true
- }
- tags = append(tags, scope.Quote(field.DBName)+" "+sqlTag)
- }
- if field.IsPrimaryKey {
- primaryKeys = append(primaryKeys, scope.Quote(field.DBName))
- }
- scope.createJoinTable(field)
- }
- var primaryKeyStr string
- if len(primaryKeys) > 0 && !primaryKeyInColumnType {
- primaryKeyStr = fmt.Sprintf(", PRIMARY KEY (%v)", strings.Join(primaryKeys, ","))
- }
- scope.Raw(fmt.Sprintf("CREATE TABLE %v (%v %v)%s", scope.QuotedTableName(), strings.Join(tags, ","), primaryKeyStr, scope.getTableOptions())).Exec()
- scope.autoIndex()
- return scope
- }
- func (scope *Scope) dropTable() *Scope {
- scope.Raw(fmt.Sprintf("DROP TABLE %v", scope.QuotedTableName())).Exec()
- return scope
- }
- func (scope *Scope) modifyColumn(column string, typ string) {
- scope.db.AddError(scope.Dialect().ModifyColumn(scope.QuotedTableName(), scope.Quote(column), typ))
- }
- func (scope *Scope) dropColumn(column string) {
- scope.Raw(fmt.Sprintf("ALTER TABLE %v DROP COLUMN %v", scope.QuotedTableName(), scope.Quote(column))).Exec()
- }
- func (scope *Scope) addIndex(unique bool, indexName string, column ...string) {
- if scope.Dialect().HasIndex(scope.TableName(), indexName) {
- return
- }
- var columns []string
- for _, name := range column {
- columns = append(columns, scope.quoteIfPossible(name))
- }
- sqlCreate := "CREATE INDEX"
- if unique {
- sqlCreate = "CREATE UNIQUE INDEX"
- }
- scope.Raw(fmt.Sprintf("%s %v ON %v(%v) %v", sqlCreate, indexName, scope.QuotedTableName(), strings.Join(columns, ", "), scope.whereSQL())).Exec()
- }
- func (scope *Scope) addForeignKey(field string, dest string, onDelete string, onUpdate string) {
- // Compatible with old generated key
- keyName := scope.Dialect().BuildKeyName(scope.TableName(), field, dest, "foreign")
- if scope.Dialect().HasForeignKey(scope.TableName(), keyName) {
- return
- }
- var query = `ALTER TABLE %s ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s ON DELETE %s ON UPDATE %s;`
- scope.Raw(fmt.Sprintf(query, scope.QuotedTableName(), scope.quoteIfPossible(keyName), scope.quoteIfPossible(field), dest, onDelete, onUpdate)).Exec()
- }
- func (scope *Scope) removeForeignKey(field string, dest string) {
- keyName := scope.Dialect().BuildKeyName(scope.TableName(), field, dest, "foreign")
- if !scope.Dialect().HasForeignKey(scope.TableName(), keyName) {
- return
- }
- var mysql mysql
- var query string
- if scope.Dialect().GetName() == mysql.GetName() {
- query = `ALTER TABLE %s DROP FOREIGN KEY %s;`
- } else {
- query = `ALTER TABLE %s DROP CONSTRAINT %s;`
- }
- scope.Raw(fmt.Sprintf(query, scope.QuotedTableName(), scope.quoteIfPossible(keyName))).Exec()
- }
- func (scope *Scope) removeIndex(indexName string) {
- scope.Dialect().RemoveIndex(scope.TableName(), indexName)
- }
- func (scope *Scope) autoMigrate() *Scope {
- tableName := scope.TableName()
- quotedTableName := scope.QuotedTableName()
- if !scope.Dialect().HasTable(tableName) {
- scope.createTable()
- } else {
- for _, field := range scope.GetModelStruct().StructFields {
- if !scope.Dialect().HasColumn(tableName, field.DBName) {
- if field.IsNormal {
- sqlTag := scope.Dialect().DataTypeOf(field)
- scope.Raw(fmt.Sprintf("ALTER TABLE %v ADD %v %v;", quotedTableName, scope.Quote(field.DBName), sqlTag)).Exec()
- }
- }
- scope.createJoinTable(field)
- }
- scope.autoIndex()
- }
- return scope
- }
- func (scope *Scope) autoIndex() *Scope {
- var indexes = map[string][]string{}
- var uniqueIndexes = map[string][]string{}
- for _, field := range scope.GetStructFields() {
- if name, ok := field.TagSettingsGet("INDEX"); ok {
- names := strings.Split(name, ",")
- for _, name := range names {
- if name == "INDEX" || name == "" {
- name = scope.Dialect().BuildKeyName("idx", scope.TableName(), field.DBName)
- }
- name, column := scope.Dialect().NormalizeIndexAndColumn(name, field.DBName)
- indexes[name] = append(indexes[name], column)
- }
- }
- if name, ok := field.TagSettingsGet("UNIQUE_INDEX"); ok {
- names := strings.Split(name, ",")
- for _, name := range names {
- if name == "UNIQUE_INDEX" || name == "" {
- name = scope.Dialect().BuildKeyName("uix", scope.TableName(), field.DBName)
- }
- name, column := scope.Dialect().NormalizeIndexAndColumn(name, field.DBName)
- uniqueIndexes[name] = append(uniqueIndexes[name], column)
- }
- }
- }
- for name, columns := range indexes {
- if db := scope.NewDB().Table(scope.TableName()).Model(scope.Value).AddIndex(name, columns...); db.Error != nil {
- scope.db.AddError(db.Error)
- }
- }
- for name, columns := range uniqueIndexes {
- if db := scope.NewDB().Table(scope.TableName()).Model(scope.Value).AddUniqueIndex(name, columns...); db.Error != nil {
- scope.db.AddError(db.Error)
- }
- }
- return scope
- }
- func (scope *Scope) getColumnAsArray(columns []string, values ...interface{}) (results [][]interface{}) {
- resultMap := make(map[string][]interface{})
- for _, value := range values {
- indirectValue := indirect(reflect.ValueOf(value))
- switch indirectValue.Kind() {
- case reflect.Slice:
- for i := 0; i < indirectValue.Len(); i++ {
- var result []interface{}
- var object = indirect(indirectValue.Index(i))
- var hasValue = false
- for _, column := range columns {
- field := object.FieldByName(column)
- if hasValue || !isBlank(field) {
- hasValue = true
- }
- result = append(result, field.Interface())
- }
- if hasValue {
- h := fmt.Sprint(result...)
- if _, exist := resultMap[h]; !exist {
- resultMap[h] = result
- }
- }
- }
- case reflect.Struct:
- var result []interface{}
- var hasValue = false
- for _, column := range columns {
- field := indirectValue.FieldByName(column)
- if hasValue || !isBlank(field) {
- hasValue = true
- }
- result = append(result, field.Interface())
- }
- if hasValue {
- h := fmt.Sprint(result...)
- if _, exist := resultMap[h]; !exist {
- resultMap[h] = result
- }
- }
- }
- }
- for _, v := range resultMap {
- results = append(results, v)
- }
- return
- }
- func (scope *Scope) getColumnAsScope(column string) *Scope {
- indirectScopeValue := scope.IndirectValue()
- switch indirectScopeValue.Kind() {
- case reflect.Slice:
- if fieldStruct, ok := scope.GetModelStruct().ModelType.FieldByName(column); ok {
- fieldType := fieldStruct.Type
- if fieldType.Kind() == reflect.Slice || fieldType.Kind() == reflect.Ptr {
- fieldType = fieldType.Elem()
- }
- resultsMap := map[interface{}]bool{}
- results := reflect.New(reflect.SliceOf(reflect.PtrTo(fieldType))).Elem()
- for i := 0; i < indirectScopeValue.Len(); i++ {
- result := indirect(indirect(indirectScopeValue.Index(i)).FieldByName(column))
- if result.Kind() == reflect.Slice {
- for j := 0; j < result.Len(); j++ {
- if elem := result.Index(j); elem.CanAddr() && resultsMap[elem.Addr()] != true {
- resultsMap[elem.Addr()] = true
- results = reflect.Append(results, elem.Addr())
- }
- }
- } else if result.CanAddr() && resultsMap[result.Addr()] != true {
- resultsMap[result.Addr()] = true
- results = reflect.Append(results, result.Addr())
- }
- }
- return scope.New(results.Interface())
- }
- case reflect.Struct:
- if field := indirectScopeValue.FieldByName(column); field.CanAddr() {
- return scope.New(field.Addr().Interface())
- }
- }
- return nil
- }
- func (scope *Scope) hasConditions() bool {
- return !scope.PrimaryKeyZero() ||
- len(scope.Search.whereConditions) > 0 ||
- len(scope.Search.orConditions) > 0 ||
- len(scope.Search.notConditions) > 0
- }
|