Make clone search conditions works

search.go

@@ -3,67 +3,91 @@ package gorm
 import "strconv"
 
 type search struct {
-	conditions         map[string][]interface{}
-	orders             []string
-	selectStr          string
-	offsetStr          string
-	limitStr           string
-	specifiedTableName string
-	unscope            bool
+	whereClause []map[string]interface{}
+	orClause    []map[string]interface{}
+	notClause   []map[string]interface{}
+	initAttrs   []interface{}
+	assignAttrs []interface{}
+	orders      []string
+	selectStr   string
+	offsetStr   string
+	limitStr    string
+	unscope     bool
 }
 
-func (s *search) addToCondition(typ string, value interface{}) {
-	s.conditions[typ] = append(s.conditions[typ], value)
+func (s *search) clone() *search {
+	return &search{
+		whereClause: s.whereClause,
+		orClause:    s.orClause,
+		notClause:   s.notClause,
+		initAttrs:   s.initAttrs,
+		assignAttrs: s.assignAttrs,
+		orders:      s.orders,
+		selectStr:   s.selectStr,
+		offsetStr:   s.offsetStr,
+		limitStr:    s.limitStr,
+		unscope:     s.unscope,
+	}
 }
 
-func (s *search) where(query string, values ...interface{}) {
-	s.addToCondition("where", map[string]interface{}{"query": query, "args": values})
+func (s *search) where(query interface{}, values ...interface{}) *search {
+	s.whereClause = append(s.whereClause, map[string]interface{}{"query": query, "args": values})
+	return s
 }
 
-func (s *search) not(query string, values ...interface{}) {
-	s.addToCondition("not", map[string]interface{}{"query": query, "args": values})
+func (s *search) not(query interface{}, values ...interface{}) *search {
+	s.notClause = append(s.notClause, map[string]interface{}{"query": query, "args": values})
+	return s
 }
 
-func (s *search) or(query string, values ...interface{}) {
-	s.addToCondition("or", map[string]interface{}{"query": query, "args": values})
+func (s *search) or(query interface{}, values ...interface{}) *search {
+	s.orClause = append(s.orClause, map[string]interface{}{"query": query, "args": values})
+	return s
 }
 
-func (s *search) attrs(attrs ...interface{}) {
-	s.addToCondition("attrs", toSearchableMap(attrs...))
+func (s *search) attrs(attrs ...interface{}) *search {
+	s.initAttrs = append(s.initAttrs, toSearchableMap(attrs...))
+	return s
 }
 
-func (s *search) assign(attrs ...interface{}) {
-	s.addToCondition("assign", toSearchableMap(attrs...))
+func (s *search) assign(attrs ...interface{}) *search {
+	s.assignAttrs = append(s.assignAttrs, toSearchableMap(attrs...))
+	return s
 }
 
-func (s *search) order(value string, reorder ...bool) {
+func (s *search) order(value string, reorder ...bool) *search {
 	if len(reorder) > 0 && reorder[0] {
 		s.orders = []string{value}
 	} else {
 		s.orders = append(s.orders, value)
 	}
+	return s
 }
 
-func (s *search) selects(value interface{}) {
+func (s *search) selects(value interface{}) *search {
 	if str, err := getInterfaceAsString(value); err == nil {
 		s.selectStr = str
 	}
+	return s
 }
 
-func (s *search) limit(value interface{}) {
+func (s *search) limit(value interface{}) *search {
 	if str, err := getInterfaceAsString(value); err == nil {
 		s.limitStr = str
 	}
+	return s
 }
 
-func (s *search) offset(value interface{}) {
+func (s *search) offset(value interface{}) *search {
 	if str, err := getInterfaceAsString(value); err == nil {
 		s.offsetStr = str
 	}
+	return s
 }
 
-func (s *search) unscoped() {
+func (s *search) unscoped() *search {
 	s.unscope = true
+	return s
 }
 
 func getInterfaceAsString(value interface{}) (str string, err error) {

search_test.go

@@ -0,0 +1,30 @@
+package gorm
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestCloneSearch(t *testing.T) {
+	s := new(search)
+	s.where("name = ?", "jinzhu").order("name").attrs("name", "jinzhu").selects("name, age")
+
+	s1 := s.clone()
+	s1.where("age = ?", 20).order("age").attrs("email", "a@e.org").selects("email")
+
+	if reflect.DeepEqual(s.whereClause, s1.whereClause) {
+		t.Errorf("Where should be copied")
+	}
+
+	if reflect.DeepEqual(s.orders, s1.orders) {
+		t.Errorf("Order should be copied")
+	}
+
+	if reflect.DeepEqual(s.initAttrs, s1.initAttrs) {
+		t.Errorf("initAttrs should be copied")
+	}
+
+	if reflect.DeepEqual(s.selectStr, s1.selectStr) {
+		t.Errorf("selectStr should be copied")
+	}
+}

utils.go

@@ -3,6 +3,7 @@ package gorm
 import (
 	"bytes"
 	"database/sql"
+	"fmt"
 
 	"reflect"
 	"strconv"
@@ -97,3 +98,8 @@ func isBlank(value reflect.Value) bool {
 	}
 	return false
 }
+
+func debug(values ...interface{}) {
+	fmt.Println("*****************")
+	fmt.Println(values)
+}