From 5a3bc3eed489d6f76ef01f115e8a14032b830def Mon Sep 17 00:00:00 2001 From: Lunny Xiao Date: Wed, 7 Jul 2021 23:50:23 +0800 Subject: [PATCH] Refactor get --- convert.go | 76 ++++++++++--- integrations/types_null_test.go | 21 ++-- session.go | 192 +++++++++++--------------------- session_get.go | 4 - 4 files changed, 139 insertions(+), 154 deletions(-) diff --git a/convert.go b/convert.go index 69277734..6886ccc3 100644 --- a/convert.go +++ b/convert.go @@ -579,10 +579,7 @@ func convertAssign(dest, src interface{}, originalLocation *time.Location, conve } func convertAssignV(dpv reflect.Value, src interface{}, originalLocation, convertedLocation *time.Location) error { - if dpv.Kind() != reflect.Ptr { - return errors.New("destination not a pointer") - } - if dpv.IsNil() { + if dpv.Kind() == reflect.Ptr && dpv.IsNil() { return errNilPtr } @@ -640,6 +637,36 @@ func convertAssignV(dpv reflect.Value, src interface{}, originalLocation, conver case reflect.String: dv.SetString(asString(src)) return nil + case reflect.Bool: + b, err := asBool(src) + if err != nil { + return err + } + dv.SetBool(b) + return nil + case reflect.Array: + var bs []byte + switch t := src.(type) { + case string: + bs = []byte(t) + case []byte: + bs = t + } + + if bs != nil { + if dv.Len() > 0 { + for i := 0; i < dv.Len(); i++ { + if i < len(bs) { + dv.Index(i).Set(reflect.ValueOf(bs[i])) + } + } + } else { + for i := 0; i < len(bs); i++ { + dv.Set(reflect.Append(dv, reflect.ValueOf(bs[i]))) + } + } + return nil + } } return fmt.Errorf("unsupported Scan, storing driver.Value type %T into type %T", src, dpv.Interface()) @@ -682,16 +709,39 @@ func asKind(vv reflect.Value, tp reflect.Type) (interface{}, error) { return nil, fmt.Errorf("unsupported primary key type: %v, %v", tp, vv) } -func asBool(bs []byte) (bool, error) { - if len(bs) == 0 { - return false, nil +func asBool(src interface{}) (bool, error) { + switch v := src.(type) { + case bool: + return v, nil + case *bool: + return *v, nil + case *sql.NullBool: + return v.Bool, nil + case int64: + return v > 0, nil + case int: + return v > 0, nil + case int8: + return v > 0, nil + case int16: + return v > 0, nil + case int32: + return v > 0, nil + case []byte: + if len(v) == 0 { + return false, nil + } + if v[0] == 0x00 { + return false, nil + } else if v[0] == 0x01 { + return true, nil + } + return strconv.ParseBool(string(v)) + case string: + return strconv.ParseBool(v) + default: + return false, fmt.Errorf("unknow type %T as bool", src) } - if bs[0] == 0x00 { - return false, nil - } else if bs[0] == 0x01 { - return true, nil - } - return strconv.ParseBool(string(bs)) } // str2PK convert string value to primary key value according to tp diff --git a/integrations/types_null_test.go b/integrations/types_null_test.go index 98bd86b9..3692a89b 100644 --- a/integrations/types_null_test.go +++ b/integrations/types_null_test.go @@ -7,7 +7,6 @@ package integrations import ( "database/sql" "database/sql/driver" - "errors" "fmt" "strconv" "strings" @@ -42,15 +41,21 @@ func (m *CustomStruct) Scan(value interface{}) error { return nil } - if s, ok := value.([]byte); ok { - seps := strings.Split(string(s), "/") - m.Year, _ = strconv.Atoi(seps[0]) - m.Month, _ = strconv.Atoi(seps[1]) - m.Day, _ = strconv.Atoi(seps[2]) - return nil + var s string + switch t := value.(type) { + case []byte: + s = string(t) + case string: + s = t + default: + return fmt.Errorf("scan data not fit %T", value) } - return errors.New("scan data not fit []byte") + seps := strings.Split(string(s), "/") + m.Year, _ = strconv.Atoi(seps[0]) + m.Month, _ = strconv.Atoi(seps[1]) + m.Day, _ = strconv.Atoi(seps[2]) + return nil } func (m CustomStruct) Value() (driver.Value, error) { diff --git a/session.go b/session.go index 486911a5..7cb89bcc 100644 --- a/session.go +++ b/session.go @@ -365,25 +365,25 @@ func (session *Session) doPrepare(db *core.DB, sqlStr string) (stmt *core.Stmt, return } -func (session *Session) getField(dataStruct *reflect.Value, key string, table *schemas.Table, idx int) (*reflect.Value, error) { +func (session *Session) getField(dataStruct *reflect.Value, key string, table *schemas.Table, idx int) (*schemas.Column, *reflect.Value, error) { var col *schemas.Column if col = table.GetColumnIdx(key, idx); col == nil { - return nil, ErrFieldIsNotExist{key, table.Name} + return nil, nil, ErrFieldIsNotExist{key, table.Name} } fieldValue, err := col.ValueOfV(dataStruct) if err != nil { - return nil, err + return nil, nil, err } if fieldValue == nil { - return nil, ErrFieldIsNotValid{key, table.Name} + return nil, nil, ErrFieldIsNotValid{key, table.Name} } if !fieldValue.IsValid() || !fieldValue.CanSet() { - return nil, ErrFieldIsNotValid{key, table.Name} + return nil, nil, ErrFieldIsNotValid{key, table.Name} } - return fieldValue, nil + return col, fieldValue, nil } // Cell cell is a result of one column field @@ -436,6 +436,38 @@ func (session *Session) row2Slice(rows *core.Rows, fields []string, bean interfa return scanResults, nil } +func (session *Session) setJSON(fieldValue *reflect.Value, fieldType reflect.Type, vv reflect.Value, rawValueType reflect.Type) error { + var bs []byte + if rawValueType.Kind() == reflect.String { + bs = []byte(vv.String()) + } else if rawValueType.ConvertibleTo(schemas.BytesType) { + bs = vv.Bytes() + } else { + return fmt.Errorf("unsupported database data type: %v", rawValueType.Kind()) + } + + if len(bs) > 0 { + if fieldType.Kind() == reflect.String { + fieldValue.SetString(string(bs)) + return nil + } + if fieldValue.CanAddr() { + err := json.DefaultJSONHandler.Unmarshal(bs, fieldValue.Addr().Interface()) + if err != nil { + return err + } + } else { + x := reflect.New(fieldType) + err := json.DefaultJSONHandler.Unmarshal(bs, x.Interface()) + if err != nil { + return err + } + fieldValue.Set(x.Elem()) + } + } + return nil +} + func (session *Session) convertBeanField(col *schemas.Column, fieldValue *reflect.Value, scanResult interface{}, table *schemas.Table) error { v, ok := scanResult.(*interface{}) @@ -482,35 +514,7 @@ func (session *Session) convertBeanField(col *schemas.Column, fieldValue *reflec fieldType := fieldValue.Type() if col.IsJSON { - var bs []byte - if rawValueType.Kind() == reflect.String { - bs = []byte(vv.String()) - } else if rawValueType.ConvertibleTo(schemas.BytesType) { - bs = vv.Bytes() - } else { - return fmt.Errorf("unsupported database data type: %s %v", col.Name, rawValueType.Kind()) - } - - if len(bs) > 0 { - if fieldType.Kind() == reflect.String { - fieldValue.SetString(string(bs)) - return nil - } - if fieldValue.CanAddr() { - err := json.DefaultJSONHandler.Unmarshal(bs, fieldValue.Addr().Interface()) - if err != nil { - return err - } - } else { - x := reflect.New(fieldType) - err := json.DefaultJSONHandler.Unmarshal(bs, x.Interface()) - if err != nil { - return err - } - fieldValue.Set(x.Elem()) - } - } - return nil + return session.setJSON(fieldValue, fieldType, vv, rawValueType) } switch fieldType.Kind() { @@ -529,32 +533,26 @@ func (session *Session) convertBeanField(col *schemas.Column, fieldValue *reflec } return nil case reflect.Complex64, reflect.Complex128: - // TODO: reimplement this - var bs []byte - if rawValueType.Kind() == reflect.String { - bs = []byte(vv.String()) - } else if rawValueType.ConvertibleTo(schemas.BytesType) { - bs = vv.Bytes() + return session.setJSON(fieldValue, fieldType, vv, rawValueType) + case reflect.Map: + switch rawValueType.Kind() { + case reflect.String: + return session.setJSON(fieldValue, fieldType, vv, rawValueType) + case reflect.Slice: + return session.setJSON(fieldValue, fieldType, vv, rawValueType) + default: + return fmt.Errorf("unsupported %v -> %T", scanResult, fieldType) } - - if len(bs) > 0 { - if fieldValue.CanAddr() { - err := json.DefaultJSONHandler.Unmarshal(bs, fieldValue.Addr().Interface()) - if err != nil { - return err - } - } else { - x := reflect.New(fieldType) - err := json.DefaultJSONHandler.Unmarshal(bs, x.Interface()) - if err != nil { - return err - } - fieldValue.Set(x.Elem()) - } - } - return nil case reflect.Slice, reflect.Array: switch rawValueType.Kind() { + case reflect.String: + x := reflect.New(fieldType) + err := json.DefaultJSONHandler.Unmarshal([]byte(vv.String()), x.Interface()) + if err != nil { + return err + } + fieldValue.Set(x.Elem()) + return nil case reflect.Slice, reflect.Array: switch rawValueType.Elem().Kind() { case reflect.Uint8: @@ -583,37 +581,6 @@ func (session *Session) convertBeanField(col *schemas.Column, fieldValue *reflec } } } - case reflect.String: - if rawValueType.Kind() == reflect.String { - fieldValue.SetString(vv.String()) - return nil - } - case reflect.Bool: - if rawValueType.Kind() == reflect.Bool { - fieldValue.SetBool(vv.Bool()) - return nil - } - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - switch rawValueType.Kind() { - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - fieldValue.SetInt(vv.Int()) - return nil - } - case reflect.Float32, reflect.Float64: - switch rawValueType.Kind() { - case reflect.Float32, reflect.Float64: - fieldValue.SetFloat(vv.Float()) - return nil - } - case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: - switch rawValueType.Kind() { - case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: - fieldValue.SetUint(vv.Uint()) - return nil - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - fieldValue.SetUint(uint64(vv.Int())) - return nil - } case reflect.Struct: if fieldType.ConvertibleTo(schemas.BigFloatType) { v, err := asBigFloat(scanResult) @@ -677,28 +644,6 @@ func (session *Session) convertBeanField(col *schemas.Column, fieldValue *reflec return nil } session.engine.logger.Errorf("sql.Sanner error: %v", err) - } else if col.IsJSON { - if rawValueType.Kind() == reflect.String { - x := reflect.New(fieldType) - if len([]byte(vv.String())) > 0 { - err := json.DefaultJSONHandler.Unmarshal([]byte(vv.String()), x.Interface()) - if err != nil { - return err - } - fieldValue.Set(x.Elem()) - } - return nil - } else if rawValueType.Kind() == reflect.Slice { - x := reflect.New(fieldType) - if len(vv.Bytes()) > 0 { - err := json.DefaultJSONHandler.Unmarshal(vv.Bytes(), x.Interface()) - if err != nil { - return err - } - fieldValue.Set(x.Elem()) - } - return nil - } } else if session.statement.UseCascade { table, err := session.engine.tagParser.ParseWithCache(*fieldValue) if err != nil { @@ -731,42 +676,30 @@ func (session *Session) convertBeanField(col *schemas.Column, fieldValue *reflec } return nil } + return session.setJSON(fieldValue, fieldType, vv, rawValueType) } // switch fieldType.Kind() - data, err := value2Bytes(&rawValue) - if err != nil { - return err - } - - return session.bytes2Value(col, fieldValue, data) + return convertAssignV(fieldValue.Addr(), scanResult, session.engine.DatabaseTZ, session.engine.TZLocation) } func (session *Session) slice2Bean(scanResults []interface{}, fields []string, bean interface{}, dataStruct *reflect.Value, table *schemas.Table) (schemas.PK, error) { - defer func() { - executeAfterSet(bean, fields, scanResults) - }() + defer executeAfterSet(bean, fields, scanResults) buildAfterProcessors(session, bean) var tempMap = make(map[string]int) var pk schemas.PK for ii, key := range fields { - var idx int var lKey = strings.ToLower(key) - var ok bool - - if idx, ok = tempMap[lKey]; !ok { + idx, ok := tempMap[lKey] + if !ok { idx = 0 } else { idx = idx + 1 } - tempMap[lKey] = idx - col := table.GetColumnIdx(key, idx) - var scanResult = scanResults[ii] - - fieldValue, err := session.getField(dataStruct, key, table, idx) + col, fieldValue, err := session.getField(dataStruct, key, table, idx) if err != nil { if _, ok := err.(ErrFieldIsNotValid); !ok { session.engine.logger.Warnf("%v", err) @@ -777,6 +710,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b continue } + var scanResult = scanResults[ii] if err := session.convertBeanField(col, fieldValue, scanResult, table); err != nil { return nil, err } diff --git a/session_get.go b/session_get.go index cc6427d7..07a8dffd 100644 --- a/session_get.go +++ b/session_get.go @@ -70,10 +70,6 @@ func (session *Session) get(bean interface{}) (bool, error) { } } - var sqlStr string - var args []interface{} - var err error - if session.statement.RawSQL == "" { if len(session.statement.TableName()) <= 0 { return false, ErrTableNotFound