diff options
Diffstat (limited to 'vendor/github.com')
31 files changed, 666 insertions, 121 deletions
diff --git a/vendor/github.com/mattn/go-isatty/isatty_bsd.go b/vendor/github.com/mattn/go-isatty/isatty_bsd.go index 39bbcf00f..d569c0c94 100644 --- a/vendor/github.com/mattn/go-isatty/isatty_bsd.go +++ b/vendor/github.com/mattn/go-isatty/isatty_bsd.go @@ -1,5 +1,5 @@ -//go:build (darwin || freebsd || openbsd || netbsd || dragonfly) && !appengine -// +build darwin freebsd openbsd netbsd dragonfly +//go:build (darwin || freebsd || openbsd || netbsd || dragonfly || hurd) && !appengine +// +build darwin freebsd openbsd netbsd dragonfly hurd // +build !appengine package isatty diff --git a/vendor/github.com/uptrace/bun/CHANGELOG.md b/vendor/github.com/uptrace/bun/CHANGELOG.md index fb1f4ee6d..bfb01565a 100644 --- a/vendor/github.com/uptrace/bun/CHANGELOG.md +++ b/vendor/github.com/uptrace/bun/CHANGELOG.md @@ -1,3 +1,29 @@ +## [1.1.10](https://github.com/uptrace/bun/compare/v1.1.9...v1.1.10) (2023-01-16) + + +### Bug Fixes + +* allow QueryEvent to better detect operations in raw queries ([8e44735](https://github.com/uptrace/bun/commit/8e4473538364bae6562055d35e94c3e9c0b77691)) +* append default VARCHAR length instead of hardcoding it in the type definition ([e5079c7](https://github.com/uptrace/bun/commit/e5079c70343ba8c8b410aed23ac1d1ae5a2c9ff6)) +* prevent panic when use pg array with custom database type ([67e4412](https://github.com/uptrace/bun/commit/67e4412a972a9ed5f3a1d07c66957beedbc8a8a3)) +* properly return sql.ErrNoRows when scanning []byte ([996fead](https://github.com/uptrace/bun/commit/996fead2595fbcaff4878b77befe6709a54b3a4d)) + + +### Features + +* mssql output support for update or delete query ([#718](https://github.com/uptrace/bun/issues/718)) ([08876b4](https://github.com/uptrace/bun/commit/08876b4d420e761cbfa658aa6bb89b3f7c62c240)) +* add Err method to query builder ([c722c90](https://github.com/uptrace/bun/commit/c722c90f3dce2642ca4f4c2ab3f9a35cd496b557)) +* add support for time.Time array in Postgres ([3dd6f3b](https://github.com/uptrace/bun/commit/3dd6f3b2ac1bfbcda08240dc1676647b61715a9c)) +* mssql and pg merge query ([#723](https://github.com/uptrace/bun/issues/723)) ([deea764](https://github.com/uptrace/bun/commit/deea764d9380b16aad34228aa32717d10f2a4bab)) +* setError on attempt to set non-positive .Varchar() ([3335e0b](https://github.com/uptrace/bun/commit/3335e0b9d6d3f424145e1f715223a0fffe773d9a)) + + +### Reverts + +* go 1.18 ([67a4488](https://github.com/uptrace/bun/commit/67a448897eaaf1ebc54d629dfd3b2509b35da352)) + + + ## [1.1.9](https://github.com/uptrace/bun/compare/v1.1.8...v1.1.9) (2022-11-23) diff --git a/vendor/github.com/uptrace/bun/README.md b/vendor/github.com/uptrace/bun/README.md index dd2c13633..07a01aa61 100644 --- a/vendor/github.com/uptrace/bun/README.md +++ b/vendor/github.com/uptrace/bun/README.md @@ -28,7 +28,7 @@ - [Migrations](https://bun.uptrace.dev/guide/migrations.html). - [Soft deletes](https://bun.uptrace.dev/guide/soft-deletes.html). -Resources: +### Resources - [**Get started**](https://bun.uptrace.dev/guide/golang-orm.html) - [Examples](https://github.com/uptrace/bun/tree/master/example) @@ -37,7 +37,11 @@ Resources: - [Reference](https://pkg.go.dev/github.com/uptrace/bun) - [Starter kit](https://github.com/go-bun/bun-starter-kit) -Featured projects using Bun: +### Tutorials + +Wrote a tutorial for Bun? Create a PR to add here and on [Bun](https://bun.uptrace.dev/) site. + +### Featured projects using Bun - [uptrace](https://github.com/uptrace/uptrace) - Distributed tracing and metrics. - [paralus](https://github.com/paralus/paralus) - All-in-one Kubernetes access manager. @@ -129,9 +133,11 @@ See [**Getting started**](https://bun.uptrace.dev/guide/golang-orm.html) guide a - [Golang ClickHouse ORM](https://github.com/uptrace/go-clickhouse) - [Golang msgpack](https://github.com/vmihailenco/msgpack) -## Contributors +## Contributing + +See [CONTRIBUTING.md](CONTRIBUTING.md) for some hints. -Thanks to all the people who already contributed! +And thanks to all the people who already contributed! <a href="https://github.com/uptrace/bun/graphs/contributors"> <img src="https://contributors-img.web.app/image?repo=uptrace/bun" /> diff --git a/vendor/github.com/uptrace/bun/db.go b/vendor/github.com/uptrace/bun/db.go index 9b8e391dc..106dfe905 100644 --- a/vendor/github.com/uptrace/bun/db.go +++ b/vendor/github.com/uptrace/bun/db.go @@ -82,6 +82,10 @@ func (db *DB) NewValues(model interface{}) *ValuesQuery { return NewValuesQuery(db, model) } +func (db *DB) NewMerge() *MergeQuery { + return NewMergeQuery(db) +} + func (db *DB) NewSelect() *SelectQuery { return NewSelectQuery(db) } @@ -330,6 +334,10 @@ func (c Conn) NewValues(model interface{}) *ValuesQuery { return NewValuesQuery(c.db, model).Conn(c) } +func (c Conn) NewMerge() *MergeQuery { + return NewMergeQuery(c.db).Conn(c) +} + func (c Conn) NewSelect() *SelectQuery { return NewSelectQuery(c.db).Conn(c) } @@ -640,6 +648,10 @@ func (tx Tx) NewValues(model interface{}) *ValuesQuery { return NewValuesQuery(tx.db, model).Conn(tx) } +func (tx Tx) NewMerge() *MergeQuery { + return NewMergeQuery(tx.db).Conn(tx) +} + func (tx Tx) NewSelect() *SelectQuery { return NewSelectQuery(tx.db).Conn(tx) } diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/append.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/append.go index a60bf5de2..75798b385 100644 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/append.go +++ b/vendor/github.com/uptrace/bun/dialect/pgdialect/append.go @@ -27,6 +27,9 @@ var ( float64Type = reflect.TypeOf((*float64)(nil)).Elem() sliceFloat64Type = reflect.TypeOf([]float64(nil)) + + timeType = reflect.TypeOf((*time.Time)(nil)).Elem() + sliceTimeType = reflect.TypeOf([]time.Time(nil)) ) func arrayAppend(fmter schema.Formatter, b []byte, v interface{}) []byte { @@ -93,6 +96,8 @@ func (d *Dialect) arrayAppender(typ reflect.Type) schema.AppenderFunc { return appendInt64SliceValue case float64Type: return appendFloat64SliceValue + case timeType: + return appendTimeSliceValue } } @@ -308,6 +313,32 @@ func arrayAppendString(b []byte, s string) []byte { return b } +func appendTimeSliceValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte { + ts := v.Convert(sliceTimeType).Interface().([]time.Time) + return appendTimeSlice(fmter, b, ts) +} + +func appendTimeSlice(fmter schema.Formatter, b []byte, ts []time.Time) []byte { + if ts == nil { + return dialect.AppendNull(b) + } + b = append(b, '\'') + b = append(b, '{') + for _, t := range ts { + b = append(b, '"') + b = t.UTC().AppendFormat(b, "2006-01-02 15:04:05.999999-07:00") + b = append(b, '"') + b = append(b, ',') + } + if len(ts) > 0 { + b[len(b)-1] = '}' // Replace trailing comma. + } else { + b = append(b, '}') + } + b = append(b, '\'') + return b +} + //------------------------------------------------------------------------------ var mapStringStringType = reflect.TypeOf(map[string]string(nil)) diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/sqltype.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/sqltype.go index 6c6294d71..dadea5c1c 100644 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/sqltype.go +++ b/vendor/github.com/uptrace/bun/dialect/pgdialect/sqltype.go @@ -45,6 +45,10 @@ var ( jsonRawMessageType = reflect.TypeOf((*json.RawMessage)(nil)).Elem() ) +func (d *Dialect) DefaultVarcharLen() int { + return 0 +} + func fieldSQLType(field *schema.Field) string { if field.UserSQLType != "" { return field.UserSQLType diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/version.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/version.go index 0be479664..b7f683df3 100644 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/version.go +++ b/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.1.9" + return "1.1.10" } diff --git a/vendor/github.com/uptrace/bun/dialect/sqlitedialect/dialect.go b/vendor/github.com/uptrace/bun/dialect/sqlitedialect/dialect.go index 720e979f5..3c809e7a7 100644 --- a/vendor/github.com/uptrace/bun/dialect/sqlitedialect/dialect.go +++ b/vendor/github.com/uptrace/bun/dialect/sqlitedialect/dialect.go @@ -87,6 +87,10 @@ func (d *Dialect) AppendBytes(b []byte, bs []byte) []byte { return b } +func (d *Dialect) DefaultVarcharLen() int { + return 0 +} + func fieldSQLType(field *schema.Field) string { switch field.DiscoveredSQLType { case sqltype.SmallInt, sqltype.BigInt: diff --git a/vendor/github.com/uptrace/bun/dialect/sqlitedialect/version.go b/vendor/github.com/uptrace/bun/dialect/sqlitedialect/version.go index b566ef6ec..0bdf81315 100644 --- a/vendor/github.com/uptrace/bun/dialect/sqlitedialect/version.go +++ b/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.1.9" + return "1.1.10" } diff --git a/vendor/github.com/uptrace/bun/hook.go b/vendor/github.com/uptrace/bun/hook.go index 81249329a..016f06a1a 100644 --- a/vendor/github.com/uptrace/bun/hook.go +++ b/vendor/github.com/uptrace/bun/hook.go @@ -6,6 +6,7 @@ import ( "strings" "sync/atomic" "time" + "unicode" "github.com/uptrace/bun/schema" ) @@ -35,13 +36,15 @@ func (e *QueryEvent) Operation() string { } func queryOperation(query string) string { - if idx := strings.IndexByte(query, ' '); idx > 0 { - query = query[:idx] + queryOp := strings.TrimLeftFunc(query, unicode.IsSpace) + + if idx := strings.IndexByte(queryOp, ' '); idx > 0 { + queryOp = queryOp[:idx] } - if len(query) > 16 { - query = query[:16] + if len(queryOp) > 16 { + queryOp = queryOp[:16] } - return query + return queryOp } type QueryHook interface { diff --git a/vendor/github.com/uptrace/bun/internal/util.go b/vendor/github.com/uptrace/bun/internal/util.go index c831dc659..641309725 100644 --- a/vendor/github.com/uptrace/bun/internal/util.go +++ b/vendor/github.com/uptrace/bun/internal/util.go @@ -25,12 +25,12 @@ func MakeSliceNextElemFunc(v reflect.Value) func() reflect.Value { if elem.IsNil() { elem.Set(reflect.New(elemType)) } - return elem.Elem() + return elem } elem := reflect.New(elemType) v.Set(reflect.Append(v, elem)) - return elem.Elem() + return elem } } diff --git a/vendor/github.com/uptrace/bun/model.go b/vendor/github.com/uptrace/bun/model.go index 88ec48992..6ad4d8efe 100644 --- a/vendor/github.com/uptrace/bun/model.go +++ b/vendor/github.com/uptrace/bun/model.go @@ -13,7 +13,10 @@ import ( var errNilModel = errors.New("bun: Model(nil)") -var timeType = reflect.TypeOf((*time.Time)(nil)).Elem() +var ( + timeType = reflect.TypeOf((*time.Time)(nil)).Elem() + bytesType = reflect.TypeOf((*[]byte)(nil)).Elem() +) type Model = schema.Model @@ -102,19 +105,22 @@ func _newModel(db *DB, dest interface{}, scan bool) (Model, error) { } v = v.Elem() + typ := v.Type() + + switch typ { + case timeType, bytesType: + return newScanModel(db, []interface{}{dest}), nil + } switch v.Kind() { case reflect.Map: - typ := v.Type() if err := validMap(typ); err != nil { return nil, err } mapPtr := v.Addr().Interface().(*map[string]interface{}) return newMapModel(db, mapPtr), nil case reflect.Struct: - if v.Type() != timeType { - return newStructTableModelValue(db, dest, v), nil - } + return newStructTableModelValue(db, dest, v), nil case reflect.Slice: switch elemType := sliceElemType(v); elemType.Kind() { case reflect.Struct: diff --git a/vendor/github.com/uptrace/bun/model_table_slice.go b/vendor/github.com/uptrace/bun/model_table_slice.go index 97e674515..b49e0ce03 100644 --- a/vendor/github.com/uptrace/bun/model_table_slice.go +++ b/vendor/github.com/uptrace/bun/model_table_slice.go @@ -6,6 +6,7 @@ import ( "reflect" "time" + "github.com/uptrace/bun/internal" "github.com/uptrace/bun/schema" ) @@ -33,7 +34,7 @@ func newSliceTableModel( slice: slice, sliceLen: slice.Len(), - nextElem: makeSliceNextElemFunc(slice), + nextElem: internal.MakeSliceNextElemFunc(slice), } m.init(slice.Type()) return m diff --git a/vendor/github.com/uptrace/bun/package.json b/vendor/github.com/uptrace/bun/package.json index 3634b56ab..7c25b6e46 100644 --- a/vendor/github.com/uptrace/bun/package.json +++ b/vendor/github.com/uptrace/bun/package.json @@ -1,6 +1,6 @@ { "name": "gobun", - "version": "1.1.9", + "version": "1.1.10", "main": "index.js", "repository": "git@github.com:uptrace/bun.git", "author": "Vladimir Mihailenco <vladimir.webdev@gmail.com>", diff --git a/vendor/github.com/uptrace/bun/query_column_add.go b/vendor/github.com/uptrace/bun/query_column_add.go index 7b0c2c525..32a21338e 100644 --- a/vendor/github.com/uptrace/bun/query_column_add.go +++ b/vendor/github.com/uptrace/bun/query_column_add.go @@ -37,6 +37,18 @@ func (q *AddColumnQuery) Model(model interface{}) *AddColumnQuery { return q } +func (q *AddColumnQuery) Err(err error) *AddColumnQuery { + q.setErr(err) + return q +} + +func (q *AddColumnQuery) Apply(fn func(*AddColumnQuery) *AddColumnQuery) *AddColumnQuery { + if fn != nil { + return fn(q) + } + return q +} + //------------------------------------------------------------------------------ func (q *AddColumnQuery) Table(tables ...string) *AddColumnQuery { diff --git a/vendor/github.com/uptrace/bun/query_column_drop.go b/vendor/github.com/uptrace/bun/query_column_drop.go index e09933800..1439ed9b9 100644 --- a/vendor/github.com/uptrace/bun/query_column_drop.go +++ b/vendor/github.com/uptrace/bun/query_column_drop.go @@ -35,6 +35,18 @@ func (q *DropColumnQuery) Model(model interface{}) *DropColumnQuery { return q } +func (q *DropColumnQuery) Err(err error) *DropColumnQuery { + q.setErr(err) + return q +} + +func (q *DropColumnQuery) Apply(fn func(*DropColumnQuery) *DropColumnQuery) *DropColumnQuery { + if fn != nil { + return fn(q) + } + return q +} + //------------------------------------------------------------------------------ func (q *DropColumnQuery) Table(tables ...string) *DropColumnQuery { diff --git a/vendor/github.com/uptrace/bun/query_delete.go b/vendor/github.com/uptrace/bun/query_delete.go index 1572ac328..49a750cc8 100644 --- a/vendor/github.com/uptrace/bun/query_delete.go +++ b/vendor/github.com/uptrace/bun/query_delete.go @@ -39,9 +39,17 @@ func (q *DeleteQuery) Model(model interface{}) *DeleteQuery { return q } +func (q *DeleteQuery) Err(err error) *DeleteQuery { + q.setErr(err) + return q +} + // Apply calls the fn passing the DeleteQuery as an argument. func (q *DeleteQuery) Apply(fn func(*DeleteQuery) *DeleteQuery) *DeleteQuery { - return fn(q) + if fn != nil { + return fn(q) + } + return q } func (q *DeleteQuery) With(name string, query schema.QueryAppender) *DeleteQuery { @@ -127,13 +135,6 @@ func (q *DeleteQuery) Returning(query string, args ...interface{}) *DeleteQuery return q } -func (q *DeleteQuery) hasReturning() bool { - if !q.db.features.Has(feature.Returning) { - return false - } - return q.returningQuery.hasReturning() -} - //------------------------------------------------------------------------------ func (q *DeleteQuery) Operation() string { @@ -189,6 +190,14 @@ func (q *DeleteQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, e } } + if q.hasFeature(feature.Output) && q.hasReturning() { + b = append(b, " OUTPUT "...) + b, err = q.appendOutput(fmter, b) + if err != nil { + return nil, err + } + } + b, err = q.mustAppendWhere(fmter, b, withAlias) if err != nil { return nil, err @@ -223,7 +232,18 @@ func (q *DeleteQuery) softDeleteSet(fmter schema.Formatter, tm time.Time) string //------------------------------------------------------------------------------ +func (q *DeleteQuery) Scan(ctx context.Context, dest ...interface{}) error { + _, err := q.scanOrExec(ctx, dest, true) + return err +} + func (q *DeleteQuery) Exec(ctx context.Context, dest ...interface{}) (sql.Result, error) { + return q.scanOrExec(ctx, dest, len(dest) > 0) +} + +func (q *DeleteQuery) scanOrExec( + ctx context.Context, dest []interface{}, hasDest bool, +) (sql.Result, error) { if q.err != nil { return nil, q.err } @@ -234,25 +254,33 @@ func (q *DeleteQuery) Exec(ctx context.Context, dest ...interface{}) (sql.Result } } + // Run append model hooks before generating the query. if err := q.beforeAppendModel(ctx, q); err != nil { return nil, err } + // Generate the query before checking hasReturning. queryBytes, err := q.AppendQuery(q.db.fmter, q.db.makeQueryBytes()) if err != nil { return nil, err } - query := internal.String(queryBytes) - - var res sql.Result + useScan := hasDest || (q.hasReturning() && q.hasFeature(feature.Returning|feature.Output)) + var model Model - if hasDest := len(dest) > 0; hasDest || q.hasReturning() { - model, err := q.getModel(dest) + if useScan { + var err error + model, err = q.getModel(dest) if err != nil { return nil, err } + } + + query := internal.String(queryBytes) + + var res sql.Result + if useScan { res, err = q.scan(ctx, q, query, model, hasDest) if err != nil { return nil, err diff --git a/vendor/github.com/uptrace/bun/query_index_create.go b/vendor/github.com/uptrace/bun/query_index_create.go index 3ef84dd91..11824cfa4 100644 --- a/vendor/github.com/uptrace/bun/query_index_create.go +++ b/vendor/github.com/uptrace/bun/query_index_create.go @@ -46,6 +46,11 @@ func (q *CreateIndexQuery) Model(model interface{}) *CreateIndexQuery { return q } +func (q *CreateIndexQuery) Err(err error) *CreateIndexQuery { + q.setErr(err) + return q +} + func (q *CreateIndexQuery) Unique() *CreateIndexQuery { q.unique = true return q diff --git a/vendor/github.com/uptrace/bun/query_index_drop.go b/vendor/github.com/uptrace/bun/query_index_drop.go index 071e0f937..ae28e7956 100644 --- a/vendor/github.com/uptrace/bun/query_index_drop.go +++ b/vendor/github.com/uptrace/bun/query_index_drop.go @@ -40,6 +40,11 @@ func (q *DropIndexQuery) Model(model interface{}) *DropIndexQuery { return q } +func (q *DropIndexQuery) Err(err error) *DropIndexQuery { + q.setErr(err) + return q +} + //------------------------------------------------------------------------------ func (q *DropIndexQuery) Concurrently() *DropIndexQuery { diff --git a/vendor/github.com/uptrace/bun/query_insert.go b/vendor/github.com/uptrace/bun/query_insert.go index 7fb358de8..7cf053756 100644 --- a/vendor/github.com/uptrace/bun/query_insert.go +++ b/vendor/github.com/uptrace/bun/query_insert.go @@ -48,9 +48,17 @@ func (q *InsertQuery) Model(model interface{}) *InsertQuery { return q } +func (q *InsertQuery) Err(err error) *InsertQuery { + q.setErr(err) + return q +} + // Apply calls the fn passing the SelectQuery as an argument. func (q *InsertQuery) Apply(fn func(*InsertQuery) *InsertQuery) *InsertQuery { - return fn(q) + if fn != nil { + return fn(q) + } + return q } func (q *InsertQuery) With(name string, query schema.QueryAppender) *InsertQuery { @@ -189,7 +197,7 @@ func (q *InsertQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, e return nil, err } - b, err = q.appendColumnsValues(fmter, b) + b, err = q.appendColumnsValues(fmter, b, false) if err != nil { return nil, err } @@ -211,7 +219,7 @@ func (q *InsertQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, e } func (q *InsertQuery) appendColumnsValues( - fmter schema.Formatter, b []byte, + fmter schema.Formatter, b []byte, skipOutput bool, ) (_ []byte, err error) { if q.hasMultiTables() { if q.columns != nil { @@ -272,7 +280,7 @@ func (q *InsertQuery) appendColumnsValues( b = q.appendFields(fmter, b, fields) b = append(b, ")"...) - if q.hasFeature(feature.Output) && q.hasReturning() { + if q.hasFeature(feature.Output) && q.hasReturning() && !skipOutput { b = append(b, " OUTPUT "...) b, err = q.appendOutput(fmter, b) if err != nil { @@ -534,35 +542,54 @@ func (q *InsertQuery) appendSetValues(b []byte, fields []*schema.Field) []byte { //------------------------------------------------------------------------------ +func (q *InsertQuery) Scan(ctx context.Context, dest ...interface{}) error { + _, err := q.scanOrExec(ctx, dest, true) + return err +} + func (q *InsertQuery) Exec(ctx context.Context, dest ...interface{}) (sql.Result, error) { + return q.scanOrExec(ctx, dest, len(dest) > 0) +} + +func (q *InsertQuery) scanOrExec( + ctx context.Context, dest []interface{}, hasDest bool, +) (sql.Result, error) { + if q.err != nil { + return nil, q.err + } + if q.table != nil { if err := q.beforeInsertHook(ctx); err != nil { return nil, err } } - if q.err != nil { - return nil, q.err - } + // Run append model hooks before generating the query. if err := q.beforeAppendModel(ctx, q); err != nil { return nil, err } + // Generate the query before checking hasReturning. queryBytes, err := q.AppendQuery(q.db.fmter, q.db.makeQueryBytes()) if err != nil { return nil, err } - query := internal.String(queryBytes) - var res sql.Result + useScan := hasDest || (q.hasReturning() && q.hasFeature(feature.InsertReturning|feature.Output)) + var model Model - if hasDest := len(dest) > 0; hasDest || - (q.hasReturning() && q.hasFeature(feature.InsertReturning|feature.Output)) { - model, err := q.getModel(dest) + if useScan { + var err error + model, err = q.getModel(dest) if err != nil { return nil, err } + } + + query := internal.String(queryBytes) + var res sql.Result + if useScan { res, err = q.scan(ctx, q, query, model, hasDest) if err != nil { return nil, err diff --git a/vendor/github.com/uptrace/bun/query_merge.go b/vendor/github.com/uptrace/bun/query_merge.go new file mode 100644 index 000000000..706dc20ae --- /dev/null +++ b/vendor/github.com/uptrace/bun/query_merge.go @@ -0,0 +1,322 @@ +package bun + +import ( + "context" + "database/sql" + "errors" + + "github.com/uptrace/bun/dialect" + "github.com/uptrace/bun/dialect/feature" + "github.com/uptrace/bun/internal" + "github.com/uptrace/bun/schema" +) + +type MergeQuery struct { + baseQuery + returningQuery + + using schema.QueryWithArgs + on schema.QueryWithArgs + when []schema.QueryAppender +} + +var _ Query = (*MergeQuery)(nil) + +func NewMergeQuery(db *DB) *MergeQuery { + q := &MergeQuery{ + baseQuery: baseQuery{ + db: db, + conn: db.DB, + }, + } + if !(q.db.dialect.Name() == dialect.MSSQL || q.db.dialect.Name() == dialect.PG) { + q.err = errors.New("bun: merge not supported for current dialect") + } + return q +} + +func (q *MergeQuery) Conn(db IConn) *MergeQuery { + q.setConn(db) + return q +} + +func (q *MergeQuery) Model(model interface{}) *MergeQuery { + q.setModel(model) + return q +} + +func (q *MergeQuery) Err(err error) *MergeQuery { + q.setErr(err) + return q +} + +// Apply calls the fn passing the MergeQuery as an argument. +func (q *MergeQuery) Apply(fn func(*MergeQuery) *MergeQuery) *MergeQuery { + if fn != nil { + return fn(q) + } + return q +} + +func (q *MergeQuery) With(name string, query schema.QueryAppender) *MergeQuery { + q.addWith(name, query, false) + return q +} + +func (q *MergeQuery) WithRecursive(name string, query schema.QueryAppender) *MergeQuery { + q.addWith(name, query, true) + return q +} + +//------------------------------------------------------------------------------ + +func (q *MergeQuery) Table(tables ...string) *MergeQuery { + for _, table := range tables { + q.addTable(schema.UnsafeIdent(table)) + } + return q +} + +func (q *MergeQuery) TableExpr(query string, args ...interface{}) *MergeQuery { + q.addTable(schema.SafeQuery(query, args)) + return q +} + +func (q *MergeQuery) ModelTableExpr(query string, args ...interface{}) *MergeQuery { + q.modelTableName = schema.SafeQuery(query, args) + return q +} + +//------------------------------------------------------------------------------ + +// Returning adds a RETURNING clause to the query. +// +// To suppress the auto-generated RETURNING clause, use `Returning("NULL")`. +// Only for mssql output, postgres not supported returning in merge query +func (q *MergeQuery) Returning(query string, args ...interface{}) *MergeQuery { + q.addReturning(schema.SafeQuery(query, args)) + return q +} + +//------------------------------------------------------------------------------ + +func (q *MergeQuery) Using(s string, args ...interface{}) *MergeQuery { + q.using = schema.SafeQuery(s, args) + return q +} + +func (q *MergeQuery) On(s string, args ...interface{}) *MergeQuery { + q.on = schema.SafeQuery(s, args) + return q +} + +// WhenInsert for when insert clause. +func (q *MergeQuery) WhenInsert(expr string, fn func(q *InsertQuery) *InsertQuery) *MergeQuery { + sq := NewInsertQuery(q.db) + // apply the model as default into sub query, since appendColumnsValues required + if q.model != nil { + sq = sq.Model(q.model) + } + sq = sq.Apply(fn) + q.when = append(q.when, &whenInsert{expr: expr, query: sq}) + return q +} + +// WhenUpdate for when update clause. +func (q *MergeQuery) WhenUpdate(expr string, fn func(q *UpdateQuery) *UpdateQuery) *MergeQuery { + sq := NewUpdateQuery(q.db) + // apply the model as default into sub query + if q.model != nil { + sq = sq.Model(q.model) + } + sq = sq.Apply(fn) + q.when = append(q.when, &whenUpdate{expr: expr, query: sq}) + return q +} + +// WhenDelete for when delete clause. +func (q *MergeQuery) WhenDelete(expr string) *MergeQuery { + q.when = append(q.when, &whenDelete{expr: expr}) + return q +} + +// When for raw expression clause. +func (q *MergeQuery) When(expr string, args ...interface{}) *MergeQuery { + q.when = append(q.when, schema.SafeQuery(expr, args)) + return q +} + +//------------------------------------------------------------------------------ + +func (q *MergeQuery) Operation() string { + return "MERGE" +} + +func (q *MergeQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { + if q.err != nil { + return nil, q.err + } + + fmter = formatterWithModel(fmter, q) + + b, err = q.appendWith(fmter, b) + if err != nil { + return nil, err + } + + b = append(b, "MERGE "...) + if q.db.dialect.Name() == dialect.PG { + b = append(b, "INTO "...) + } + + b, err = q.appendFirstTableWithAlias(fmter, b) + if err != nil { + return nil, err + } + + b = append(b, " USING "...) + b, err = q.using.AppendQuery(fmter, b) + if err != nil { + return nil, err + } + + b = append(b, " ON "...) + b, err = q.on.AppendQuery(fmter, b) + if err != nil { + return nil, err + } + + for _, w := range q.when { + b = append(b, " WHEN "...) + b, err = w.AppendQuery(fmter, b) + if err != nil { + return nil, err + } + } + + if q.hasFeature(feature.Output) && q.hasReturning() { + b = append(b, " OUTPUT "...) + b, err = q.appendOutput(fmter, b) + if err != nil { + return nil, err + } + } + + // A MERGE statement must be terminated by a semi-colon (;). + b = append(b, ";"...) + + return b, nil +} + +//------------------------------------------------------------------------------ + +func (q *MergeQuery) Scan(ctx context.Context, dest ...interface{}) error { + _, err := q.scanOrExec(ctx, dest, true) + return err +} + +func (q *MergeQuery) Exec(ctx context.Context, dest ...interface{}) (sql.Result, error) { + return q.scanOrExec(ctx, dest, len(dest) > 0) +} + +func (q *MergeQuery) scanOrExec( + ctx context.Context, dest []interface{}, hasDest bool, +) (sql.Result, error) { + if q.err != nil { + return nil, q.err + } + + // Run append model hooks before generating the query. + if err := q.beforeAppendModel(ctx, q); err != nil { + return nil, err + } + + // Generate the query before checking hasReturning. + queryBytes, err := q.AppendQuery(q.db.fmter, q.db.makeQueryBytes()) + if err != nil { + return nil, err + } + + useScan := hasDest || (q.hasReturning() && q.hasFeature(feature.InsertReturning|feature.Output)) + var model Model + + if useScan { + var err error + model, err = q.getModel(dest) + if err != nil { + return nil, err + } + } + + query := internal.String(queryBytes) + var res sql.Result + + if useScan { + res, err = q.scan(ctx, q, query, model, true) + if err != nil { + return nil, err + } + } else { + res, err = q.exec(ctx, q, query) + if err != nil { + return nil, err + } + } + + return res, nil +} + +func (q *MergeQuery) String() string { + buf, err := q.AppendQuery(q.db.Formatter(), nil) + if err != nil { + panic(err) + } + + return string(buf) +} + +//------------------------------------------------------------------------------ + +type whenInsert struct { + expr string + query *InsertQuery +} + +func (w *whenInsert) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { + b = append(b, w.expr...) + if w.query != nil { + b = append(b, " THEN INSERT"...) + b, err = w.query.appendColumnsValues(fmter, b, true) + if err != nil { + return nil, err + } + } + return b, nil +} + +type whenUpdate struct { + expr string + query *UpdateQuery +} + +func (w *whenUpdate) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { + b = append(b, w.expr...) + if w.query != nil { + b = append(b, " THEN UPDATE SET "...) + b, err = w.query.appendSet(fmter, b) + if err != nil { + return nil, err + } + } + return b, nil +} + +type whenDelete struct { + expr string +} + +func (w *whenDelete) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { + b = append(b, w.expr...) + b = append(b, " THEN DELETE"...) + return b, nil +} diff --git a/vendor/github.com/uptrace/bun/query_raw.go b/vendor/github.com/uptrace/bun/query_raw.go index afbe12130..7afa4d536 100644 --- a/vendor/github.com/uptrace/bun/query_raw.go +++ b/vendor/github.com/uptrace/bun/query_raw.go @@ -41,6 +41,11 @@ func (q *RawQuery) Conn(db IConn) *RawQuery { return q } +func (q *RawQuery) Err(err error) *RawQuery { + q.setErr(err) + return q +} + func (q *RawQuery) Scan(ctx context.Context, dest ...interface{}) error { if q.err != nil { return q.err diff --git a/vendor/github.com/uptrace/bun/query_select.go b/vendor/github.com/uptrace/bun/query_select.go index 19db0bb3a..a24a9f6f1 100644 --- a/vendor/github.com/uptrace/bun/query_select.go +++ b/vendor/github.com/uptrace/bun/query_select.go @@ -61,9 +61,17 @@ func (q *SelectQuery) Model(model interface{}) *SelectQuery { return q } +func (q *SelectQuery) Err(err error) *SelectQuery { + q.setErr(err) + return q +} + // Apply calls the fn passing the SelectQuery as an argument. func (q *SelectQuery) Apply(fn func(*SelectQuery) *SelectQuery) *SelectQuery { - return fn(q) + if fn != nil { + return fn(q) + } + return q } func (q *SelectQuery) With(name string, query schema.QueryAppender) *SelectQuery { diff --git a/vendor/github.com/uptrace/bun/query_table_create.go b/vendor/github.com/uptrace/bun/query_table_create.go index 002250bc1..518dbfd1c 100644 --- a/vendor/github.com/uptrace/bun/query_table_create.go +++ b/vendor/github.com/uptrace/bun/query_table_create.go @@ -3,8 +3,10 @@ package bun import ( "context" "database/sql" + "fmt" "sort" "strconv" + "strings" "github.com/uptrace/bun/dialect/feature" "github.com/uptrace/bun/dialect/sqltype" @@ -17,7 +19,12 @@ type CreateTableQuery struct { temp bool ifNotExists bool - varchar int + + // varchar changes the default length for VARCHAR columns. + // Because some dialects require that length is always specified for VARCHAR type, + // we will use the exact user-defined type if length is set explicitly, as in `bun:",type:varchar(5)"`, + // but assume the new default length when it's omitted, e.g. `bun:",type:varchar"`. + varchar int fks []schema.QueryWithArgs partitionBy schema.QueryWithArgs @@ -32,6 +39,7 @@ func NewCreateTableQuery(db *DB) *CreateTableQuery { db: db, conn: db.DB, }, + varchar: db.Dialect().DefaultVarcharLen(), } return q } @@ -46,6 +54,11 @@ func (q *CreateTableQuery) Model(model interface{}) *CreateTableQuery { return q } +func (q *CreateTableQuery) Err(err error) *CreateTableQuery { + q.setErr(err) + return q +} + // ------------------------------------------------------------------------------ func (q *CreateTableQuery) Table(tables ...string) *CreateTableQuery { @@ -82,7 +95,12 @@ func (q *CreateTableQuery) IfNotExists() *CreateTableQuery { return q } +// Varchar sets default length for VARCHAR columns. func (q *CreateTableQuery) Varchar(n int) *CreateTableQuery { + if n <= 0 { + q.setErr(fmt.Errorf("bun: illegal VARCHAR length: %d", n)) + return q + } q.varchar = n return q } @@ -120,7 +138,7 @@ func (q *CreateTableQuery) WithForeignKeys() *CreateTableQuery { return q } -//------------------------------------------------------------------------------ +// ------------------------------------------------------------------------------ func (q *CreateTableQuery) Operation() string { return "CREATE TABLE" @@ -221,19 +239,23 @@ func (q *CreateTableQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []by } func (q *CreateTableQuery) appendSQLType(b []byte, field *schema.Field) []byte { - if field.CreateTableSQLType != field.DiscoveredSQLType { + // Most of the time these two will match, but for the cases where DiscoveredSQLType is dialect-specific, + // e.g. pgdialect would change sqltype.SmallInt to pgTypeSmallSerial for columns that have `bun:",autoincrement"` + if !strings.EqualFold(field.CreateTableSQLType, field.DiscoveredSQLType) { return append(b, field.CreateTableSQLType...) } - if q.varchar > 0 && - field.CreateTableSQLType == sqltype.VarChar { - b = append(b, "varchar("...) - b = strconv.AppendInt(b, int64(q.varchar), 10) - b = append(b, ")"...) - return b + // For all common SQL types except VARCHAR, both UserDefinedSQLType and DiscoveredSQLType specify the correct type, + // and we needn't modify it. For VARCHAR columns, we will stop to check if a valid length has been set in .Varchar(int). + if !strings.EqualFold(field.CreateTableSQLType, sqltype.VarChar) || q.varchar <= 0 { + return append(b, field.CreateTableSQLType...) } - return append(b, field.CreateTableSQLType...) + b = append(b, sqltype.VarChar...) + b = append(b, "("...) + b = strconv.AppendInt(b, int64(q.varchar), 10) + b = append(b, ")"...) + return b } func (q *CreateTableQuery) appendUniqueConstraints(fmter schema.Formatter, b []byte) []byte { diff --git a/vendor/github.com/uptrace/bun/query_table_drop.go b/vendor/github.com/uptrace/bun/query_table_drop.go index f5098eb50..e4447a8d2 100644 --- a/vendor/github.com/uptrace/bun/query_table_drop.go +++ b/vendor/github.com/uptrace/bun/query_table_drop.go @@ -37,6 +37,11 @@ func (q *DropTableQuery) Model(model interface{}) *DropTableQuery { return q } +func (q *DropTableQuery) Err(err error) *DropTableQuery { + q.setErr(err) + return q +} + //------------------------------------------------------------------------------ func (q *DropTableQuery) Table(tables ...string) *DropTableQuery { diff --git a/vendor/github.com/uptrace/bun/query_table_truncate.go b/vendor/github.com/uptrace/bun/query_table_truncate.go index ceeae889a..a704b7b10 100644 --- a/vendor/github.com/uptrace/bun/query_table_truncate.go +++ b/vendor/github.com/uptrace/bun/query_table_truncate.go @@ -38,6 +38,11 @@ func (q *TruncateTableQuery) Model(model interface{}) *TruncateTableQuery { return q } +func (q *TruncateTableQuery) Err(err error) *TruncateTableQuery { + q.setErr(err) + return q +} + //------------------------------------------------------------------------------ func (q *TruncateTableQuery) Table(tables ...string) *TruncateTableQuery { diff --git a/vendor/github.com/uptrace/bun/query_update.go b/vendor/github.com/uptrace/bun/query_update.go index 1662245a8..708bcfbce 100644 --- a/vendor/github.com/uptrace/bun/query_update.go +++ b/vendor/github.com/uptrace/bun/query_update.go @@ -47,9 +47,17 @@ func (q *UpdateQuery) Model(model interface{}) *UpdateQuery { return q } +func (q *UpdateQuery) Err(err error) *UpdateQuery { + q.setErr(err) + return q +} + // Apply calls the fn passing the SelectQuery as an argument. func (q *UpdateQuery) Apply(fn func(*UpdateQuery) *UpdateQuery) *UpdateQuery { - return fn(q) + if fn != nil { + return fn(q) + } + return q } func (q *UpdateQuery) With(name string, query schema.QueryAppender) *UpdateQuery { @@ -174,13 +182,6 @@ func (q *UpdateQuery) Returning(query string, args ...interface{}) *UpdateQuery return q } -func (q *UpdateQuery) hasReturning() bool { - if !q.db.features.Has(feature.Returning) { - return false - } - return q.returningQuery.hasReturning() -} - //------------------------------------------------------------------------------ func (q *UpdateQuery) Operation() string { @@ -229,6 +230,14 @@ func (q *UpdateQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, e } } + if q.hasFeature(feature.Output) && q.hasReturning() { + b = append(b, " OUTPUT "...) + b, err = q.appendOutput(fmter, b) + if err != nil { + return nil, err + } + } + b, err = q.mustAppendWhere(fmter, b, q.hasTableAlias(fmter)) if err != nil { return nil, err @@ -426,7 +435,18 @@ func (q *UpdateQuery) updateSliceWhere(fmter schema.Formatter, model *sliceTable //------------------------------------------------------------------------------ +func (q *UpdateQuery) Scan(ctx context.Context, dest ...interface{}) error { + _, err := q.scanOrExec(ctx, dest, true) + return err +} + func (q *UpdateQuery) Exec(ctx context.Context, dest ...interface{}) (sql.Result, error) { + return q.scanOrExec(ctx, dest, len(dest) > 0) +} + +func (q *UpdateQuery) scanOrExec( + ctx context.Context, dest []interface{}, hasDest bool, +) (sql.Result, error) { if q.err != nil { return nil, q.err } @@ -437,25 +457,33 @@ func (q *UpdateQuery) Exec(ctx context.Context, dest ...interface{}) (sql.Result } } + // Run append model hooks before generating the query. if err := q.beforeAppendModel(ctx, q); err != nil { return nil, err } + // Generate the query before checking hasReturning. queryBytes, err := q.AppendQuery(q.db.fmter, q.db.makeQueryBytes()) if err != nil { return nil, err } - query := internal.String(queryBytes) - - var res sql.Result + useScan := hasDest || (q.hasReturning() && q.hasFeature(feature.Returning|feature.Output)) + var model Model - if hasDest := len(dest) > 0; hasDest || q.hasReturning() { - model, err := q.getModel(dest) + if useScan { + var err error + model, err = q.getModel(dest) if err != nil { return nil, err } + } + + query := internal.String(queryBytes) + + var res sql.Result + if useScan { res, err = q.scan(ctx, q, query, model, hasDest) if err != nil { return nil, err @@ -498,7 +526,7 @@ func (q *UpdateQuery) afterUpdateHook(ctx context.Context) error { // table_alias.column_alias. func (q *UpdateQuery) FQN(column string) Ident { if q.table == nil { - panic("UpdateQuery.SetName requires a model") + panic("UpdateQuery.FQN requires a model") } if q.hasTableAlias(q.db.fmter) { return Ident(q.table.Alias + "." + column) diff --git a/vendor/github.com/uptrace/bun/query_values.go b/vendor/github.com/uptrace/bun/query_values.go index a02b3e4b7..5c2abef60 100644 --- a/vendor/github.com/uptrace/bun/query_values.go +++ b/vendor/github.com/uptrace/bun/query_values.go @@ -37,6 +37,11 @@ func (q *ValuesQuery) Conn(db IConn) *ValuesQuery { return q } +func (q *ValuesQuery) Err(err error) *ValuesQuery { + q.setErr(err) + return q +} + func (q *ValuesQuery) Column(columns ...string) *ValuesQuery { for _, column := range columns { q.addColumn(schema.UnsafeIdent(column)) diff --git a/vendor/github.com/uptrace/bun/schema/dialect.go b/vendor/github.com/uptrace/bun/schema/dialect.go index b73d89bd0..fea8238dc 100644 --- a/vendor/github.com/uptrace/bun/schema/dialect.go +++ b/vendor/github.com/uptrace/bun/schema/dialect.go @@ -30,9 +30,14 @@ type Dialect interface { AppendBytes(b []byte, bs []byte) []byte AppendJSON(b, jsonb []byte) []byte AppendBool(b []byte, v bool) []byte + + // DefaultVarcharLen should be returned for dialects in which specifying VARCHAR length + // is mandatory in queries that modify the schema (CREATE TABLE / ADD COLUMN, etc). + // Dialects that do not have such requirement may return 0, which should be interpreted so by the caller. + DefaultVarcharLen() int } -//------------------------------------------------------------------------------ +// ------------------------------------------------------------------------------ type BaseDialect struct{} @@ -131,7 +136,7 @@ func (BaseDialect) AppendBool(b []byte, v bool) []byte { return dialect.AppendBool(b, v) } -//------------------------------------------------------------------------------ +// ------------------------------------------------------------------------------ type nopDialect struct { BaseDialect @@ -168,3 +173,7 @@ func (d *nopDialect) OnTable(table *Table) {} func (d *nopDialect) IdentQuote() byte { return '"' } + +func (d *nopDialect) DefaultVarcharLen() int { + return 0 +} diff --git a/vendor/github.com/uptrace/bun/util.go b/vendor/github.com/uptrace/bun/util.go index ce56be805..09ffbb996 100644 --- a/vendor/github.com/uptrace/bun/util.go +++ b/vendor/github.com/uptrace/bun/util.go @@ -66,49 +66,3 @@ func sliceElemType(v reflect.Value) reflect.Type { } return indirectType(elemType) } - -func makeSliceNextElemFunc(v reflect.Value) func() reflect.Value { - if v.Kind() == reflect.Array { - var pos int - return func() reflect.Value { - v := v.Index(pos) - pos++ - return v - } - } - - sliceType := v.Type() - elemType := sliceType.Elem() - - if elemType.Kind() == reflect.Ptr { - elemType = elemType.Elem() - return func() reflect.Value { - if v.Len() < v.Cap() { - v.Set(v.Slice(0, v.Len()+1)) - elem := v.Index(v.Len() - 1) - if elem.IsNil() { - elem.Set(reflect.New(elemType)) - } - return elem.Elem() - } - - elem := reflect.New(elemType) - v.Set(reflect.Append(v, elem)) - return elem.Elem() - } - } - - zero := reflect.Zero(elemType) - return func() reflect.Value { - l := v.Len() - c := v.Cap() - - if l < c { - v.Set(v.Slice(0, l+1)) - return v.Index(l) - } - - v.Set(reflect.Append(v, zero)) - return v.Index(l) - } -} diff --git a/vendor/github.com/uptrace/bun/version.go b/vendor/github.com/uptrace/bun/version.go index 3be066d3d..14a4ddbca 100644 --- a/vendor/github.com/uptrace/bun/version.go +++ b/vendor/github.com/uptrace/bun/version.go @@ -2,5 +2,5 @@ package bun // Version is the current release version. func Version() string { - return "1.1.9" + return "1.1.10" } |