mirrors/gotosocial
1
0
Fork 0
mirror of https://github.com/superseriousbusiness/gotosocial.git synced 2025-12-14 21:13:01 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

upstep bun to v1.0.14 (#291)

Browse source
This commit is contained in:
tobi 2021-10-24 13:14:37 +02:00 • committed by GitHub
commit 8b7c3507fe
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
100 changed files with 5071 additions and 3836 deletions
Download patch file Download diff file Expand all files Collapse all files

43
vendor/github.com/uptrace/bun/schema/append.go generated vendored
View file

@ -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
}

112
vendor/github.com/uptrace/bun/schema/append_value.go generated vendored
View file

@ -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(typ reflect.Type, custom CustomAppender) AppenderFunc {
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(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
}

109
vendor/github.com/uptrace/bun/schema/dialect.go generated vendored
View file

@ -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
}

4
vendor/github.com/uptrace/bun/schema/formatter.go generated vendored
View file

@ -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)
}
}

39
vendor/github.com/uptrace/bun/schema/hook.go generated vendored
View file

@ -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()

18
vendor/github.com/uptrace/bun/schema/scan.go generated vendored
View file

@ -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 {

13
vendor/github.com/uptrace/bun/schema/sqlfmt.go generated vendored
View file

@ -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 {

10
vendor/github.com/uptrace/bun/schema/sqltype.go generated vendored
View file

@ -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 {

61
vendor/github.com/uptrace/bun/schema/table.go generated vendored
View file

@ -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) }
//------------------------------------------------------------------------------