完成测试

framework/core/tag/assign/tag.go

@@ -53,6 +53,10 @@ func parseTag(fromElemValue reflect.Value, toElemValue *reflect.Value, onParsedF
 		}
 
 		if fromFieldValue.Kind() == reflect.Pointer && fromFieldValue.IsNil() {
+			if !fromFieldValue.CanSet() {
+				return errors.New("无法设置值，请检查是否传递的是非指针结构变量且字段为nil")
+			}
+
 			fromFieldValue.Set(reflect.New(fromField.Type.Elem()))
 		}
 

framework/core/tag/sql/sql_mapping/tag.go

@@ -54,6 +54,10 @@ func parseTag(entityElemValue reflect.Value, onParsedFieldTagFunc OnParsedFieldT
 		}
 
 		if entityFieldValue.Kind() == reflect.Pointer && entityFieldValue.IsNil() {
+			if !entityFieldValue.CanSet() {
+				return errors.New("无法设置值，请检查是否传递的是非指针结构变量且字段为nil")
+			}
+
 			entityFieldValue.Set(reflect.New(entityField.Type.Elem()))
 		}
 

framework/core/tag/sql/sql_mapping/usage.go

@@ -39,14 +39,20 @@ func defaultCallback(fields *[]Field) OnParsedFieldTagFunc {
 			CanUpdateClear: tag.CanUpdateClear,
 		}
 
+		entityFieldKind := reflectutils.GroupValueKind(entityFieldElemValue)
+
 		if entityFieldElemValue.IsZero() && !reflectutils.IsValueTime(entityFieldElemValue) {
-			field.Value = reflectutils.ZeroValueToAny(entityFieldElemValue)
+			if entityFieldKind == reflect.Slice && reflectutils.IsSliceValueOf(entityFieldElemValue, reflect.String) ||
+				entityFieldKind == reflect.String {
+				field.Value = ""
+			} else {
+				field.Value = reflectutils.ZeroValueToAny(entityFieldElemValue)
+			}
+
 			*fields = append(*fields, field)
 			return nil
 		}
 
