kris/Go-Back-Skeleton
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

update dependencies

Browse source
This commit is contained in:
dhax 2017-10-21 18:30:08 +02:00
parent fce1b99683
commit 397e9c0842
164 changed files with 5207 additions and 2213 deletions
Download patch file Download diff file Expand all files Collapse all files

16
vendor/github.com/go-pg/pg/db.go generated vendored
View file

@ -151,11 +151,11 @@ func (db *DB) Close() error {
// Exec executes a query ignoring returned rows. The params are for any
// placeholders in the query.
func (db *DB) Exec(query interface{}, params ...interface{}) (res orm.Result, err error) {
for i := 0; i <= db.opt.MaxRetries; i++ {
for attempt := 0; attempt <= db.opt.MaxRetries; attempt++ {
var cn *pool.Conn
if i >= 1 {
time.Sleep(db.retryBackoff(i - 1))
if attempt >= 1 {
time.Sleep(db.retryBackoff(attempt - 1))
}
cn, err = db.conn()
@ -166,7 +166,7 @@ func (db *DB) Exec(query interface{}, params ...interface{}) (res orm.Result, er
start := time.Now()
res, err = db.simpleQuery(cn, query, params...)
db.freeConn(cn, err)
db.queryProcessed(db, start, query, params, res, err)
db.queryProcessed(db, start, query, params, attempt, res, err)
if !db.shouldRetry(err) {
break
@ -193,11 +193,11 @@ func (db *DB) ExecOne(query interface{}, params ...interface{}) (orm.Result, err
// Query executes a query that returns rows, typically a SELECT.
// The params are for any placeholders in the query.
func (db *DB) Query(model, query interface{}, params ...interface{}) (res orm.Result, err error) {
for i := 0; i <= db.opt.MaxRetries; i++ {
for attempt := 0; attempt <= db.opt.MaxRetries; attempt++ {
var cn *pool.Conn
if i >= 1 {
time.Sleep(db.retryBackoff(i - 1))
if attempt >= 1 {
time.Sleep(db.retryBackoff(attempt - 1))
}
cn, err = db.conn()
@ -208,7 +208,7 @@ func (db *DB) Query(model, query interface{}, params ...interface{}) (res orm.Re
start := time.Now()
res, err = db.simpleQueryData(cn, model, query, params...)
db.freeConn(cn, err)
db.queryProcessed(db, start, query, params, res, err)
db.queryProcessed(db, start, query, params, attempt, res, err)
if !db.shouldRetry(err) {
break

37
vendor/github.com/go-pg/pg/example_model_test.go generated vendored
View file

@ -735,16 +735,41 @@ func ExampleDB_Model_manyToMany() {
func ExampleDB_Update() {
db := modelDB()
err := db.Update(&Book{
Id: 1,
Title: "updated book 1",
})
book := &Book{Id: 1}
err := db.Select(book)
if err != nil {
panic(err)
}
var book Book
err = db.Model(&book).Where("id = ?", 1).Select()
book.Title = "updated book 1"
err = db.Update(book)
if err != nil {
panic(err)
}
err = db.Select(book)
if err != nil {
panic(err)
}
fmt.Println(book)
// Output: Book<Id=1 Title="updated book 1">
}
func ExampleDB_Update_notNull() {
db := modelDB()
book := &Book{
Id: 1,
Title: "updated book 1",
}
_, err := db.Model(book).UpdateNotNull()
if err != nil {
panic(err)
}
book = new(Book)
err = db.Model(book).Where("id = ?", 1).Select()
if err != nil {
panic(err)
}

23
vendor/github.com/go-pg/pg/hook.go generated vendored
View file

@ -25,11 +25,12 @@ type QueryProcessedEvent struct {
File string
Line int
DB orm.DB
Query interface{}
Params []interface{}
Result orm.Result
Error error
DB orm.DB
Query interface{}
Params []interface{}
Attempt int
Result orm.Result
Error error
}
func (ev *QueryProcessedEvent) UnformattedQuery() (string, error) {
@ -74,6 +75,7 @@ func (db *DB) queryProcessed(
start time.Time,
query interface{},
params []interface{},
attempt int,
res orm.Result,
err error,
) {
@ -88,11 +90,12 @@ func (db *DB) queryProcessed(
File: file,
Line: line,
DB: ormDB,
Query: query,
Params: params,
Result: res,
Error: err,
DB: ormDB,
Query: query,
Params: params,
Attempt: attempt,
Result: res,
Error: err,
}
for _, hook := range db.queryProcessedHooks {
hook(event)

19
vendor/github.com/go-pg/pg/internal/pool/pool.go generated vendored
View file

@ -61,8 +61,10 @@ type Options struct {
type ConnPool struct {
opt *Options
dialErrorsNum uint32 // atomic
_lastDialError atomic.Value
dialErrorsNum uint32 // atomic
lastDialErrorMu sync.RWMutex
lastDialError error
queue chan struct{}
@ -101,7 +103,7 @@ func (p *ConnPool) NewConn() (*Conn, error) {
}
if atomic.LoadUint32(&p.dialErrorsNum) >= uint32(p.opt.PoolSize) {
return nil, p.lastDialError()
return nil, p.getLastDialError()
}
netConn, err := p.opt.Dialer()
@ -142,11 +144,16 @@ func (p *ConnPool) tryDial() {
}
func (p *ConnPool) setLastDialError(err error) {
p._lastDialError.Store(err)
p.lastDialErrorMu.Lock()
p.lastDialError = err
p.lastDialErrorMu.Unlock()
}
func (p *ConnPool) lastDialError() error {
return p._lastDialError.Load().(error)
func (p *ConnPool) getLastDialError() error {
p.lastDialErrorMu.RLock()
err := p.lastDialError
p.lastDialErrorMu.RUnlock()
return err
}
func (p *ConnPool) isStaleConn(cn *Conn) bool {

6
vendor/github.com/go-pg/pg/options.go generated vendored
View file

@ -75,12 +75,6 @@ type Options struct {
// Frequency of idle checks.
// Default is 1 minute.
IdleCheckFrequency time.Duration
// When true Tx does not issue BEGIN, COMMIT, or ROLLBACK.
// Also underlying database connection is immediately returned to the pool.
// This is primarily useful for running your database tests in one big
// transaction, because PostgreSQL does not support nested transactions.
DisableTransaction bool
}
func (opt *Options) init() {

2
vendor/github.com/go-pg/pg/orm/field.go generated vendored
View file

@ -20,7 +20,7 @@ type Field struct {
GoName string // struct field name, e.g. Id
SQLName string // SQL name, .e.g. id
Column types.Q // escaped SQL name
Column types.Q // escaped SQL name, e.g. "id"
SQLType string
Index []int
Default types.Q

39
vendor/github.com/go-pg/pg/orm/insert.go generated vendored
View file

@ -52,36 +52,41 @@ func (q insertQuery) AppendQuery(b []byte) ([]byte, error) {
} else {
b = q.q.appendFirstTable(b)
}
b = append(b, " ("...)
if q.q.hasModel() {
b = appendColumns(b, table.Fields)
} else if q.q.columns != nil {
b = q.q.appendColumns(b)
}
b = append(b, ')')
if q.q.hasModel() {
b = append(b, " VALUES ("...)
if q.q.hasOtherTables() && q.q.columns != nil {
b = append(b, " ("...)
b = q.q.appendColumns(b)
b = append(b, ")"...)
b = append(b, " SELECT * FROM "...)
b = q.q.appendOtherTables(b)
} else {
fields, err := q.q.getFields()
if err != nil {
return nil, err
}
if len(fields) == 0 {
fields = table.Fields
}
b = append(b, " ("...)
b = appendColumns(b, fields)
b = append(b, ") VALUES ("...)
if value.Kind() == reflect.Struct {
b = q.appendValues(b, table.Fields, value)
b = q.appendValues(b, fields, value)
} else {
for i := 0; i < value.Len(); i++ {
el := value.Index(i)
if el.Kind() == reflect.Interface {
el = el.Elem()
}
b = q.appendValues(b, table.Fields, reflect.Indirect(el))
b = q.appendValues(b, fields, reflect.Indirect(el))
if i != value.Len()-1 {
b = append(b, "), ("...)
}
}
}
b = append(b, ')')
}
if q.q.hasOtherTables() {
b = append(b, " SELECT * FROM "...)
b = q.q.appendOtherTables(b)
b = append(b, ")"...)
}
if q.q.onConflict != nil {

12
vendor/github.com/go-pg/pg/orm/insert_test.go generated vendored
View file

@ -43,6 +43,18 @@ type InsertQTest struct {
}
var _ = Describe("Insert", func() {
It("supports Column", func() {
model := &InsertTest{
Id: 1,
Value: "hello",
}
q := NewQuery(nil, model).Column("id")
b, err := insertQuery{q: q}.AppendQuery(nil)
Expect(err).NotTo(HaveOccurred())
Expect(string(b)).To(Equal(`INSERT INTO "insert_tests" ("id") VALUES (1)`))
})
It("multi inserts", func() {
q := NewQuery(nil, &InsertTest{
Id: 1,

29
vendor/github.com/go-pg/pg/orm/query.go generated vendored
View file

@ -188,7 +188,7 @@ func (q *Query) getDataFields() ([]*Field, error) {
return q._getFields(true)
}
func (q *Query) _getFields(filterPKs bool) ([]*Field, error) {
func (q *Query) _getFields(omitPKs bool) ([]*Field, error) {
table := q.model.Table()
var columns []*Field
@ -203,7 +203,7 @@ func (q *Query) _getFields(filterPKs bool) ([]*Field, error) {
return nil, err
}
if filterPKs && field.HasFlag(PrimaryKeyFlag) {
if omitPKs && field.HasFlag(PrimaryKeyFlag) {
continue
}
@ -595,10 +595,16 @@ func (q *Query) SelectOrInsert(values ...interface{}) (inserted bool, err error)
return false, q.stickyErr
}
insertq := q
if len(insertq.columns) > 0 {
insertq = insertq.Copy()
insertq.columns = nil
}
var insertErr error
for i := 0; i < 5; i++ {
if i >= 2 {
time.Sleep(internal.RetryBackoff(i-2, 250*time.Millisecond, 4*time.Second))
time.Sleep(internal.RetryBackoff(i-2, 250*time.Millisecond, 5*time.Second))
}
err := q.Select(values...)
@ -609,7 +615,7 @@ func (q *Query) SelectOrInsert(values ...interface{}) (inserted bool, err error)
return false, err
}
res, err := q.Insert(values...)
res, err := insertq.Insert(values...)
if err != nil {
insertErr = err
if pgErr, ok := err.(internal.PGError); ok {
@ -636,12 +642,21 @@ func (q *Query) SelectOrInsert(values ...interface{}) (inserted bool, err error)
}
// Update updates the model.
func (q *Query) Update(values ...interface{}) (Result, error) {
func (q *Query) Update(scan ...interface{}) (Result, error) {
return q.update(scan, false)
}
// Update updates the model omitting null columns.
func (q *Query) UpdateNotNull(scan ...interface{}) (Result, error) {
return q.update(scan, true)
}
func (q *Query) update(scan []interface{}, omitZero bool) (Result, error) {
if q.stickyErr != nil {
return nil, q.stickyErr
}
model, err := q.newModel(values...)
model, err := q.newModel(scan...)
if err != nil {
return nil, err
}
@ -652,7 +667,7 @@ func (q *Query) Update(values ...interface{}) (Result, error) {
}
}
res, err := q.db.Query(model, updateQuery{q}, q.model)
res, err := q.db.Query(model, updateQuery{q: q, omitZero: omitZero}, q.model)
if err != nil {
return nil, err
}

10
vendor/github.com/go-pg/pg/orm/table.go generated vendored
View file

@ -32,10 +32,10 @@ type Table struct {
Alias types.Q
ModelName string
Fields []*Field
PKs []*Field
Columns []*Field
FieldsMap map[string]*Field
Fields []*Field // PKs + DataFields
PKs []*Field
DataFields []*Field
FieldsMap map[string]*Field
Methods map[string]*Method
Relations map[string]*Relation
@ -71,7 +71,7 @@ func (t *Table) AddField(field *Field) {
if field.HasFlag(PrimaryKeyFlag) {
t.PKs = append(t.PKs, field)
} else {
t.Columns = append(t.Columns, field)
t.DataFields = append(t.DataFields, field)
}
t.FieldsMap[field.SQLName] = field
}

16
vendor/github.com/go-pg/pg/orm/update.go generated vendored
View file

@ -17,6 +17,8 @@ func Update(db DB, model ...interface{}) error {
type updateQuery struct {
q *Query
omitZero bool
}
var _ QueryAppender = (*updateQuery)(nil)
@ -107,12 +109,18 @@ func (q updateQuery) appendSetStruct(b []byte, strct reflect.Value) ([]byte, err
}
if len(fields) == 0 {
fields = q.q.model.Table().Columns
fields = q.q.model.Table().DataFields
}
for i, f := range fields {
if i > 0 {
pos := len(b)
for _, f := range fields {
if q.omitZero && f.OmitZero(strct) {
continue
}
if len(b) != pos {
b = append(b, ", "...)
pos = len(b)
}
b = append(b, f.Column...)
@ -129,7 +137,7 @@ func (q updateQuery) appendSetSlice(b []byte, slice reflect.Value) ([]byte, erro
}
if len(fields) == 0 {
fields = q.q.model.Table().Columns
fields = q.q.model.Table().DataFields
}
for i, f := range fields {

20
vendor/github.com/go-pg/pg/orm/update_test.go generated vendored
View file

@ -11,6 +11,22 @@ type UpdateTest struct {
}
var _ = Describe("Update", func() {
It("updates model", func() {
q := NewQuery(nil, &UpdateTest{})
b, err := updateQuery{q: q}.AppendQuery(nil)
Expect(err).NotTo(HaveOccurred())
Expect(string(b)).To(Equal(`UPDATE "update_tests" AS "update_test" SET "value" = NULL WHERE "update_test"."id" = NULL`))
})
It("omits zero", func() {
q := NewQuery(nil, &UpdateTest{})
b, err := updateQuery{q: q, omitZero: true}.AppendQuery(nil)
Expect(err).NotTo(HaveOccurred())
Expect(string(b)).To(Equal(`UPDATE "update_tests" AS "update_test" SET WHERE "update_test"."id" = NULL`))
})
It("bulk updates", func() {
q := NewQuery(nil, &UpdateTest{}).
Model(&UpdateTest{
@ -20,7 +36,7 @@ var _ = Describe("Update", func() {
Id: 2,
})
b, err := updateQuery{q}.AppendQuery(nil)
b, err := updateQuery{q: q}.AppendQuery(nil)
Expect(err).NotTo(HaveOccurred())
Expect(string(b)).To(Equal(`UPDATE "update_tests" AS "update_test" SET "value" = _data."value" FROM (VALUES (1, 'hello'::mytype), (2, NULL::mytype)) AS _data("id", "value") WHERE "update_test"."id" = _data."id"`))
})
@ -32,7 +48,7 @@ var _ = Describe("Update", func() {
Table("wrapper").
Where("update_test.id = wrapper.id")
b, err := updateQuery{q}.AppendQuery(nil)
b, err := updateQuery{q: q}.AppendQuery(nil)
Expect(err).NotTo(HaveOccurred())
Expect(string(b)).To(Equal(`WITH "wrapper" AS (SELECT "update_test"."id", "update_test"."value" FROM "update_tests" AS "update_test") UPDATE "update_tests" AS "update_test" SET "value" = NULL FROM "wrapper" WHERE (update_test.id = wrapper.id)`))
})

16
vendor/github.com/go-pg/pg/stmt.go generated vendored
View file

@ -64,14 +64,14 @@ func (stmt *Stmt) exec(params ...interface{}) (orm.Result, error) {
// Exec executes a prepared statement with the given parameters.
func (stmt *Stmt) Exec(params ...interface{}) (res orm.Result, err error) {
for i := 0; i <= stmt.db.opt.MaxRetries; i++ {
if i >= 1 {
time.Sleep(stmt.db.retryBackoff(i - 1))
for attempt := 0; attempt <= stmt.db.opt.MaxRetries; attempt++ {
if attempt >= 1 {
time.Sleep(stmt.db.retryBackoff(attempt - 1))
}
start := time.Now()
res, err = stmt.exec(params...)
stmt.db.queryProcessed(stmt.db, start, stmt.q, params, res, err)
stmt.db.queryProcessed(stmt.db, start, stmt.q, params, attempt, res, err)
if !stmt.db.shouldRetry(err) {
break
@ -123,14 +123,14 @@ func (stmt *Stmt) query(model interface{}, params ...interface{}) (orm.Result, e
// Query executes a prepared query statement with the given parameters.
func (stmt *Stmt) Query(model interface{}, params ...interface{}) (res orm.Result, err error) {
for i := 0; i <= stmt.db.opt.MaxRetries; i++ {
if i >= 1 {
time.Sleep(stmt.db.retryBackoff(i - 1))
for attempt := 0; attempt <= stmt.db.opt.MaxRetries; attempt++ {
if attempt >= 1 {
time.Sleep(stmt.db.retryBackoff(attempt - 1))
}
start := time.Now()
res, err = stmt.query(model, params...)
stmt.db.queryProcessed(stmt.db, start, stmt.q, params, res, err)
stmt.db.queryProcessed(stmt.db, start, stmt.q, params, attempt, res, err)
if !stmt.db.shouldRetry(err) {
break

50
vendor/github.com/go-pg/pg/tx.go generated vendored
View file

@ -36,13 +36,11 @@ func (db *DB) Begin() (*Tx, error) {
db: db,
}
if !db.opt.DisableTransaction {
cn, err := db.conn()
if err != nil {
return nil, err
}
tx.cn = cn
cn, err := db.conn()
if err != nil {
return nil, err
}
tx.cn = cn
if err := tx.begin(); err != nil {
return nil, err
@ -85,29 +83,15 @@ func (tx *Tx) RunInTransaction(fn func(*Tx) error) error {
}
func (tx *Tx) conn() (*pool.Conn, error) {
var cn *pool.Conn
if tx.db.opt.DisableTransaction {
var err error
cn, err = tx.db.conn()
if err != nil {
return nil, err
}
} else {
cn = tx.cn
if cn == nil {
return nil, errTxDone
}
if tx.cn == nil {
return nil, errTxDone
}
cn.SetTimeout(tx.db.opt.ReadTimeout, tx.db.opt.WriteTimeout)
return cn, nil
tx.cn.SetTimeout(tx.db.opt.ReadTimeout, tx.db.opt.WriteTimeout)
return tx.cn, nil
}
func (tx *Tx) freeConn(cn *pool.Conn, err error) {
if tx.db.opt.DisableTransaction {
_ = tx.db.freeConn(cn, err)
}
}
func (tx *Tx) freeConn(cn *pool.Conn, err error) {}
// Stmt returns a transaction-specific prepared statement from an existing statement.
func (tx *Tx) Stmt(stmt *Stmt) *Stmt {
@ -152,7 +136,7 @@ func (tx *Tx) Exec(query interface{}, params ...interface{}) (orm.Result, error)
start := time.Now()
res, err := tx.db.simpleQuery(cn, query, params...)
tx.freeConn(cn, err)
tx.db.queryProcessed(tx, start, query, params, res, err)
tx.db.queryProcessed(tx, start, query, params, 0, res, err)
return res, err
}
@ -180,7 +164,7 @@ func (tx *Tx) Query(model interface{}, query interface{}, params ...interface{})
start := time.Now()
res, err := tx.db.simpleQueryData(cn, model, query, params...)
tx.freeConn(cn, err)
tx.db.queryProcessed(tx, start, query, params, res, err)
tx.db.queryProcessed(tx, start, query, params, 0, res, err)
if err != nil {
return nil, err
@ -279,10 +263,6 @@ func (tx *Tx) FormatQuery(dst []byte, query string, params ...interface{}) []byt
}
func (tx *Tx) begin() error {
if tx.db.opt.DisableTransaction {
return nil
}
_, err := tx.Exec("BEGIN")
if err != nil {
tx.close(err)
@ -292,10 +272,6 @@ func (tx *Tx) begin() error {
// Commit commits the transaction.
func (tx *Tx) Commit() error {
if tx.db.opt.DisableTransaction {
return nil
}
_, err := tx.Exec("COMMIT")
tx.close(err)
return err
@ -303,10 +279,6 @@ func (tx *Tx) Commit() error {
// Rollback aborts the transaction.
func (tx *Tx) Rollback() error {
if tx.db.opt.DisableTransaction {
return nil
}
_, err := tx.Exec("ROLLBACK")
tx.close(err)
return err