vendor/github.com/jinzhu/gorm/callback_query.go

   1 package gorm
   2
   3 import (
   4         "errors"
   5         "fmt"
   6         "reflect"
   7 )
   8
   9 // Define callbacks for querying
  10 func init() {
  11         DefaultCallback.Query().Register("gorm:query", queryCallback)
  12         DefaultCallback.Query().Register("gorm:preload", preloadCallback)
  13         DefaultCallback.Query().Register("gorm:after_query", afterQueryCallback)
  14 }
  15
  16 // queryCallback used to query data from database
  17 func queryCallback(scope *Scope) {
  18         if _, skip := scope.InstanceGet("gorm:skip_query_callback"); skip {
  19                 return
  20         }
  21
  22         //we are only preloading relations, dont touch base model
  23         if _, skip := scope.InstanceGet("gorm:only_preload"); skip {
  24                 return
  25         }
  26
  27         defer scope.trace(NowFunc())
  28
  29         var (
  30                 isSlice, isPtr bool
  31                 resultType     reflect.Type
  32                 results        = scope.IndirectValue()
  33         )
  34
  35         if orderBy, ok := scope.Get("gorm:order_by_primary_key"); ok {
  36                 if primaryField := scope.PrimaryField(); primaryField != nil {
  37                         scope.Search.Order(fmt.Sprintf("%v.%v %v", scope.QuotedTableName(), scope.Quote(primaryField.DBName), orderBy))
  38                 }
  39         }
  40
  41         if value, ok := scope.Get("gorm:query_destination"); ok {
  42                 results = indirect(reflect.ValueOf(value))
  43         }
  44
  45         if kind := results.Kind(); kind == reflect.Slice {
  46                 isSlice = true
  47                 resultType = results.Type().Elem()
  48                 results.Set(reflect.MakeSlice(results.Type(), 0, 0))
  49
  50                 if resultType.Kind() == reflect.Ptr {
  51                         isPtr = true
  52                         resultType = resultType.Elem()
  53                 }
  54         } else if kind != reflect.Struct {
  55                 scope.Err(errors.New("unsupported destination, should be slice or struct"))
  56                 return
  57         }
  58
  59         scope.prepareQuerySQL()
  60
  61         if !scope.HasError() {
  62                 scope.db.RowsAffected = 0
  63                 if str, ok := scope.Get("gorm:query_option"); ok {
  64                         scope.SQL += addExtraSpaceIfExist(fmt.Sprint(str))
  65                 }
  66
  67                 if rows, err := scope.SQLDB().Query(scope.SQL, scope.SQLVars...); scope.Err(err) == nil {
  68                         defer rows.Close()
  69
  70                         columns, _ := rows.Columns()
  71                         for rows.Next() {
  72                                 scope.db.RowsAffected++
  73
  74                                 elem := results
  75                                 if isSlice {
  76                                         elem = reflect.New(resultType).Elem()
  77                                 }
  78
  79                                 scope.scan(rows, columns, scope.New(elem.Addr().Interface()).Fields())
  80
  81                                 if isSlice {
  82                                         if isPtr {
  83                                                 results.Set(reflect.Append(results, elem.Addr()))
  84                                         } else {
  85                                                 results.Set(reflect.Append(results, elem))
  86                                         }
  87                                 }
  88                         }
  89
  90                         if err := rows.Err(); err != nil {
  91                                 scope.Err(err)
  92                         } else if scope.db.RowsAffected == 0 && !isSlice {
  93                                 scope.Err(ErrRecordNotFound)
  94                         }
  95                 }
  96         }
  97 }
  98
  99 // afterQueryCallback will invoke `AfterFind` method after querying
 100 func afterQueryCallback(scope *Scope) {
 101         if !scope.HasError() {
 102                 scope.CallMethod("AfterFind")
 103         }
 104 }