-		entityFieldKind := reflectutils.GroupValueKind(entityFieldElemValue)
-
 		switch entityFieldKind {
 		case reflect.Struct:
 			if !reflectutils.IsValueTime(entityFieldElemValue) {

test/assign_tag_test.go

@@ -3,13 +3,14 @@ package test
 import (
 	"git.sxidc.com/go-framework/baize/framework/core/tag/assign"
 	"git.sxidc.com/go-tools/utils/strutils"
+	"github.com/pkg/errors"
 	"math/rand"
 	"strings"
 	"testing"
 	"time"
 )
 
-type AssignFrom struct {
+type AssignTagFrom struct {
 	StringField                  string              `assign:"toField:StringField"`
 	BoolField                    bool                `assign:"toField:BoolField"`
 	Int8Field                    int8                `assign:"toField:Int8Field"`
@@ -33,7 +34,7 @@ type AssignFrom struct {
 	FromStringToTimeField        string              `assign:"toField:FromStringToTimeField"`
 }
 
-type AssignFromPointerField struct {
+type AssignTagFromPointerField struct {
 	StringField                  *string              `assign:"toField:StringField"`
 	BoolField                    *bool                `assign:"toField:BoolField"`
 	Int8Field                    *int8                `assign:"toField:Int8Field"`
@@ -57,7 +58,7 @@ type AssignFromPointerField struct {
 	FromStringToTimeField        *string              `assign:"toField:FromStringToTimeField"`
 }
 
-type AssignTo struct {
+type AssignTagTo struct {
 	StringField                  string
 	BoolField                    bool
 	Int8Field                    int8
@@ -81,118 +82,118 @@ type AssignTo struct {
 	FromStringToTimeField        time.Time
 }
 
-func (to AssignTo) checkFields(t *testing.T, from AssignFrom) {
+func (to AssignTagTo) checkFields(t *testing.T, from AssignTagFrom) {
 	if from.StringField != to.StringField {
-		t.Fatalf("StringField not equal: from %v, to %v",
-			from.StringField, to.StringField)
+		t.Fatalf("%+v", errors.Errorf("StringField not equal: from %v, to %v",
+			from.StringField, to.StringField))
 	}
 
 	if from.BoolField != to.BoolField {
-		t.Fatalf("BoolField not equal: from %v, to %v",
-			from.BoolField, to.BoolField)
+		t.Fatalf("%+v", errors.Errorf("BoolField not equal: from %v, to %v",
+			from.BoolField, to.BoolField))
 	}
 
 	if from.Int8Field != to.Int8Field {
-		t.Fatalf("Int8Field not equal: from %v, to %v",
-			from.Int8Field, to.Int8Field)
+		t.Fatalf("%+v", errors.Errorf("Int8Field not equal: from %v, to %v",
+			from.Int8Field, to.Int8Field))
 	}
 
 	if from.Int16Field != to.Int16Field {
-		t.Fatalf("Int16Field not equal: from %v, to %v",
-			from.Int16Field, to.Int16Field)
+		t.Fatalf("%+v", errors.Errorf("Int16Field not equal: from %v, to %v",
+			from.Int16Field, to.Int16Field))
 	}
 
 	if from.Int32Field != to.Int32Field {
-		t.Fatalf("Int32Field not equal: from %v, to %v",
-			from.Int32Field, to.Int32Field)
+		t.Fatalf("%+v", errors.Errorf("Int32Field not equal: from %v, to %v",
+			from.Int32Field, to.Int32Field))
 	}
 
 	if from.Int64Field != to.Int64Field {
-		t.Fatalf("Int64Field not equal: from %v, to %v",
-			from.Int64Field, to.Int64Field)
+		t.Fatalf("%+v", errors.Errorf("Int64Field not equal: from %v, to %v",
+			from.Int64Field, to.Int64Field))
 	}
 
 	if from.Uint8Field != to.Uint8Field {
-		t.Fatalf("Uint8Field not equal: from %v, to %v",
-			from.Uint8Field, to.Uint8Field)
+		t.Fatalf("%+v", errors.Errorf("Uint8Field not equal: from %v, to %v",
+			from.Uint8Field, to.Uint8Field))
 	}
 
 	if from.Uint16Field != to.Uint16Field {
-		t.Fatalf("Uint16Field not equal: from %v, to %v",
-			from.Uint16Field, to.Uint16Field)
+		t.Fatalf("%+v", errors.Errorf("Uint16Field not equal: from %v, to %v",
+			from.Uint16Field, to.Uint16Field))
 	}
 
 	if from.Uint32Field != to.Uint32Field {
-		t.Fatalf("Uint32Field not equal: from %v, to %v",
-			from.Uint32Field, to.Uint32Field)
+		t.Fatalf("%+v", errors.Errorf("Uint32Field not equal: from %v, to %v",
+			from.Uint32Field, to.Uint32Field))
 	}
 
 	if from.Uint64Field != to.Uint64Field {
-		t.Fatalf("Uint64Field not equal: from %v, to %v",
-			from.Uint64Field, to.Uint64Field)
+		t.Fatalf("%+v", errors.Errorf("Uint64Field not equal: from %v, to %v",
+			from.Uint64Field, to.Uint64Field))
 	}
 
 	if from.Float32Field != to.Float32Field {
-		t.Fatalf("Float32Field not equal: from %v, to %v",
-			from.Float32Field, to.Float32Field)
+		t.Fatalf("%+v", errors.Errorf("Float32Field not equal: from %v, to %v",
+			from.Float32Field, to.Float32Field))
 	}
 
 	if from.Float64Field != to.Float64Field {
-		t.Fatalf("Float64Field not equal: from %v, to %v",
-			from.Float64Field, to.Float64Field)
+		t.Fatalf("%+v", errors.Errorf("Float64Field not equal: from %v, to %v",
+			from.Float64Field, to.Float64Field))
 	}
 
 	for i, value := range from.SliceField {
 		if value != to.SliceField[i] {
-			t.Fatalf("SliceField not equal: from %v, to %v",
-				value, to.SliceField[i])
+			t.Fatalf("%+v", errors.Errorf("SliceField not equal: from %v, to %v",
+				value, to.SliceField[i]))
 		}
 	}
 
 	for key, value := range from.MapField {
 		if value != to.MapField[key] {
-			t.Fatalf("MapField not equal: from %v, to %v",
-				value, to.MapField[key])
+			t.Fatalf("%+v", errors.Errorf("MapField not equal: from %v, to %v",
+				value, to.MapField[key]))
 		}
 	}
 
 	if from.ChanField != to.ChanField {
-		t.Fatalf("ChanField not equal: from %v, to %v",
-			from.ChanField, to.ChanField)
+		t.Fatalf("%+v", errors.Errorf("ChanField not equal: from %v, to %v",
+			from.ChanField, to.ChanField))
 	}
 
 	if from.FuncField() != to.FuncField() {
-		t.Fatalf("FuncField not equal: from %v, to %v",
-			from.FuncField(), to.FuncField())
+		t.Fatalf("%+v", errors.Errorf("FuncField not equal: from %v, to %v",
+			from.FuncField(), to.FuncField()))
 	}
 
 	if from.StructField.ID != to.StructField.ID {
-		t.Fatalf("StructField not equal: from %v, to %v",
-			from.StructField.ID, to.StructField.ID)
+		t.Fatalf("%+v", errors.Errorf("StructField not equal: from %v, to %v",
+			from.StructField.ID, to.StructField.ID))
 	}
 
 	if strings.Join(from.FromStringSliceToStringField, "::") != to.FromStringSliceToStringField {
-		t.Fatalf("FromStringSliceToStringField not equal: from %v, to %v",
-			strings.Join(from.FromStringSliceToStringField, "::"), to.FromStringSliceToStringField)
+		t.Fatalf("%+v", errors.Errorf("FromStringSliceToStringField not equal: from %v, to %v",
+			strings.Join(from.FromStringSliceToStringField, "::"), to.FromStringSliceToStringField))
 	}
 
 	if from.FromTimeToStringField.Format(time.DateTime) != to.FromTimeToStringField {
-		t.Fatalf("FromTimeToStringField not equal: from %v, to %v",
-			from.FromTimeToStringField.Format(time.DateTime), to.FromTimeToStringField)
+		t.Fatalf("%+v", errors.Errorf("FromTimeToStringField not equal: from %v, to %v",
+			from.FromTimeToStringField.Format(time.DateTime), to.FromTimeToStringField))
 	}
 
 	if from.FromTimeToTimeField.Format(time.DateTime) != to.FromTimeToTimeField.Format(time.DateTime) {
-		t.Fatalf("FromTimeToTimeField not equal: from %v, to %v",
-			from.FromTimeToTimeField.Format(time.DateTime), to.FromTimeToTimeField.Format(time.DateTime))
+		t.Fatalf("%+v", errors.Errorf("FromTimeToTimeField not equal: from %v, to %v",
+			from.FromTimeToTimeField.Format(time.DateTime), to.FromTimeToTimeField.Format(time.DateTime)))
 	}
 
 	if from.FromStringToTimeField != to.FromStringToTimeField.Format(time.DateTime) {
-		t.Fatalf("FromStringToTimeField not equal: from %v, to %v",
-			from.FromStringToTimeField, to.FromStringToTimeField.Format(time.DateTime))
+		t.Fatalf("%+v", errors.Errorf("FromStringToTimeField not equal: from %v, to %v",
+			from.FromStringToTimeField, to.FromStringToTimeField.Format(time.DateTime)))
 	}
 }
 
-type AssignToPointerField struct {
+type AssignTagToPointerField struct {
 	StringField                  *string
 	BoolField                    *bool
 	Int8Field                    *int8
@@ -216,114 +217,114 @@ type AssignToPointerField struct {
 	FromStringToTimeField        *time.Time
 }
 
-func (to AssignToPointerField) checkFields(t *testing.T, from AssignFrom) {
+func (to AssignTagToPointerField) checkFields(t *testing.T, from AssignTagFrom) {
 	if from.StringField != *to.StringField {
-		t.Fatalf("StringField not equal: from %v, to %v",
-			from.StringField, *to.StringField)
+		t.Fatalf("%+v", errors.Errorf("StringField not equal: from %v, to %v",
+			from.StringField, *to.StringField))
 	}
 
 	if from.BoolField != *to.BoolField {
-		t.Fatalf("BoolField not equal: from %v, to %v",
-			from.BoolField, *to.BoolField)
+		t.Fatalf("%+v", errors.Errorf("BoolField not equal: from %v, to %v",
+			from.BoolField, *to.BoolField))
 	}
 
 	if from.Int8Field != *to.Int8Field {
-		t.Fatalf("Int8Field not equal: from %v, to %v",
-			from.Int8Field, *to.Int8Field)
+		t.Fatalf("%+v", errors.Errorf("Int8Field not equal: from %v, to %v",
+			from.Int8Field, *to.Int8Field))
 	}
 
 	if from.Int16Field != *to.Int16Field {
-		t.Fatalf("Int16Field not equal: from %v, to %v",
-			from.Int16Field, *to.Int16Field)
+		t.Fatalf("%+v", errors.Errorf("Int16Field not equal: from %v, to %v",
+			from.Int16Field, *to.Int16Field))
 	}
 
 	if from.Int32Field != *to.Int32Field {
-		t.Fatalf("Int32Field not equal: from %v, to %v",
-			from.Int32Field, *to.Int32Field)
+		t.Fatalf("%+v", errors.Errorf("Int32Field not equal: from %v, to %v",
+			from.Int32Field, *to.Int32Field))
 	}
 
 	if from.Int64Field != *to.Int64Field {
-		t.Fatalf("Int64Field not equal: from %v, to %v",
-			from.Int64Field, *to.Int64Field)
+		t.Fatalf("%+v", errors.Errorf("Int64Field not equal: from %v, to %v",
+			from.Int64Field, *to.Int64Field))
 	}
 
 	if from.Uint8Field != *to.Uint8Field {
-		t.Fatalf("Uint8Field not equal: from %v, to %v",
-			from.Uint8Field, *to.Uint8Field)
+		t.Fatalf("%+v", errors.Errorf("Uint8Field not equal: from %v, to %v",
+			from.Uint8Field, *to.Uint8Field))
 	}
 
 	if from.Uint16Field != *to.Uint16Field {
-		t.Fatalf("Uint16Field not equal: from %v, to %v",
-			from.Uint16Field, *to.Uint16Field)
+		t.Fatalf("%+v", errors.Errorf("Uint16Field not equal: from %v, to %v",
+			from.Uint16Field, *to.Uint16Field))
 	}
 
 	if from.Uint32Field != *to.Uint32Field {
-		t.Fatalf("Uint32Field not equal: from %v, to %v",
-			from.Uint32Field, *to.Uint32Field)
+		t.Fatalf("%+v", errors.Errorf("Uint32Field not equal: from %v, to %v",
+			from.Uint32Field, *to.Uint32Field))
 	}
 
 	if from.Uint64Field != *to.Uint64Field {
-		t.Fatalf("Uint64Field not equal: from %v, to %v",
-			from.Uint64Field, *to.Uint64Field)
+		t.Fatalf("%+v", errors.Errorf("Uint64Field not equal: from %v, to %v",
+			from.Uint64Field, *to.Uint64Field))
 	}
 
 	if from.Float32Field != *to.Float32Field {
-		t.Fatalf("Float32Field not equal: from %v, to %v",
-			from.Float32Field, *to.Float32Field)
+		t.Fatalf("%+v", errors.Errorf("Float32Field not equal: from %v, to %v",
+			from.Float32Field, *to.Float32Field))
 	}
 
 	if from.Float64Field != *to.Float64Field {
-		t.Fatalf("Float64Field not equal: from %v, to %v",
-			from.Float64Field, *to.Float64Field)
+		t.Fatalf("%+v", errors.Errorf("Float64Field not equal: from %v, to %v",
+			from.Float64Field, *to.Float64Field))
 	}
 
 	for i, value := range from.SliceField {
 		if value != (*to.SliceField)[i] {
-			t.Fatalf("SliceField not equal: from %v, to %v",
-				value, (*to.SliceField)[i])
+			t.Fatalf("%+v", errors.Errorf("SliceField not equal: from %v, to %v",
+				value, (*to.SliceField)[i]))
 		}
 	}
 
 	for key, value := range from.MapField {
 		if value != (*to.MapField)[key] {
-			t.Fatalf("MapField not equal: from %v, to %v",
-				value, (*to.MapField)[key])
+			t.Fatalf("%+v", errors.Errorf("MapField not equal: from %v, to %v",
+				value, (*to.MapField)[key]))
 		}
 	}
 
 	if from.ChanField != *to.ChanField {
-		t.Fatalf("ChanField not equal: from %v, to %v",
-			from.ChanField, *to.ChanField)
+		t.Fatalf("%+v", errors.Errorf("ChanField not equal: from %v, to %v",
+			from.ChanField, *to.ChanField))
 	}
 
 	if from.FuncField() != (*to.FuncField)() {
-		t.Fatalf("FuncField not equal: from %v, to %v",
-			from.FuncField(), (*to.FuncField)())
+		t.Fatalf("%+v", errors.Errorf("FuncField not equal: from %v, to %v",
+			from.FuncField(), (*to.FuncField)()))
 	}
 
 	if from.StructField.ID != (*to.StructField).ID {
-		t.Fatalf("StructField not equal: from %v, to %v",
-			from.StructField.ID, (*to.StructField).ID)
+		t.Fatalf("%+v", errors.Errorf("StructField not equal: from %v, to %v",
+			from.StructField.ID, (*to.StructField).ID))
 	}
 
 	if strings.Join(from.FromStringSliceToStringField, "::") != *to.FromStringSliceToStringField {
-		t.Fatalf("FromStringSliceToStringField not equal: from %v, to %v",
-			strings.Join(from.FromStringSliceToStringField, "::"), to.FromStringSliceToStringField)
+		t.Fatalf("%+v", errors.Errorf("FromStringSliceToStringField not equal: from %v, to %v",
+			strings.Join(from.FromStringSliceToStringField, "::"), to.FromStringSliceToStringField))
 	}
 
 	if from.FromTimeToStringField.Format(time.DateTime) != *to.FromTimeToStringField {
-		t.Fatalf("FromTimeToStringField not equal: from %v, to %v",
-			from.FromTimeToStringField.Format(time.DateTime), to.FromTimeToStringField)
+		t.Fatalf("%+v", errors.Errorf("FromTimeToStringField not equal: from %v, to %v",
+			from.FromTimeToStringField.Format(time.DateTime), to.FromTimeToStringField))
 	}
 
 	if from.FromTimeToTimeField.Format(time.DateTime) != (*to.FromTimeToTimeField).Format(time.DateTime) {
-		t.Fatalf("FromTimeToTimeField not equal: from %v, to %v",
-			from.FromTimeToTimeField.Format(time.DateTime), (*to.FromTimeToTimeField).Format(time.DateTime))
+		t.Fatalf("%+v", errors.Errorf("FromTimeToTimeField not equal: from %v, to %v",
+			from.FromTimeToTimeField.Format(time.DateTime), (*to.FromTimeToTimeField).Format(time.DateTime)))
 	}
 
 	if from.FromStringToTimeField != (*to.FromStringToTimeField).Format(time.DateTime) {
-		t.Fatalf("FromStringToTimeField not equal: from %v, to %v",
-			from.FromStringToTimeField, (*to.FromStringToTimeField).Format(time.DateTime))
+		t.Fatalf("%+v", errors.Errorf("FromStringToTimeField not equal: from %v, to %v",
+			from.FromStringToTimeField, (*to.FromStringToTimeField).Format(time.DateTime)))
 	}
 }
 
@@ -351,7 +352,7 @@ func TestAssignTagDefaultUsage(t *testing.T) {
 	fromTimeToTimeField := time.Now().Local()
 	fromStringToTimeField := time.Now().Local().Format(time.DateTime)
 
-	from := AssignFrom{
+	from := AssignTagFrom{
 		StringField:                  stringField,
 		BoolField:                    boolField,
 		Int8Field:                    int8Field,
@@ -375,7 +376,7 @@ func TestAssignTagDefaultUsage(t *testing.T) {
 		FromStringToTimeField:        fromStringToTimeField,
 	}
 
-	fromPointer := AssignFromPointerField{
+	fromPointer := AssignTagFromPointerField{
 		StringField:                  &stringField,
 		BoolField:                    &boolField,
 		Int8Field:                    &int8Field,
@@ -399,101 +400,127 @@ func TestAssignTagDefaultUsage(t *testing.T) {
 		FromStringToTimeField:        &fromStringToTimeField,
 	}
 
-	to := AssignTo{}
-	toPointer := AssignToPointerField{}
+	fromPointerNil := AssignTagFromPointerField{}
+
+	to := AssignTagTo{}
+	toPointer := AssignTagToPointerField{}
 
 	err := assign.DefaultUsage(from, to)
 	if err == nil || err.Error() != "返回类型不是结构指针" {
-		t.Fatal("to参数必须是指针类型")
+		t.Fatalf("%+v", errors.Errorf("to参数必须是指针类型"))
 	}
 
 	err = assign.DefaultUsage(from, toPointer)
 	if err == nil || err.Error() != "返回类型不是结构指针" {
-		t.Fatal("to参数必须是指针类型")
+		t.Fatalf("%+v", errors.Errorf("to参数必须是指针类型"))
 	}
 
 	err = assign.DefaultUsage(fromPointer, to)
 	if err == nil || err.Error() != "返回类型不是结构指针" {
-		t.Fatal("to参数必须是指针类型")
+		t.Fatalf("%+v", errors.Errorf("to参数必须是指针类型"))
 	}
 
 	err = assign.DefaultUsage(fromPointer, toPointer)
 	if err == nil || err.Error() != "返回类型不是结构指针" {
-		t.Fatal("to参数必须是指针类型")
+		t.Fatalf("%+v", errors.Errorf("to参数必须是指针类型"))
 	}
 
 	err = assign.DefaultUsage(from, &to)
 	if err != nil {
-		t.Fatal(err)
+		t.Fatalf("%+v", errors.Errorf(err.Error()))
 	}
 
 	to.checkFields(t, from)
 
 	err = assign.DefaultUsage(from, &toPointer)
 	if err != nil {
-		t.Fatal(err)
+		t.Fatalf("%+v", errors.Errorf(err.Error()))
 	}
 
 	toPointer.checkFields(t, from)
 
 	err = assign.DefaultUsage(fromPointer, &to)
 	if err != nil {
-		t.Fatal(err)
+		t.Fatalf("%+v", errors.Errorf(err.Error()))
 	}
 
 	to.checkFields(t, from)
 
 	err = assign.DefaultUsage(fromPointer, &toPointer)
 	if err != nil {
-		t.Fatal(err)
+		t.Fatalf("%+v", errors.Errorf(err.Error()))
 	}
 
 	toPointer.checkFields(t, from)
 
 	err = assign.DefaultUsage(&from, to)
 	if err == nil || err.Error() != "返回类型不是结构指针" {
-		t.Fatal("to参数必须是指针类型")
+		t.Fatalf("%+v", errors.Errorf("to参数必须是指针类型"))
 	}
 
 	err = assign.DefaultUsage(&from, toPointer)
 	if err == nil || err.Error() != "返回类型不是结构指针" {
-		t.Fatal("to参数必须是指针类型")
+		t.Fatalf("%+v", errors.Errorf("to参数必须是指针类型"))
 	}
 
 	err = assign.DefaultUsage(&fromPointer, to)
 	if err == nil || err.Error() != "返回类型不是结构指针" {
-		t.Fatal("to参数必须是指针类型")
+		t.Fatalf("%+v", errors.Errorf("to参数必须是指针类型"))
 	}
 
 	err = assign.DefaultUsage(&fromPointer, toPointer)
 	if err == nil || err.Error() != "返回类型不是结构指针" {
-		t.Fatal("to参数必须是指针类型")
+		t.Fatalf("%+v", errors.Errorf("to参数必须是指针类型"))
 	}
 
 	err = assign.DefaultUsage(&from, &to)
 	if err != nil {
-		t.Fatal(err)
+		t.Fatalf("%+v", errors.Errorf(err.Error()))
 	}
 
 	to.checkFields(t, from)
 
 	err = assign.DefaultUsage(&from, &toPointer)
 	if err != nil {
-		t.Fatal(err)
+		t.Fatalf("%+v", errors.Errorf(err.Error()))
 	}
 
 	toPointer.checkFields(t, from)
 
 	err = assign.DefaultUsage(&fromPointer, &to)
 	if err != nil {
-		t.Fatal(err)
+		t.Fatalf("%+v", errors.Errorf(err.Error()))
 	}
 
 	to.checkFields(t, from)
 
 	err = assign.DefaultUsage(&fromPointer, &toPointer)
 	if err != nil {
-		t.Fatal(err)
+		t.Fatalf("%+v", errors.Errorf(err.Error()))
+	}
+
+	toPointer.checkFields(t, from)
+
+	err = assign.DefaultUsage(fromPointerNil, &to)
+	if err == nil || err.Error() != "无法设置值，请检查是否传递的是非指针结构变量且字段为nil" {
+		t.Fatalf("%+v", errors.Errorf("from如果有nil字段，必须使用指针结构变量"))
+	}
+
+	err = assign.DefaultUsage(fromPointerNil, &toPointer)
+	if err == nil || err.Error() != "无法设置值，请检查是否传递的是非指针结构变量且字段为nil" {
+		t.Fatalf("%+v", errors.Errorf("from如果有nil字段，必须使用指针结构变量"))
+	}
+
+	err = assign.DefaultUsage(&fromPointerNil, &to)
+	if err != nil {
+		t.Fatalf("%+v", errors.Errorf(err.Error()))
+	}
+
+	to.checkFields(t, from)
+
+	err = assign.DefaultUsage(&fromPointerNil, &toPointer)
+	if err != nil {
+		t.Fatalf("%+v", errors.Errorf(err.Error()))
 	}
 
 	toPointer.checkFields(t, from)

test/check_tag_test.go

@@ -0,0 +1,11 @@
+package test
+
+import "testing"
+
+//type CheckStruct {
+//
+//}
+
+func TestCustomCheckTag(t *testing.T) {
+
+}

test/sql_mapping_tag_test.go

@@ -4,11 +4,13 @@ import (
 	"git.sxidc.com/go-framework/baize/framework/core/tag/sql/sql_mapping"
 	"git.sxidc.com/go-tools/utils/encoding"
 	"git.sxidc.com/go-tools/utils/strutils"
+	"github.com/pkg/errors"
+	"math/rand"
 	"strings"
 	"testing"
 )
 
-type SqlMappingStruct struct {
+type SqlMappingTagStruct struct {
 	Ignore          string   `sqlmapping:"-"`
 	Column          string   `sqlmapping:"column:test_column"`
 	Key             string   `sqlmapping:"key"`
@@ -26,201 +28,456 @@ type SqlMappingStruct struct {
 	WrongTrimSuffix int      `sqlmapping:"trimSuffix:}}"`
 }
 
-func (s SqlMappingStruct) checkFields(t *testing.T, fields []sql_mapping.Field) {
+func (s SqlMappingTagStruct) checkFields(t *testing.T, fields []sql_mapping.Field) {
 	for _, field := range fields {
 		if field.FieldName == "Ignore" || field.ColumnName == "ignore" {
-			t.Fatal("忽略字段没有被忽略")
+			t.Fatalf("%+v", errors.Errorf("忽略字段没有被忽略"))
 		}
 
 		switch field.FieldName {
 		case "Column":
 			if s.Column != field.Value {
-				t.Fatalf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
-					field.FieldName, s.Column, field.Value)
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, s.Column, field.Value))
 			}
 
 			if field.ColumnName != "test_column" {
-				t.Fatalf("列名解析测试错误: fieldName: %v, actual columnName: %v",
-					field.FieldName, field.ColumnName)
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
 			}
 		case "Key":
 			if field.ColumnName != "key" {
-				t.Fatalf("列名解析测试错误: fieldName: %v, actual columnName: %v",
-					field.FieldName, field.ColumnName)
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
 			}
 
 			if s.Key != field.Value {
-				t.Fatalf("值不正确: fieldName: %v, fieldValue %v, tagValue %v",
-					field.FieldName, s.Key, field.Value)
+				t.Fatalf("%+v", errors.Errorf("值不正确: fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, s.Key, field.Value))
 			}
 
 			if !field.IsKey {
-				t.Fatal("key解析错误")
+				t.Fatalf("%+v", errors.Errorf("key解析错误"))
 			}
 		case "NotUpdate":
 			if field.ColumnName != "not_update" {
-				t.Fatalf("列名解析测试错误: fieldName: %v, actual columnName: %v",
-					field.FieldName, field.ColumnName)
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
 			}
 
 			if s.NotUpdate != field.Value {
-				t.Fatalf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
-					field.FieldName, s.NotUpdate, field.Value)
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, s.NotUpdate, field.Value))
 			}
 
 			if field.CanUpdate {
-				t.Fatal("notUpdate解析错误")
+				t.Fatalf("%+v", errors.Errorf("notUpdate解析错误"))
 			}
 		case "UpdateClear":
 			if field.ColumnName != "update_clear" {
-				t.Fatalf("列名解析测试错误: fieldName: %v, actual columnName: %v",
-					field.FieldName, field.ColumnName)
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
 			}
 
 			if s.UpdateClear != field.Value {
-				t.Fatalf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
-					field.FieldName, s.UpdateClear, field.Value)
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, s.UpdateClear, field.Value))
 			}
 
 			if !field.CanUpdateClear {
-				t.Fatal("updateClear解析错误")
+				t.Fatalf("%+v", errors.Errorf("updateClear解析错误"))
 			}
 		case "Aes":
 			if field.ColumnName != "aes" {
-				t.Fatalf("列名解析测试错误: fieldName: %v, actual columnName: %v",
-					field.FieldName, field.ColumnName)
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
 			}
 
 			encrypted, err := encoding.AESEncrypt(s.Aes, "@MKU^*HF%p%G43Fd)UAHCVD#$XZSWQ@L")
 			if err != nil {
-				t.Fatal(err)
+				t.Fatalf("%+v", errors.Errorf(err.Error()))
 			}
 
 			if encrypted != field.Value {
-				t.Fatalf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
-					field.FieldName, encrypted, field.Value)
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, encrypted, field.Value))
 			}
 		case "JoinWith":
 			if field.ColumnName != "join_with" {
-				t.Fatalf("列名解析测试错误: fieldName: %v, actual columnName: %v",
-					field.FieldName, field.ColumnName)
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
 			}
 
 			if strings.Join(s.JoinWith, "##") != field.Value {
-				t.Fatalf("值不正确: fieldName: %v, fieldValue %v, tagValue %v",
-					field.FieldName, strings.Join(s.JoinWith, "##"), field.Value)
+				t.Fatalf("%+v", errors.Errorf("值不正确: fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, strings.Join(s.JoinWith, "##"), field.Value))
 			}
 		case "Trim":
 			if field.ColumnName != "trim" {
-				t.Fatalf("列名解析测试错误: fieldName: %v, actual columnName: %v",
-					field.FieldName, field.ColumnName)
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
 			}
 
 			if strings.Trim(s.Trim, "||") != field.Value {
-				t.Fatalf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
-					field.FieldName, strings.Trim(s.Trim, "||"), field.Value)
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, strings.Trim(s.Trim, "||"), field.Value))
 			}
 		case "TrimPrefix":
 			if field.ColumnName != "trim_prefix" {
-				t.Fatalf("列名解析测试错误: fieldName: %v, actual columnName: %v",
-					field.FieldName, field.ColumnName)
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
 			}
 
 			if strings.TrimPrefix(s.TrimPrefix, "{{") != field.Value {
-				t.Fatalf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
-					field.FieldName, strings.TrimPrefix(s.TrimPrefix, "{{"), field.Value)
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, strings.TrimPrefix(s.TrimPrefix, "{{"), field.Value))
 			}
 		case "TrimSuffix":
 			if field.ColumnName != "trim_suffix" {
-				t.Fatalf("列名解析测试错误: fieldName: %v, actual columnName: %v",
-					field.FieldName, field.ColumnName)
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
 			}
 
 			if strings.TrimSuffix(s.TrimSuffix, "}}") != field.Value {
-				t.Fatalf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
-					field.FieldName, strings.TrimSuffix(s.TrimPrefix, "}}"), field.Value)
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, strings.TrimSuffix(s.TrimPrefix, "}}"), field.Value))
 			}
 		case "WrongAes":
 			if field.ColumnName != "wrong_aes" {
-				t.Fatalf("列名解析测试错误: fieldName: %v, actual columnName: %v",
-					field.FieldName, field.ColumnName)
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
 			}
 
 			if s.WrongAes != field.Value {
-				t.Fatalf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
-					field.FieldName, s.WrongAes, field.Value)
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, s.WrongAes, field.Value))
 			}
 		case "WrongJoinWith":
 			if field.ColumnName != "wrong_join_with" {
-				t.Fatalf("列名解析测试错误: fieldName: %v, actual columnName: %v",
-					field.FieldName, field.ColumnName)
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
 			}
 
 			if s.WrongJoinWith != field.Value {
-				t.Fatalf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
-					field.FieldName, s.WrongJoinWith, field.Value)
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, s.WrongJoinWith, field.Value))
 			}
 		case "WrongTrim":
 			if field.ColumnName != "wrong_trim" {
-				t.Fatalf("列名解析测试错误: fieldName: %v, actual columnName: %v",
-					field.FieldName, field.ColumnName)
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
 			}
 
 			if s.WrongTrim != field.Value {
-				t.Fatalf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
-					field.FieldName, s.WrongTrim, field.Value)
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, s.WrongTrim, field.Value))
 			}
 		case "WrongTrimPrefix":
 			if field.ColumnName != "wrong_trim_prefix" {
-				t.Fatalf("列名解析测试错误: fieldName: %v, actual columnName: %v",
-					field.FieldName, field.ColumnName)
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
 			}
 
 			if s.WrongTrimPrefix != field.Value {
-				t.Fatalf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
-					field.FieldName, s.WrongTrimPrefix, field.Value)
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, s.WrongTrimPrefix, field.Value))
 			}
 		case "WrongTrimSuffix":
 			if field.ColumnName != "wrong_trim_suffix" {
-				t.Fatalf("列名解析测试错误: fieldName: %v, actual columnName: %v",
-					field.FieldName, field.ColumnName)
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
 			}
 
 			if s.WrongTrimSuffix != field.Value {
-				t.Fatalf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
-					field.FieldName, s.WrongTrimPrefix, field.Value)
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, s.WrongTrimPrefix, field.Value))
 			}
 		default:
