Merge branch 'develop' of github.com:beego/beego into develop

client/orm/internal/logs/log.go

@@ -0,0 +1,20 @@
+package logs
+
+import (
+	"io"
+	"log"
+	"os"
+)
+
+var DebugLog = NewLog(os.Stdout)
+
+// Log implement the log.Logger
+type Log struct {
+	*log.Logger
+}
+
+func NewLog(out io.Writer) *Log {
+	d := new(Log)
+	d.Logger = log.New(out, "[ORM]", log.LstdFlags)
+	return d
+}

client/orm/internal/models/models_fields.go

@@ -0,0 +1,785 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package models
+
+import (
+	"fmt"
+	"strconv"
+	"time"
+
+	"github.com/beego/beego/v2/client/orm/internal/utils"
+)
+
+// Define the Type enum
+const (
+	TypeBooleanField = 1 << iota
+	TypeVarCharField
+	TypeCharField
+	TypeTextField
+	TypeTimeField
+	TypeDateField
+	TypeDateTimeField
+	TypeBitField
+	TypeSmallIntegerField
+	TypeIntegerField
+	TypeBigIntegerField
+	TypePositiveBitField
+	TypePositiveSmallIntegerField
+	TypePositiveIntegerField
+	TypePositiveBigIntegerField
+	TypeFloatField
+	TypeDecimalField
+	TypeJSONField
+	TypeJsonbField
+	RelForeignKey
+	RelOneToOne
+	RelManyToMany
+	RelReverseOne
+	RelReverseMany
+)
+
+// Define some logic enum
+const (
+	IsIntegerField         = ^-TypePositiveBigIntegerField >> 6 << 7
+	IsPositiveIntegerField = ^-TypePositiveBigIntegerField >> 10 << 11
+	IsRelField             = ^-RelReverseMany >> 18 << 19
+	IsFieldType            = ^-RelReverseMany<<1 + 1
+)
+
+// BooleanField A true/false field.
+type BooleanField bool
+
+// Value return the BooleanField
+func (e BooleanField) Value() bool {
+	return bool(e)
+}
+
+// Set will set the BooleanField
+func (e *BooleanField) Set(d bool) {
+	*e = BooleanField(d)
+}
+
+// String format the Bool to string
+func (e *BooleanField) String() string {
+	return strconv.FormatBool(e.Value())
+}
+
+// FieldType return BooleanField the type
+func (e *BooleanField) FieldType() int {
+	return TypeBooleanField
+}
+
+// SetRaw set the interface to bool
+func (e *BooleanField) SetRaw(value interface{}) error {
+	switch d := value.(type) {
+	case bool:
+		e.Set(d)
+	case string:
+		v, err := utils.StrTo(d).Bool()
+		if err == nil {
+			e.Set(v)
+		}
+		return err
+	default:
+		return fmt.Errorf("<BooleanField.SetRaw> unknown value `%s`", value)
+	}
+	return nil
+}
+
+// RawValue return the current value
+func (e *BooleanField) RawValue() interface{} {
+	return e.Value()
+}
+
+// verify the BooleanField implement the Fielder interface
+var _ Fielder = new(BooleanField)
+
+// CharField A string field
+// required values tag: size
+// The size is enforced at the database level and in models’s validation.
+// eg: `orm:"size(120)"`
+type CharField string
+
+// Value return the CharField's Value
+func (e CharField) Value() string {
+	return string(e)
+}
+
+// Set CharField value
+func (e *CharField) Set(d string) {
+	*e = CharField(d)
+}
+
+// String return the CharField
+func (e *CharField) String() string {
+	return e.Value()
+}
+
+// FieldType return the enum type
+func (e *CharField) FieldType() int {
+	return TypeVarCharField
+}
+
+// SetRaw set the interface to string
+func (e *CharField) SetRaw(value interface{}) error {
+	switch d := value.(type) {
+	case string:
+		e.Set(d)
+	default:
+		return fmt.Errorf("<CharField.SetRaw> unknown value `%s`", value)
+	}
+	return nil
+}
+
+// RawValue return the CharField value
+func (e *CharField) RawValue() interface{} {
+	return e.Value()
+}
+
+// verify CharField implement Fielder
+var _ Fielder = new(CharField)
+
+// TimeField A time, represented in go by a time.Time instance.
+// only time values like 10:00:00
+// Has a few extra, optional attr tag:
+//
+// auto_now:
+// Automatically set the field to now every time the object is saved. Useful for “last-modified” timestamps.
+// Note that the current date is always used; it’s not just a default value that you can override.
+//
+// auto_now_add:
+// Automatically set the field to now when the object is first created. Useful for creation of timestamps.
+// Note that the current date is always used; it’s not just a default value that you can override.
+//
+// eg: `orm:"auto_now"` or `orm:"auto_now_add"`
+type TimeField time.Time
+
+// Value return the time.Time
+func (e TimeField) Value() time.Time {
+	return time.Time(e)
+}
+
+// Set set the TimeField's value
+func (e *TimeField) Set(d time.Time) {
+	*e = TimeField(d)
+}
+
+// String convert time to string
+func (e *TimeField) String() string {
+	return e.Value().String()
+}
+
+// FieldType return enum type Date
+func (e *TimeField) FieldType() int {
+	return TypeDateField
+}
+
+// SetRaw convert the interface to time.Time. Allow string and time.Time
+func (e *TimeField) SetRaw(value interface{}) error {
+	switch d := value.(type) {
+	case time.Time:
+		e.Set(d)
+	case string:
+		v, err := utils.TimeParse(d, utils.FormatTime)
+		if err == nil {
+			e.Set(v)
+		}
+		return err
+	default:
+		return fmt.Errorf("<TimeField.SetRaw> unknown value `%s`", value)
+	}
+	return nil
+}
+
+// RawValue return time value
+func (e *TimeField) RawValue() interface{} {
+	return e.Value()
+}
+
+var _ Fielder = new(TimeField)
+
+// DateField A date, represented in go by a time.Time instance.
+// only date values like 2006-01-02
+// Has a few extra, optional attr tag:
+//
+// auto_now:
+// Automatically set the field to now every time the object is saved. Useful for “last-modified” timestamps.
+// Note that the current date is always used; it’s not just a default value that you can override.
+//
+// auto_now_add:
+// Automatically set the field to now when the object is first created. Useful for creation of timestamps.
+// Note that the current date is always used; it’s not just a default value that you can override.
+//
+// eg: `orm:"auto_now"` or `orm:"auto_now_add"`
+type DateField time.Time
+
+// Value return the time.Time
+func (e DateField) Value() time.Time {
+	return time.Time(e)
+}
+
+// Set set the DateField's value
+func (e *DateField) Set(d time.Time) {
+	*e = DateField(d)
+}
+
+// String convert datetime to string
+func (e *DateField) String() string {
+	return e.Value().String()
+}
+
+// FieldType return enum type Date
+func (e *DateField) FieldType() int {
+	return TypeDateField
+}
+
+// SetRaw convert the interface to time.Time. Allow string and time.Time
+func (e *DateField) SetRaw(value interface{}) error {
+	switch d := value.(type) {
+	case time.Time:
+		e.Set(d)
+	case string:
+		v, err := utils.TimeParse(d, utils.FormatDate)
+		if err == nil {
+			e.Set(v)
+		}
+		return err
+	default:
+		return fmt.Errorf("<DateField.SetRaw> unknown value `%s`", value)
+	}
+	return nil
+}
+
+// RawValue return Date value
+func (e *DateField) RawValue() interface{} {
+	return e.Value()
+}
+
+// verify DateField implement fielder interface
+var _ Fielder = new(DateField)
+
+// DateTimeField A date, represented in go by a time.Time instance.
+// datetime values like 2006-01-02 15:04:05
+// Takes the same extra arguments as DateField.
+type DateTimeField time.Time
+
+// Value return the datetime value
+func (e DateTimeField) Value() time.Time {
+	return time.Time(e)
+}
+
+// Set set the time.Time to datetime
+func (e *DateTimeField) Set(d time.Time) {
+	*e = DateTimeField(d)
+}
+
+// String return the time's String
+func (e *DateTimeField) String() string {
+	return e.Value().String()
+}
+
+// FieldType return the enum TypeDateTimeField
+func (e *DateTimeField) FieldType() int {
+	return TypeDateTimeField
+}
+
+// SetRaw convert the string or time.Time to DateTimeField
+func (e *DateTimeField) SetRaw(value interface{}) error {
+	switch d := value.(type) {
+	case time.Time:
+		e.Set(d)
+	case string:
+		v, err := utils.TimeParse(d, utils.FormatDateTime)
+		if err == nil {
+			e.Set(v)
+		}
+		return err
+	default:
+		return fmt.Errorf("<DateTimeField.SetRaw> unknown value `%s`", value)
+	}
+	return nil
+}
+
+// RawValue return the datetime value
+func (e *DateTimeField) RawValue() interface{} {
+	return e.Value()
+}
+
+// verify datetime implement fielder
+var _ Fielder = new(DateTimeField)
+
+// FloatField A floating-point number represented in go by a float32 value.
+type FloatField float64
+
+// Value return the FloatField value
+func (e FloatField) Value() float64 {
+	return float64(e)
+}
+
+// Set the Float64
+func (e *FloatField) Set(d float64) {
+	*e = FloatField(d)
+}
+
+// String return the string
+func (e *FloatField) String() string {
+	return utils.ToStr(e.Value(), -1, 32)
+}
+
+// FieldType return the enum type
+func (e *FloatField) FieldType() int {
+	return TypeFloatField
+}
+
+// SetRaw converter interface Float64 float32 or string to FloatField
+func (e *FloatField) SetRaw(value interface{}) error {
+	switch d := value.(type) {
+	case float32:
+		e.Set(float64(d))
+	case float64:
+		e.Set(d)
+	case string:
+		v, err := utils.StrTo(d).Float64()
+		if err == nil {
+			e.Set(v)
+		}
+		return err
+	default:
+		return fmt.Errorf("<FloatField.SetRaw> unknown value `%s`", value)
+	}
+	return nil
+}
+
+// RawValue return the FloatField value
+func (e *FloatField) RawValue() interface{} {
+	return e.Value()
+}
+
+// verify FloatField implement Fielder
+var _ Fielder = new(FloatField)
+
+// SmallIntegerField -32768 to 32767
+type SmallIntegerField int16
+
+// Value return int16 value
+func (e SmallIntegerField) Value() int16 {
+	return int16(e)
+}
+
+// Set the SmallIntegerField value
+func (e *SmallIntegerField) Set(d int16) {
+	*e = SmallIntegerField(d)
+}
+
+// String convert smallint to string
+func (e *SmallIntegerField) String() string {
+	return utils.ToStr(e.Value())
+}
+
+// FieldType return enum type SmallIntegerField
+func (e *SmallIntegerField) FieldType() int {
+	return TypeSmallIntegerField
+}
+
+// SetRaw convert interface int16/string to int16
+func (e *SmallIntegerField) SetRaw(value interface{}) error {
+	switch d := value.(type) {
+	case int16:
+		e.Set(d)
+	case string:
+		v, err := utils.StrTo(d).Int16()
+		if err == nil {
+			e.Set(v)
+		}
+		return err
+	default:
+		return fmt.Errorf("<SmallIntegerField.SetRaw> unknown value `%s`", value)
+	}
+	return nil
+}
+
+// RawValue return smallint value
+func (e *SmallIntegerField) RawValue() interface{} {
+	return e.Value()
+}
+
+// verify SmallIntegerField implement Fielder
+var _ Fielder = new(SmallIntegerField)
+
+// IntegerField -2147483648 to 2147483647
+type IntegerField int32
+
+// Value return the int32
+func (e IntegerField) Value() int32 {
+	return int32(e)
+}
+
+// Set IntegerField value
+func (e *IntegerField) Set(d int32) {
+	*e = IntegerField(d)
+}
+
+// String convert Int32 to string
+func (e *IntegerField) String() string {
+	return utils.ToStr(e.Value())
+}
+
+// FieldType return the enum type
+func (e *IntegerField) FieldType() int {
+	return TypeIntegerField
+}
+
+// SetRaw convert interface int32/string to int32
+func (e *IntegerField) SetRaw(value interface{}) error {
+	switch d := value.(type) {
+	case int32:
+		e.Set(d)
+	case string:
+		v, err := utils.StrTo(d).Int32()
+		if err == nil {
+			e.Set(v)
+		}
+		return err
+	default:
+		return fmt.Errorf("<IntegerField.SetRaw> unknown value `%s`", value)
+	}
+	return nil
+}
+
+// RawValue return IntegerField value
+func (e *IntegerField) RawValue() interface{} {
+	return e.Value()
+}
+
+// verify IntegerField implement Fielder
+var _ Fielder = new(IntegerField)
+
+// BigIntegerField -9223372036854775808 to 9223372036854775807.
+type BigIntegerField int64
+
+// Value return int64
+func (e BigIntegerField) Value() int64 {
+	return int64(e)
+}
+
+// Set the BigIntegerField value
+func (e *BigIntegerField) Set(d int64) {
+	*e = BigIntegerField(d)
+}
+
+// String convert BigIntegerField to string
+func (e *BigIntegerField) String() string {
+	return utils.ToStr(e.Value())
+}
+
+// FieldType return enum type
+func (e *BigIntegerField) FieldType() int {
+	return TypeBigIntegerField
+}
+
+// SetRaw convert interface int64/string to int64
+func (e *BigIntegerField) SetRaw(value interface{}) error {
+	switch d := value.(type) {
+	case int64:
+		e.Set(d)
+	case string:
+		v, err := utils.StrTo(d).Int64()
+		if err == nil {
+			e.Set(v)
+		}
+		return err
+	default:
+		return fmt.Errorf("<BigIntegerField.SetRaw> unknown value `%s`", value)
+	}
+	return nil
+}
+
+// RawValue return BigIntegerField value
+func (e *BigIntegerField) RawValue() interface{} {
+	return e.Value()
+}
+
+// verify BigIntegerField implement Fielder
+var _ Fielder = new(BigIntegerField)
+
+// PositiveSmallIntegerField 0 to 65535
+type PositiveSmallIntegerField uint16
+
+// Value return uint16
+func (e PositiveSmallIntegerField) Value() uint16 {
+	return uint16(e)
+}
+
+// Set PositiveSmallIntegerField value
+func (e *PositiveSmallIntegerField) Set(d uint16) {
+	*e = PositiveSmallIntegerField(d)
+}
+
+// String convert uint16 to string
+func (e *PositiveSmallIntegerField) String() string {
+	return utils.ToStr(e.Value())
+}
+
+// FieldType return enum type
+func (e *PositiveSmallIntegerField) FieldType() int {
+	return TypePositiveSmallIntegerField
+}
+
+// SetRaw convert Interface uint16/string to uint16
+func (e *PositiveSmallIntegerField) SetRaw(value interface{}) error {
+	switch d := value.(type) {
+	case uint16:
+		e.Set(d)
+	case string:
+		v, err := utils.StrTo(d).Uint16()
+		if err == nil {
+			e.Set(v)
+		}
+		return err
+	default:
+		return fmt.Errorf("<PositiveSmallIntegerField.SetRaw> unknown value `%s`", value)
+	}
+	return nil
+}
+
+// RawValue returns PositiveSmallIntegerField value
+func (e *PositiveSmallIntegerField) RawValue() interface{} {
+	return e.Value()
+}
+
+// verify PositiveSmallIntegerField implement Fielder
+var _ Fielder = new(PositiveSmallIntegerField)
+
+// PositiveIntegerField 0 to 4294967295
+type PositiveIntegerField uint32
+
+// Value return PositiveIntegerField value. Uint32
+func (e PositiveIntegerField) Value() uint32 {
+	return uint32(e)
+}
+
+// Set the PositiveIntegerField value
+func (e *PositiveIntegerField) Set(d uint32) {
+	*e = PositiveIntegerField(d)
+}
+
+// String convert PositiveIntegerField to string
+func (e *PositiveIntegerField) String() string {
+	return utils.ToStr(e.Value())
+}
+
+// FieldType return enum type
+func (e *PositiveIntegerField) FieldType() int {
+	return TypePositiveIntegerField
+}
+
+// SetRaw convert interface uint32/string to Uint32
+func (e *PositiveIntegerField) SetRaw(value interface{}) error {
+	switch d := value.(type) {
+	case uint32:
+		e.Set(d)
+	case string:
+		v, err := utils.StrTo(d).Uint32()
+		if err == nil {
+			e.Set(v)
+		}
+		return err
+	default:
+		return fmt.Errorf("<PositiveIntegerField.SetRaw> unknown value `%s`", value)
+	}
+	return nil
+}
+
+// RawValue return the PositiveIntegerField Value
+func (e *PositiveIntegerField) RawValue() interface{} {
+	return e.Value()
+}
+
+// verify PositiveIntegerField implement Fielder
+var _ Fielder = new(PositiveIntegerField)
+
+// PositiveBigIntegerField 0 to 18446744073709551615
+type PositiveBigIntegerField uint64
+
+// Value return uint64
+func (e PositiveBigIntegerField) Value() uint64 {
+	return uint64(e)
+}
+
+// Set PositiveBigIntegerField value
+func (e *PositiveBigIntegerField) Set(d uint64) {
+	*e = PositiveBigIntegerField(d)
+}
+
+// String convert PositiveBigIntegerField to string
+func (e *PositiveBigIntegerField) String() string {
+	return utils.ToStr(e.Value())
+}
+
+// FieldType return enum type
+func (e *PositiveBigIntegerField) FieldType() int {
+	return TypePositiveIntegerField
+}
+
+// SetRaw convert interface uint64/string to Uint64
+func (e *PositiveBigIntegerField) SetRaw(value interface{}) error {
+	switch d := value.(type) {
+	case uint64:
+		e.Set(d)
+	case string:
+		v, err := utils.StrTo(d).Uint64()
+		if err == nil {
+			e.Set(v)
+		}
+		return err
+	default:
+		return fmt.Errorf("<PositiveBigIntegerField.SetRaw> unknown value `%s`", value)
+	}
+	return nil
+}
+
+// RawValue return PositiveBigIntegerField value
+func (e *PositiveBigIntegerField) RawValue() interface{} {
+	return e.Value()
+}
+
+// verify PositiveBigIntegerField implement Fielder
+var _ Fielder = new(PositiveBigIntegerField)
+
+// TextField A large text field.
+type TextField string
+
+// Value return TextField value
+func (e TextField) Value() string {
+	return string(e)
+}
+
+// Set the TextField value
+func (e *TextField) Set(d string) {
+	*e = TextField(d)
+}
+
+// String convert TextField to string
+func (e *TextField) String() string {
+	return e.Value()
+}
+
+// FieldType return enum type
+func (e *TextField) FieldType() int {
+	return TypeTextField
+}
+
+// SetRaw convert interface string to string
+func (e *TextField) SetRaw(value interface{}) error {
+	switch d := value.(type) {
+	case string:
+		e.Set(d)
+	default:
+		return fmt.Errorf("<TextField.SetRaw> unknown value `%s`", value)
+	}
+	return nil
+}
+
+// RawValue return TextField value
+func (e *TextField) RawValue() interface{} {
+	return e.Value()
+}
+
+// verify TextField implement Fielder
+var _ Fielder = new(TextField)
+
+// JSONField postgres json field.
+type JSONField string
+
+// Value return JSONField value
+func (j JSONField) Value() string {
+	return string(j)
+}
+
+// Set the JSONField value
+func (j *JSONField) Set(d string) {
+	*j = JSONField(d)
+}
+
+// String convert JSONField to string
+func (j *JSONField) String() string {
+	return j.Value()
+}
+
+// FieldType return enum type
+func (j *JSONField) FieldType() int {
+	return TypeJSONField
+}
+
+// SetRaw convert interface string to string
+func (j *JSONField) SetRaw(value interface{}) error {
+	switch d := value.(type) {
+	case string:
+		j.Set(d)
+	default:
+		return fmt.Errorf("<JSONField.SetRaw> unknown value `%s`", value)
+	}
+	return nil
+}
+
+// RawValue return JSONField value
+func (j *JSONField) RawValue() interface{} {
+	return j.Value()
+}
+
+// verify JSONField implement Fielder
+var _ Fielder = new(JSONField)
+
+// JsonbField postgres json field.
+type JsonbField string
+
+// Value return JsonbField value
+func (j JsonbField) Value() string {
+	return string(j)
+}
+
+// Set the JsonbField value
+func (j *JsonbField) Set(d string) {
+	*j = JsonbField(d)
+}
+
+// String convert JsonbField to string
+func (j *JsonbField) String() string {
+	return j.Value()
+}
+
+// FieldType return enum type
+func (j *JsonbField) FieldType() int {
+	return TypeJsonbField
+}
+
+// SetRaw convert interface string to string
+func (j *JsonbField) SetRaw(value interface{}) error {
+	switch d := value.(type) {
+	case string:
+		j.Set(d)
+	default:
+		return fmt.Errorf("<JsonbField.SetRaw> unknown value `%s`", value)
+	}
+	return nil
+}
+
+// RawValue return JsonbField value
+func (j *JsonbField) RawValue() interface{} {
+	return j.Value()
+}
+
+// verify JsonbField implement Fielder
+var _ Fielder = new(JsonbField)

