summaryrefslogtreecommitdiff
path: root/vendor/github.com/uptrace/bun/schema
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/uptrace/bun/schema')
-rw-r--r--vendor/github.com/uptrace/bun/schema/append.go43
-rw-r--r--vendor/github.com/uptrace/bun/schema/append_value.go112
-rw-r--r--vendor/github.com/uptrace/bun/schema/dialect.go109
-rw-r--r--vendor/github.com/uptrace/bun/schema/formatter.go4
-rw-r--r--vendor/github.com/uptrace/bun/schema/hook.go39
-rw-r--r--vendor/github.com/uptrace/bun/schema/scan.go18
-rw-r--r--vendor/github.com/uptrace/bun/schema/sqlfmt.go13
-rw-r--r--vendor/github.com/uptrace/bun/schema/sqltype.go10
-rw-r--r--vendor/github.com/uptrace/bun/schema/table.go61
9 files changed, 275 insertions, 134 deletions
diff --git a/vendor/github.com/uptrace/bun/schema/append.go b/vendor/github.com/uptrace/bun/schema/append.go
index 57d292bfe..fccdd17e7 100644
--- a/vendor/github.com/uptrace/bun/schema/append.go
+++ b/vendor/github.com/uptrace/bun/schema/append.go
@@ -5,13 +5,10 @@ import (
"strconv"
"time"
- "github.com/vmihailenco/msgpack/v5"
-
"github.com/uptrace/bun/dialect"
- "github.com/uptrace/bun/internal"
)
-func Append(fmter Formatter, b []byte, v interface{}, custom CustomAppender) []byte {
+func Append(fmter Formatter, b []byte, v interface{}) []byte {
switch v := v.(type) {
case nil:
return dialect.AppendNull(b)
@@ -24,11 +21,11 @@ func Append(fmter Formatter, b []byte, v interface{}, custom CustomAppender) []b
case int64:
return strconv.AppendInt(b, v, 10)
case uint:
- return strconv.AppendUint(b, uint64(v), 10)
+ return strconv.AppendInt(b, int64(v), 10)
case uint32:
- return strconv.AppendUint(b, uint64(v), 10)
+ return fmter.Dialect().AppendUint32(b, v)
case uint64:
- return strconv.AppendUint(b, v, 10)
+ return fmter.Dialect().AppendUint64(b, v)
case float32:
return dialect.AppendFloat32(b, v)
case float64:
@@ -36,9 +33,9 @@ func Append(fmter Formatter, b []byte, v interface{}, custom CustomAppender) []b
case string:
return dialect.AppendString(b, v)
case time.Time:
- return dialect.AppendTime(b, v)
+ return fmter.Dialect().AppendTime(b, v)
case []byte:
- return dialect.AppendBytes(b, v)
+ return fmter.Dialect().AppendBytes(b, v)
case QueryAppender:
return AppendQueryAppender(fmter, b, v)
default:
@@ -46,33 +43,7 @@ func Append(fmter Formatter, b []byte, v interface{}, custom CustomAppender) []b
if vv.Kind() == reflect.Ptr && vv.IsNil() {
return dialect.AppendNull(b)
}
- appender := Appender(vv.Type(), custom)
+ appender := Appender(fmter.Dialect(), vv.Type())
return appender(fmter, b, vv)
}
}
-
-func appendMsgpack(fmter Formatter, b []byte, v reflect.Value) []byte {
- hexEnc := internal.NewHexEncoder(b)
-
- enc := msgpack.GetEncoder()
- defer msgpack.PutEncoder(enc)
-
- enc.Reset(hexEnc)
- if err := enc.EncodeValue(v); err != nil {
- return dialect.AppendError(b, err)
- }
-
- if err := hexEnc.Close(); err != nil {
- return dialect.AppendError(b, err)
- }
-
- return hexEnc.Bytes()
-}
-
-func AppendQueryAppender(fmter Formatter, b []byte, app QueryAppender) []byte {
- bb, err := app.AppendQuery(fmter, b)
- if err != nil {
- return dialect.AppendError(b, err)
- }
- return bb
-}
diff --git a/vendor/github.com/uptrace/bun/schema/append_value.go b/vendor/github.com/uptrace/bun/schema/append_value.go
index 8fe8a13b2..c93f5b291 100644
--- a/vendor/github.com/uptrace/bun/schema/append_value.go
+++ b/vendor/github.com/uptrace/bun/schema/append_value.go
@@ -7,12 +7,14 @@ import (
"reflect"
"strconv"
"strings"
+ "sync"
"time"
"github.com/uptrace/bun/dialect"
"github.com/uptrace/bun/dialect/sqltype"
"github.com/uptrace/bun/extra/bunjson"
"github.com/uptrace/bun/internal"
+ "github.com/vmihailenco/msgpack/v5"
)
type (
@@ -30,8 +32,8 @@ var appenders = []AppenderFunc{
reflect.Uint: AppendUintValue,
reflect.Uint8: AppendUintValue,
reflect.Uint16: AppendUintValue,
- reflect.Uint32: AppendUintValue,
- reflect.Uint64: AppendUintValue,
+ reflect.Uint32: appendUint32Value,
+ reflect.Uint64: appendUint64Value,
reflect.Uintptr: nil,
reflect.Float32: AppendFloat32Value,
reflect.Float64: AppendFloat64Value,
@@ -49,6 +51,8 @@ var appenders = []AppenderFunc{
reflect.UnsafePointer: nil,
}
+var appenderMap sync.Map
+
func FieldAppender(dialect Dialect, field *Field) AppenderFunc {
if field.Tag.HasOption("msgpack") {
return appendMsgpack
@@ -59,10 +63,23 @@ func FieldAppender(dialect Dialect, field *Field) AppenderFunc {
return AppendJSONValue
}
- return dialect.Appender(field.StructField.Type)
+ return Appender(dialect, field.StructField.Type)
+}
+
+func Appender(dialect Dialect, typ reflect.Type) AppenderFunc {
+ if v, ok := appenderMap.Load(typ); ok {
+ return v.(AppenderFunc)
+ }
+
+ fn := appender(dialect, typ)
+
+ if v, ok := appenderMap.LoadOrStore(typ, fn); ok {
+ return v.(AppenderFunc)
+ }
+ return fn
}
-func Appender(typ reflect.Type, custom CustomAppender) AppenderFunc {
+func appender(dialect Dialect, typ reflect.Type) AppenderFunc {
switch typ {
case bytesType:
return appendBytesValue
@@ -80,7 +97,7 @@ func Appender(typ reflect.Type, custom CustomAppender) AppenderFunc {
return appendQueryAppenderValue
}
if typ.Implements(driverValuerType) {
- return driverValueAppender(custom)
+ return appendDriverValue
}
kind := typ.Kind()
@@ -88,18 +105,18 @@ func Appender(typ reflect.Type, custom CustomAppender) AppenderFunc {
if kind != reflect.Ptr {
ptr := reflect.PtrTo(typ)
if ptr.Implements(queryAppenderType) {
- return addrAppender(appendQueryAppenderValue, custom)
+ return addrAppender(appendQueryAppenderValue)
}
if ptr.Implements(driverValuerType) {
- return addrAppender(driverValueAppender(custom), custom)
+ return addrAppender(appendDriverValue)
}
}
switch kind {
case reflect.Interface:
- return ifaceAppenderFunc(typ, custom)
+ return ifaceAppenderFunc
case reflect.Ptr:
- if fn := Appender(typ.Elem(), custom); fn != nil {
+ if fn := Appender(dialect, typ.Elem()); fn != nil {
return PtrAppender(fn)
}
case reflect.Slice:
@@ -112,23 +129,16 @@ func Appender(typ reflect.Type, custom CustomAppender) AppenderFunc {
}
}
- if custom != nil {
- if fn := custom(typ); fn != nil {
- return fn
- }
- }
return appenders[typ.Kind()]
}
-func ifaceAppenderFunc(typ reflect.Type, custom func(reflect.Type) AppenderFunc) AppenderFunc {
- return func(fmter Formatter, b []byte, v reflect.Value) []byte {
- if v.IsNil() {
- return dialect.AppendNull(b)
- }
- elem := v.Elem()
- appender := Appender(elem.Type(), custom)
- return appender(fmter, b, elem)
+func ifaceAppenderFunc(fmter Formatter, b []byte, v reflect.Value) []byte {
+ if v.IsNil() {
+ return dialect.AppendNull(b)
}
+ elem := v.Elem()
+ appender := Appender(fmter.Dialect(), elem.Type())
+ return appender(fmter, b, elem)
}
func PtrAppender(fn AppenderFunc) AppenderFunc {
@@ -152,6 +162,14 @@ func AppendUintValue(fmter Formatter, b []byte, v reflect.Value) []byte {
return strconv.AppendUint(b, v.Uint(), 10)
}
+func appendUint32Value(fmter Formatter, b []byte, v reflect.Value) []byte {
+ return fmter.Dialect().AppendUint32(b, uint32(v.Uint()))
+}
+
+func appendUint64Value(fmter Formatter, b []byte, v reflect.Value) []byte {
+ return fmter.Dialect().AppendUint64(b, v.Uint())
+}
+
func AppendFloat32Value(fmter Formatter, b []byte, v reflect.Value) []byte {
return dialect.AppendFloat32(b, float32(v.Float()))
}
@@ -161,17 +179,17 @@ func AppendFloat64Value(fmter Formatter, b []byte, v reflect.Value) []byte {
}
func appendBytesValue(fmter Formatter, b []byte, v reflect.Value) []byte {
- return dialect.AppendBytes(b, v.Bytes())
+ return fmter.Dialect().AppendBytes(b, v.Bytes())
}
func appendArrayBytesValue(fmter Formatter, b []byte, v reflect.Value) []byte {
if v.CanAddr() {
- return dialect.AppendBytes(b, v.Slice(0, v.Len()).Bytes())
+ return fmter.Dialect().AppendBytes(b, v.Slice(0, v.Len()).Bytes())
}
tmp := make([]byte, v.Len())
reflect.Copy(reflect.ValueOf(tmp), v)
- b = dialect.AppendBytes(b, tmp)
+ b = fmter.Dialect().AppendBytes(b, tmp)
return b
}
@@ -189,12 +207,12 @@ func AppendJSONValue(fmter Formatter, b []byte, v reflect.Value) []byte {
bb = bb[:len(bb)-1]
}
- return dialect.AppendJSON(b, bb)
+ return fmter.Dialect().AppendJSON(b, bb)
}
func appendTimeValue(fmter Formatter, b []byte, v reflect.Value) []byte {
tm := v.Interface().(time.Time)
- return dialect.AppendTime(b, tm)
+ return fmter.Dialect().AppendTime(b, tm)
}
func appendIPValue(fmter Formatter, b []byte, v reflect.Value) []byte {
@@ -219,21 +237,15 @@ func appendQueryAppenderValue(fmter Formatter, b []byte, v reflect.Value) []byte
return AppendQueryAppender(fmter, b, v.Interface().(QueryAppender))
}
-func driverValueAppender(custom CustomAppender) AppenderFunc {
- return func(fmter Formatter, b []byte, v reflect.Value) []byte {
- return appendDriverValue(fmter, b, v.Interface().(driver.Valuer), custom)
- }
-}
-
-func appendDriverValue(fmter Formatter, b []byte, v driver.Valuer, custom CustomAppender) []byte {
- value, err := v.Value()
+func appendDriverValue(fmter Formatter, b []byte, v reflect.Value) []byte {
+ value, err := v.Interface().(driver.Valuer).Value()
if err != nil {
return dialect.AppendError(b, err)
}
- return Append(fmter, b, value, custom)
+ return Append(fmter, b, value)
}
-func addrAppender(fn AppenderFunc, custom CustomAppender) AppenderFunc {
+func addrAppender(fn AppenderFunc) AppenderFunc {
return func(fmter Formatter, b []byte, v reflect.Value) []byte {
if !v.CanAddr() {
err := fmt.Errorf("bun: Append(nonaddressable %T)", v.Interface())
@@ -242,3 +254,29 @@ func addrAppender(fn AppenderFunc, custom CustomAppender) AppenderFunc {
return fn(fmter, b, v.Addr())
}
}
+
+func appendMsgpack(fmter Formatter, b []byte, v reflect.Value) []byte {
+ hexEnc := internal.NewHexEncoder(b)
+
+ enc := msgpack.GetEncoder()
+ defer msgpack.PutEncoder(enc)
+
+ enc.Reset(hexEnc)
+ if err := enc.EncodeValue(v); err != nil {
+ return dialect.AppendError(b, err)
+ }
+
+ if err := hexEnc.Close(); err != nil {
+ return dialect.AppendError(b, err)
+ }
+
+ return hexEnc.Bytes()
+}
+
+func AppendQueryAppender(fmter Formatter, b []byte, app QueryAppender) []byte {
+ bb, err := app.AppendQuery(fmter, b)
+ if err != nil {
+ return dialect.AppendError(b, err)
+ }
+ return bb
+}
diff --git a/vendor/github.com/uptrace/bun/schema/dialect.go b/vendor/github.com/uptrace/bun/schema/dialect.go
index c50de715a..f015807dc 100644
--- a/vendor/github.com/uptrace/bun/schema/dialect.go
+++ b/vendor/github.com/uptrace/bun/schema/dialect.go
@@ -2,11 +2,12 @@ package schema
import (
"database/sql"
- "reflect"
- "sync"
+ "strconv"
+ "time"
"github.com/uptrace/bun/dialect"
"github.com/uptrace/bun/dialect/feature"
+ "github.com/uptrace/bun/internal/parser"
)
type Dialect interface {
@@ -19,20 +20,76 @@ type Dialect interface {
OnTable(table *Table)
IdentQuote() byte
- Append(fmter Formatter, b []byte, v interface{}) []byte
- Appender(typ reflect.Type) AppenderFunc
- FieldAppender(field *Field) AppenderFunc
- Scanner(typ reflect.Type) ScannerFunc
+
+ AppendUint32(b []byte, n uint32) []byte
+ AppendUint64(b []byte, n uint64) []byte
+ AppendTime(b []byte, tm time.Time) []byte
+ AppendBytes(b []byte, bs []byte) []byte
+ AppendJSON(b, jsonb []byte) []byte
+}
+
+//------------------------------------------------------------------------------
+
+type BaseDialect struct{}
+
+func (BaseDialect) AppendUint32(b []byte, n uint32) []byte {
+ return strconv.AppendUint(b, uint64(n), 10)
+}
+
+func (BaseDialect) AppendUint64(b []byte, n uint64) []byte {
+ return strconv.AppendUint(b, n, 10)
+}
+
+func (BaseDialect) AppendTime(b []byte, tm time.Time) []byte {
+ b = append(b, '\'')
+ b = tm.UTC().AppendFormat(b, "2006-01-02 15:04:05.999999-07:00")
+ b = append(b, '\'')
+ return b
+}
+
+func (BaseDialect) AppendBytes(b, bs []byte) []byte {
+ return dialect.AppendBytes(b, bs)
+}
+
+func (BaseDialect) AppendJSON(b, jsonb []byte) []byte {
+ b = append(b, '\'')
+
+ p := parser.New(jsonb)
+ for p.Valid() {
+ c := p.Read()
+ switch c {
+ case '"':
+ b = append(b, '"')
+ case '\'':
+ b = append(b, "''"...)
+ case '\000':
+ continue
+ case '\\':
+ if p.SkipBytes([]byte("u0000")) {
+ b = append(b, `\\u0000`...)
+ } else {
+ b = append(b, '\\')
+ if p.Valid() {
+ b = append(b, p.Read())
+ }
+ }
+ default:
+ b = append(b, c)
+ }
+ }
+
+ b = append(b, '\'')
+
+ return b
}
//------------------------------------------------------------------------------
type nopDialect struct {
+ BaseDialect
+
tables *Tables
features feature.Feature
-
- appenderMap sync.Map
- scannerMap sync.Map
}
func newNopDialect() *nopDialect {
@@ -63,37 +120,3 @@ func (d *nopDialect) OnTable(table *Table) {}
func (d *nopDialect) IdentQuote() byte {
return '"'
}
-
-func (d *nopDialect) Append(fmter Formatter, b []byte, v interface{}) []byte {
- return Append(fmter, b, v, nil)
-}
-
-func (d *nopDialect) Appender(typ reflect.Type) AppenderFunc {
- if v, ok := d.appenderMap.Load(typ); ok {
- return v.(AppenderFunc)
- }
-
- fn := Appender(typ, nil)
-
- if v, ok := d.appenderMap.LoadOrStore(typ, fn); ok {
- return v.(AppenderFunc)
- }
- return fn
-}
-
-func (d *nopDialect) FieldAppender(field *Field) AppenderFunc {
- return FieldAppender(d, field)
-}
-
-func (d *nopDialect) Scanner(typ reflect.Type) ScannerFunc {
- if v, ok := d.scannerMap.Load(typ); ok {
- return v.(ScannerFunc)
- }
-
- fn := Scanner(typ)
-
- if v, ok := d.scannerMap.LoadOrStore(typ, fn); ok {
- return v.(ScannerFunc)
- }
- return fn
-}
diff --git a/vendor/github.com/uptrace/bun/schema/formatter.go b/vendor/github.com/uptrace/bun/schema/formatter.go
index 45a246307..dd1859acf 100644
--- a/vendor/github.com/uptrace/bun/schema/formatter.go
+++ b/vendor/github.com/uptrace/bun/schema/formatter.go
@@ -50,7 +50,7 @@ func (f Formatter) AppendValue(b []byte, v reflect.Value) []byte {
if v.Kind() == reflect.Ptr && v.IsNil() {
return dialect.AppendNull(b)
}
- appender := f.dialect.Appender(v.Type())
+ appender := Appender(f.dialect, v.Type())
return appender(f, b, v)
}
@@ -167,7 +167,7 @@ func (f Formatter) appendArg(b []byte, arg interface{}) []byte {
}
return bb
default:
- return f.dialect.Append(f, b, arg)
+ return Append(f, b, arg)
}
}
diff --git a/vendor/github.com/uptrace/bun/schema/hook.go b/vendor/github.com/uptrace/bun/schema/hook.go
index 5391981d5..624601c9f 100644
--- a/vendor/github.com/uptrace/bun/schema/hook.go
+++ b/vendor/github.com/uptrace/bun/schema/hook.go
@@ -2,9 +2,32 @@ package schema
import (
"context"
+ "database/sql"
"reflect"
)
+type Model interface {
+ ScanRows(ctx context.Context, rows *sql.Rows) (int, error)
+ Value() interface{}
+}
+
+type Query interface {
+ QueryAppender
+ Operation() string
+ GetModel() Model
+ GetTableName() string
+}
+
+//------------------------------------------------------------------------------
+
+type BeforeAppendModelHook interface {
+ BeforeAppendModel(ctx context.Context, query Query) error
+}
+
+var beforeAppendModelHookType = reflect.TypeOf((*BeforeAppendModelHook)(nil)).Elem()
+
+//------------------------------------------------------------------------------
+
type BeforeScanHook interface {
BeforeScan(context.Context) error
}
@@ -18,3 +41,19 @@ type AfterScanHook interface {
}
var afterScanHookType = reflect.TypeOf((*AfterScanHook)(nil)).Elem()
+
+//------------------------------------------------------------------------------
+
+type BeforeScanRowHook interface {
+ BeforeScanRow(context.Context) error
+}
+
+var beforeScanRowHookType = reflect.TypeOf((*BeforeScanRowHook)(nil)).Elem()
+
+//------------------------------------------------------------------------------
+
+type AfterScanRowHook interface {
+ AfterScanRow(context.Context) error
+}
+
+var afterScanRowHookType = reflect.TypeOf((*AfterScanRowHook)(nil)).Elem()
diff --git a/vendor/github.com/uptrace/bun/schema/scan.go b/vendor/github.com/uptrace/bun/schema/scan.go
index 60ad27d53..30abcfc35 100644
--- a/vendor/github.com/uptrace/bun/schema/scan.go
+++ b/vendor/github.com/uptrace/bun/schema/scan.go
@@ -8,6 +8,7 @@ import (
"reflect"
"strconv"
"strings"
+ "sync"
"time"
"github.com/vmihailenco/msgpack/v5"
@@ -52,6 +53,8 @@ func init() {
}
}
+var scannerMap sync.Map
+
func FieldScanner(dialect Dialect, field *Field) ScannerFunc {
if field.Tag.HasOption("msgpack") {
return scanMsgpack
@@ -65,10 +68,23 @@ func FieldScanner(dialect Dialect, field *Field) ScannerFunc {
return scanJSONIntoInterface
}
}
- return dialect.Scanner(field.StructField.Type)
+ return Scanner(field.StructField.Type)
}
func Scanner(typ reflect.Type) ScannerFunc {
+ if v, ok := scannerMap.Load(typ); ok {
+ return v.(ScannerFunc)
+ }
+
+ fn := scanner(typ)
+
+ if v, ok := scannerMap.LoadOrStore(typ, fn); ok {
+ return v.(ScannerFunc)
+ }
+ return fn
+}
+
+func scanner(typ reflect.Type) ScannerFunc {
kind := typ.Kind()
if kind == reflect.Ptr {
diff --git a/vendor/github.com/uptrace/bun/schema/sqlfmt.go b/vendor/github.com/uptrace/bun/schema/sqlfmt.go
index bbdb0a01f..93a801c86 100644
--- a/vendor/github.com/uptrace/bun/schema/sqlfmt.go
+++ b/vendor/github.com/uptrace/bun/schema/sqlfmt.go
@@ -1,5 +1,11 @@
package schema
+import (
+ "strings"
+
+ "github.com/uptrace/bun/internal"
+)
+
type QueryAppender interface {
AppendQuery(fmter Formatter, b []byte) ([]byte, error)
}
@@ -42,8 +48,13 @@ var _ QueryAppender = QueryWithArgs{}
func SafeQuery(query string, args []interface{}) QueryWithArgs {
if args == nil {
args = make([]interface{}, 0)
+ } else if len(query) > 0 && strings.IndexByte(query, '?') == -1 {
+ internal.Warn.Printf("query %q has args %v, but no placeholders", query, args)
+ }
+ return QueryWithArgs{
+ Query: query,
+ Args: args,
}
- return QueryWithArgs{Query: query, Args: args}
}
func UnsafeIdent(ident string) QueryWithArgs {
diff --git a/vendor/github.com/uptrace/bun/schema/sqltype.go b/vendor/github.com/uptrace/bun/schema/sqltype.go
index 72609cf7a..90551d6aa 100644
--- a/vendor/github.com/uptrace/bun/schema/sqltype.go
+++ b/vendor/github.com/uptrace/bun/schema/sqltype.go
@@ -61,6 +61,14 @@ func DiscoverSQLType(typ reflect.Type) string {
case nullStringType:
return sqltype.VarChar
}
+
+ switch typ.Kind() {
+ case reflect.Slice:
+ if typ.Elem().Kind() == reflect.Uint8 {
+ return sqltype.Blob
+ }
+ }
+
return sqlTypes[typ.Kind()]
}
@@ -99,7 +107,7 @@ func (tm NullTime) AppendQuery(fmter Formatter, b []byte) ([]byte, error) {
if tm.IsZero() {
return dialect.AppendNull(b), nil
}
- return dialect.AppendTime(b, tm.Time), nil
+ return fmter.Dialect().AppendTime(b, tm.Time), nil
}
func (tm *NullTime) Scan(src interface{}) error {
diff --git a/vendor/github.com/uptrace/bun/schema/table.go b/vendor/github.com/uptrace/bun/schema/table.go
index 213f821ab..2d762e135 100644
--- a/vendor/github.com/uptrace/bun/schema/table.go
+++ b/vendor/github.com/uptrace/bun/schema/table.go
@@ -15,8 +15,11 @@ import (
)
const (
- beforeScanHookFlag internal.Flag = 1 << iota
+ beforeAppendModelHookFlag internal.Flag = 1 << iota
+ beforeScanHookFlag
afterScanHookFlag
+ beforeScanRowHookFlag
+ afterScanRowHookFlag
)
var (
@@ -84,8 +87,13 @@ func newTable(dialect Dialect, typ reflect.Type) *Table {
typ reflect.Type
flag internal.Flag
}{
+ {beforeAppendModelHookType, beforeAppendModelHookFlag},
+
{beforeScanHookType, beforeScanHookFlag},
{afterScanHookType, afterScanHookFlag},
+
+ {beforeScanRowHookType, beforeScanRowHookFlag},
+ {afterScanRowHookType, afterScanRowHookFlag},
}
typ = reflect.PtrTo(t.Type)
@@ -95,6 +103,22 @@ func newTable(dialect Dialect, typ reflect.Type) *Table {
}
}
+ // Deprecated.
+ deprecatedHooks := []struct {
+ typ reflect.Type
+ flag internal.Flag
+ msg string
+ }{
+ {beforeScanHookType, beforeScanHookFlag, "rename BeforeScan hook to BeforeScanRow"},
+ {afterScanHookType, afterScanHookFlag, "rename AfterScan hook to AfterScanRow"},
+ }
+ for _, hook := range deprecatedHooks {
+ if typ.Implements(hook.typ) {
+ internal.Deprecated.Printf("%s: %s", t.TypeName, hook.msg)
+ t.flags = t.flags.Set(hook.flag)
+ }
+ }
+
return t
}
@@ -334,15 +358,6 @@ func (t *Table) newField(f reflect.StructField, index []int) *Field {
if tag.HasOption("pk") {
field.markAsPK()
}
- if tag.HasOption("allowzero") {
- if tag.HasOption("nullzero") {
- internal.Warn.Printf(
- "%s.%s: nullzero and allowzero options are mutually exclusive",
- t.TypeName, f.Name,
- )
- }
- field.NullZero = false
- }
if v, ok := tag.Options["unique"]; ok {
// Split the value by comma, this will allow multiple names to be specified.
@@ -362,7 +377,7 @@ func (t *Table) newField(f reflect.StructField, index []int) *Field {
field.UserSQLType = s
}
field.DiscoveredSQLType = DiscoverSQLType(field.IndirectType)
- field.Append = t.dialect.FieldAppender(field)
+ field.Append = FieldAppender(t.dialect, field)
field.Scan = FieldScanner(t.dialect, field)
field.IsZero = zeroChecker(field.StructField.Type)
@@ -385,6 +400,17 @@ func (t *Table) newField(f reflect.StructField, index []int) *Field {
t.UpdateSoftDeleteField = softDeleteFieldUpdater(field)
}
+ // Check this in the end to undo NullZero.
+ if tag.HasOption("allowzero") {
+ if tag.HasOption("nullzero") {
+ internal.Warn.Printf(
+ "%s.%s: nullzero and allowzero options are mutually exclusive",
+ t.TypeName, f.Name,
+ )
+ }
+ field.NullZero = false
+ }
+
return field
}
@@ -775,9 +801,18 @@ func (t *Table) inlineFields(field *Field, seen map[reflect.Type]struct{}) {
//------------------------------------------------------------------------------
-func (t *Table) Dialect() Dialect { return t.dialect }
+func (t *Table) Dialect() Dialect { return t.dialect }
+
+func (t *Table) HasBeforeAppendModelHook() bool { return t.flags.Has(beforeAppendModelHookFlag) }
+
+// DEPRECATED. Use HasBeforeScanRowHook.
func (t *Table) HasBeforeScanHook() bool { return t.flags.Has(beforeScanHookFlag) }
-func (t *Table) HasAfterScanHook() bool { return t.flags.Has(afterScanHookFlag) }
+
+// DEPRECATED. Use HasAfterScanRowHook.
+func (t *Table) HasAfterScanHook() bool { return t.flags.Has(afterScanHookFlag) }
+
+func (t *Table) HasBeforeScanRowHook() bool { return t.flags.Has(beforeScanRowHookFlag) }
+func (t *Table) HasAfterScanRowHook() bool { return t.flags.Has(afterScanRowHookFlag) }
//------------------------------------------------------------------------------
generated by cgit v1.2.3 (git 2.46.0) at 2025-10-14 23:09:28 +0000