bump uptrace/bun dependencies from 1.2.6 to 1.2.8 (#3645)

vendor/github.com/uptrace/bun/dialect/pgdialect/append.go

@@ -11,22 +11,22 @@ import (
 )
 
 var (
-	driverValuerType = reflect.TypeOf((*driver.Valuer)(nil)).Elem()
+	driverValuerType = reflect.TypeFor[driver.Valuer]()
 
-	stringType      = reflect.TypeOf((*string)(nil)).Elem()
-	sliceStringType = reflect.TypeOf([]string(nil))
+	stringType      = reflect.TypeFor[string]()
+	sliceStringType = reflect.TypeFor[[]string]()
 
-	intType      = reflect.TypeOf((*int)(nil)).Elem()
-	sliceIntType = reflect.TypeOf([]int(nil))
+	intType      = reflect.TypeFor[int]()
+	sliceIntType = reflect.TypeFor[[]int]()
 
-	int64Type      = reflect.TypeOf((*int64)(nil)).Elem()
-	sliceInt64Type = reflect.TypeOf([]int64(nil))
+	int64Type      = reflect.TypeFor[int64]()
+	sliceInt64Type = reflect.TypeFor[[]int64]()
 
-	float64Type      = reflect.TypeOf((*float64)(nil)).Elem()
-	sliceFloat64Type = reflect.TypeOf([]float64(nil))
+	float64Type      = reflect.TypeFor[float64]()
+	sliceFloat64Type = reflect.TypeFor[[]float64]()
 
-	timeType      = reflect.TypeOf((*time.Time)(nil)).Elem()
-	sliceTimeType = reflect.TypeOf([]time.Time(nil))
+	timeType      = reflect.TypeFor[time.Time]()
+	sliceTimeType = reflect.TypeFor[[]time.Time]()
 )
 
 func appendTime(buf []byte, tm time.Time) []byte {
@@ -67,9 +67,9 @@ func appendMapStringString(b []byte, m map[string]string) []byte {
 	b = append(b, '\'')
 
 	for key, value := range m {
-		b = arrayAppendString(b, key)
+		b = appendStringElem(b, key)
 		b = append(b, '=', '>')
-		b = arrayAppendString(b, value)
+		b = appendStringElem(b, value)
 		b = append(b, ',')
 	}
 	if len(m) > 0 {

vendor/github.com/uptrace/bun/dialect/pgdialect/array.go

@@ -3,13 +3,11 @@ package pgdialect
 import (
 	"database/sql"
 	"database/sql/driver"
-	"encoding/hex"
 	"fmt"
 	"math"
 	"reflect"
 	"strconv"
 	"time"
-	"unicode/utf8"
 
 	"github.com/uptrace/bun/dialect"
 	"github.com/uptrace/bun/internal"
@@ -146,44 +144,21 @@ func (d *Dialect) arrayElemAppender(typ reflect.Type) schema.AppenderFunc {
 	}
 	switch typ.Kind() {
 	case reflect.String:
-		return arrayAppendStringValue
+		return appendStringElemValue
 	case reflect.Slice:
 		if typ.Elem().Kind() == reflect.Uint8 {
-			return arrayAppendBytesValue
+			return appendBytesElemValue
 		}
 	}
 	return schema.Appender(d, typ)
 }
 
-func arrayAppend(fmter schema.Formatter, b []byte, v interface{}) []byte {
-	switch v := v.(type) {
-	case int64:
-		return strconv.AppendInt(b, v, 10)
-	case float64:
-		return arrayAppendFloat64(b, v)
-	case bool:
-		return dialect.AppendBool(b, v)
-	case []byte:
-		return arrayAppendBytes(b, v)
-	case string:
-		return arrayAppendString(b, v)
-	case time.Time:
-		b = append(b, '"')
-		b = appendTime(b, v)
-		b = append(b, '"')
-		return b
-	default:
-		err := fmt.Errorf("pgdialect: can't append %T", v)
-		return dialect.AppendError(b, err)
-	}
+func appendStringElemValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte {
+	return appendStringElem(b, v.String())
 }
 
-func arrayAppendStringValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte {
-	return arrayAppendString(b, v.String())
-}
-
-func arrayAppendBytesValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte {
-	return arrayAppendBytes(b, v.Bytes())
+func appendBytesElemValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte {
+	return appendBytesElem(b, v.Bytes())
 }
 
 func arrayAppendDriverValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte {
@@ -191,7 +166,7 @@ func arrayAppendDriverValue(fmter schema.Formatter, b []byte, v reflect.Value) [
 	if err != nil {
 		return dialect.AppendError(b, err)
 	}
-	return arrayAppend(fmter, b, iface)
+	return appendElem(b, iface)
 }
 
 func appendStringSliceValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte {
@@ -208,7 +183,7 @@ func appendStringSlice(b []byte, ss []string) []byte {
 
 	b = append(b, '{')
 	for _, s := range ss {
-		b = arrayAppendString(b, s)
+		b = appendStringElem(b, s)
 		b = append(b, ',')
 	}
 	if len(ss) > 0 {
@@ -496,7 +471,7 @@ func decodeIntSlice(src interface{}) ([]int, error) {
 			continue
 		}
 
-		n, err := strconv.Atoi(bytesToString(elem))
+		n, err := strconv.Atoi(internal.String(elem))
 		if err != nil {
 			return nil, err
 		}
@@ -545,7 +520,7 @@ func decodeInt64Slice(src interface{}) ([]int64, error) {
 			continue
 		}
 
-		n, err := strconv.ParseInt(bytesToString(elem), 10, 64)
+		n, err := strconv.ParseInt(internal.String(elem), 10, 64)
 		if err != nil {
 			return nil, err
 		}
@@ -594,7 +569,7 @@ func scanFloat64Slice(src interface{}) ([]float64, error) {
 			continue
 		}
 
-		n, err := strconv.ParseFloat(bytesToString(elem), 64)
+		n, err := strconv.ParseFloat(internal.String(elem), 64)
 		if err != nil {
 			return nil, err
 		}
@@ -610,57 +585,10 @@ func scanFloat64Slice(src interface{}) ([]float64, error) {
 func toBytes(src interface{}) ([]byte, error) {
 	switch src := src.(type) {
 	case string:
-		return stringToBytes(src), nil
+		return internal.Bytes(src), nil
 	case []byte:
 		return src, nil
 	default:
 		return nil, fmt.Errorf("pgdialect: got %T, wanted []byte or string", src)
 	}
 }
-
-//------------------------------------------------------------------------------
-
-func arrayAppendBytes(b []byte, bs []byte) []byte {
-	if bs == nil {
-		return dialect.AppendNull(b)
-	}
-
-	b = append(b, `"\\x`...)
-
-	s := len(b)
-	b = append(b, make([]byte, hex.EncodedLen(len(bs)))...)
-	hex.Encode(b[s:], bs)
-
-	b = append(b, '"')
-
-	return b
-}
-
-func arrayAppendString(b []byte, s string) []byte {
-	b = append(b, '"')
-	for _, r := range s {
-		switch r {
-		case 0:
-			// ignore
-		case '\'':
-			b = append(b, "''"...)
-		case '"':
-			b = append(b, '\\', '"')
-		case '\\':
-			b = append(b, '\\', '\\')
-		default:
-			if r < utf8.RuneSelf {
-				b = append(b, byte(r))
-				break
-			}
-			l := len(b)
-			if cap(b)-l < utf8.UTFMax {
-				b = append(b, make([]byte, utf8.UTFMax)...)
-			}
-			n := utf8.EncodeRune(b[l:l+utf8.UTFMax], r)
-			b = b[:l+n]
-		}
-	}
-	b = append(b, '"')
-	return b
-}

vendor/github.com/uptrace/bun/dialect/pgdialect/array_scan.go

@@ -1 +0,0 @@
-package pgdialect

vendor/github.com/uptrace/bun/dialect/pgdialect/dialect.go

@@ -3,7 +3,6 @@ package pgdialect
 import (
 	"database/sql"
 	"fmt"
-	"strconv"
 	"strings"
 
 	"github.com/uptrace/bun"
@@ -34,7 +33,7 @@ var _ schema.Dialect = (*Dialect)(nil)
 var _ sqlschema.InspectorDialect = (*Dialect)(nil)
 var _ sqlschema.MigratorDialect = (*Dialect)(nil)
 
-func New() *Dialect {
+func New(opts ...DialectOption) *Dialect {
 	d := new(Dialect)
 	d.tables = schema.NewTables(d)
 	d.features = feature.CTE |
@@ -55,9 +54,22 @@ func New() *Dialect {
 		feature.GeneratedIdentity |
 		feature.CompositeIn |
 		feature.DeleteReturning
+
+	for _, opt := range opts {
+		opt(d)
+	}
+
 	return d
 }
 
+type DialectOption func(d *Dialect)
+
+func WithoutFeature(other feature.Feature) DialectOption {
+	return func(d *Dialect) {
+		d.features = d.features.Remove(other)
+	}
+}
+
 func (d *Dialect) Init(*sql.DB) {}
 
 func (d *Dialect) Name() dialect.Name {
@@ -115,14 +127,6 @@ func (d *Dialect) IdentQuote() byte {
 	return '"'
 }
 
-func (d *Dialect) AppendUint32(b []byte, n uint32) []byte {
-	return strconv.AppendInt(b, int64(int32(n)), 10)
-}
-
-func (d *Dialect) AppendUint64(b []byte, n uint64) []byte {
-	return strconv.AppendInt(b, int64(n), 10)
-}
-
 func (d *Dialect) AppendSequence(b []byte, _ *schema.Table, _ *schema.Field) []byte {
 	return appendGeneratedAsIdentity(b)
 }

vendor/github.com/uptrace/bun/dialect/pgdialect/elem.go

@@ -0,0 +1,87 @@
+package pgdialect
+
+import (
+	"database/sql/driver"
+	"encoding/hex"
+	"fmt"
+	"strconv"
+	"time"
+	"unicode/utf8"
+
+	"github.com/uptrace/bun/dialect"
+)
+
+func appendElem(buf []byte, val interface{}) []byte {
+	switch val := val.(type) {
+	case int64:
+		return strconv.AppendInt(buf, val, 10)
+	case float64:
+		return arrayAppendFloat64(buf, val)
+	case bool:
+		return dialect.AppendBool(buf, val)
+	case []byte:
+		return appendBytesElem(buf, val)
+	case string:
+		return appendStringElem(buf, val)
+	case time.Time:
+		buf = append(buf, '"')
+		buf = appendTime(buf, val)
+		buf = append(buf, '"')
+		return buf
+	case driver.Valuer:
+		val2, err := val.Value()
+		if err != nil {
+			err := fmt.Errorf("pgdialect: can't append elem value: %w", err)
+			return dialect.AppendError(buf, err)
+		}
+		return appendElem(buf, val2)
+	default:
+		err := fmt.Errorf("pgdialect: can't append elem %T", val)
+		return dialect.AppendError(buf, err)
+	}
+}
+
+func appendBytesElem(b []byte, bs []byte) []byte {
+	if bs == nil {
+		return dialect.AppendNull(b)
+	}
+
+	b = append(b, `"\\x`...)
+
+	s := len(b)
+	b = append(b, make([]byte, hex.EncodedLen(len(bs)))...)
+	hex.Encode(b[s:], bs)
+
+	b = append(b, '"')
+
+	return b
+}
+
+func appendStringElem(b []byte, s string) []byte {
+	b = append(b, '"')
+	for _, r := range s {
+		switch r {
+		case 0:
+			// ignore
+		case '\'':
+			b = append(b, "''"...)
+		case '"':
+			b = append(b, '\\', '"')
+		case '\\':
+			b = append(b, '\\', '\\')
+		default:
+			if r < utf8.RuneSelf {
+				b = append(b, byte(r))
+				break
+			}
+			l := len(b)
+			if cap(b)-l < utf8.UTFMax {
+				b = append(b, make([]byte, utf8.UTFMax)...)
+			}
+			n := utf8.EncodeRune(b[l:l+utf8.UTFMax], r)
+			b = b[:l+n]
+		}
+	}
+	b = append(b, '"')
+	return b
+}

vendor/github.com/uptrace/bun/dialect/pgdialect/inspector.go

@@ -5,8 +5,8 @@ import (
 	"strings"
 
 	"github.com/uptrace/bun"
+	"github.com/uptrace/bun/internal/ordered"
 	"github.com/uptrace/bun/migrate/sqlschema"
-	orderedmap "github.com/wk8/go-ordered-map/v2"
 )
 
 type (
@@ -34,7 +34,7 @@ func newInspector(db *bun.DB, options ...sqlschema.InspectorOption) *Inspector {
 
 func (in *Inspector) Inspect(ctx context.Context) (sqlschema.Database, error) {
 	dbSchema := Schema{
-		Tables:      orderedmap.New[string, sqlschema.Table](),
+		Tables:      ordered.NewMap[string, sqlschema.Table](),
 		ForeignKeys: make(map[sqlschema.ForeignKey]string),
 	}
 
@@ -61,7 +61,7 @@ func (in *Inspector) Inspect(ctx context.Context) (sqlschema.Database, error) {
 			return dbSchema, err
 		}
 
-		colDefs := orderedmap.New[string, sqlschema.Column]()
+		colDefs := ordered.NewMap[string, sqlschema.Column]()
 		uniqueGroups := make(map[string][]string)
 
 		for _, c := range columns {
@@ -72,7 +72,7 @@ func (in *Inspector) Inspect(ctx context.Context) (sqlschema.Database, error) {
 				def = strings.ToLower(def)
 			}
 
-			colDefs.Set(c.Name, &Column{
+			colDefs.Store(c.Name, &Column{
 				Name:            c.Name,
 				SQLType:         c.DataType,
 				VarcharLen:      c.VarcharLen,
@@ -103,7 +103,7 @@ func (in *Inspector) Inspect(ctx context.Context) (sqlschema.Database, error) {
 			}
 		}
 
-		dbSchema.Tables.Set(table.Name, &Table{
+		dbSchema.Tables.Store(table.Name, &Table{
 			Schema:            table.Schema,
 			Name:              table.Name,
 			Columns:           colDefs,

vendor/github.com/uptrace/bun/dialect/pgdialect/parser.go

@@ -0,0 +1,107 @@
+package pgdialect
+
+import (
+	"bytes"
+	"encoding/hex"
+
+	"github.com/uptrace/bun/internal/parser"
+)
+
+type pgparser struct {
+	parser.Parser
+	buf []byte
+}
+
+func newParser(b []byte) *pgparser {
+	p := new(pgparser)
+	p.Reset(b)
+	return p
+}
+
+func (p *pgparser) ReadLiteral(ch byte) []byte {
+	p.Unread()
+	lit, _ := p.ReadSep(',')
+	return lit
+}
+
+func (p *pgparser) ReadUnescapedSubstring(ch byte) ([]byte, error) {
+	return p.readSubstring(ch, false)
+}
+
+func (p *pgparser) ReadSubstring(ch byte) ([]byte, error) {
+	return p.readSubstring(ch, true)
+}
+
+func (p *pgparser) readSubstring(ch byte, escaped bool) ([]byte, error) {
+	ch, err := p.ReadByte()
+	if err != nil {
+		return nil, err
+	}
+
+	p.buf = p.buf[:0]
+	for {
+		if ch == '"' {
+			break
+		}
+
+		next, err := p.ReadByte()
+		if err != nil {
+			return nil, err
+		}
+
+		if ch == '\\' {
+			switch next {
+			case '\\', '"':
+				p.buf = append(p.buf, next)
+
+				ch, err = p.ReadByte()
+				if err != nil {
+					return nil, err
+				}
+			default:
+				p.buf = append(p.buf, '\\')
+				ch = next
+			}
+			continue
+		}
+
+		if escaped && ch == '\'' && next == '\'' {
+			p.buf = append(p.buf, next)
+			ch, err = p.ReadByte()
+			if err != nil {
+				return nil, err
+			}
+			continue
+		}
+
+		p.buf = append(p.buf, ch)
+		ch = next
+	}
+
+	if bytes.HasPrefix(p.buf, []byte("\\x")) && len(p.buf)%2 == 0 {
+		data := p.buf[2:]
+		buf := make([]byte, hex.DecodedLen(len(data)))
+		n, err := hex.Decode(buf, data)
+		if err != nil {
+			return nil, err
+		}
+		return buf[:n], nil
+	}
+
+	return p.buf, nil
+}
+
+func (p *pgparser) ReadRange(ch byte) ([]byte, error) {
+	p.buf = p.buf[:0]
+	p.buf = append(p.buf, ch)
+
+	for p.Valid() {
+		ch = p.Read()
+		p.buf = append(p.buf, ch)
+		if ch == ']' || ch == ')' {
+			break
+		}
+	}
+
+	return p.buf, nil
+}

vendor/github.com/uptrace/bun/dialect/pgdialect/range.go

@@ -1,15 +1,12 @@
 package pgdialect
 
 import (
-	"bytes"
 	"database/sql"
-	"encoding/hex"
 	"fmt"
 	"io"
 	"time"
 
 	"github.com/uptrace/bun/internal"
-	"github.com/uptrace/bun/internal/parser"
 	"github.com/uptrace/bun/schema"
 )
 
@@ -41,7 +38,10 @@ func NewRange[T any](lower, upper T) Range[T] {
 var _ sql.Scanner = (*Range[any])(nil)
 
 func (r *Range[T]) Scan(anySrc any) (err error) {
-	src := anySrc.([]byte)
+	src, ok := anySrc.([]byte)
+	if !ok {
+		return fmt.Errorf("pgdialect: Range can't scan %T", anySrc)
+	}
 
 	if len(src) == 0 {
 		return io.ErrUnexpectedEOF
@@ -90,18 +90,6 @@ func (r *Range[T]) AppendQuery(fmt schema.Formatter, buf []byte) ([]byte, error)
 	return buf, nil
 }
 
-func appendElem(buf []byte, val any) []byte {
-	switch val := val.(type) {
-	case time.Time:
-		buf = append(buf, '"')
-		buf = appendTime(buf, val)
-		buf = append(buf, '"')
-		return buf
-	default:
-		panic(fmt.Errorf("unsupported range type: %T", val))
-	}
-}
-
 func scanElem(ptr any, src []byte) ([]byte, error) {
 	switch ptr := ptr.(type) {
 	case *time.Time:
@@ -117,6 +105,17 @@ func scanElem(ptr any, src []byte) ([]byte, error) {
 		*ptr = tm
 
 		return src, nil
+
+	case sql.Scanner:
+		src, str, err := readStringLiteral(src)
+		if err != nil {
+			return nil, err
+		}
+		if err := ptr.Scan(str); err != nil {
+			return nil, err
+		}
+		return src, nil
+
 	default:
 		panic(fmt.Errorf("unsupported range type: %T", ptr))
 	}
@@ -137,104 +136,3 @@ func readStringLiteral(src []byte) ([]byte, []byte, error) {
 	src = p.Remaining()
 	return src, str, nil
 }
-
-//------------------------------------------------------------------------------
-
-type pgparser struct {
-	parser.Parser
-	buf []byte
-}
-
-func newParser(b []byte) *pgparser {
-	p := new(pgparser)
-	p.Reset(b)
-	return p
-}
-
-func (p *pgparser) ReadLiteral(ch byte) []byte {
-	p.Unread()
-	lit, _ := p.ReadSep(',')
-	return lit
-}
-
-func (p *pgparser) ReadUnescapedSubstring(ch byte) ([]byte, error) {
-	return p.readSubstring(ch, false)
-}
-
-func (p *pgparser) ReadSubstring(ch byte) ([]byte, error) {
-	return p.readSubstring(ch, true)
-}
-
-func (p *pgparser) readSubstring(ch byte, escaped bool) ([]byte, error) {
-	ch, err := p.ReadByte()
-	if err != nil {
-		return nil, err
-	}
-
-	p.buf = p.buf[:0]
-	for {
-		if ch == '"' {
-			break
-		}
-
-		next, err := p.ReadByte()
-		if err != nil {
-			return nil, err
-		}
-
-		if ch == '\\' {
-			switch next {
-			case '\\', '"':
-				p.buf = append(p.buf, next)
-
-				ch, err = p.ReadByte()
-				if err != nil {
-					return nil, err
-				}
-			default:
-				p.buf = append(p.buf, '\\')
-				ch = next
-			}
-			continue
-		}
-
-		if escaped && ch == '\'' && next == '\'' {
-			p.buf = append(p.buf, next)
-			ch, err = p.ReadByte()
-			if err != nil {
-				return nil, err
-			}
-			continue
-		}
-
-		p.buf = append(p.buf, ch)
-		ch = next
-	}
-
-	if bytes.HasPrefix(p.buf, []byte("\\x")) && len(p.buf)%2 == 0 {
-		data := p.buf[2:]
-		buf := make([]byte, hex.DecodedLen(len(data)))
-		n, err := hex.Decode(buf, data)
-		if err != nil {
-			return nil, err
-		}
-		return buf[:n], nil
-	}
-
-	return p.buf, nil
-}
-
-func (p *pgparser) ReadRange(ch byte) ([]byte, error) {
-	p.buf = p.buf[:0]
-	p.buf = append(p.buf, ch)
-
-	for p.Valid() {
-		ch = p.Read()
-		p.buf = append(p.buf, ch)
-		if ch == ']' || ch == ')' {
-			break
-		}
-	}
-
-	return p.buf, nil
-}

vendor/github.com/uptrace/bun/dialect/pgdialect/safe.go

@@ -1,11 +0,0 @@
-// +build appengine
-
-package pgdialect
-
-func bytesToString(b []byte) string {
-	return string(b)
-}
-
-func stringToBytes(s string) []byte {
-	return []byte(s)
-}

vendor/github.com/uptrace/bun/dialect/pgdialect/scan.go

@@ -1,11 +0,0 @@
-package pgdialect
-
-import (
-	"reflect"
-
-	"github.com/uptrace/bun/schema"
-)
-
-func scanner(typ reflect.Type) schema.ScannerFunc {
-	return schema.Scanner(typ)
-}

vendor/github.com/uptrace/bun/dialect/pgdialect/sqltype.go

@@ -44,10 +44,10 @@ const (
 )
 
 var (
-	ipType             = reflect.TypeOf((*net.IP)(nil)).Elem()
-	ipNetType          = reflect.TypeOf((*net.IPNet)(nil)).Elem()
-	jsonRawMessageType = reflect.TypeOf((*json.RawMessage)(nil)).Elem()
-	nullStringType     = reflect.TypeOf((*sql.NullString)(nil)).Elem()
+	ipType             = reflect.TypeFor[net.IP]()
+	ipNetType          = reflect.TypeFor[net.IPNet]()
+	jsonRawMessageType = reflect.TypeFor[json.RawMessage]()
+	nullStringType     = reflect.TypeFor[sql.NullString]()
 )
 
 func (d *Dialect) DefaultVarcharLen() int {

vendor/github.com/uptrace/bun/dialect/pgdialect/unsafe.go

@@ -1,18 +0,0 @@
-// +build !appengine
-
-package pgdialect
-
-import "unsafe"
-
-func bytesToString(b []byte) string {
-	return *(*string)(unsafe.Pointer(&b))
-}
-
-func stringToBytes(s string) []byte {
-	return *(*[]byte)(unsafe.Pointer(
-		&struct {
-			string
-			Cap int
-		}{s, len(s)},
-	))
-}

vendor/github.com/uptrace/bun/dialect/pgdialect/version.go

@@ -2,5 +2,5 @@ package pgdialect
 
 // Version is the current release version.
 func Version() string {
-	return "1.2.6"
+	return "1.2.8"
 }

vendor/github.com/uptrace/bun/dialect/sqlitedialect/dialect.go

@@ -26,7 +26,7 @@ type Dialect struct {
 	features feature.Feature
 }
 
-func New() *Dialect {
+func New(opts ...DialectOption) *Dialect {
 	d := new(Dialect)
 	d.tables = schema.NewTables(d)
 	d.features = feature.CTE |
@@ -42,9 +42,22 @@ func New() *Dialect {
 		feature.AutoIncrement |
 		feature.CompositeIn |
 		feature.DeleteReturning
+
+	for _, opt := range opts {
+		opt(d)
+	}
+
 	return d
 }
 
+type DialectOption func(d *Dialect)
+
+func WithoutFeature(other feature.Feature) DialectOption {
+	return func(d *Dialect) {
+		d.features = d.features.Remove(other)
+	}
+}
+
 func (d *Dialect) Init(*sql.DB) {}
 
 func (d *Dialect) Name() dialect.Name {

vendor/github.com/uptrace/bun/dialect/sqlitedialect/scan.go

@@ -1,11 +0,0 @@
-package sqlitedialect
-
-import (
-	"reflect"
-
-	"github.com/uptrace/bun/schema"
-)
-
-func scanner(typ reflect.Type) schema.ScannerFunc {
-	return schema.Scanner(typ)
-}

vendor/github.com/uptrace/bun/dialect/sqlitedialect/version.go

@@ -2,5 +2,5 @@ package sqlitedialect
 
 // Version is the current release version.
 func Version() string {
-	return "1.2.6"
+	return "1.2.8"
 }