gorm/do.go

790 lines
20 KiB
Go
Raw Normal View History

2013-10-26 05:49:40 +04:00
package gorm
import (
2013-10-27 15:41:58 +04:00
"database/sql"
"errors"
2013-10-26 08:33:05 +04:00
"fmt"
2013-10-26 07:59:58 +04:00
"reflect"
2013-10-27 16:54:23 +04:00
"regexp"
"strconv"
2013-10-26 05:49:40 +04:00
"strings"
2013-11-04 16:32:46 +04:00
"time"
2013-10-26 05:49:40 +04:00
)
2013-10-27 15:41:58 +04:00
type Do struct {
2013-10-28 16:27:25 +04:00
chain *Chain
db *sql.DB
driver string
guessedTableName string
specifiedTableName string
2013-11-10 04:14:41 +04:00
debug bool
2013-10-28 16:27:25 +04:00
Errors []error
2013-10-27 15:41:58 +04:00
model *Model
value interface{}
2013-10-29 03:39:26 +04:00
sqlResult sql.Result
sql string
sqlVars []interface{}
2013-10-27 15:41:58 +04:00
whereClause []map[string]interface{}
orClause []map[string]interface{}
2013-10-31 13:31:00 +04:00
notClause []map[string]interface{}
selectStr string
orderStrs []string
offsetStr string
limitStr string
unscoped bool
2013-10-28 17:52:22 +04:00
updateAttrs map[string]interface{}
ignoreProtectedAttrs bool
2013-11-06 17:43:41 +04:00
singularTableName bool
}
2013-10-28 16:27:25 +04:00
func (s *Do) tableName() string {
if s.specifiedTableName == "" {
2013-10-29 03:39:26 +04:00
var err error
2013-11-06 17:43:41 +04:00
s.guessedTableName, err = s.model.tableName(s.singularTableName)
2013-10-29 03:39:26 +04:00
s.err(err)
2013-10-28 16:27:25 +04:00
return s.guessedTableName
} else {
return s.specifiedTableName
}
}
2013-10-29 03:39:26 +04:00
func (s *Do) err(err error) error {
2013-10-27 15:41:58 +04:00
if err != nil {
s.Errors = append(s.Errors, err)
s.chain.err(err)
2013-10-26 07:59:58 +04:00
}
2013-10-29 03:39:26 +04:00
return err
2013-10-26 07:59:58 +04:00
}
2013-10-28 08:12:12 +04:00
func (s *Do) hasError() bool {
return len(s.Errors) > 0
}
2013-11-02 13:29:56 +04:00
func (s *Do) setModel(value interface{}) *Do {
2013-10-29 03:39:26 +04:00
s.model = &Model{data: value, driver: s.driver}
2013-10-27 15:41:58 +04:00
s.value = value
2013-11-02 13:29:56 +04:00
return s
2013-10-26 07:59:58 +04:00
}
2013-10-27 15:41:58 +04:00
func (s *Do) addToVars(value interface{}) string {
2013-10-29 03:39:26 +04:00
s.sqlVars = append(s.sqlVars, value)
2013-11-04 16:32:46 +04:00
if s.driver == "postgres" {
return fmt.Sprintf("$%d", len(s.sqlVars))
} else {
return "?"
}
2013-10-27 15:41:58 +04:00
}
2013-10-26 08:33:05 +04:00
func (s *Do) exec(sql ...string) {
2013-10-28 08:12:12 +04:00
if s.hasError() {
return
}
2013-10-27 15:41:58 +04:00
var err error
if len(sql) == 0 {
if len(s.sql) > 0 {
s.sqlResult, err = s.db.Exec(s.sql, s.sqlVars...)
}
2013-10-27 15:41:58 +04:00
} else {
2013-10-29 03:39:26 +04:00
s.sqlResult, err = s.db.Exec(sql[0])
2013-10-26 08:33:05 +04:00
}
s.err(err)
2013-10-26 05:49:40 +04:00
}
2013-11-02 16:05:05 +04:00
func (s *Do) save() (i int64) {
2013-10-28 11:55:41 +04:00
if s.model.primaryKeyZero() {
2013-11-02 16:05:05 +04:00
return s.create()
2013-10-27 15:41:58 +04:00
} else {
2013-11-02 16:05:05 +04:00
return s.update()
2013-10-27 05:32:49 +04:00
}
2013-10-29 03:39:26 +04:00
return
2013-10-27 05:32:49 +04:00
}
2013-10-29 03:39:26 +04:00
func (s *Do) prepareCreateSql() {
2013-10-28 17:52:22 +04:00
var sqls, columns []string
2013-10-26 19:30:17 +04:00
2013-10-28 17:52:22 +04:00
for key, value := range s.model.columnsAndValues("create") {
columns = append(columns, key)
2013-10-26 19:30:17 +04:00
sqls = append(sqls, s.addToVars(value))
}
2013-10-29 03:39:26 +04:00
s.sql = fmt.Sprintf(
2013-11-03 17:19:38 +04:00
"INSERT INTO %v (%v) VALUES (%v) %v",
2013-10-28 16:27:25 +04:00
s.tableName(),
2013-10-29 03:39:26 +04:00
strings.Join(columns, ","),
2013-10-26 19:30:17 +04:00
strings.Join(sqls, ","),
2013-10-28 11:55:41 +04:00
s.model.returningStr(),
2013-10-26 05:49:40 +04:00
)
2013-10-29 03:39:26 +04:00
return
2013-10-26 05:49:40 +04:00
}
2013-11-02 13:29:56 +04:00
func (s *Do) saveBeforeAssociations() {
for _, field := range s.model.beforeAssociations() {
var id interface{}
2013-11-02 13:29:56 +04:00
do := &Do{chain: s.chain, db: s.db, driver: s.driver}
reflect_value := reflect.ValueOf(field.Value)
if reflect_value.CanAddr() {
id = do.setModel(reflect_value.Addr().Interface()).save()
} else {
dest_value := reflect.New(reflect_value.Type()).Elem()
m := &Model{data: field.Value, driver: s.driver}
for _, f := range m.columnsHasValue("other") {
dest_value.FieldByName(f.Name).Set(reflect.ValueOf(f.Value))
}
id = do.setModel(dest_value.Addr().Interface()).save()
m.setValueByColumn(field.Name, dest_value.Interface(), s.value)
}
2013-11-02 16:05:05 +04:00
if len(field.foreignKey) > 0 {
s.model.setValueByColumn(field.foreignKey, id, s.model.data)
}
2013-11-02 13:29:56 +04:00
}
}
func (s *Do) saveAfterAssociations() {
for _, field := range s.model.afterAssociations() {
reflect_value := reflect.ValueOf(field.Value)
2013-11-05 18:34:49 +04:00
2013-11-02 13:29:56 +04:00
switch reflect.TypeOf(field.Value).Kind() {
case reflect.Slice:
for i := 0; i < reflect_value.Len(); i++ {
2013-11-02 16:05:05 +04:00
value := reflect_value.Index(i).Addr().Interface()
2013-11-02 13:29:56 +04:00
do := &Do{chain: s.chain, db: s.db, driver: s.driver}
2013-11-02 16:05:05 +04:00
if len(field.foreignKey) > 0 {
s.model.setValueByColumn(field.foreignKey, s.model.primaryKeyValue(), value)
}
do.setModel(value).save()
2013-11-02 13:29:56 +04:00
}
default:
do := &Do{chain: s.chain, db: s.db, driver: s.driver}
2013-11-05 18:34:49 +04:00
if reflect_value.CanAddr() {
s.model.setValueByColumn(field.foreignKey, s.model.primaryKeyValue(), field.Value)
do.setModel(field.Value).save()
} else {
dest_value := reflect.New(reflect.TypeOf(field.Value)).Elem()
m := &Model{data: field.Value, driver: s.driver}
for _, f := range m.columnsHasValue("other") {
2013-11-05 18:34:49 +04:00
dest_value.FieldByName(f.Name).Set(reflect.ValueOf(f.Value))
}
setFieldValue(dest_value.FieldByName(field.foreignKey), s.model.primaryKeyValue())
do.setModel(dest_value.Addr().Interface()).save()
m.setValueByColumn(field.Name, dest_value.Interface(), s.value)
2013-11-05 18:34:49 +04:00
}
2013-11-02 13:29:56 +04:00
}
2013-11-02 11:17:11 +04:00
}
}
2013-11-02 16:05:05 +04:00
func (s *Do) create() (i int64) {
2013-10-27 10:51:23 +04:00
s.err(s.model.callMethod("BeforeCreate"))
s.err(s.model.callMethod("BeforeSave"))
2013-10-27 15:41:58 +04:00
2013-11-02 13:29:56 +04:00
s.saveBeforeAssociations()
2013-10-27 15:41:58 +04:00
s.prepareCreateSql()
2013-10-26 16:20:49 +04:00
2013-10-29 03:39:26 +04:00
if !s.hasError() {
2013-10-27 15:41:58 +04:00
var id int64
2013-10-27 12:06:45 +04:00
if s.driver == "postgres" {
2013-10-29 03:39:26 +04:00
s.err(s.db.QueryRow(s.sql, s.sqlVars...).Scan(&id))
2013-10-27 12:06:45 +04:00
} else {
var err error
2013-10-29 03:39:26 +04:00
s.sqlResult, err = s.db.Exec(s.sql, s.sqlVars...)
2013-11-04 16:32:46 +04:00
if s.err(err) == nil {
id, err = s.sqlResult.LastInsertId()
s.err(err)
}
2013-10-27 12:06:45 +04:00
}
2013-10-29 03:39:26 +04:00
if !s.hasError() {
2013-11-02 13:29:56 +04:00
result := reflect.Indirect(reflect.ValueOf(s.value))
2013-11-02 14:25:01 +04:00
if !setFieldValue(result.FieldByName(s.model.primaryKey()), id) {
fmt.Printf("Can't set primary key for %#v\n", result.Interface())
}
2013-11-02 13:29:56 +04:00
s.saveAfterAssociations()
2013-10-29 03:39:26 +04:00
s.err(s.model.callMethod("AfterCreate"))
s.err(s.model.callMethod("AfterSave"))
}
2013-11-02 16:05:05 +04:00
return id
2013-10-27 12:06:45 +04:00
}
2013-10-27 15:41:58 +04:00
2013-10-29 03:39:26 +04:00
return
2013-10-26 16:20:49 +04:00
}
func (s *Do) setUpdateAttrs(values interface{}, ignore_protected_attrs ...bool) *Do {
switch values.(type) {
case map[string]interface{}:
s.updateAttrs = values.(map[string]interface{})
2013-10-31 05:34:27 +04:00
case []interface{}:
for _, value := range values.([]interface{}) {
s.setUpdateAttrs(value, ignore_protected_attrs...)
}
case interface{}:
m := &Model{data: values, driver: s.driver}
2013-11-02 11:17:11 +04:00
fields := m.columnsHasValue("other")
s.updateAttrs = make(map[string]interface{}, len(fields))
for _, field := range fields {
s.updateAttrs[field.DbName] = field.Value
}
}
2013-10-31 04:15:19 +04:00
s.ignoreProtectedAttrs = len(ignore_protected_attrs) > 0 && ignore_protected_attrs[0]
return s
}
func (s *Do) prepareUpdateAttrs() (results map[string]interface{}, update bool) {
if len(s.updateAttrs) > 0 {
results, update = s.model.updatedColumnsAndValues(s.updateAttrs)
2013-10-28 17:52:22 +04:00
}
return
}
2013-10-28 17:52:22 +04:00
func (s *Do) prepareUpdateSql(results map[string]interface{}) {
2013-10-28 17:52:22 +04:00
var sqls []string
for key, value := range results {
sqls = append(sqls, fmt.Sprintf("%v = %v", key, s.addToVars(value)))
}
update_attrs := s.model.columnsAndValues("update")
2013-10-28 17:52:22 +04:00
for key, value := range update_attrs {
2013-10-29 03:39:26 +04:00
sqls = append(sqls, fmt.Sprintf("%v = %v", key, s.addToVars(value)))
2013-10-26 17:37:42 +04:00
}
2013-10-29 03:39:26 +04:00
s.sql = fmt.Sprintf(
2013-10-26 19:30:17 +04:00
"UPDATE %v SET %v %v",
2013-10-28 16:27:25 +04:00
s.tableName(),
2013-10-28 17:52:22 +04:00
strings.Join(sqls, ", "),
2013-10-27 07:21:33 +04:00
s.combinedSql(),
2013-10-26 17:37:42 +04:00
)
2013-10-29 03:39:26 +04:00
return
2013-10-26 16:20:49 +04:00
}
2013-11-02 16:05:05 +04:00
func (s *Do) update() (i int64) {
update_attrs := s.updateAttrs
if len(update_attrs) > 0 {
var need_update bool
update_attrs, need_update = s.prepareUpdateAttrs()
if !need_update {
return
}
}
2013-10-27 10:51:23 +04:00
s.err(s.model.callMethod("BeforeUpdate"))
s.err(s.model.callMethod("BeforeSave"))
2013-10-29 03:39:26 +04:00
2013-11-02 13:29:56 +04:00
s.saveBeforeAssociations()
s.prepareUpdateSql(update_attrs)
2013-10-29 03:39:26 +04:00
if !s.hasError() {
s.exec()
2013-11-02 13:29:56 +04:00
s.saveAfterAssociations()
2013-10-29 03:39:26 +04:00
if !s.hasError() {
s.err(s.model.callMethod("AfterUpdate"))
s.err(s.model.callMethod("AfterSave"))
}
2013-10-27 12:06:45 +04:00
}
2013-11-02 16:05:05 +04:00
return s.model.primaryKeyValue()
2013-10-26 16:20:49 +04:00
}
2013-10-29 03:39:26 +04:00
func (s *Do) prepareDeleteSql() {
s.sql = fmt.Sprintf("DELETE FROM %v %v", s.tableName(), s.combinedSql())
return
2013-10-26 05:49:40 +04:00
}
2013-10-27 10:51:23 +04:00
2013-10-29 03:39:26 +04:00
func (s *Do) delete() {
2013-10-27 10:51:23 +04:00
s.err(s.model.callMethod("BeforeDelete"))
2013-10-29 03:39:26 +04:00
if !s.hasError() {
2013-10-29 06:19:20 +04:00
if !s.unscoped && s.model.hasColumn("DeletedAt") {
delete_sql := "deleted_at=" + s.addToVars(time.Now())
s.sql = fmt.Sprintf("UPDATE %v SET %v %v", s.tableName(), delete_sql, s.combinedSql())
s.exec()
} else {
s.prepareDeleteSql()
s.exec()
}
2013-10-29 03:39:26 +04:00
if !s.hasError() {
s.err(s.model.callMethod("AfterDelete"))
}
2013-10-27 12:06:45 +04:00
}
2013-10-29 03:39:26 +04:00
return
2013-10-27 15:41:58 +04:00
}
2013-10-29 03:39:26 +04:00
func (s *Do) prepareQuerySql() {
s.sql = fmt.Sprintf("SELECT %v FROM %v %v", s.selectSql(), s.tableName(), s.combinedSql())
return
2013-10-27 15:41:58 +04:00
}
func (s *Do) first() {
s.limitStr = "1"
s.orderStrs = append(s.orderStrs, s.model.primaryKeyDb())
s.query()
}
func (s *Do) last() {
s.limitStr = "1"
s.orderStrs = append(s.orderStrs, s.model.primaryKeyDb()+" DESC")
s.query()
}
func (s *Do) getForeignKey(from *Model, to *Model, foreign_key string) (err error, from_from bool, foreign_value interface{}) {
if has_column, is_slice, value := from.ColumnAndValue(foreign_key); has_column {
from_from = true
if is_slice {
foreign_value = to.primaryKeyValue()
} else {
foreign_value = value
}
2013-11-05 18:34:49 +04:00
} else if has_column, _, _ := to.ColumnAndValue(foreign_key); has_column {
foreign_value = from.primaryKeyValue()
} else {
err = errors.New("Can't find valid foreign Key")
}
return
}
func (s *Do) related(value interface{}, foreign_keys ...string) {
var foreign_value interface{}
var from_from bool
var foreign_key string
var err error
from := &Model{data: value, driver: s.driver}
to := &Model{data: s.value, driver: s.driver}
foreign_keys = append(foreign_keys, from.typeName()+"Id", to.typeName()+"Id")
for _, fk := range foreign_keys {
err, from_from, foreign_value = s.getForeignKey(from, to, snakeToUpperCamel(fk))
if err == nil {
foreign_key = fk
break
}
}
if from_from {
s.where(foreign_value).query()
} else {
query := fmt.Sprintf("%v = %v", toSnake(foreign_key), foreign_value)
s.where(query).query()
}
}
2013-10-29 16:20:25 +04:00
func (s *Do) query() {
2013-10-27 15:41:58 +04:00
var (
is_slice bool
dest_type reflect.Type
)
dest_out := reflect.Indirect(reflect.ValueOf(s.value))
2013-10-29 06:19:20 +04:00
if dest_out.Kind() == reflect.Slice {
2013-10-27 15:41:58 +04:00
is_slice = true
dest_type = dest_out.Type().Elem()
} else {
s.limitStr = "1"
2013-10-27 15:41:58 +04:00
}
s.prepareQuerySql()
2013-10-29 03:39:26 +04:00
if !s.hasError() {
rows, err := s.db.Query(s.sql, s.sqlVars...)
if s.err(err) != nil {
return
}
2013-10-28 08:12:12 +04:00
2013-10-29 03:39:26 +04:00
defer rows.Close()
2013-10-28 08:12:12 +04:00
2013-10-29 03:39:26 +04:00
if rows.Err() != nil {
s.err(rows.Err())
}
2013-10-28 08:12:12 +04:00
2013-10-29 03:39:26 +04:00
counts := 0
for rows.Next() {
counts += 1
var dest reflect.Value
if is_slice {
dest = reflect.New(dest_type).Elem()
} else {
2013-10-29 18:00:06 +04:00
dest = dest_out
2013-10-29 03:39:26 +04:00
}
2013-10-27 15:41:58 +04:00
2013-10-29 03:39:26 +04:00
columns, _ := rows.Columns()
var values []interface{}
for _, value := range columns {
field := dest.FieldByName(snakeToUpperCamel(value))
if field.IsValid() {
2013-11-02 16:05:05 +04:00
if field.CanAddr() {
values = append(values, field.Addr().Interface())
} else {
s.err(errors.New(fmt.Sprintf("Can't take address of %v, should be ptr", dest)))
return
}
} else {
var null interface{}
values = append(values, &null)
2013-10-29 03:39:26 +04:00
}
}
s.err(rows.Scan(values...))
2013-10-27 15:41:58 +04:00
2013-10-29 03:39:26 +04:00
if is_slice {
dest_out.Set(reflect.Append(dest_out, dest))
2013-10-28 16:27:25 +04:00
}
2013-10-27 15:41:58 +04:00
}
2013-10-29 03:39:26 +04:00
if (counts == 0) && !is_slice {
s.err(errors.New("Record not found!"))
2013-10-27 15:41:58 +04:00
}
}
2013-10-27 10:51:23 +04:00
}
2013-10-27 16:07:13 +04:00
func (s *Do) count(value interface{}) {
dest_out := reflect.Indirect(reflect.ValueOf(value))
s.prepareQuerySql()
2013-10-29 03:39:26 +04:00
if !s.hasError() {
rows, err := s.db.Query(s.sql, s.sqlVars...)
if s.err(err) != nil {
return
}
defer rows.Close()
for rows.Next() {
var dest int64
if s.err(rows.Scan(&dest)) == nil {
setFieldValue(dest_out, dest)
2013-10-29 03:39:26 +04:00
}
}
2013-10-27 16:07:13 +04:00
}
return
}
2013-10-29 03:39:26 +04:00
func (s *Do) pluck(column string, value interface{}) {
s.selectStr = column
2013-10-27 15:41:58 +04:00
dest_out := reflect.Indirect(reflect.ValueOf(value))
2013-10-29 18:00:06 +04:00
if dest_out.Kind() != reflect.Slice {
s.err(errors.New("Return results should be a slice"))
return
}
2013-10-27 15:41:58 +04:00
dest_type := dest_out.Type().Elem()
2013-10-29 18:00:06 +04:00
2013-10-27 15:41:58 +04:00
s.prepareQuerySql()
2013-10-29 03:39:26 +04:00
if !s.hasError() {
rows, err := s.db.Query(s.sql, s.sqlVars...)
if s.err(err) != nil {
return
}
defer rows.Close()
for rows.Next() {
dest := reflect.New(dest_type).Elem().Interface()
s.err(rows.Scan(&dest))
2013-10-29 18:00:06 +04:00
2013-10-29 03:39:26 +04:00
switch dest.(type) {
case []uint8:
if dest_type.String() == "string" {
dest = string(dest.([]uint8))
2013-11-04 16:32:46 +04:00
} else if dest_type.String() == "int64" {
dest, _ = strconv.Atoi(string(dest.([]uint8)))
dest = int64(dest.(int))
2013-10-29 03:39:26 +04:00
}
2013-11-04 16:32:46 +04:00
2013-10-29 03:39:26 +04:00
dest_out.Set(reflect.Append(dest_out, reflect.ValueOf(dest)))
default:
dest_out.Set(reflect.Append(dest_out, reflect.ValueOf(dest)))
2013-10-27 15:41:58 +04:00
}
}
}
2013-10-29 03:39:26 +04:00
return
2013-10-27 15:41:58 +04:00
}
2013-10-29 16:20:25 +04:00
func (s *Do) where(where ...interface{}) *Do {
if len(where) > 0 {
s.whereClause = append(s.whereClause, map[string]interface{}{"query": where[0], "args": where[1:len(where)]})
}
return s
2013-10-27 16:54:23 +04:00
}
func (s *Do) primaryCondiation(value interface{}) string {
2013-10-29 03:39:26 +04:00
return fmt.Sprintf("(%v = %v)", s.model.primaryKeyDb(), value)
2013-10-27 16:54:23 +04:00
}
func (s *Do) buildWhereCondition(clause map[string]interface{}) (str string) {
2013-10-29 13:37:45 +04:00
query := clause["query"]
switch query.(type) {
2013-10-27 16:54:23 +04:00
case string:
2013-10-29 13:37:45 +04:00
value := query.(string)
2013-10-27 16:54:23 +04:00
if regexp.MustCompile("^\\s*\\d+\\s*$").MatchString(value) {
id, _ := strconv.Atoi(value)
return s.primaryCondiation(s.addToVars(id))
} else {
str = "( " + value + " )"
}
case int, int64, int32:
2013-10-29 13:37:45 +04:00
return s.primaryCondiation(s.addToVars(query))
2013-10-29 11:37:58 +04:00
case []int64, []int, []int32, []string:
str = fmt.Sprintf("(%v in (?))", s.model.primaryKeyDb())
2013-10-29 13:37:45 +04:00
clause["args"] = []interface{}{query}
2013-10-29 13:52:37 +04:00
case map[string]interface{}:
var sqls []string
for key, value := range query.(map[string]interface{}) {
sqls = append(sqls, fmt.Sprintf(" ( %v = %v ) ", key, s.addToVars(value)))
}
return strings.Join(sqls, " AND ")
2013-10-29 13:37:45 +04:00
case interface{}:
m := &Model{data: query, driver: s.driver}
var sqls []string
2013-11-02 11:17:11 +04:00
for _, field := range m.columnsHasValue("other") {
2013-10-29 13:37:45 +04:00
sqls = append(sqls, fmt.Sprintf(" ( %v = %v ) ", field.DbName, s.addToVars(field.Value)))
}
return strings.Join(sqls, " AND ")
2013-10-27 16:54:23 +04:00
}
2013-10-27 08:00:39 +04:00
args := clause["args"].([]interface{})
for _, arg := range args {
switch reflect.TypeOf(arg).Kind() {
case reflect.Slice: // For where("id in (?)", []int64{1,2})
2013-10-29 18:00:06 +04:00
values := reflect.ValueOf(arg)
2013-10-27 08:00:39 +04:00
var temp_marks []string
2013-10-29 18:00:06 +04:00
for i := 0; i < values.Len(); i++ {
temp_marks = append(temp_marks, s.addToVars(values.Index(i).Addr().Interface()))
2013-10-27 08:00:39 +04:00
}
str = strings.Replace(str, "?", strings.Join(temp_marks, ","), 1)
default:
str = strings.Replace(str, "?", s.addToVars(arg), 1)
}
}
2013-10-27 16:54:23 +04:00
return
2013-10-27 08:00:39 +04:00
}
2013-10-26 05:49:40 +04:00
2013-10-31 13:31:00 +04:00
func (s *Do) buildNotCondition(clause map[string]interface{}) (str string) {
query := clause["query"]
var not_equal_sql string
switch query.(type) {
case string:
value := query.(string)
if regexp.MustCompile("^\\s*\\d+\\s*$").MatchString(value) {
id, _ := strconv.Atoi(value)
return fmt.Sprintf("(%v <> %v)", s.model.primaryKeyDb(), id)
2013-10-31 18:49:48 +04:00
} else if regexp.MustCompile("(?i) (=|<>|>|<|LIKE|IS) ").MatchString(value) {
str = fmt.Sprintf(" NOT (%v) ", value)
not_equal_sql = fmt.Sprintf(" NOT (%v) ", value)
2013-10-31 13:31:00 +04:00
} else {
2013-10-31 14:12:18 +04:00
str = fmt.Sprintf(" (%v NOT IN (?)) ", value)
not_equal_sql = fmt.Sprintf(" (%v <> ?) ", value)
2013-10-31 13:31:00 +04:00
}
case int, int64, int32:
return fmt.Sprintf("(%v <> %v)", s.model.primaryKeyDb(), query)
case []int64, []int, []int32, []string:
if reflect.ValueOf(query).Len() > 0 {
str = fmt.Sprintf("(%v not in (?))", s.model.primaryKeyDb())
clause["args"] = []interface{}{query}
} else {
2013-10-31 14:12:18 +04:00
return ""
2013-10-31 13:31:00 +04:00
}
case map[string]interface{}:
var sqls []string
for key, value := range query.(map[string]interface{}) {
sqls = append(sqls, fmt.Sprintf(" ( %v <> %v ) ", key, s.addToVars(value)))
}
return strings.Join(sqls, " AND ")
case interface{}:
m := &Model{data: query, driver: s.driver}
var sqls []string
2013-11-02 11:17:11 +04:00
for _, field := range m.columnsHasValue("other") {
2013-10-31 13:31:00 +04:00
sqls = append(sqls, fmt.Sprintf(" ( %v <> %v ) ", field.DbName, s.addToVars(field.Value)))
}
return strings.Join(sqls, " AND ")
}
args := clause["args"].([]interface{})
for _, arg := range args {
switch reflect.TypeOf(arg).Kind() {
case reflect.Slice: // For where("id in (?)", []int64{1,2})
values := reflect.ValueOf(arg)
var temp_marks []string
for i := 0; i < values.Len(); i++ {
temp_marks = append(temp_marks, s.addToVars(values.Index(i).Addr().Interface()))
}
str = strings.Replace(str, "?", strings.Join(temp_marks, ","), 1)
default:
str = strings.Replace(not_equal_sql, "?", s.addToVars(arg), 1)
}
}
return
}
2013-10-27 15:41:58 +04:00
func (s *Do) whereSql() (sql string) {
2013-10-29 06:19:20 +04:00
var primary_condiations, and_conditions, or_conditions []string
if !s.unscoped && s.model.hasColumn("DeletedAt") {
primary_condiations = append(primary_condiations, "(deleted_at is null or deleted_at <= '0001-01-02')")
}
2013-10-29 18:00:06 +04:00
2013-10-28 11:55:41 +04:00
if !s.model.primaryKeyZero() {
2013-10-29 06:19:20 +04:00
primary_condiations = append(primary_condiations, s.primaryCondiation(s.addToVars(s.model.primaryKeyValue())))
2013-10-27 08:00:39 +04:00
}
for _, clause := range s.whereClause {
and_conditions = append(and_conditions, s.buildWhereCondition(clause))
}
for _, clause := range s.orClause {
or_conditions = append(or_conditions, s.buildWhereCondition(clause))
}
2013-10-31 13:31:00 +04:00
for _, clause := range s.notClause {
and_conditions = append(and_conditions, s.buildNotCondition(clause))
}
2013-10-27 08:00:39 +04:00
and_sql := strings.Join(and_conditions, " AND ")
2013-10-27 08:31:51 +04:00
or_sql := strings.Join(or_conditions, " OR ")
2013-10-27 08:00:39 +04:00
combined_conditions := and_sql
if len(combined_conditions) > 0 {
if len(or_sql) > 0 {
combined_conditions = combined_conditions + " OR " + or_sql
2013-10-26 10:10:47 +04:00
}
2013-10-27 08:00:39 +04:00
} else {
combined_conditions = or_sql
2013-10-26 10:10:47 +04:00
}
2013-10-26 19:30:17 +04:00
2013-10-29 06:19:20 +04:00
if len(primary_condiations) > 0 {
sql = "WHERE " + strings.Join(primary_condiations, " AND ")
2013-10-27 08:00:39 +04:00
if len(combined_conditions) > 0 {
sql = sql + " AND ( " + combined_conditions + " )"
}
} else if len(combined_conditions) > 0 {
sql = "WHERE " + combined_conditions
2013-10-26 19:30:17 +04:00
}
2013-10-26 05:49:40 +04:00
return
}
2013-10-26 19:30:17 +04:00
2013-10-27 15:41:58 +04:00
func (s *Do) selectSql() string {
2013-10-27 05:50:11 +04:00
if len(s.selectStr) == 0 {
return " * "
} else {
return s.selectStr
}
}
2013-10-27 15:41:58 +04:00
func (s *Do) orderSql() string {
2013-10-27 07:21:33 +04:00
if len(s.orderStrs) == 0 {
2013-10-27 07:38:05 +04:00
return ""
2013-10-27 07:21:33 +04:00
} else {
return " ORDER BY " + strings.Join(s.orderStrs, ",")
}
}
2013-10-27 15:41:58 +04:00
func (s *Do) limitSql() string {
2013-10-27 07:38:05 +04:00
if len(s.limitStr) == 0 {
return ""
} else {
return " LIMIT " + s.limitStr
}
}
2013-10-27 15:41:58 +04:00
func (s *Do) offsetSql() string {
2013-10-27 07:44:47 +04:00
if len(s.offsetStr) == 0 {
return ""
} else {
return " OFFSET " + s.offsetStr
}
}
2013-10-27 15:41:58 +04:00
func (s *Do) combinedSql() string {
2013-10-27 07:44:47 +04:00
return s.whereSql() + s.orderSql() + s.limitSql() + s.offsetSql()
2013-10-27 07:21:33 +04:00
}
2013-10-27 15:41:58 +04:00
func (s *Do) createTable() *Do {
2013-10-28 08:12:12 +04:00
var sqls []string
for _, field := range s.model.fields("other") {
2013-11-02 10:12:18 +04:00
if len(field.SqlType) > 0 {
sqls = append(sqls, field.DbName+" "+field.SqlType)
}
2013-10-28 08:12:12 +04:00
}
2013-10-29 18:00:06 +04:00
2013-10-29 03:39:26 +04:00
s.sql = fmt.Sprintf(
2013-11-03 17:19:38 +04:00
"CREATE TABLE %v (%v)",
2013-10-28 16:27:25 +04:00
s.tableName(),
2013-10-28 08:12:12 +04:00
strings.Join(sqls, ","),
)
2013-11-07 07:42:36 +04:00
s.exec()
2013-10-27 15:41:58 +04:00
return s
2013-10-26 19:30:17 +04:00
}
2013-11-01 11:01:39 +04:00
func (s *Do) dropTable() *Do {
s.sql = fmt.Sprintf(
2013-11-03 17:19:38 +04:00
"DROP TABLE %v",
2013-11-01 11:01:39 +04:00
s.tableName(),
)
2013-11-07 07:42:36 +04:00
s.exec()
2013-11-01 11:01:39 +04:00
return s
}
2013-11-07 05:09:54 +04:00
func (s *Do) autoMigrate() *Do {
2013-11-07 07:42:36 +04:00
var table_name string
sql := fmt.Sprintf("SELECT table_name FROM INFORMATION_SCHEMA.tables where table_name = %v", s.addToVars(s.tableName()))
s.db.QueryRow(sql, s.sqlVars...).Scan(&table_name)
s.sqlVars = []interface{}{}
// If table doesn't exist
if len(table_name) == 0 {
s.createTable()
} else {
for _, field := range s.model.fields("other") {
var column_name, data_type string
sql := fmt.Sprintf("SELECT column_name, data_type FROM information_schema.columns WHERE table_name = %v", s.addToVars(s.tableName()))
s.db.QueryRow(fmt.Sprintf(sql+" and column_name = %v", s.addToVars(field.DbName)), s.sqlVars...).Scan(&column_name, &data_type)
s.sqlVars = []interface{}{}
// If column doesn't exist
if len(column_name) == 0 && len(field.SqlType) > 0 {
s.sql = fmt.Sprintf("ALTER TABLE %v ADD %v %v;", s.tableName(), field.DbName, field.SqlType)
2013-11-07 07:42:36 +04:00
s.exec()
}
}
2013-11-07 05:09:54 +04:00
}
return s
}
2013-10-29 16:20:25 +04:00
func (s *Do) initializeWithSearchCondition() {
m := Model{data: s.value, driver: s.driver}
for _, clause := range s.whereClause {
query := clause["query"]
switch query.(type) {
case map[string]interface{}:
for key, value := range query.(map[string]interface{}) {
m.setValueByColumn(key, value, s.value)
}
case []interface{}:
for _, obj := range query.([]interface{}) {
switch reflect.ValueOf(obj).Kind() {
case reflect.Struct:
m := &Model{data: obj, driver: s.driver}
2013-11-02 11:17:11 +04:00
for _, field := range m.columnsHasValue("other") {
m.setValueByColumn(field.DbName, field.Value, s.value)
}
case reflect.Map:
for key, value := range obj.(map[string]interface{}) {
m.setValueByColumn(key, value, s.value)
}
}
}
case interface{}:
m := &Model{data: query, driver: s.driver}
2013-11-02 11:17:11 +04:00
for _, field := range m.columnsHasValue("other") {
m.setValueByColumn(field.DbName, field.Value, s.value)
}
}
}
}