update dependencies

vendor/github.com/go-pg/migrations/.travis.yml

@@ -10,6 +10,7 @@ addons:
 go:
   - 1.7
   - 1.8
+  - 1.9
   - tip
 
 matrix:

vendor/github.com/go-pg/migrations/README.md

@@ -1,5 +1,6 @@
 # SQL migrations for Golang and PostgreSQL
 
 [![Build Status](https://travis-ci.org/go-pg/migrations.svg)](https://travis-ci.org/go-pg/migrations)
+[![GoDoc](https://godoc.org/github.com/go-pg/migrations?status.svg)](https://godoc.org/github.com/go-pg/migrations)
 
 This package allows you to run migrations on your PostgreSQL database using [Golang Postgres client](https://github.com/go-pg/pg). See [example](example) for details.

vendor/github.com/go-pg/migrations/migrations.go

@@ -80,6 +80,7 @@ func RunMigrations(db DB, migrations []Migration, a ...string) (oldVersion, newV
 	if err != nil {
 		return
 	}
+	newVersion = oldVersion
 
 	switch cmd {
 	case "create":

vendor/github.com/go-pg/pg/db.go

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

vendor/github.com/go-pg/pg/example_model_test.go

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

vendor/github.com/go-pg/pg/hook.go

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

vendor/github.com/go-pg/pg/internal/pool/pool.go

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

vendor/github.com/go-pg/pg/options.go

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

vendor/github.com/go-pg/pg/orm/field.go

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

vendor/github.com/go-pg/pg/orm/insert.go

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

vendor/github.com/go-pg/pg/orm/insert_test.go

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

vendor/github.com/go-pg/pg/orm/query.go

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

vendor/github.com/go-pg/pg/orm/table.go

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

vendor/github.com/go-pg/pg/orm/update.go

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

vendor/github.com/go-pg/pg/orm/update_test.go

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

vendor/github.com/go-pg/pg/stmt.go

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

vendor/github.com/go-pg/pg/tx.go

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