diff --git a/base_test.go b/base_test.go
index 37b62b1f..418bc39d 100644
--- a/base_test.go
+++ b/base_test.go
@@ -152,7 +152,7 @@ func insertTwoTable(engine *Engine, t *testing.T) {
 
 func update(engine *Engine, t *testing.T) {
 	// update by id
-	user := Userinfo{Username: "xxx"}
+	user := Userinfo{Username: "xxx", Height: 1.2}
 	_, err := engine.Id(1).Update(&user)
 	if err != nil {
 		t.Error(err)
@@ -640,13 +640,28 @@ type MyUInt uint
 type MyFloat float64
 type MyString string
 
+func (s MyString) FromDB(data []byte) error {
+	s = MyString(string(data))
+	return nil
+}
+
+func (s MyString) ToDB() ([]byte, error) {
+	return []byte(string(s)), nil
+}
+
 type MyStruct struct {
 	Type MyInt
 	U    MyUInt
 	F    MyFloat
 	//S    MyString
+	//IA []MyInt
+	//UA        []MyUInt
+	//FA        []MyFloat
+	//SA        []MyString
+	//NameArray []string
 	Name string
-	UI   uint
+	//UIA       []uint
+	UI uint
 }
 
 func testCustomType(engine *Engine, t *testing.T) {
diff --git a/session.go b/session.go
index 7265fce4..19acfe5e 100644
--- a/session.go
+++ b/session.go
@@ -206,7 +206,19 @@ func (session *Session) scanMapIntoStruct(obj interface{}, objMap map[string][]b
 		switch structField.Type().Kind() {
 		case reflect.Slice:
 			v = data
-			structField.Set(reflect.ValueOf(v))
+			vv := reflect.ValueOf(v)
+			if structField.Type().String() == "[]byte" {
+				fmt.Println("...[]byte...")
+			}
+			if vv.Type().Kind() == reflect.Slice {
+				for i := 0; i < vv.Len(); i++ {
+					//vv.Index(i)
+					structField = reflect.AppendSlice(structField, vv)
+					//reflect.Append(structField, vv.Index(i))
+				}
+			} else {
+				return errors.New(fmt.Sprintf("unsupported from other %v to %v", vv.Type().Kind(), structField.Type().Kind()))
+			}
 		case reflect.Array:
 			if structField.Type().Elem() == reflect.TypeOf(b) {
 				v = data
@@ -825,6 +837,17 @@ func (session *Session) InsertMulti(rowsSlicePtr interface{}) (int64, error) {
 }
 
 func (session *Session) value2Interface(fieldValue reflect.Value) (interface{}, error) {
+	if fieldValue.CanAddr() {
+		if fieldConvert, ok := fieldValue.Addr().Interface().(Conversion); ok {
+			data, err := fieldConvert.ToDB()
+			if err != nil {
+				return 0, err
+			} else {
+				return string(data), nil
+			}
+		}
+	}
+
 	if fieldValue.Type().Kind() == reflect.Bool {
 		if fieldValue.Bool() {
 			return 1, nil
@@ -834,17 +857,6 @@ func (session *Session) value2Interface(fieldValue reflect.Value) (interface{},
 	} else if fieldValue.Type().String() == "time.Time" {
 		return fieldValue.Interface(), nil
 	} else if fieldValue.Type().Kind() == reflect.Struct {
-		if fieldValue.CanAddr() {
-			if fieldConvert, ok := fieldValue.Addr().Interface().(Conversion); ok {
-				data, err := fieldConvert.ToDB()
-				if err != nil {
-					return 0, err
-				} else {
-					return string(data), nil
-				}
-			}
-		}
-
 		if fieldTable, ok := session.Engine.Tables[fieldValue.Type()]; ok {
 			if fieldTable.PrimaryKey != "" {
 				pkField := reflect.Indirect(fieldValue).FieldByName(fieldTable.PKColumn().FieldName)
@@ -855,6 +867,11 @@ func (session *Session) value2Interface(fieldValue reflect.Value) (interface{},
 		} else {
 			return 0, errors.New(fmt.Sprintf("Unsupported type %v", fieldValue.Type()))
 		}
+	} else if fieldValue.Type().Kind() == reflect.Array ||
+		fieldValue.Type().Kind() == reflect.Slice {
+		data := fmt.Sprintf("%v", fieldValue.Interface())
+		fmt.Println(data, "--------")
+		return data, nil
 	} else {
 		return fieldValue.Interface(), nil
 	}
diff --git a/statement.go b/statement.go
index b23dcff8..35a13bc7 100644
--- a/statement.go
+++ b/statement.go
@@ -93,10 +93,18 @@ func BuildConditions(engine *Engine, table *Table, bean interface{}) ([]string,
 			if fieldValue.String() == "" {
 				continue
 			}
-		case reflect.Int, reflect.Int32, reflect.Int64:
+		case reflect.Int8, reflect.Int16, reflect.Int, reflect.Int32, reflect.Int64:
 			if fieldValue.Int() == 0 {
 				continue
 			}
+		case reflect.Float32, reflect.Float64:
+			if fieldValue.Float() == 0.0 {
+				continue
+			}
+		case reflect.Uint8, reflect.Uint16, reflect.Uint, reflect.Uint32, reflect.Uint64:
+			if fieldValue.Uint() == 0 {
+				continue
+			}
 		case reflect.Struct:
 			if fieldType == reflect.TypeOf(time.Now()) {
 				t := fieldValue.Interface().(time.Time)