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

   1 package gorm
   2
   3 import (
   4         "fmt"
   5 )
   6
   7 type search struct {
   8         db               *DB
   9         whereConditions  []map[string]interface{}
  10         orConditions     []map[string]interface{}
  11         notConditions    []map[string]interface{}
  12         havingConditions []map[string]interface{}
  13         joinConditions   []map[string]interface{}
  14         initAttrs        []interface{}
  15         assignAttrs      []interface{}
  16         selects          map[string]interface{}
  17         omits            []string
  18         orders           []interface{}
  19         preload          []searchPreload
  20         offset           interface{}
  21         limit            interface{}
  22         group            string
  23         tableName        string
  24         raw              bool
  25         Unscoped         bool
  26         ignoreOrderQuery bool
  27 }
  28
  29 type searchPreload struct {
  30         schema     string
  31         conditions []interface{}
  32 }
  33
  34 func (s *search) clone() *search {
  35         clone := *s
  36         return &clone
  37 }
  38
  39 func (s *search) Where(query interface{}, values ...interface{}) *search {
  40         s.whereConditions = append(s.whereConditions, map[string]interface{}{"query": query, "args": values})
  41         return s
  42 }
  43
  44 func (s *search) Not(query interface{}, values ...interface{}) *search {
  45         s.notConditions = append(s.notConditions, map[string]interface{}{"query": query, "args": values})
  46         return s
  47 }
  48
  49 func (s *search) Or(query interface{}, values ...interface{}) *search {
  50         s.orConditions = append(s.orConditions, map[string]interface{}{"query": query, "args": values})
  51         return s
  52 }
  53
  54 func (s *search) Attrs(attrs ...interface{}) *search {
  55         s.initAttrs = append(s.initAttrs, toSearchableMap(attrs...))
  56         return s
  57 }
  58
  59 func (s *search) Assign(attrs ...interface{}) *search {
  60         s.assignAttrs = append(s.assignAttrs, toSearchableMap(attrs...))
  61         return s
  62 }
  63
  64 func (s *search) Order(value interface{}, reorder ...bool) *search {
  65         if len(reorder) > 0 && reorder[0] {
  66                 s.orders = []interface{}{}
  67         }
  68
  69         if value != nil && value != "" {
  70                 s.orders = append(s.orders, value)
  71         }
  72         return s
  73 }
  74
  75 func (s *search) Select(query interface{}, args ...interface{}) *search {
  76         s.selects = map[string]interface{}{"query": query, "args": args}
  77         return s
  78 }
  79
  80 func (s *search) Omit(columns ...string) *search {
  81         s.omits = columns
  82         return s
  83 }
  84
  85 func (s *search) Limit(limit interface{}) *search {
  86         s.limit = limit
  87         return s
  88 }
  89
  90 func (s *search) Offset(offset interface{}) *search {
  91         s.offset = offset
  92         return s
  93 }
  94
  95 func (s *search) Group(query string) *search {
  96         s.group = s.getInterfaceAsSQL(query)
  97         return s
  98 }
  99
 100 func (s *search) Having(query interface{}, values ...interface{}) *search {
 101         if val, ok := query.(*expr); ok {
 102                 s.havingConditions = append(s.havingConditions, map[string]interface{}{"query": val.expr, "args": val.args})
 103         } else {
 104                 s.havingConditions = append(s.havingConditions, map[string]interface{}{"query": query, "args": values})
 105         }
 106         return s
 107 }
 108
 109 func (s *search) Joins(query string, values ...interface{}) *search {
 110         s.joinConditions = append(s.joinConditions, map[string]interface{}{"query": query, "args": values})
 111         return s
 112 }
 113
 114 func (s *search) Preload(schema string, values ...interface{}) *search {
 115         var preloads []searchPreload
 116         for _, preload := range s.preload {
 117                 if preload.schema != schema {
 118                         preloads = append(preloads, preload)
 119                 }
 120         }
 121         preloads = append(preloads, searchPreload{schema, values})
 122         s.preload = preloads
 123         return s
 124 }
 125
 126 func (s *search) Raw(b bool) *search {
 127         s.raw = b
 128         return s
 129 }
 130
 131 func (s *search) unscoped() *search {
 132         s.Unscoped = true
 133         return s
 134 }
 135
 136 func (s *search) Table(name string) *search {
 137         s.tableName = name
 138         return s
 139 }
 140
 141 func (s *search) getInterfaceAsSQL(value interface{}) (str string) {
 142         switch value.(type) {
 143         case string, int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
 144                 str = fmt.Sprintf("%v", value)
 145         default:
 146                 s.db.AddError(ErrInvalidSQL)
 147         }
 148
 149         if str == "-1" {
 150                 return ""
 151         }
 152         return
 153 }