-			t.Fatalf("未知的字段名: tag fieldName: %v", field.FieldName)
+			t.Fatalf("%+v", errors.Errorf("未知的字段名: tag fieldName: %v", field.FieldName))
+		}
+	}
+}
+
+type SqlMappingTagStructPointerFields struct {
+	Ignore          *string   `sqlmapping:"-"`
+	Column          *string   `sqlmapping:"column:test_column"`
+	Key             *string   `sqlmapping:"key"`
+	NotUpdate       *string   `sqlmapping:"notUpdate"`
+	UpdateClear     *string   `sqlmapping:"updateClear"`
+	Aes             *string   `sqlmapping:"aes:@MKU^*HF%p%G43Fd)UAHCVD#$XZSWQ@L"`
+	JoinWith        *[]string `sqlmapping:"joinWith:##"`
+	Trim            *string   `sqlmapping:"trim:||"`
+	TrimPrefix      *string   `sqlmapping:"trimPrefix:{{"`
+	TrimSuffix      *string   `sqlmapping:"trimSuffix:}}"`
+	WrongAes        *int      `sqlmapping:"aes:@MKU^*HF%p%G43Fd)UAHCVD#$XZSWQ@L"`
+	WrongJoinWith   *string   `sqlmapping:"joinWith:##"`
+	WrongTrim       *int      `sqlmapping:"trim:||"`
+	WrongTrimPrefix *int      `sqlmapping:"trimPrefix:{{"`
+	WrongTrimSuffix *int      `sqlmapping:"trimSuffix:}}"`
+}
+
+func (s SqlMappingTagStructPointerFields) checkFields(t *testing.T, fields []sql_mapping.Field) {
+	for _, field := range fields {
+		if field.FieldName == "Ignore" || field.ColumnName == "ignore" {
+			t.Fatalf("%+v", errors.Errorf("忽略字段没有被忽略"))
+		}
+
+		switch field.FieldName {
+		case "Column":
+			if *s.Column != field.Value {
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, s.Column, field.Value))
+			}
+
+			if field.ColumnName != "test_column" {
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
+			}
+		case "Key":
+			if field.ColumnName != "key" {
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
+			}
+
+			if *s.Key != field.Value {
+				t.Fatalf("%+v", errors.Errorf("值不正确: fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, s.Key, field.Value))
+			}
+
+			if !field.IsKey {
+				t.Fatalf("%+v", errors.Errorf("key解析错误"))
+			}
+		case "NotUpdate":
+			if field.ColumnName != "not_update" {
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
+			}
+
+			if *s.NotUpdate != field.Value {
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, s.NotUpdate, field.Value))
+			}
+
+			if field.CanUpdate {
+				t.Fatalf("%+v", errors.Errorf("notUpdate解析错误"))
+			}
+		case "UpdateClear":
+			if field.ColumnName != "update_clear" {
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
+			}
+
+			if *s.UpdateClear != field.Value {
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, s.UpdateClear, field.Value))
+			}
+
+			if !field.CanUpdateClear {
+				t.Fatalf("%+v", errors.Errorf("updateClear解析错误"))
+			}
+		case "Aes":
+			if field.ColumnName != "aes" {
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
+			}
+
+			encrypted, err := encoding.AESEncrypt(*s.Aes, "@MKU^*HF%p%G43Fd)UAHCVD#$XZSWQ@L")
+			if err != nil {
+				t.Fatalf("%+v", errors.Errorf(err.Error()))
+			}
+
+			if encrypted != field.Value {
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, encrypted, field.Value))
+			}
+		case "JoinWith":
+			if field.ColumnName != "join_with" {
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
+			}
+
+			if strings.Join(*s.JoinWith, "##") != field.Value {
+				t.Fatalf("%+v", errors.Errorf("值不正确: fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, strings.Join(*s.JoinWith, "##"), field.Value))
+			}
+		case "Trim":
+			if field.ColumnName != "trim" {
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
+			}
+
+			if strings.Trim(*s.Trim, "||") != field.Value {
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, strings.Trim(*s.Trim, "||"), field.Value))
+			}
+		case "TrimPrefix":
+			if field.ColumnName != "trim_prefix" {
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
+			}
+
+			if strings.TrimPrefix(*s.TrimPrefix, "{{") != field.Value {
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, strings.TrimPrefix(*s.TrimPrefix, "{{"), field.Value))
+			}
+		case "TrimSuffix":
+			if field.ColumnName != "trim_suffix" {
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
+			}
+
+			if strings.TrimSuffix(*s.TrimSuffix, "}}") != field.Value {
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, strings.TrimSuffix(*s.TrimPrefix, "}}"), field.Value))
+			}
+		case "WrongAes":
+			if field.ColumnName != "wrong_aes" {
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
+			}
+
+			if *s.WrongAes != field.Value {
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, s.WrongAes, field.Value))
+			}
+		case "WrongJoinWith":
+			if field.ColumnName != "wrong_join_with" {
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
+			}
+
+			if *s.WrongJoinWith != field.Value {
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, s.WrongJoinWith, field.Value))
+			}
+		case "WrongTrim":
+			if field.ColumnName != "wrong_trim" {
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
+			}
+
+			if *s.WrongTrim != field.Value {
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, s.WrongTrim, field.Value))
+			}
+		case "WrongTrimPrefix":
+			if field.ColumnName != "wrong_trim_prefix" {
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
+			}
+
+			if *s.WrongTrimPrefix != field.Value {
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, s.WrongTrimPrefix, field.Value))
+			}
+		case "WrongTrimSuffix":
+			if field.ColumnName != "wrong_trim_suffix" {
+				t.Fatalf("%+v", errors.Errorf("列名解析测试错误: fieldName: %v, actual columnName: %v",
+					field.FieldName, field.ColumnName))
+			}
+
+			if *s.WrongTrimSuffix != field.Value {
+				t.Fatalf("%+v", errors.Errorf("值不正确:fieldName: %v, fieldValue %v, tagValue %v",
+					field.FieldName, s.WrongTrimPrefix, field.Value))
+			}
+		default:
+			t.Fatalf("%+v", errors.Errorf("未知的字段名: tag fieldName: %v", field.FieldName))
 		}
 	}
 }
 
 func TestSqlMappingTagDefaultTag(t *testing.T) {
-	s := SqlMappingStruct{
-		Ignore:      strutils.SimpleUUID(),
-		Column:      strutils.SimpleUUID(),
-		Key:         strutils.SimpleUUID(),
-		NotUpdate:   strutils.SimpleUUID(),
-		UpdateClear: strutils.SimpleUUID(),
-		Aes:         strutils.SimpleUUID(),
-		JoinWith:    []string{strutils.SimpleUUID(), strutils.SimpleUUID()},
-		Trim:        strutils.SimpleUUID(),
-		TrimPrefix:  strutils.SimpleUUID(),
-		TrimSuffix:  strutils.SimpleUUID(),
+	ignore := strutils.SimpleUUID()
+	column := strutils.SimpleUUID()
+	key := strutils.SimpleUUID()
+	notUpdate := strutils.SimpleUUID()
+	updateClear := strutils.SimpleUUID()
+	aes := strutils.SimpleUUID()
+	joinWith := []string{strutils.SimpleUUID(), strutils.SimpleUUID()}
+	trim := strutils.SimpleUUID()
+	trimPrefix := strutils.SimpleUUID()
+	trimSuffix := strutils.SimpleUUID()
+	wrongAes := rand.Int()
+	wrongJoinWith := strutils.SimpleUUID()
+	wrongTrim := rand.Int()
+	wrongTrimPrefix := rand.Int()
+	wrongTrimSuffix := rand.Int()
+
+	s := SqlMappingTagStruct{
+		Ignore:          ignore,
+		Column:          column,
+		Key:             key,
+		NotUpdate:       notUpdate,
+		UpdateClear:     updateClear,
+		Aes:             aes,
+		JoinWith:        joinWith,
+		Trim:            trim,
+		TrimPrefix:      trimPrefix,
+		TrimSuffix:      trimSuffix,
+		WrongAes:        wrongAes,
+		WrongJoinWith:   wrongJoinWith,
+		WrongTrim:       wrongTrim,
+		WrongTrimPrefix: wrongTrimPrefix,
+		WrongTrimSuffix: wrongTrimSuffix,
 	}
 
+	sPointerFields := SqlMappingTagStructPointerFields{
+		Ignore:          &ignore,
+		Column:          &column,
+		Key:             &key,
+		NotUpdate:       &notUpdate,
+		UpdateClear:     &updateClear,
+		Aes:             &aes,
+		JoinWith:        &joinWith,
+		Trim:            &trim,
+		TrimPrefix:      &trimPrefix,
+		TrimSuffix:      &trimSuffix,
+		WrongAes:        &wrongAes,
+		WrongJoinWith:   &wrongJoinWith,
+		WrongTrim:       &wrongTrim,
+		WrongTrimPrefix: &wrongTrimPrefix,
+		WrongTrimSuffix: &wrongTrimSuffix,
+	}
+
+	sPointerFieldsNil := SqlMappingTagStructPointerFields{}
+
 	fields, err := sql_mapping.DefaultUsage(s)
 	if err != nil {
-		t.Fatal(err)
+		t.Fatalf("%+v", errors.Errorf(err.Error()))
 	}
 
 	s.checkFields(t, fields)
 
 	fields, err = sql_mapping.DefaultUsage(&s)
 	if err != nil {
-		t.Fatal(err)
+		t.Fatalf("%+v", errors.Errorf(err.Error()))
 	}
 
 	s.checkFields(t, fields)
+
+	fields, err = sql_mapping.DefaultUsage(sPointerFields)
+	if err != nil {
+		t.Fatalf("%+v", errors.Errorf(err.Error()))
+	}
+
+	sPointerFields.checkFields(t, fields)
+
+	fields, err = sql_mapping.DefaultUsage(&sPointerFields)
+	if err != nil {
+		t.Fatalf("%+v", errors.Errorf(err.Error()))
+	}
+
+	sPointerFields.checkFields(t, fields)
+
+	fields, err = sql_mapping.DefaultUsage(sPointerFieldsNil)
+	if err == nil || err.Error() != "无法设置值，请检查是否传递的是非指针结构变量且字段为nil" {
+		t.Fatalf("%+v", errors.Errorf("from如果有nil字段，必须使用指针结构变量"))
+	}
+
+	fields, err = sql_mapping.DefaultUsage(&sPointerFieldsNil)
+	if err != nil {
+		t.Fatalf("%+v", errors.Errorf(err.Error()))
+	}
+
+	sPointerFieldsNil.checkFields(t, fields)
 }