client/orm/internal/models/models_info_f.go

@@ -20,7 +20,7 @@ import (
 	"reflect"
 	"strings"
 
-	"github.com/beego/beego/v2/client/orm"
+	"github.com/beego/beego/v2/client/orm/internal/utils"
 )
 
 var errSkipField = errors.New("skip field")
@@ -125,7 +125,7 @@ type FieldInfo struct {
 	Column              string
 	AddrValue           reflect.Value
 	Sf                  reflect.StructField
-	Initial             orm.StrTo // store the default value
+	Initial             utils.StrTo // store the default value
 	Size                int
 	ReverseField        string
 	ReverseFieldInfo    *FieldInfo
@@ -147,7 +147,7 @@ func NewFieldInfo(mi *ModelInfo, field reflect.Value, sf reflect.StructField, mN
 	var (
 		tag       string
 		tagValue  string
-		initial   orm.StrTo // store the default value
+		initial   utils.StrTo // store the default value
 		fieldType int
 		attrs     map[string]bool
 		tags      map[string]string
@@ -163,7 +163,7 @@ func NewFieldInfo(mi *ModelInfo, field reflect.Value, sf reflect.StructField, mN
 	addrField = field
 	if field.CanAddr() && field.Kind() != reflect.Ptr {
 		addrField = field.Addr()
-		if _, ok := addrField.Interface().(orm.Fielder); !ok {
+		if _, ok := addrField.Interface().(Fielder); !ok {
 			if field.Kind() == reflect.Slice {
 				addrField = field
 			}
@@ -188,14 +188,14 @@ func NewFieldInfo(mi *ModelInfo, field reflect.Value, sf reflect.StructField, mN
 
 checkType:
 	switch f := addrField.Interface().(type) {
-	case orm.Fielder:
+	case Fielder:
 		fi.IsFielder = true
 		if field.Kind() == reflect.Ptr {
 			err = fmt.Errorf("the model Fielder can not be use ptr")
 			goto end
 		}
 		fieldType = f.FieldType()
-		if fieldType&orm.IsRelField > 0 {
+		if fieldType&IsRelField > 0 {
 			err = fmt.Errorf("unsupport type custom field, please refer to https://github.com/beego/beego/v2/blob/master/orm/models_fields.go#L24-L42")
 			goto end
 		}
@@ -205,13 +205,13 @@ checkType:
 		if tagValue != "" {
 			switch tagValue {
 			case "fk":
-				fieldType = orm.RelForeignKey
+				fieldType = RelForeignKey
 				break checkType
 			case "one":
-				fieldType = orm.RelOneToOne
+				fieldType = RelOneToOne
 				break checkType
 			case "m2m":
-				fieldType = orm.RelManyToMany
+				fieldType = RelManyToMany
 				if tv := tags["rel_table"]; tv != "" {
 					fi.RelTable = tv
 				} else if tv := tags["rel_through"]; tv != "" {
@@ -228,10 +228,10 @@ checkType:
 		if tagValue != "" {
 			switch tagValue {
 			case "one":
-				fieldType = orm.RelReverseOne
+				fieldType = RelReverseOne
 				break checkType
 			case "many":
-				fieldType = orm.RelReverseMany
+				fieldType = RelReverseMany
 				if tv := tags["rel_table"]; tv != "" {
 					fi.RelTable = tv
 				} else if tv := tags["rel_through"]; tv != "" {
@@ -248,26 +248,26 @@ checkType:
 		if err != nil {
 			goto end
 		}
-		if fieldType == orm.TypeVarCharField {
+		if fieldType == TypeVarCharField {
 			switch tags["type"] {
 			case "char":
-				fieldType = orm.TypeCharField
+				fieldType = TypeCharField
 			case "text":
-				fieldType = orm.TypeTextField
+				fieldType = TypeTextField
 			case "json":
-				fieldType = orm.TypeJSONField
+				fieldType = TypeJSONField
 			case "jsonb":
-				fieldType = orm.TypeJsonbField
+				fieldType = TypeJsonbField
 			}
 		}
-		if fieldType == orm.TypeFloatField && (digits != "" || decimals != "") {
-			fieldType = orm.TypeDecimalField
+		if fieldType == TypeFloatField && (digits != "" || decimals != "") {
+			fieldType = TypeDecimalField
 		}
-		if fieldType == orm.TypeDateTimeField && tags["type"] == "date" {
-			fieldType = orm.TypeDateField
+		if fieldType == TypeDateTimeField && tags["type"] == "date" {
+			fieldType = TypeDateField
 		}
-		if fieldType == orm.TypeTimeField && tags["type"] == "time" {
-			fieldType = orm.TypeTimeField
+		if fieldType == TypeTimeField && tags["type"] == "time" {
+			fieldType = TypeTimeField
 		}
 	}
 
@@ -275,12 +275,12 @@ checkType:
 	// rel should Ptr
 	// reverse should slice []*struct
 	switch fieldType {
-	case orm.RelForeignKey, orm.RelOneToOne, orm.RelReverseOne:
+	case RelForeignKey, RelOneToOne, RelReverseOne:
 		if field.Kind() != reflect.Ptr {
 			err = fmt.Errorf("rel/reverse:one field must be *%s", field.Type().Name())
 			goto end
 		}
-	case orm.RelManyToMany, orm.RelReverseMany:
+	case RelManyToMany, RelReverseMany:
 		if field.Kind() != reflect.Slice {
 			err = fmt.Errorf("rel/reverse:many field must be slice")
 			goto end
@@ -292,7 +292,7 @@ checkType:
 		}
 	}
 
-	if fieldType&orm.IsFieldType == 0 {
+	if fieldType&IsFieldType == 0 {
 		err = fmt.Errorf("wrong field type")
 		goto end
 	}
@@ -317,7 +317,7 @@ checkType:
 	}
 
 	switch fieldType {
-	case orm.RelManyToMany, orm.RelReverseMany, orm.RelReverseOne:
+	case RelManyToMany, RelReverseMany, RelReverseOne:
 		fi.Null = false
 		fi.Index = false
 		fi.Auto = false
@@ -328,12 +328,12 @@ checkType:
 	}
 
 	switch fieldType {
-	case orm.RelForeignKey, orm.RelOneToOne, orm.RelManyToMany:
+	case RelForeignKey, RelOneToOne, RelManyToMany:
 		fi.Rel = true
-		if fieldType == orm.RelOneToOne {
+		if fieldType == RelOneToOne {
 			fi.Unique = true
 		}
-	case orm.RelReverseMany, orm.RelReverseOne:
+	case RelReverseMany, RelReverseOne:
 		fi.Reverse = true
 	}
 
@@ -363,10 +363,10 @@ checkType:
 	}
 
 	switch fieldType {
-	case orm.TypeBooleanField:
-	case orm.TypeVarCharField, orm.TypeCharField, orm.TypeJSONField, orm.TypeJsonbField:
+	case TypeBooleanField:
+	case TypeVarCharField, TypeCharField, TypeJSONField, TypeJsonbField:
 		if size != "" {
-			v, e := orm.StrTo(size).Int32()
+			v, e := utils.StrTo(size).Int32()
 			if e != nil {
 				err = fmt.Errorf("wrong size value `%s`", size)
 			} else {
@@ -376,13 +376,13 @@ checkType:
 			fi.Size = 255
 			fi.ToText = true
 		}
-	case orm.TypeTextField:
+	case TypeTextField:
 		fi.Index = false
 		fi.Unique = false
-	case orm.TypeTimeField, orm.TypeDateField, orm.TypeDateTimeField:
-		if fieldType == orm.TypeDateTimeField {
+	case TypeTimeField, TypeDateField, TypeDateTimeField:
+		if fieldType == TypeDateTimeField {
 			if precision != "" {
-				v, e := orm.StrTo(precision).Int()
+				v, e := utils.StrTo(precision).Int()
 				if e != nil {
 					err = fmt.Errorf("convert %s to int error:%v", precision, e)
 				} else {
@@ -396,12 +396,12 @@ checkType:
 		} else if attrs["auto_now_add"] {
 			fi.AutoNowAdd = true
 		}
-	case orm.TypeFloatField:
-	case orm.TypeDecimalField:
+	case TypeFloatField:
+	case TypeDecimalField:
 		d1 := digits
 		d2 := decimals
-		v1, er1 := orm.StrTo(d1).Int8()
-		v2, er2 := orm.StrTo(d2).Int8()
+		v1, er1 := utils.StrTo(d1).Int8()
+		v2, er2 := utils.StrTo(d2).Int8()
 		if er1 != nil || er2 != nil {
 			err = fmt.Errorf("wrong digits/decimals value %s/%s", d2, d1)
 			goto end
@@ -410,12 +410,12 @@ checkType:
 		fi.Decimals = int(v2)
 	default:
 		switch {
-		case fieldType&orm.IsIntegerField > 0:
-		case fieldType&orm.IsRelField > 0:
+		case fieldType&IsIntegerField > 0:
+		case fieldType&IsRelField > 0:
 		}
 	}
 
-	if fieldType&orm.IsIntegerField == 0 {
+	if fieldType&IsIntegerField == 0 {
 		if fi.Auto {
 			err = fmt.Errorf("non-integer type cannot set auto")
 			goto end
@@ -442,32 +442,32 @@ checkType:
 	}
 
 	// can not set default for these type
-	if fi.Auto || fi.Pk || fi.Unique || fieldType == orm.TypeTimeField || fieldType == orm.TypeDateField || fieldType == orm.TypeDateTimeField {
+	if fi.Auto || fi.Pk || fi.Unique || fieldType == TypeTimeField || fieldType == TypeDateField || fieldType == TypeDateTimeField {
 		initial.Clear()
 	}
 
 	if initial.Exist() {
 		v := initial
 		switch fieldType {
-		case orm.TypeBooleanField:
+		case TypeBooleanField:
 			_, err = v.Bool()
-		case orm.TypeFloatField, orm.TypeDecimalField:
+		case TypeFloatField, TypeDecimalField:
 			_, err = v.Float64()
-		case orm.TypeBitField:
+		case TypeBitField:
 			_, err = v.Int8()
-		case orm.TypeSmallIntegerField:
+		case TypeSmallIntegerField:
 			_, err = v.Int16()
-		case orm.TypeIntegerField:
+		case TypeIntegerField:
 			_, err = v.Int32()
-		case orm.TypeBigIntegerField:
+		case TypeBigIntegerField:
 			_, err = v.Int64()
-		case orm.TypePositiveBitField:
+		case TypePositiveBitField:
 			_, err = v.Uint8()
-		case orm.TypePositiveSmallIntegerField:
+		case TypePositiveSmallIntegerField:
 			_, err = v.Uint16()
-		case orm.TypePositiveIntegerField:
+		case TypePositiveIntegerField:
 			_, err = v.Uint32()
-		case orm.TypePositiveBigIntegerField:
+		case TypePositiveBigIntegerField:
 			_, err = v.Uint64()
 		}
 		if err != nil {

client/orm/internal/models/models_info_m.go

@@ -18,8 +18,6 @@ import (
 	"fmt"
 	"os"
 	"reflect"
-
-	"github.com/beego/beego/v2/client/orm"
 )
 
 // ModelInfo single model info
@@ -113,7 +111,7 @@ func NewM2MModelInfo(m1, m2 *ModelInfo) (mi *ModelInfo) {
 	fa := new(FieldInfo) // pk
 	f1 := new(FieldInfo) // m1 table RelForeignKey
 	f2 := new(FieldInfo) // m2 table RelForeignKey
-	fa.FieldType = orm.TypeBigIntegerField
+	fa.FieldType = TypeBigIntegerField
 	fa.Auto = true
 	fa.Pk = true
 	fa.DBcol = true
@@ -123,8 +121,8 @@ func NewM2MModelInfo(m1, m2 *ModelInfo) (mi *ModelInfo) {
 
 	f1.DBcol = true
 	f2.DBcol = true
-	f1.FieldType = orm.RelForeignKey
-	f2.FieldType = orm.RelForeignKey
+	f1.FieldType = RelForeignKey
+	f2.FieldType = RelForeignKey
 	f1.Name = CamelString(m1.Table)
 	f2.Name = CamelString(m2.Table)
 	f1.FullName = mi.FullName + "." + f1.Name

client/orm/internal/models/models_utils.go

@@ -21,7 +21,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/beego/beego/v2/client/orm"
+	"github.com/beego/beego/v2/client/orm/internal/logs"
 )
 
 // 1 is attr
@@ -145,11 +145,11 @@ func getColumnName(ft int, addrField reflect.Value, sf reflect.StructField, col
 		column = NameStrategyMap[NameStrategy](sf.Name)
 	}
 	switch ft {
-	case orm.RelForeignKey, orm.RelOneToOne:
+	case RelForeignKey, RelOneToOne:
 		if len(col) == 0 {
 			column = column + "_id"
 		}
-	case orm.RelManyToMany, orm.RelReverseMany, orm.RelReverseOne:
+	case RelManyToMany, RelReverseMany, RelReverseOne:
 		column = sf.Name
 	}
 	return column
@@ -159,76 +159,76 @@ func getColumnName(ft int, addrField reflect.Value, sf reflect.StructField, col
 func getFieldType(val reflect.Value) (ft int, err error) {
 	switch val.Type() {
 	case reflect.TypeOf(new(int8)):
-		ft = orm.TypeBitField
+		ft = TypeBitField
 	case reflect.TypeOf(new(int16)):
-		ft = orm.TypeSmallIntegerField
+		ft = TypeSmallIntegerField
 	case reflect.TypeOf(new(int32)),
 		reflect.TypeOf(new(int)):
-		ft = orm.TypeIntegerField
+		ft = TypeIntegerField
 	case reflect.TypeOf(new(int64)):
-		ft = orm.TypeBigIntegerField
+		ft = TypeBigIntegerField
 	case reflect.TypeOf(new(uint8)):
-		ft = orm.TypePositiveBitField
+		ft = TypePositiveBitField
 	case reflect.TypeOf(new(uint16)):
-		ft = orm.TypePositiveSmallIntegerField
+		ft = TypePositiveSmallIntegerField
 	case reflect.TypeOf(new(uint32)),
 		reflect.TypeOf(new(uint)):
-		ft = orm.TypePositiveIntegerField
+		ft = TypePositiveIntegerField
 	case reflect.TypeOf(new(uint64)):
-		ft = orm.TypePositiveBigIntegerField
+		ft = TypePositiveBigIntegerField
 	case reflect.TypeOf(new(float32)),
 		reflect.TypeOf(new(float64)):
-		ft = orm.TypeFloatField
+		ft = TypeFloatField
 	case reflect.TypeOf(new(bool)):
-		ft = orm.TypeBooleanField
+		ft = TypeBooleanField
 	case reflect.TypeOf(new(string)):
-		ft = orm.TypeVarCharField
+		ft = TypeVarCharField
 	case reflect.TypeOf(new(time.Time)):
-		ft = orm.TypeDateTimeField
+		ft = TypeDateTimeField
 	default:
 		elm := reflect.Indirect(val)
 		switch elm.Kind() {
 		case reflect.Int8:
-			ft = orm.TypeBitField
+			ft = TypeBitField
 		case reflect.Int16:
-			ft = orm.TypeSmallIntegerField
+			ft = TypeSmallIntegerField
 		case reflect.Int32, reflect.Int:
-			ft = orm.TypeIntegerField
+			ft = TypeIntegerField
 		case reflect.Int64:
-			ft = orm.TypeBigIntegerField
+			ft = TypeBigIntegerField
 		case reflect.Uint8:
-			ft = orm.TypePositiveBitField
+			ft = TypePositiveBitField
 		case reflect.Uint16:
-			ft = orm.TypePositiveSmallIntegerField
+			ft = TypePositiveSmallIntegerField
 		case reflect.Uint32, reflect.Uint:
-			ft = orm.TypePositiveIntegerField
+			ft = TypePositiveIntegerField
 		case reflect.Uint64:
-			ft = orm.TypePositiveBigIntegerField
+			ft = TypePositiveBigIntegerField
 		case reflect.Float32, reflect.Float64:
-			ft = orm.TypeFloatField
+			ft = TypeFloatField
 		case reflect.Bool:
-			ft = orm.TypeBooleanField
+			ft = TypeBooleanField
 		case reflect.String:
-			ft = orm.TypeVarCharField
+			ft = TypeVarCharField
 		default:
 			if elm.Interface() == nil {
 				panic(fmt.Errorf("%s is nil pointer, may be miss setting tag", val))
 			}
 			switch elm.Interface().(type) {
 			case sql.NullInt64:
-				ft = orm.TypeBigIntegerField
+				ft = TypeBigIntegerField
 			case sql.NullFloat64:
-				ft = orm.TypeFloatField
+				ft = TypeFloatField
 			case sql.NullBool:
-				ft = orm.TypeBooleanField
+				ft = TypeBooleanField
 			case sql.NullString:
-				ft = orm.TypeVarCharField
+				ft = TypeVarCharField
 			case time.Time:
-				ft = orm.TypeDateTimeField
+				ft = TypeDateTimeField
 			}
 		}
 	}
-	if ft&orm.IsFieldType == 0 {
+	if ft&IsFieldType == 0 {
 		err = fmt.Errorf("unsupport field type %s, may be miss setting tag", val)
 	}
 	return
@@ -252,7 +252,7 @@ func ParseStructTag(data string) (attrs map[string]bool, tags map[string]string)
 				tags[name] = v
 			}
 		} else {
-			orm.DebugLog.Println("unsupport orm tag", v)
+			logs.DebugLog.Println("unsupport orm tag", v)
 		}
 	}
 	return

client/orm/internal/models/types.go

@@ -0,0 +1,23 @@
+// Copyright 2023 beego-dev. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package models
+
+// Fielder define field info
+type Fielder interface {
+	String() string
+	FieldType() int
+	SetRaw(interface{}) error
+	RawValue() interface{}
+}

client/orm/internal/utils/utils.go

@@ -0,0 +1,249 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package utils
+
+import (
+	"fmt"
+	"math/big"
+	"reflect"
+	"strconv"
+	"time"
+)
+
+// StrTo is the target string
+type StrTo string
+
+// Set string
+func (f *StrTo) Set(v string) {
+	if v != "" {
+		*f = StrTo(v)
+	} else {
+		f.Clear()
+	}
+}
+
+// Clear string
+func (f *StrTo) Clear() {
+	*f = StrTo(rune(0x1E))
+}
+
+// Exist check string exist
+func (f StrTo) Exist() bool {
+	return string(f) != string(rune(0x1E))
+}
+
+// Bool string to bool
+func (f StrTo) Bool() (bool, error) {
+	return strconv.ParseBool(f.String())
+}
+
+// Float32 string to float32
+func (f StrTo) Float32() (float32, error) {
+	v, err := strconv.ParseFloat(f.String(), 32)
+	return float32(v), err
+}
+
+// Float64 string to float64
+func (f StrTo) Float64() (float64, error) {
+	return strconv.ParseFloat(f.String(), 64)
+}
+
+// Int string to int
+func (f StrTo) Int() (int, error) {
+	v, err := strconv.ParseInt(f.String(), 10, 32)
+	return int(v), err
+}
+
+// Int8 string to int8
+func (f StrTo) Int8() (int8, error) {
+	v, err := strconv.ParseInt(f.String(), 10, 8)
+	return int8(v), err
+}
+
+// Int16 string to int16
+func (f StrTo) Int16() (int16, error) {
+	v, err := strconv.ParseInt(f.String(), 10, 16)
+	return int16(v), err
+}
+
+// Int32 string to int32
+func (f StrTo) Int32() (int32, error) {
+	v, err := strconv.ParseInt(f.String(), 10, 32)
+	return int32(v), err
+}
+
+// Int64 string to int64
+func (f StrTo) Int64() (int64, error) {
+	v, err := strconv.ParseInt(f.String(), 10, 64)
+	if err != nil {
+		i := new(big.Int)
+		ni, ok := i.SetString(f.String(), 10) // octal
+		if !ok {
+			return v, err
+		}
+		return ni.Int64(), nil
+	}
+	return v, err
+}
+
+// Uint string to uint
+func (f StrTo) Uint() (uint, error) {
+	v, err := strconv.ParseUint(f.String(), 10, 32)
+	return uint(v), err
+}
+
+// Uint8 string to uint8
+func (f StrTo) Uint8() (uint8, error) {
+	v, err := strconv.ParseUint(f.String(), 10, 8)
+	return uint8(v), err
+}
+
+// Uint16 string to uint16
+func (f StrTo) Uint16() (uint16, error) {
+	v, err := strconv.ParseUint(f.String(), 10, 16)
+	return uint16(v), err
+}
+
+// Uint32 string to uint32
+func (f StrTo) Uint32() (uint32, error) {
+	v, err := strconv.ParseUint(f.String(), 10, 32)
+	return uint32(v), err
+}
+
+// Uint64 string to uint64
+func (f StrTo) Uint64() (uint64, error) {
+	v, err := strconv.ParseUint(f.String(), 10, 64)
+	if err != nil {
+		i := new(big.Int)
+		ni, ok := i.SetString(f.String(), 10)
+		if !ok {
+			return v, err
+		}
+		return ni.Uint64(), nil
+	}
+	return v, err
+}
+
+// String string to string
+func (f StrTo) String() string {
+	if f.Exist() {
+		return string(f)
+	}
+	return ""
+}
+
+// ToStr interface to string
+func ToStr(value interface{}, args ...int) (s string) {
+	switch v := value.(type) {
+	case bool:
+		s = strconv.FormatBool(v)
+	case float32:
+		s = strconv.FormatFloat(float64(v), 'f', ArgInt(args).Get(0, -1), ArgInt(args).Get(1, 32))
+	case float64:
+		s = strconv.FormatFloat(v, 'f', ArgInt(args).Get(0, -1), ArgInt(args).Get(1, 64))
+	case int:
+		s = strconv.FormatInt(int64(v), ArgInt(args).Get(0, 10))
+	case int8:
+		s = strconv.FormatInt(int64(v), ArgInt(args).Get(0, 10))
+	case int16:
+		s = strconv.FormatInt(int64(v), ArgInt(args).Get(0, 10))
+	case int32:
+		s = strconv.FormatInt(int64(v), ArgInt(args).Get(0, 10))
+	case int64:
+		s = strconv.FormatInt(v, ArgInt(args).Get(0, 10))
+	case uint:
+		s = strconv.FormatUint(uint64(v), ArgInt(args).Get(0, 10))
+	case uint8:
+		s = strconv.FormatUint(uint64(v), ArgInt(args).Get(0, 10))
+	case uint16:
+		s = strconv.FormatUint(uint64(v), ArgInt(args).Get(0, 10))
+	case uint32:
+		s = strconv.FormatUint(uint64(v), ArgInt(args).Get(0, 10))
+	case uint64:
+		s = strconv.FormatUint(v, ArgInt(args).Get(0, 10))
+	case string:
+		s = v
+	case []byte:
+		s = string(v)
+	default:
+		s = fmt.Sprintf("%v", v)
+	}
+	return s
+}
+
+// ToInt64 interface to int64
+func ToInt64(value interface{}) (d int64) {
+	val := reflect.ValueOf(value)
+	switch value.(type) {
+	case int, int8, int16, int32, int64:
+		d = val.Int()
+	case uint, uint8, uint16, uint32, uint64:
+		d = int64(val.Uint())
+	default:
+		panic(fmt.Errorf("ToInt64 need numeric not `%T`", value))
+	}
+	return
+}
+
+type ArgString []string
+
+// Get get string by index from string slice
+func (a ArgString) Get(i int, args ...string) (r string) {
+	if i >= 0 && i < len(a) {
+		r = a[i]
+	} else if len(args) > 0 {
+		r = args[0]
+	}
+	return
+}
+
+type ArgInt []int
+
+// Get get int by index from int slice
+func (a ArgInt) Get(i int, args ...int) (r int) {
+	if i >= 0 && i < len(a) {
+		r = a[i]
+	}
+	if len(args) > 0 {
+		r = args[0]
+	}
+	return
+}
+
+// TimeParse parse time to string with location
+func TimeParse(dateString, format string) (time.Time, error) {
+	tp, err := time.ParseInLocation(format, dateString, DefaultTimeLoc)
+	return tp, err
+}
+
+// IndirectType get pointer indirect type
+func IndirectType(v reflect.Type) reflect.Type {
+	switch v.Kind() {
+	case reflect.Ptr:
+		return IndirectType(v.Elem())
+	default:
+		return v
+	}
+}
+
+const (
+	FormatTime     = "15:04:05"
+	FormatDate     = "2006-01-02"
+	FormatDateTime = "2006-01-02 15:04:05"
+)
+
+var (
+	DefaultTimeLoc = time.Local
+)