Closes go-xorm#10 iterate Neq and Eq in predictable order

Also, uncomment an older test that is now passing reliably!
And change error from "to be update" to "to be insert" in
builder_insert.

Author: fasterthanlime

builder_insert.go

@@ -15,7 +15,7 @@ func (b *Builder) insertWriteTo(w Writer) error {
 		return errors.New("no table indicated")
 	}
 	if len(b.inserts) <= 0 {
-		return errors.New("no column to be update")
+		return errors.New("no column to be insert")
 	}
 
 	if _, err := fmt.Fprintf(w, "INSERT INTO %s (", b.tableName); err != nil {
@@ -26,7 +26,9 @@ func (b *Builder) insertWriteTo(w Writer) error {
 	var bs []byte
 	var valBuffer = bytes.NewBuffer(bs)
 	var i = 0
-	for col, value := range b.inserts {
+
+	for _, col := range b.inserts.sortedKeys() {
+		value := b.inserts[col]
 		fmt.Fprint(w, col)
 		if e, ok := value.(expr); ok {
 			fmt.Fprint(valBuffer, e.sql)

builder_test.go

@@ -110,12 +110,11 @@ func TestBuilderCond(t *testing.T) {
 			"0=0",
 			[]interface{}{},
 		},
-		// FIXME: since map will not guarantee the sequence, this may be failed random
-		/*{
+		{
 			Or(Eq{"a": 1, "b": 2}, Eq{"c": 3, "d": 4}),
 			"(a=? AND b=?) OR (c=? AND d=?)",
 			[]interface{}{1, 2, 3, 4},
-		},*/
+		},
 	}
 
 	for _, k := range cases {
@@ -208,14 +207,14 @@ func TestSubquery(t *testing.T) {
 	subb := Select("id").From("table_b").Where(Eq{"b": "a"})
 	b := Select("a, b").From("table_a").Where(
 		Eq{
-			"id":   23,
 			"b_id": subb,
+			"id":   23,
 		},
 	)
 	sql, args, err := b.ToSQL()
 	assert.NoError(t, err)
-	assert.EqualValues(t, "SELECT a, b FROM table_a WHERE id=? AND b_id=(SELECT id FROM table_b WHERE b=?)", sql)
-	assert.EqualValues(t, []interface{}{23, "a"}, args)
+	assert.EqualValues(t, "SELECT a, b FROM table_a WHERE b_id=(SELECT id FROM table_b WHERE b=?) AND id=?", sql)
+	assert.EqualValues(t, []interface{}{"a", 23}, args)
 }
 
 // https://github.com/go-xorm/xorm/issues/820

cond_compare.go

@@ -10,7 +10,13 @@ import "fmt"
 func WriteMap(w Writer, data map[string]interface{}, op string) error {
 	var args = make([]interface{}, 0, len(data))
 	var i = 0
-	for k, v := range data {
+	keys := make([]string, 0, len(data))
+	for k := range data {
+		keys = append(keys, k)
+	}
+
+	for _, k := range keys {
+		v := data[k]
 		switch v.(type) {
 		case expr:
 			if _, err := fmt.Fprintf(w, "%s%s(", k, op); err != nil {

cond_eq.go

@@ -4,7 +4,10 @@
 
 package builder
 
-import "fmt"
+import (
+	"fmt"
+	"sort"
+)
 
 // Incr implements a type used by Eq
 type Incr int
@@ -19,7 +22,8 @@ var _ Cond = Eq{}
 
 func (eq Eq) opWriteTo(op string, w Writer) error {
 	var i = 0
-	for k, v := range eq {
+	for _, k := range eq.sortedKeys() {
+		v := eq[k]
 		switch v.(type) {
 		case []int, []int64, []string, []int32, []int16, []int8, []uint, []uint64, []uint32, []uint16, []interface{}:
 			if err := In(k, v).WriteTo(w); err != nil {
@@ -94,3 +98,15 @@ func (eq Eq) Or(conds ...Cond) Cond {
 func (eq Eq) IsValid() bool {
 	return len(eq) > 0
 }
+
+// sortedKeys returns all keys of this Eq sorted with sort.Strings.
+// It is used internally for consistent ordering when generating
+// SQL, see https://github.com/go-xorm/builder/issues/10
+func (eq Eq) sortedKeys() []string {
+	keys := make([]string, 0, len(eq))
+	for key := range eq {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	return keys
+}

cond_neq.go

@@ -4,7 +4,10 @@
 
 package builder
 
-import "fmt"
+import (
+	"fmt"
+	"sort"
+)
 
 // Neq defines not equal conditions
 type Neq map[string]interface{}
@@ -15,7 +18,8 @@ var _ Cond = Neq{}
 func (neq Neq) WriteTo(w Writer) error {
 	var args = make([]interface{}, 0, len(neq))
 	var i = 0
-	for k, v := range neq {
+	for _, k := range neq.sortedKeys() {
+		v := neq[k]
 		switch v.(type) {
 		case []int, []int64, []string, []int32, []int16, []int8:
 			if err := NotIn(k, v).WriteTo(w); err != nil {
@@ -76,3 +80,15 @@ func (neq Neq) Or(conds ...Cond) Cond {
 func (neq Neq) IsValid() bool {
 	return len(neq) > 0
 }
+
+// sortedKeys returns all keys of this Neq sorted with sort.Strings.
+// It is used internally for consistent ordering when generating
+// SQL, see https://github.com/go-xorm/builder/issues/10
+func (neq Neq) sortedKeys() []string {
+	keys := make([]string, 0, len(neq))
+	for key := range neq {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	return keys
+}