updates for theme branch

2020-06-06 13:17:50 +02:00 · 2020-06-06 13:17:50 +02:00 · b39c995204
commit b39c995204
parent c23395555d
108 changed files with 14102 additions and 7077 deletions
--- a/cmd/qrz/qrz.go
+++ b/cmd/qrz/qrz.go
@ -8,7 +8,7 @@ import (
 	"git.paulbsd.com/paulbsd/qrz/src/database"
 	"git.paulbsd.com/paulbsd/qrz/src/qrz"
 	"git.paulbsd.com/paulbsd/qrz/src/qrzws"
-	_ "github.com/go-sql-driver/mysql"
+	_ "github.com/lib/pq"
 )
 var version string
--- a/go.mod
+++ b/go.mod
@ -5,14 +5,14 @@ go 1.12
 require (
 	github.com/antchfx/htmlquery v1.0.0
 	github.com/antchfx/xpath v1.0.0 // indirect
 	github.com/go-sql-driver/mysql v1.4.1
 	github.com/gobuffalo/packr/v2 v2.8.0
 	github.com/jinzhu/gorm v1.9.12
 	github.com/jmoiron/sqlx v1.2.0
 	github.com/labstack/echo/v4 v4.1.16
 	github.com/lib/pq v1.1.1
 	github.com/markbates/pkger v0.14.0
 	github.com/robfig/cron v1.2.0
 	github.com/smartystreets/goconvey v0.0.0-20190731233626-505e41936337 // indirect
 	golang.org/x/text v0.3.2
 	google.golang.org/appengine v1.6.2 // indirect
 	gopkg.in/ini.v1 v1.46.0
 )
--- a/go.sum
+++ b/go.sum
@ -22,8 +22,12 @@ github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/denisenkom/go-mssqldb v0.0.0-20191124224453-732737034ffd h1:83Wprp6ROGeiHFAP8WJdI2RoxALQYgdllERc3N5N2DM=
 github.com/denisenkom/go-mssqldb v0.0.0-20191124224453-732737034ffd/go.mod h1:xbL0rPBG9cCiLr28tMa8zpbdarY27NDyej4t/EjAShU=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
 github.com/erikstmartin/go-testdb v0.0.0-20160219214506-8d10e4a1bae5 h1:Yzb9+7DPaBjB8zlTR87/ElzFsnQfuHnVUVqpZZIcV5Y=
 github.com/erikstmartin/go-testdb v0.0.0-20160219214506-8d10e4a1bae5/go.mod h1:a2zkGnVExMxdzMo3M0Hi/3sEU+cWnZpSni0O6/Yb/P0=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
 github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
@ -43,6 +47,8 @@ github.com/gobuffalo/packr/v2 v2.8.0 h1:IULGd15bQL59ijXLxEvA5wlMxsmx/ZkQv9T282zN
 github.com/gobuffalo/packr/v2 v2.8.0/go.mod h1:PDk2k3vGevNE3SwVyVRgQCCXETC9SaONCNSXT1Q8M1g=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
 github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe h1:lXe2qZdvpiX5WZkZR4hgp4KJVfY3nMkvmwbVkpv1rVY=
 github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
 github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
@ -59,6 +65,12 @@ github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
 github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
 github.com/jinzhu/gorm v1.9.12 h1:Drgk1clyWT9t9ERbzHza6Mj/8FY/CqMyVzOiHviMo6Q=
 github.com/jinzhu/gorm v1.9.12/go.mod h1:vhTjlKSJUTWNtcbQtrMBFCxy7eXTzeCAzfL5fBZT/Qs=
 github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
 github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
 github.com/jinzhu/now v1.0.1 h1:HjfetcXq097iXP0uoPCdnM4Efp5/9MsM0/M+XOTeR3M=
 github.com/jinzhu/now v1.0.1/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
 github.com/jmoiron/sqlx v1.2.0 h1:41Ip0zITnmWNR/vHV+S4m+VoUivnWY5E4OJfLZjCJMA=
 github.com/jmoiron/sqlx v1.2.0/go.mod h1:1FEQNm3xlJgrMD+FBdI9+xvCksHtbpVBBw5dYhBSsks=
 github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
@ -84,6 +96,8 @@ github.com/labstack/gommon v0.3.0 h1:JEeO0bvc78PKdyHxloTKiF8BD5iGrH8T6MSeGvSgob0
 github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k=
 github.com/lib/pq v1.0.0 h1:X5PMW56eZitiTeO7tKzZxFCSpbFZJtkMMooicw2us9A=
 github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 github.com/lib/pq v1.1.1 h1:sJZmqHoEaY7f+NPP8pgLB/WxulyR3fewgCM2qaSlBb4=
 github.com/lib/pq v1.1.1/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
 github.com/markbates/errx v1.1.0 h1:QDFeR+UP95dO12JgW+tgi2UVfo0V8YBHiUIOaeBPiEI=
 github.com/markbates/errx v1.1.0/go.mod h1:PLa46Oex9KNbVDZhKel8v1OT7hD5JZ2eI7AHhA0wswc=
@ -102,6 +116,8 @@ github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHX
 github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/mattn/go-sqlite3 v1.9.0 h1:pDRiWfl+++eC2FEFRy6jXmQlvp4Yh3z1MJKg4UeYM/4=
 github.com/mattn/go-sqlite3 v1.9.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
 github.com/mattn/go-sqlite3 v2.0.1+incompatible h1:xQ15muvnzGBHpIpdrNi1DA5x0+TcBZzsIDwmw9uTHzw=
 github.com/mattn/go-sqlite3 v2.0.1+incompatible/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
@ -167,14 +183,17 @@ go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/
 go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190325154230-a5d413f7728c/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191122220453-ac88ee75c92c/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20191205180655-e7c4368fe9dd/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20200221231518-2aa609cf4a9d h1:1ZiEyfaQIg3Qh0EoqpwAakHVhecoE5wlSg5GjnafJGw=
 golang.org/x/crypto v0.0.0-20200221231518-2aa609cf4a9d/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@ -222,6 +241,7 @@ golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8T
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/appengine v1.6.2 h1:j8RI1yW0SkI+paT6uGwMlrMI/6zwYA6/CFil8rxOzGI=
 google.golang.org/appengine v1.6.2/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
 google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
--- a/src/database/main.go
+++ b/src/database/main.go
@ -10,7 +10,7 @@ import (
 // Initialize creates connection to database and exec Schema
 func Initialize(config *config.Config) (err error) {
-	config.Db, err = sqlx.Connect("mysql", fmt.Sprintf("%s:%s@tcp(%s)/%s", config.DbUsername, config.DbPassword, config.DbHostname, config.DbName))
+	config.Db, err = sqlx.Connect("postgres", fmt.Sprintf("postgres://%s:%s@%s/%s", config.DbUsername, config.DbPassword, config.DbHostname, config.DbName))
 	if err != nil {
 		log.Fatalln(err)
 	}
--- a/src/qrz/main.go
+++ b/src/qrz/main.go
@ -8,9 +8,11 @@ import (
 	"net/http"
 	"regexp"
 	"strings"
 	"time"
 	"git.paulbsd.com/paulbsd/qrz/src/config"
 	"github.com/antchfx/htmlquery"
 	"github.com/jinzhu/gorm"
 	"github.com/robfig/cron"
 )
@ -170,3 +172,17 @@ type FrsEntry struct {
 	Country sql.NullString `db:"country"`
 	Fts     sql.NullString `db:"fts"`
 }
 // Qrz is the structure of qrz entries
 type Qrz struct {
 	gorm.Model
 	Name         string
 	Age          sql.NullInt64
 	Birthday     *time.Time
 	Email        string  `gorm:"type:varchar(100);unique_index"`
 	Role         string  `gorm:"size:255"`        // set field size to 255
 	MemberNumber *string `gorm:"unique;not null"` // set member number to unique and not null
 	Num          int     `gorm:"AUTO_INCREMENT"`  // set num to auto incrementable
 	Address      string  `gorm:"index:addr"`      // create index with name `addr` for address
 	IgnoreMe     int     `gorm:"-"`               // ignore this field
 }
--- a/src/qrzws/main.go
+++ b/src/qrzws/main.go
@ -146,7 +146,7 @@ func BuildQueryCountTotal(config config.Config, qrzdt QrzDatatableInput) (cnt in
 // SetSelectStatement build the sql select statement part
 func SetSelectStatement(config config.Config, qrzdt QrzDatatableInput) (selectstatement string, err error) {
 	var cols []string
-	colre := regexp.MustCompile(`^[a-z]+$`)
+	colre := regexp.MustCompile(`^[A-Za-z0-9]+$`)
 	if len(qrzdt.Columns) > 0 {
 		for _, col := range qrzdt.Columns {
 			valid := colre.MatchString(col.Name)
@ -168,7 +168,7 @@ func SetSelectStatement(config config.Config, qrzdt QrzDatatableInput) (selectst
 // SetOrderStatement build the sql order statement part
 func SetOrderStatement(config config.Config, qrzdt QrzDatatableInput) (orderstmt string, err error) {
 	var orderstmts []string
-	colre := regexp.MustCompile(`^[a-z]+$`)
+	colre := regexp.MustCompile(`^[A-Za-z0-9]+$`)
 	orderre := regexp.MustCompile(`^(ASC|asc|DESC|desc)$`)
 	for _, col := range qrzdt.Order {
 		if colre.MatchString(qrzdt.Columns[col.Column].Name) && orderre.MatchString(col.Dir) {
--- a/static/css/main.css
+++ b/static/css/main.css
@ -2,8 +2,6 @@ body
 {
  font-family: "Helvetica Neue", "HelveticaNeue", "Helvetica", "Arial", "sans-serif";
 }
 <<<<<<< Updated upstream
 =======
 #main_table_length
 {
@ -16,4 +14,3 @@ body
 }
 #main_table_paginate
 >>>>>>> Stashed changes
--- a/templates/index.html
+++ b/templates/index.html
@ -3,22 +3,13 @@
 <head>
  <link rel="stylesheet" type="text/css" href="static/css/main.css" media="screen">
  <link rel="stylesheet" type="text/css" href="static/css/font-awesome/all.css">
 <<<<<<< Updated upstream
  <link rel="stylesheet" type="text/css" href="static/css/bootstrap.css">
  <link rel="stylesheet" type="text/css" href="static/css/materialize.min.css">
 =======
  <link rel="stylesheet" type="text/css" href="static/css/bootstrap.min.css">
  <link rel="stylesheet" type="text/css" href="static/css/dataTables.bootstrap4.min.css">
 >>>>>>> Stashed changes
  <script type="text/javascript" src="static/js/jquery.js"></script>
  <script type="text/javascript" src="static/js/jquery.dataTables.min.js"></script>
  <script type="text/javascript" src="static/js/bootstrap.min.js"></script>
  <script type="text/javascript" src="static/js/dataTables.bootstrap4.min.js"></script>
 <<<<<<< Updated upstream
  <script type="text/javascript" src="static/js/materialize.min.js"></script>
 =======
 >>>>>>> Stashed changes
  <script type="text/javascript" src="static/js/axios.min.js"></script>
  <script type="text/javascript" src="static/js/vue.min.js"></script>
  <script type="text/javascript" src="static/js/datatable.js"></script>
@ -29,11 +20,7 @@
  <h1 class="display-3">FRS QRZ database</h1>
  <p>Mirror of <a href="http://groupe-frs.hamstation.eu">http://groupe-frs.hamstation.eu</a> list of users</p>
  <div>
 <<<<<<< Updated upstream
    <table id="main_table" class="striped highlight responsive-table">
 =======
    <table id="main_table" class="display table table-hover">
 >>>>>>> Stashed changes
      <thead class="thead-dark">
        <tr>
          <td>QRZ</td>
--- a/vendor/github.com/go-sql-driver/mysql/.gitignore
+++ b/vendor/github.com/go-sql-driver/mysql/.gitignore
@ -1,9 +0,0 @@
 .DS_Store
 .DS_Store?
 ._*
 .Spotlight-V100
 .Trashes
 Icon?
 ehthumbs.db
 Thumbs.db
 .idea
--- a/vendor/github.com/go-sql-driver/mysql/.travis.yml
+++ b/vendor/github.com/go-sql-driver/mysql/.travis.yml
@ -1,107 +0,0 @@
 sudo: false
 language: go
 go:
  - 1.7.x
  - 1.8.x
  - 1.9.x
  - 1.10.x
  - master
 before_install:
  - go get golang.org/x/tools/cmd/cover
  - go get github.com/mattn/goveralls
 before_script:
  - echo -e "[server]\ninnodb_log_file_size=256MB\ninnodb_buffer_pool_size=512MB\nmax_allowed_packet=16MB" | sudo tee -a /etc/mysql/my.cnf
  - sudo service mysql restart
  - .travis/wait_mysql.sh
  - mysql -e 'create database gotest;'
 matrix:
  include:
    - env: DB=MYSQL8
      sudo: required
      dist: trusty
      go: 1.10.x
      services:
        - docker
      before_install:
        - go get golang.org/x/tools/cmd/cover
        - go get github.com/mattn/goveralls
        - docker pull mysql:8.0
        - docker run -d -p 127.0.0.1:3307:3306 --name mysqld -e MYSQL_DATABASE=gotest -e MYSQL_USER=gotest -e MYSQL_PASSWORD=secret -e MYSQL_ROOT_PASSWORD=verysecret
          mysql:8.0 --innodb_log_file_size=256MB --innodb_buffer_pool_size=512MB --max_allowed_packet=16MB --local-infile=1
        - cp .travis/docker.cnf ~/.my.cnf
        - .travis/wait_mysql.sh
      before_script:
        - export MYSQL_TEST_USER=gotest
        - export MYSQL_TEST_PASS=secret
        - export MYSQL_TEST_ADDR=127.0.0.1:3307
        - export MYSQL_TEST_CONCURRENT=1
    - env: DB=MYSQL57
      sudo: required
      dist: trusty
      go: 1.10.x
      services:
        - docker
      before_install:
        - go get golang.org/x/tools/cmd/cover
        - go get github.com/mattn/goveralls
        - docker pull mysql:5.7
        - docker run -d -p 127.0.0.1:3307:3306 --name mysqld -e MYSQL_DATABASE=gotest -e MYSQL_USER=gotest -e MYSQL_PASSWORD=secret -e MYSQL_ROOT_PASSWORD=verysecret
          mysql:5.7 --innodb_log_file_size=256MB --innodb_buffer_pool_size=512MB --max_allowed_packet=16MB --local-infile=1
        - cp .travis/docker.cnf ~/.my.cnf
        - .travis/wait_mysql.sh
      before_script:
        - export MYSQL_TEST_USER=gotest
        - export MYSQL_TEST_PASS=secret
        - export MYSQL_TEST_ADDR=127.0.0.1:3307
        - export MYSQL_TEST_CONCURRENT=1
    - env: DB=MARIA55
      sudo: required
      dist: trusty
      go: 1.10.x
      services:
        - docker
      before_install:
        - go get golang.org/x/tools/cmd/cover
        - go get github.com/mattn/goveralls
        - docker pull mariadb:5.5
        - docker run -d -p 127.0.0.1:3307:3306 --name mysqld -e MYSQL_DATABASE=gotest -e MYSQL_USER=gotest -e MYSQL_PASSWORD=secret -e MYSQL_ROOT_PASSWORD=verysecret
          mariadb:5.5 --innodb_log_file_size=256MB --innodb_buffer_pool_size=512MB --max_allowed_packet=16MB --local-infile=1
        - cp .travis/docker.cnf ~/.my.cnf
        - .travis/wait_mysql.sh
      before_script:
        - export MYSQL_TEST_USER=gotest
        - export MYSQL_TEST_PASS=secret
        - export MYSQL_TEST_ADDR=127.0.0.1:3307
        - export MYSQL_TEST_CONCURRENT=1
    - env: DB=MARIA10_1
      sudo: required
      dist: trusty
      go: 1.10.x
      services:
        - docker
      before_install:
        - go get golang.org/x/tools/cmd/cover
        - go get github.com/mattn/goveralls
        - docker pull mariadb:10.1
        - docker run -d -p 127.0.0.1:3307:3306 --name mysqld -e MYSQL_DATABASE=gotest -e MYSQL_USER=gotest -e MYSQL_PASSWORD=secret -e MYSQL_ROOT_PASSWORD=verysecret
          mariadb:10.1 --innodb_log_file_size=256MB --innodb_buffer_pool_size=512MB --max_allowed_packet=16MB --local-infile=1
        - cp .travis/docker.cnf ~/.my.cnf
        - .travis/wait_mysql.sh
      before_script:
        - export MYSQL_TEST_USER=gotest
        - export MYSQL_TEST_PASS=secret
        - export MYSQL_TEST_ADDR=127.0.0.1:3307
        - export MYSQL_TEST_CONCURRENT=1
 script:
  - go test -v -covermode=count -coverprofile=coverage.out
  - go vet ./...
  - .travis/gofmt.sh
 after_script:
  - $HOME/gopath/bin/goveralls -coverprofile=coverage.out -service=travis-ci
--- a/vendor/github.com/go-sql-driver/mysql/AUTHORS
+++ b/vendor/github.com/go-sql-driver/mysql/AUTHORS
@ -1,89 +0,0 @@
 # This is the official list of Go-MySQL-Driver authors for copyright purposes.
 # If you are submitting a patch, please add your name or the name of the
 # organization which holds the copyright to this list in alphabetical order.
 # Names should be added to this file as
 #	Name <email address>
 # The email address is not required for organizations.
 # Please keep the list sorted.
 # Individual Persons
 Aaron Hopkins <go-sql-driver at die.net>
 Achille Roussel <achille.roussel at gmail.com>
 Alexey Palazhchenko <alexey.palazhchenko at gmail.com>
 Andrew Reid <andrew.reid at tixtrack.com>
 Arne Hormann <arnehormann at gmail.com>
 Asta Xie <xiemengjun at gmail.com>
 Bulat Gaifullin <gaifullinbf at gmail.com>
 Carlos Nieto <jose.carlos at menteslibres.net>
 Chris Moos <chris at tech9computers.com>
 Craig Wilson <craiggwilson at gmail.com>
 Daniel Montoya <dsmontoyam at gmail.com>
 Daniel Nichter <nil at codenode.com>
 Daniël van Eeden <git at myname.nl>
 Dave Protasowski <dprotaso at gmail.com>
 DisposaBoy <disposaboy at dby.me>
 Egor Smolyakov <egorsmkv at gmail.com>
 Evan Shaw <evan at vendhq.com>
 Frederick Mayle <frederickmayle at gmail.com>
 Gustavo Kristic <gkristic at gmail.com>
 Hajime Nakagami <nakagami at gmail.com>
 Hanno Braun <mail at hannobraun.com>
 Henri Yandell <flamefew at gmail.com>
 Hirotaka Yamamoto <ymmt2005 at gmail.com>
 ICHINOSE Shogo <shogo82148 at gmail.com>
 INADA Naoki <songofacandy at gmail.com>
 Jacek Szwec <szwec.jacek at gmail.com>
 James Harr <james.harr at gmail.com>
 Jeff Hodges <jeff at somethingsimilar.com>
 Jeffrey Charles <jeffreycharles at gmail.com>
 Jian Zhen <zhenjl at gmail.com>
 Joshua Prunier <joshua.prunier at gmail.com>
 Julien Lefevre <julien.lefevr at gmail.com>
 Julien Schmidt <go-sql-driver at julienschmidt.com>
 Justin Li <jli at j-li.net>
 Justin Nuß <nuss.justin at gmail.com>
 Kamil Dziedzic <kamil at klecza.pl>
 Kevin Malachowski <kevin at chowski.com>
 Kieron Woodhouse <kieron.woodhouse at infosum.com>
 Lennart Rudolph <lrudolph at hmc.edu>
 Leonardo YongUk Kim <dalinaum at gmail.com>
 Linh Tran Tuan <linhduonggnu at gmail.com>
 Lion Yang <lion at aosc.xyz>
 Luca Looz <luca.looz92 at gmail.com>
 Lucas Liu <extrafliu at gmail.com>
 Luke Scott <luke at webconnex.com>
 Maciej Zimnoch <maciej.zimnoch at codilime.com>
 Michael Woolnough <michael.woolnough at gmail.com>
 Nicola Peduzzi <thenikso at gmail.com>
 Olivier Mengué <dolmen at cpan.org>
 oscarzhao <oscarzhaosl at gmail.com>
 Paul Bonser <misterpib at gmail.com>
 Peter Schultz <peter.schultz at classmarkets.com>
 Rebecca Chin <rchin at pivotal.io>
 Reed Allman <rdallman10 at gmail.com>
 Richard Wilkes <wilkes at me.com>
 Robert Russell <robert at rrbrussell.com>
 Runrioter Wung <runrioter at gmail.com>
 Shuode Li <elemount at qq.com>
 Soroush Pour <me at soroushjp.com>
 Stan Putrya <root.vagner at gmail.com>
 Stanley Gunawan <gunawan.stanley at gmail.com>
 Xiangyu Hu <xiangyu.hu at outlook.com>
 Xiaobing Jiang <s7v7nislands at gmail.com>
 Xiuming Chen <cc at cxm.cc>
 Zhenye Xie <xiezhenye at gmail.com>
 # Organizations
 Barracuda Networks, Inc.
 Counting Ltd.
 Google Inc.
 InfoSum Ltd.
 Keybase Inc.
 Percona LLC
 Pivotal Inc.
 Stripe Inc.
--- a/vendor/github.com/go-sql-driver/mysql/CHANGELOG.md
+++ b/vendor/github.com/go-sql-driver/mysql/CHANGELOG.md
@ -1,178 +0,0 @@
 ## Version 1.4.1 (2018-11-14)
 Bugfixes:
 - Fix TIME format for binary columns (#818)
 - Fix handling of empty auth plugin names (#835)
 - Fix caching_sha2_password with empty password (#826)
 - Fix canceled context broke mysqlConn (#862)
 - Fix OldAuthSwitchRequest support (#870)
 - Fix Auth Response packet for cleartext password (#887)
 ## Version 1.4 (2018-06-03)
 Changes:
 - Documentation fixes (#530, #535, #567)
 - Refactoring (#575, #579, #580, #581, #603, #615, #704)
 - Cache column names (#444)
 - Sort the DSN parameters in DSNs generated from a config (#637)
 - Allow native password authentication by default (#644)
 - Use the default port if it is missing in the DSN (#668)
 - Removed the `strict` mode (#676)
 - Do not query `max_allowed_packet` by default (#680)
 - Dropped support Go 1.6 and lower (#696)
 - Updated `ConvertValue()` to match the database/sql/driver implementation (#760)
 - Document the usage of `0000-00-00T00:00:00` as the time.Time zero value (#783)
 - Improved the compatibility of the authentication system (#807)
 New Features:
 - Multi-Results support (#537)
 - `rejectReadOnly` DSN option (#604)
 - `context.Context` support (#608, #612, #627, #761)
 - Transaction isolation level support (#619, #744)
 - Read-Only transactions support (#618, #634)
 - `NewConfig` function which initializes a config with default values (#679)
 - Implemented the `ColumnType` interfaces (#667, #724)
 - Support for custom string types in `ConvertValue` (#623)
 - Implemented `NamedValueChecker`, improving support for uint64 with high bit set (#690, #709, #710)
 - `caching_sha2_password` authentication plugin support (#794, #800, #801, #802)
 - Implemented `driver.SessionResetter` (#779)
 - `sha256_password` authentication plugin support (#808)
 Bugfixes:
 - Use the DSN hostname as TLS default ServerName if `tls=true` (#564, #718)
 - Fixed LOAD LOCAL DATA INFILE for empty files (#590)
 - Removed columns definition cache since it sometimes cached invalid data (#592)
 - Don't mutate registered TLS configs (#600)
 - Make RegisterTLSConfig concurrency-safe (#613)
 - Handle missing auth data in the handshake packet correctly (#646)
 - Do not retry queries when data was written to avoid data corruption (#302, #736)
 - Cache the connection pointer for error handling before invalidating it (#678)
 - Fixed imports for appengine/cloudsql (#700)
 - Fix sending STMT_LONG_DATA for 0 byte data (#734)
 - Set correct capacity for []bytes read from length-encoded strings (#766)
 - Make RegisterDial concurrency-safe (#773)
 ## Version 1.3 (2016-12-01)
 Changes:
 - Go 1.1 is no longer supported
 - Use decimals fields in MySQL to format time types (#249)
 - Buffer optimizations (#269)
 - TLS ServerName defaults to the host (#283)
 - Refactoring (#400, #410, #437)
 - Adjusted documentation for second generation CloudSQL (#485)
 - Documented DSN system var quoting rules (#502)
 - Made statement.Close() calls idempotent to avoid errors in Go 1.6+ (#512)
 New Features:
 - Enable microsecond resolution on TIME, DATETIME and TIMESTAMP (#249)
 - Support for returning table alias on Columns() (#289, #359, #382)
 - Placeholder interpolation, can be actived with the DSN parameter `interpolateParams=true` (#309, #318, #490)
 - Support for uint64 parameters with high bit set (#332, #345)
 - Cleartext authentication plugin support (#327)
 - Exported ParseDSN function and the Config struct (#403, #419, #429)
 - Read / Write timeouts (#401)
 - Support for JSON field type (#414)
 - Support for multi-statements and multi-results (#411, #431)
 - DSN parameter to set the driver-side max_allowed_packet value manually (#489)
 - Native password authentication plugin support (#494, #524)
 Bugfixes:
 - Fixed handling of queries without columns and rows (#255)
 - Fixed a panic when SetKeepAlive() failed (#298)
 - Handle ERR packets while reading rows (#321)
 - Fixed reading NULL length-encoded integers in MySQL 5.6+ (#349)
 - Fixed absolute paths support in LOAD LOCAL DATA INFILE (#356)
 - Actually zero out bytes in handshake response (#378)
 - Fixed race condition in registering LOAD DATA INFILE handler (#383)
 - Fixed tests with MySQL 5.7.9+ (#380)
 - QueryUnescape TLS config names (#397)
 - Fixed "broken pipe" error by writing to closed socket (#390)
 - Fixed LOAD LOCAL DATA INFILE buffering (#424)
 - Fixed parsing of floats into float64 when placeholders are used (#434)
 - Fixed DSN tests with Go 1.7+ (#459)
 - Handle ERR packets while waiting for EOF (#473)
 - Invalidate connection on error while discarding additional results (#513)
 - Allow terminating packets of length 0 (#516)
 ## Version 1.2 (2014-06-03)
 Changes:
 - We switched back to a "rolling release". `go get` installs the current master branch again
 - Version v1 of the driver will not be maintained anymore. Go 1.0 is no longer supported by this driver
 - Exported errors to allow easy checking from application code
 - Enabled TCP Keepalives on TCP connections
 - Optimized INFILE handling (better buffer size calculation, lazy init, ...)
 - The DSN parser also checks for a missing separating slash
 - Faster binary date / datetime to string formatting
 - Also exported the MySQLWarning type
 - mysqlConn.Close returns the first error encountered instead of ignoring all errors
 - writePacket() automatically writes the packet size to the header
 - readPacket() uses an iterative approach instead of the recursive approach to merge splitted packets
 New Features:
 - `RegisterDial` allows the usage of a custom dial function to establish the network connection
 - Setting the connection collation is possible with the `collation` DSN parameter. This parameter should be preferred over the `charset` parameter
 - Logging of critical errors is configurable with `SetLogger`
 - Google CloudSQL support
 Bugfixes:
 - Allow more than 32 parameters in prepared statements
 - Various old_password fixes
 - Fixed TestConcurrent test to pass Go's race detection
 - Fixed appendLengthEncodedInteger for large numbers
 - Renamed readLengthEnodedString to readLengthEncodedString and skipLengthEnodedString to skipLengthEncodedString (fixed typo)
 ## Version 1.1 (2013-11-02)
 Changes:
  - Go-MySQL-Driver now requires Go 1.1
  - Connections now use the collation `utf8_general_ci` by default. Adding `&charset=UTF8` to the DSN should not be necessary anymore
  - Made closing rows and connections error tolerant. This allows for example deferring rows.Close() without checking for errors
  - `[]byte(nil)` is now treated as a NULL value. Before, it was treated like an empty string / `[]byte("")`
  - DSN parameter values must now be url.QueryEscape'ed. This allows text values to contain special characters, such as '&'.
  - Use the IO buffer also for writing. This results in zero allocations (by the driver) for most queries
  - Optimized the buffer for reading
  - stmt.Query now caches column metadata
  - New Logo
  - Changed the copyright header to include all contributors
  - Improved the LOAD INFILE documentation
  - The driver struct is now exported to make the driver directly accessible
  - Refactored the driver tests
  - Added more benchmarks and moved all to a separate file
  - Other small refactoring
 New Features:
  - Added *old_passwords* support: Required in some cases, but must be enabled by adding `allowOldPasswords=true` to the DSN since it is insecure
  - Added a `clientFoundRows` parameter: Return the number of matching rows instead of the number of rows changed on UPDATEs
  - Added TLS/SSL support: Use a TLS/SSL encrypted connection to the server. Custom TLS configs can be registered and used
 Bugfixes:
  - Fixed MySQL 4.1 support: MySQL 4.1 sends packets with lengths which differ from the specification
  - Convert to DB timezone when inserting `time.Time`
  - Splitted packets (more than 16MB) are now merged correctly
  - Fixed false positive `io.EOF` errors when the data was fully read
  - Avoid panics on reuse of closed connections
  - Fixed empty string producing false nil values
  - Fixed sign byte for positive TIME fields
 ## Version 1.0 (2013-05-14)
 Initial Release
--- a/vendor/github.com/go-sql-driver/mysql/CONTRIBUTING.md
+++ b/vendor/github.com/go-sql-driver/mysql/CONTRIBUTING.md
@ -1,23 +0,0 @@
 # Contributing Guidelines
 ## Reporting Issues
 Before creating a new Issue, please check first if a similar Issue [already exists](https://github.com/go-sql-driver/mysql/issues?state=open) or was [recently closed](https://github.com/go-sql-driver/mysql/issues?direction=desc&page=1&sort=updated&state=closed).
 ## Contributing Code
 By contributing to this project, you share your code under the Mozilla Public License 2, as specified in the LICENSE file.
 Don't forget to add yourself to the AUTHORS file.
 ### Code Review
 Everyone is invited to review and comment on pull requests.
 If it looks fine to you, comment with "LGTM" (Looks good to me).
 If changes are required, notice the reviewers with "PTAL" (Please take another look) after committing the fixes.
 Before merging the Pull Request, at least one [team member](https://github.com/go-sql-driver?tab=members) must have commented with "LGTM".
 ## Development Ideas
 If you are looking for ideas for code contributions, please check our [Development Ideas](https://github.com/go-sql-driver/mysql/wiki/Development-Ideas) Wiki page.
--- a/vendor/github.com/go-sql-driver/mysql/LICENSE
+++ b/vendor/github.com/go-sql-driver/mysql/LICENSE
@ -1,373 +0,0 @@
 Mozilla Public License Version 2.0
 ==================================
 1. Definitions
 --------------
 1.1. "Contributor"
    means each individual or legal entity that creates, contributes to
    the creation of, or owns Covered Software.
 1.2. "Contributor Version"
    means the combination of the Contributions of others (if any) used
    by a Contributor and that particular Contributor's Contribution.
 1.3. "Contribution"
    means Covered Software of a particular Contributor.
 1.4. "Covered Software"
    means Source Code Form to which the initial Contributor has attached
    the notice in Exhibit A, the Executable Form of such Source Code
    Form, and Modifications of such Source Code Form, in each case
    including portions thereof.
 1.5. "Incompatible With Secondary Licenses"
    means
    (a) that the initial Contributor has attached the notice described
        in Exhibit B to the Covered Software; or
    (b) that the Covered Software was made available under the terms of
        version 1.1 or earlier of the License, but not also under the
        terms of a Secondary License.
 1.6. "Executable Form"
    means any form of the work other than Source Code Form.
 1.7. "Larger Work"
    means a work that combines Covered Software with other material, in 
    a separate file or files, that is not Covered Software.
 1.8. "License"
    means this document.
 1.9. "Licensable"
    means having the right to grant, to the maximum extent possible,
    whether at the time of the initial grant or subsequently, any and
    all of the rights conveyed by this License.
 1.10. "Modifications"
    means any of the following:
    (a) any file in Source Code Form that results from an addition to,
        deletion from, or modification of the contents of Covered
        Software; or
    (b) any new file in Source Code Form that contains any Covered
        Software.
 1.11. "Patent Claims" of a Contributor
    means any patent claim(s), including without limitation, method,
    process, and apparatus claims, in any patent Licensable by such
    Contributor that would be infringed, but for the grant of the
    License, by the making, using, selling, offering for sale, having
    made, import, or transfer of either its Contributions or its
    Contributor Version.
 1.12. "Secondary License"
    means either the GNU General Public License, Version 2.0, the GNU
    Lesser General Public License, Version 2.1, the GNU Affero General
    Public License, Version 3.0, or any later versions of those
    licenses.
 1.13. "Source Code Form"
    means the form of the work preferred for making modifications.
 1.14. "You" (or "Your")
    means an individual or a legal entity exercising rights under this
    License. For legal entities, "You" includes any entity that
    controls, is controlled by, or is under common control with You. For
    purposes of this definition, "control" means (a) the power, direct
    or indirect, to cause the direction or management of such entity,
    whether by contract or otherwise, or (b) ownership of more than
    fifty percent (50%) of the outstanding shares or beneficial
    ownership of such entity.
 2. License Grants and Conditions
 --------------------------------
 2.1. Grants
 Each Contributor hereby grants You a world-wide, royalty-free,
 non-exclusive license:
 (a) under intellectual property rights (other than patent or trademark)
    Licensable by such Contributor to use, reproduce, make available,
    modify, display, perform, distribute, and otherwise exploit its
    Contributions, either on an unmodified basis, with Modifications, or
    as part of a Larger Work; and
 (b) under Patent Claims of such Contributor to make, use, sell, offer
    for sale, have made, import, and otherwise transfer either its
    Contributions or its Contributor Version.
 2.2. Effective Date
 The licenses granted in Section 2.1 with respect to any Contribution
 become effective for each Contribution on the date the Contributor first
 distributes such Contribution.
 2.3. Limitations on Grant Scope
 The licenses granted in this Section 2 are the only rights granted under
 this License. No additional rights or licenses will be implied from the
 distribution or licensing of Covered Software under this License.
 Notwithstanding Section 2.1(b) above, no patent license is granted by a
 Contributor:
 (a) for any code that a Contributor has removed from Covered Software;
    or
 (b) for infringements caused by: (i) Your and any other third party's
    modifications of Covered Software, or (ii) the combination of its
    Contributions with other software (except as part of its Contributor
    Version); or
 (c) under Patent Claims infringed by Covered Software in the absence of
    its Contributions.
 This License does not grant any rights in the trademarks, service marks,
 or logos of any Contributor (except as may be necessary to comply with
 the notice requirements in Section 3.4).
 2.4. Subsequent Licenses
 No Contributor makes additional grants as a result of Your choice to
 distribute the Covered Software under a subsequent version of this
 License (see Section 10.2) or under the terms of a Secondary License (if
 permitted under the terms of Section 3.3).
 2.5. Representation
 Each Contributor represents that the Contributor believes its
 Contributions are its original creation(s) or it has sufficient rights
 to grant the rights to its Contributions conveyed by this License.
 2.6. Fair Use
 This License is not intended to limit any rights You have under
 applicable copyright doctrines of fair use, fair dealing, or other
 equivalents.
 2.7. Conditions
 Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
 in Section 2.1.
 3. Responsibilities
 -------------------
 3.1. Distribution of Source Form
 All distribution of Covered Software in Source Code Form, including any
 Modifications that You create or to which You contribute, must be under
 the terms of this License. You must inform recipients that the Source
 Code Form of the Covered Software is governed by the terms of this
 License, and how they can obtain a copy of this License. You may not
 attempt to alter or restrict the recipients' rights in the Source Code
 Form.
 3.2. Distribution of Executable Form
 If You distribute Covered Software in Executable Form then:
 (a) such Covered Software must also be made available in Source Code
    Form, as described in Section 3.1, and You must inform recipients of
    the Executable Form how they can obtain a copy of such Source Code
    Form by reasonable means in a timely manner, at a charge no more
    than the cost of distribution to the recipient; and
 (b) You may distribute such Executable Form under the terms of this
    License, or sublicense it under different terms, provided that the
    license for the Executable Form does not attempt to limit or alter
    the recipients' rights in the Source Code Form under this License.
 3.3. Distribution of a Larger Work
 You may create and distribute a Larger Work under terms of Your choice,
 provided that You also comply with the requirements of this License for
 the Covered Software. If the Larger Work is a combination of Covered
 Software with a work governed by one or more Secondary Licenses, and the
 Covered Software is not Incompatible With Secondary Licenses, this
 License permits You to additionally distribute such Covered Software
 under the terms of such Secondary License(s), so that the recipient of
 the Larger Work may, at their option, further distribute the Covered
 Software under the terms of either this License or such Secondary
 License(s).
 3.4. Notices
 You may not remove or alter the substance of any license notices
 (including copyright notices, patent notices, disclaimers of warranty,
 or limitations of liability) contained within the Source Code Form of
 the Covered Software, except that You may alter any license notices to
 the extent required to remedy known factual inaccuracies.
 3.5. Application of Additional Terms
 You may choose to offer, and to charge a fee for, warranty, support,
 indemnity or liability obligations to one or more recipients of Covered
 Software. However, You may do so only on Your own behalf, and not on
 behalf of any Contributor. You must make it absolutely clear that any
 such warranty, support, indemnity, or liability obligation is offered by
 You alone, and You hereby agree to indemnify every Contributor for any
 liability incurred by such Contributor as a result of warranty, support,
 indemnity or liability terms You offer. You may include additional
 disclaimers of warranty and limitations of liability specific to any
 jurisdiction.
 4. Inability to Comply Due to Statute or Regulation
 ---------------------------------------------------
 If it is impossible for You to comply with any of the terms of this
 License with respect to some or all of the Covered Software due to
 statute, judicial order, or regulation then You must: (a) comply with
 the terms of this License to the maximum extent possible; and (b)
 describe the limitations and the code they affect. Such description must
 be placed in a text file included with all distributions of the Covered
 Software under this License. Except to the extent prohibited by statute
 or regulation, such description must be sufficiently detailed for a
 recipient of ordinary skill to be able to understand it.
 5. Termination
 --------------
 5.1. The rights granted under this License will terminate automatically
 if You fail to comply with any of its terms. However, if You become
 compliant, then the rights granted under this License from a particular
 Contributor are reinstated (a) provisionally, unless and until such
 Contributor explicitly and finally terminates Your grants, and (b) on an
 ongoing basis, if such Contributor fails to notify You of the
 non-compliance by some reasonable means prior to 60 days after You have
 come back into compliance. Moreover, Your grants from a particular
 Contributor are reinstated on an ongoing basis if such Contributor
 notifies You of the non-compliance by some reasonable means, this is the
 first time You have received notice of non-compliance with this License
 from such Contributor, and You become compliant prior to 30 days after
 Your receipt of the notice.
 5.2. If You initiate litigation against any entity by asserting a patent
 infringement claim (excluding declaratory judgment actions,
 counter-claims, and cross-claims) alleging that a Contributor Version
 directly or indirectly infringes any patent, then the rights granted to
 You by any and all Contributors for the Covered Software under Section
 2.1 of this License shall terminate.
 5.3. In the event of termination under Sections 5.1 or 5.2 above, all
 end user license agreements (excluding distributors and resellers) which
 have been validly granted by You or Your distributors under this License
 prior to termination shall survive termination.
 ************************************************************************
 *                                                                      *
 *  6. Disclaimer of Warranty                                           *
 *  -------------------------                                           *
 *                                                                      *
 *  Covered Software is provided under this License on an "as is"       *
 *  basis, without warranty of any kind, either expressed, implied, or  *
 *  statutory, including, without limitation, warranties that the       *
 *  Covered Software is free of defects, merchantable, fit for a        *
 *  particular purpose or non-infringing. The entire risk as to the     *
 *  quality and performance of the Covered Software is with You.        *
 *  Should any Covered Software prove defective in any respect, You     *
 *  (not any Contributor) assume the cost of any necessary servicing,   *
 *  repair, or correction. This disclaimer of warranty constitutes an   *
 *  essential part of this License. No use of any Covered Software is   *
 *  authorized under this License except under this disclaimer.         *
 *                                                                      *
 ************************************************************************
 ************************************************************************
 *                                                                      *
 *  7. Limitation of Liability                                          *
 *  --------------------------                                          *
 *                                                                      *
 *  Under no circumstances and under no legal theory, whether tort      *
 *  (including negligence), contract, or otherwise, shall any           *
 *  Contributor, or anyone who distributes Covered Software as          *
 *  permitted above, be liable to You for any direct, indirect,         *
 *  special, incidental, or consequential damages of any character      *
 *  including, without limitation, damages for lost profits, loss of    *
 *  goodwill, work stoppage, computer failure or malfunction, or any    *
 *  and all other commercial damages or losses, even if such party      *
 *  shall have been informed of the possibility of such damages. This   *
 *  limitation of liability shall not apply to liability for death or   *
 *  personal injury resulting from such party's negligence to the       *
 *  extent applicable law prohibits such limitation. Some               *
 *  jurisdictions do not allow the exclusion or limitation of           *
 *  incidental or consequential damages, so this exclusion and          *
 *  limitation may not apply to You.                                    *
 *                                                                      *
 ************************************************************************
 8. Litigation
 -------------
 Any litigation relating to this License may be brought only in the
 courts of a jurisdiction where the defendant maintains its principal
 place of business and such litigation shall be governed by laws of that
 jurisdiction, without reference to its conflict-of-law provisions.
 Nothing in this Section shall prevent a party's ability to bring
 cross-claims or counter-claims.
 9. Miscellaneous
 ----------------
 This License represents the complete agreement concerning the subject
 matter hereof. If any provision of this License is held to be
 unenforceable, such provision shall be reformed only to the extent
 necessary to make it enforceable. Any law or regulation which provides
 that the language of a contract shall be construed against the drafter
 shall not be used to construe this License against a Contributor.
 10. Versions of the License
 ---------------------------
 10.1. New Versions
 Mozilla Foundation is the license steward. Except as provided in Section
 10.3, no one other than the license steward has the right to modify or
 publish new versions of this License. Each version will be given a
 distinguishing version number.
 10.2. Effect of New Versions
 You may distribute the Covered Software under the terms of the version
 of the License under which You originally received the Covered Software,
 or under the terms of any subsequent version published by the license
 steward.
 10.3. Modified Versions
 If you create software not governed by this License, and you want to
 create a new license for such software, you may create and use a
 modified version of this License if you rename the license and remove
 any references to the name of the license steward (except to note that
 such modified license differs from this License).
 10.4. Distributing Source Code Form that is Incompatible With Secondary
 Licenses
 If You choose to distribute Source Code Form that is Incompatible With
 Secondary Licenses under the terms of this version of the License, the
 notice described in Exhibit B of this License must be attached.
 Exhibit A - Source Code Form License Notice
 -------------------------------------------
  This Source Code Form is subject to the terms of the Mozilla Public
  License, v. 2.0. If a copy of the MPL was not distributed with this
  file, You can obtain one at http://mozilla.org/MPL/2.0/.
 If it is not possible or desirable to put the notice in a particular
 file, then You may include the notice in a location (such as a LICENSE
 file in a relevant directory) where a recipient would be likely to look
 for such a notice.
 You may add additional accurate notices of copyright ownership.
 Exhibit B - "Incompatible With Secondary Licenses" Notice
 ---------------------------------------------------------
  This Source Code Form is "Incompatible With Secondary Licenses", as
  defined by the Mozilla Public License, v. 2.0.
--- a/vendor/github.com/go-sql-driver/mysql/README.md
+++ b/vendor/github.com/go-sql-driver/mysql/README.md
@ -1,490 +0,0 @@
 # Go-MySQL-Driver
 A MySQL-Driver for Go's [database/sql](https://golang.org/pkg/database/sql/) package
 ![Go-MySQL-Driver logo](https://raw.github.com/wiki/go-sql-driver/mysql/gomysql_m.png "Golang Gopher holding the MySQL Dolphin")
 ---------------------------------------
  * [Features](#features)
  * [Requirements](#requirements)
  * [Installation](#installation)
  * [Usage](#usage)
    * [DSN (Data Source Name)](#dsn-data-source-name)
      * [Password](#password)
      * [Protocol](#protocol)
      * [Address](#address)
      * [Parameters](#parameters)
      * [Examples](#examples)
    * [Connection pool and timeouts](#connection-pool-and-timeouts)
    * [context.Context Support](#contextcontext-support)
    * [ColumnType Support](#columntype-support)
    * [LOAD DATA LOCAL INFILE support](#load-data-local-infile-support)
    * [time.Time support](#timetime-support)
    * [Unicode support](#unicode-support)
  * [Testing / Development](#testing--development)
  * [License](#license)
 ---------------------------------------
 ## Features
  * Lightweight and [fast](https://github.com/go-sql-driver/sql-benchmark "golang MySQL-Driver performance")
  * Native Go implementation. No C-bindings, just pure Go
  * Connections over TCP/IPv4, TCP/IPv6, Unix domain sockets or [custom protocols](https://godoc.org/github.com/go-sql-driver/mysql#DialFunc)
  * Automatic handling of broken connections
  * Automatic Connection Pooling *(by database/sql package)*
  * Supports queries larger than 16MB
  * Full [`sql.RawBytes`](https://golang.org/pkg/database/sql/#RawBytes) support.
  * Intelligent `LONG DATA` handling in prepared statements
  * Secure `LOAD DATA LOCAL INFILE` support with file Whitelisting and `io.Reader` support
  * Optional `time.Time` parsing
  * Optional placeholder interpolation
 ## Requirements
  * Go 1.7 or higher. We aim to support the 3 latest versions of Go.
  * MySQL (4.1+), MariaDB, Percona Server, Google CloudSQL or Sphinx (2.2.3+)
 ---------------------------------------
 ## Installation
 Simple install the package to your [$GOPATH](https://github.com/golang/go/wiki/GOPATH "GOPATH") with the [go tool](https://golang.org/cmd/go/ "go command") from shell:
 ```bash
 $ go get -u github.com/go-sql-driver/mysql
 ```
 Make sure [Git is installed](https://git-scm.com/downloads) on your machine and in your system's `PATH`.
 ## Usage
 _Go MySQL Driver_ is an implementation of Go's `database/sql/driver` interface. You only need to import the driver and can use the full [`database/sql`](https://golang.org/pkg/database/sql/) API then.
 Use `mysql` as `driverName` and a valid [DSN](#dsn-data-source-name)  as `dataSourceName`:
 ```go
 import "database/sql"
 import _ "github.com/go-sql-driver/mysql"
 db, err := sql.Open("mysql", "user:password@/dbname")
 ```
 [Examples are available in our Wiki](https://github.com/go-sql-driver/mysql/wiki/Examples "Go-MySQL-Driver Examples").
 ### DSN (Data Source Name)
 The Data Source Name has a common format, like e.g. [PEAR DB](http://pear.php.net/manual/en/package.database.db.intro-dsn.php) uses it, but without type-prefix (optional parts marked by squared brackets):
 ```
 [username[:password]@][protocol[(address)]]/dbname[?param1=value1&...&paramN=valueN]
 ```
 A DSN in its fullest form:
 ```
 username:password@protocol(address)/dbname?param=value
 ```
 Except for the databasename, all values are optional. So the minimal DSN is:
 ```
 /dbname
 ```
 If you do not want to preselect a database, leave `dbname` empty:
 ```
 /
 ```
 This has the same effect as an empty DSN string:
 ```
 ```
 Alternatively, [Config.FormatDSN](https://godoc.org/github.com/go-sql-driver/mysql#Config.FormatDSN) can be used to create a DSN string by filling a struct.
 #### Password
 Passwords can consist of any character. Escaping is **not** necessary.
 #### Protocol
 See [net.Dial](https://golang.org/pkg/net/#Dial) for more information which networks are available.
 In general you should use an Unix domain socket if available and TCP otherwise for best performance.
 #### Address
 For TCP and UDP networks, addresses have the form `host[:port]`.
 If `port` is omitted, the default port will be used.
 If `host` is a literal IPv6 address, it must be enclosed in square brackets.
 The functions [net.JoinHostPort](https://golang.org/pkg/net/#JoinHostPort) and [net.SplitHostPort](https://golang.org/pkg/net/#SplitHostPort) manipulate addresses in this form.
 For Unix domain sockets the address is the absolute path to the MySQL-Server-socket, e.g. `/var/run/mysqld/mysqld.sock` or `/tmp/mysql.sock`.
 #### Parameters
 *Parameters are case-sensitive!*
 Notice that any of `true`, `TRUE`, `True` or `1` is accepted to stand for a true boolean value. Not surprisingly, false can be specified as any of: `false`, `FALSE`, `False` or `0`.
 ##### `allowAllFiles`
 ```
 Type:           bool
 Valid Values:   true, false
 Default:        false
 ```
 `allowAllFiles=true` disables the file Whitelist for `LOAD DATA LOCAL INFILE` and allows *all* files.
 [*Might be insecure!*](http://dev.mysql.com/doc/refman/5.7/en/load-data-local.html)
 ##### `allowCleartextPasswords`
 ```
 Type:           bool
 Valid Values:   true, false
 Default:        false
 ```
 `allowCleartextPasswords=true` allows using the [cleartext client side plugin](http://dev.mysql.com/doc/en/cleartext-authentication-plugin.html) if required by an account, such as one defined with the [PAM authentication plugin](http://dev.mysql.com/doc/en/pam-authentication-plugin.html). Sending passwords in clear text may be a security problem in some configurations. To avoid problems if there is any possibility that the password would be intercepted, clients should connect to MySQL Server using a method that protects the password. Possibilities include [TLS / SSL](#tls), IPsec, or a private network.
 ##### `allowNativePasswords`
 ```
 Type:           bool
 Valid Values:   true, false
 Default:        true
 ```
 `allowNativePasswords=false` disallows the usage of MySQL native password method.
 ##### `allowOldPasswords`
 ```
 Type:           bool
 Valid Values:   true, false
 Default:        false
 ```
 `allowOldPasswords=true` allows the usage of the insecure old password method. This should be avoided, but is necessary in some cases. See also [the old_passwords wiki page](https://github.com/go-sql-driver/mysql/wiki/old_passwords).
 ##### `charset`
 ```
 Type:           string
 Valid Values:   <name>
 Default:        none
 ```
 Sets the charset used for client-server interaction (`"SET NAMES <value>"`). If multiple charsets are set (separated by a comma), the following charset is used if setting the charset failes. This enables for example support for `utf8mb4` ([introduced in MySQL 5.5.3](http://dev.mysql.com/doc/refman/5.5/en/charset-unicode-utf8mb4.html)) with fallback to `utf8` for older servers (`charset=utf8mb4,utf8`).
 Usage of the `charset` parameter is discouraged because it issues additional queries to the server.
 Unless you need the fallback behavior, please use `collation` instead.
 ##### `collation`
 ```
 Type:           string
 Valid Values:   <name>
 Default:        utf8_general_ci
 ```
 Sets the collation used for client-server interaction on connection. In contrast to `charset`, `collation` does not issue additional queries. If the specified collation is unavailable on the target server, the connection will fail.
 A list of valid charsets for a server is retrievable with `SHOW COLLATION`.
 ##### `clientFoundRows`
 ```
 Type:           bool
 Valid Values:   true, false
 Default:        false
 ```
 `clientFoundRows=true` causes an UPDATE to return the number of matching rows instead of the number of rows changed.
 ##### `columnsWithAlias`
 ```
 Type:           bool
 Valid Values:   true, false
 Default:        false
 ```
 When `columnsWithAlias` is true, calls to `sql.Rows.Columns()` will return the table alias and the column name separated by a dot. For example:
 ```
 SELECT u.id FROM users as u
 ```
 will return `u.id` instead of just `id` if `columnsWithAlias=true`.
 ##### `interpolateParams`
 ```
 Type:           bool
 Valid Values:   true, false
 Default:        false
 ```
 If `interpolateParams` is true, placeholders (`?`) in calls to `db.Query()` and `db.Exec()` are interpolated into a single query string with given parameters. This reduces the number of roundtrips, since the driver has to prepare a statement, execute it with given parameters and close the statement again with `interpolateParams=false`.
 *This can not be used together with the multibyte encodings BIG5, CP932, GB2312, GBK or SJIS. These are blacklisted as they may [introduce a SQL injection vulnerability](http://stackoverflow.com/a/12118602/3430118)!*
 ##### `loc`
 ```
 Type:           string
 Valid Values:   <escaped name>
 Default:        UTC
 ```
 Sets the location for time.Time values (when using `parseTime=true`). *"Local"* sets the system's location. See [time.LoadLocation](https://golang.org/pkg/time/#LoadLocation) for details.
 Note that this sets the location for time.Time values but does not change MySQL's [time_zone setting](https://dev.mysql.com/doc/refman/5.5/en/time-zone-support.html). For that see the [time_zone system variable](#system-variables), which can also be set as a DSN parameter.
 Please keep in mind, that param values must be [url.QueryEscape](https://golang.org/pkg/net/url/#QueryEscape)'ed. Alternatively you can manually replace the `/` with `%2F`. For example `US/Pacific` would be `loc=US%2FPacific`.
 ##### `maxAllowedPacket`
 ```
 Type:          decimal number
 Default:       4194304
 ```
 Max packet size allowed in bytes. The default value is 4 MiB and should be adjusted to match the server settings. `maxAllowedPacket=0` can be used to automatically fetch the `max_allowed_packet` variable from server *on every connection*.
 ##### `multiStatements`
 ```
 Type:           bool
 Valid Values:   true, false
 Default:        false
 ```
 Allow multiple statements in one query. While this allows batch queries, it also greatly increases the risk of SQL injections. Only the result of the first query is returned, all other results are silently discarded.
 When `multiStatements` is used, `?` parameters must only be used in the first statement.
 ##### `parseTime`
 ```
 Type:           bool
 Valid Values:   true, false
 Default:        false
 ```
 `parseTime=true` changes the output type of `DATE` and `DATETIME` values to `time.Time` instead of `[]byte` / `string`
 The date or datetime like `0000-00-00 00:00:00` is converted into zero value of `time.Time`.
 ##### `readTimeout`
 ```
 Type:           duration
 Default:        0
 ```
 I/O read timeout. The value must be a decimal number with a unit suffix (*"ms"*, *"s"*, *"m"*, *"h"*), such as *"30s"*, *"0.5m"* or *"1m30s"*.
 ##### `rejectReadOnly`
 ```
 Type:           bool
 Valid Values:   true, false
 Default:        false
 ```
 `rejectReadOnly=true` causes the driver to reject read-only connections. This
 is for a possible race condition during an automatic failover, where the mysql
 client gets connected to a read-only replica after the failover.
 Note that this should be a fairly rare case, as an automatic failover normally
 happens when the primary is down, and the race condition shouldn't happen
 unless it comes back up online as soon as the failover is kicked off. On the
 other hand, when this happens, a MySQL application can get stuck on a
 read-only connection until restarted. It is however fairly easy to reproduce,
 for example, using a manual failover on AWS Aurora's MySQL-compatible cluster.
 If you are not relying on read-only transactions to reject writes that aren't
 supposed to happen, setting this on some MySQL providers (such as AWS Aurora)
 is safer for failovers.
 Note that ERROR 1290 can be returned for a `read-only` server and this option will
 cause a retry for that error. However the same error number is used for some
 other cases. You should ensure your application will never cause an ERROR 1290
 except for `read-only` mode when enabling this option.
 ##### `serverPubKey`
 ```
 Type:           string
 Valid Values:   <name>
 Default:        none
 ```
 Server public keys can be registered with [`mysql.RegisterServerPubKey`](https://godoc.org/github.com/go-sql-driver/mysql#RegisterServerPubKey), which can then be used by the assigned name in the DSN.
 Public keys are used to transmit encrypted data, e.g. for authentication.
 If the server's public key is known, it should be set manually to avoid expensive and potentially insecure transmissions of the public key from the server to the client each time it is required.
 ##### `timeout`
 ```
 Type:           duration
 Default:        OS default
 ```
 Timeout for establishing connections, aka dial timeout. The value must be a decimal number with a unit suffix (*"ms"*, *"s"*, *"m"*, *"h"*), such as *"30s"*, *"0.5m"* or *"1m30s"*.
 ##### `tls`
 ```
 Type:           bool / string
 Valid Values:   true, false, skip-verify, <name>
 Default:        false
 ```
 `tls=true` enables TLS / SSL encrypted connection to the server. Use `skip-verify` if you want to use a self-signed or invalid certificate (server side). Use a custom value registered with [`mysql.RegisterTLSConfig`](https://godoc.org/github.com/go-sql-driver/mysql#RegisterTLSConfig).
 ##### `writeTimeout`
 ```
 Type:           duration
 Default:        0
 ```
 I/O write timeout. The value must be a decimal number with a unit suffix (*"ms"*, *"s"*, *"m"*, *"h"*), such as *"30s"*, *"0.5m"* or *"1m30s"*.
 ##### System Variables
 Any other parameters are interpreted as system variables:
  * `<boolean_var>=<value>`: `SET <boolean_var>=<value>`
  * `<enum_var>=<value>`: `SET <enum_var>=<value>`
  * `<string_var>=%27<value>%27`: `SET <string_var>='<value>'`
 Rules:
 * The values for string variables must be quoted with `'`.
 * The values must also be [url.QueryEscape](http://golang.org/pkg/net/url/#QueryEscape)'ed!
 (which implies values of string variables must be wrapped with `%27`).
 Examples:
  * `autocommit=1`: `SET autocommit=1`
  * [`time_zone=%27Europe%2FParis%27`](https://dev.mysql.com/doc/refman/5.5/en/time-zone-support.html): `SET time_zone='Europe/Paris'`
  * [`tx_isolation=%27REPEATABLE-READ%27`](https://dev.mysql.com/doc/refman/5.5/en/server-system-variables.html#sysvar_tx_isolation): `SET tx_isolation='REPEATABLE-READ'`
 #### Examples
 ```
 user@unix(/path/to/socket)/dbname
 ```
 ```
 root:pw@unix(/tmp/mysql.sock)/myDatabase?loc=Local
 ```
 ```
 user:password@tcp(localhost:5555)/dbname?tls=skip-verify&autocommit=true
 ```
 Treat warnings as errors by setting the system variable [`sql_mode`](https://dev.mysql.com/doc/refman/5.7/en/sql-mode.html):
 ```
 user:password@/dbname?sql_mode=TRADITIONAL
 ```
 TCP via IPv6:
 ```
 user:password@tcp([de:ad:be:ef::ca:fe]:80)/dbname?timeout=90s&collation=utf8mb4_unicode_ci
 ```
 TCP on a remote host, e.g. Amazon RDS:
 ```
 id:password@tcp(your-amazonaws-uri.com:3306)/dbname
 ```
 Google Cloud SQL on App Engine (First Generation MySQL Server):
 ```
 user@cloudsql(project-id:instance-name)/dbname
 ```
 Google Cloud SQL on App Engine (Second Generation MySQL Server):
 ```
 user@cloudsql(project-id:regionname:instance-name)/dbname
 ```
 TCP using default port (3306) on localhost:
 ```
 user:password@tcp/dbname?charset=utf8mb4,utf8&sys_var=esc%40ped
 ```
 Use the default protocol (tcp) and host (localhost:3306):
 ```
 user:password@/dbname
 ```
 No Database preselected:
 ```
 user:password@/
 ```
 ### Connection pool and timeouts
 The connection pool is managed by Go's database/sql package. For details on how to configure the size of the pool and how long connections stay in the pool see `*DB.SetMaxOpenConns`, `*DB.SetMaxIdleConns`, and `*DB.SetConnMaxLifetime` in the [database/sql documentation](https://golang.org/pkg/database/sql/). The read, write, and dial timeouts for each individual connection are configured with the DSN parameters [`readTimeout`](#readtimeout), [`writeTimeout`](#writetimeout), and [`timeout`](#timeout), respectively.
 ## `ColumnType` Support
 This driver supports the [`ColumnType` interface](https://golang.org/pkg/database/sql/#ColumnType) introduced in Go 1.8, with the exception of [`ColumnType.Length()`](https://golang.org/pkg/database/sql/#ColumnType.Length), which is currently not supported.
 ## `context.Context` Support
 Go 1.8 added `database/sql` support for `context.Context`. This driver supports query timeouts and cancellation via contexts.
 See [context support in the database/sql package](https://golang.org/doc/go1.8#database_sql) for more details.
 ### `LOAD DATA LOCAL INFILE` support
 For this feature you need direct access to the package. Therefore you must change the import path (no `_`):
 ```go
 import "github.com/go-sql-driver/mysql"
 ```
 Files must be whitelisted by registering them with `mysql.RegisterLocalFile(filepath)` (recommended) or the Whitelist check must be deactivated by using the DSN parameter `allowAllFiles=true` ([*Might be insecure!*](http://dev.mysql.com/doc/refman/5.7/en/load-data-local.html)).
 To use a `io.Reader` a handler function must be registered with `mysql.RegisterReaderHandler(name, handler)` which returns a `io.Reader` or `io.ReadCloser`. The Reader is available with the filepath `Reader::<name>` then. Choose different names for different handlers and `DeregisterReaderHandler` when you don't need it anymore.
 See the [godoc of Go-MySQL-Driver](https://godoc.org/github.com/go-sql-driver/mysql "golang mysql driver documentation") for details.
 ### `time.Time` support
 The default internal output type of MySQL `DATE` and `DATETIME` values is `[]byte` which allows you to scan the value into a `[]byte`, `string` or `sql.RawBytes` variable in your program.
 However, many want to scan MySQL `DATE` and `DATETIME` values into `time.Time` variables, which is the logical opposite in Go to `DATE` and `DATETIME` in MySQL. You can do that by changing the internal output type from `[]byte` to `time.Time` with the DSN parameter `parseTime=true`. You can set the default [`time.Time` location](https://golang.org/pkg/time/#Location) with the `loc` DSN parameter.
 **Caution:** As of Go 1.1, this makes `time.Time` the only variable type you can scan `DATE` and `DATETIME` values into. This breaks for example [`sql.RawBytes` support](https://github.com/go-sql-driver/mysql/wiki/Examples#rawbytes).
 Alternatively you can use the [`NullTime`](https://godoc.org/github.com/go-sql-driver/mysql#NullTime) type as the scan destination, which works with both `time.Time` and `string` / `[]byte`.
 ### Unicode support
 Since version 1.1 Go-MySQL-Driver automatically uses the collation `utf8_general_ci` by default.
 Other collations / charsets can be set using the [`collation`](#collation) DSN parameter.
 Version 1.0 of the driver recommended adding `&charset=utf8` (alias for `SET NAMES utf8`) to the DSN to enable proper UTF-8 support. This is not necessary anymore. The [`collation`](#collation) parameter should be preferred to set another collation / charset than the default.
 See http://dev.mysql.com/doc/refman/5.7/en/charset-unicode.html for more details on MySQL's Unicode support.
 ## Testing / Development
 To run the driver tests you may need to adjust the configuration. See the [Testing Wiki-Page](https://github.com/go-sql-driver/mysql/wiki/Testing "Testing") for details.
 Go-MySQL-Driver is not feature-complete yet. Your help is very appreciated.
 If you want to contribute, you can work on an [open issue](https://github.com/go-sql-driver/mysql/issues?state=open) or review a [pull request](https://github.com/go-sql-driver/mysql/pulls).
 See the [Contribution Guidelines](https://github.com/go-sql-driver/mysql/blob/master/CONTRIBUTING.md) for details.
 ---------------------------------------
 ## License
 Go-MySQL-Driver is licensed under the [Mozilla Public License Version 2.0](https://raw.github.com/go-sql-driver/mysql/master/LICENSE)
 Mozilla summarizes the license scope as follows:
 > MPL: The copyleft applies to any files containing MPLed code.
 That means:
  * You can **use** the **unchanged** source code both in private and commercially.
  * When distributing, you **must publish** the source code of any **changed files** licensed under the MPL 2.0 under a) the MPL 2.0 itself or b) a compatible license (e.g. GPL 3.0 or Apache License 2.0).
  * You **needn't publish** the source code of your library as long as the files licensed under the MPL 2.0 are **unchanged**.
 Please read the [MPL 2.0 FAQ](https://www.mozilla.org/en-US/MPL/2.0/FAQ/) if you have further questions regarding the license.
 You can read the full terms here: [LICENSE](https://raw.github.com/go-sql-driver/mysql/master/LICENSE).
 ![Go Gopher and MySQL Dolphin](https://raw.github.com/wiki/go-sql-driver/mysql/go-mysql-driver_m.jpg "Golang Gopher transporting the MySQL Dolphin in a wheelbarrow")
--- a/vendor/github.com/go-sql-driver/mysql/appengine.go
+++ b/vendor/github.com/go-sql-driver/mysql/appengine.go
@ -1,19 +0,0 @@
 // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
 //
 // Copyright 2013 The Go-MySQL-Driver Authors. All rights reserved.
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this file,
 // You can obtain one at http://mozilla.org/MPL/2.0/.
 // +build appengine
 package mysql
 import (
 	"google.golang.org/appengine/cloudsql"
 )
 func init() {
 	RegisterDial("cloudsql", cloudsql.Dial)
 }
--- a/vendor/github.com/go-sql-driver/mysql/auth.go
+++ b/vendor/github.com/go-sql-driver/mysql/auth.go
@ -1,420 +0,0 @@
 // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
 //
 // Copyright 2018 The Go-MySQL-Driver Authors. All rights reserved.
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this file,
 // You can obtain one at http://mozilla.org/MPL/2.0/.
 package mysql
 import (
 	"crypto/rand"
 	"crypto/rsa"
 	"crypto/sha1"
 	"crypto/sha256"
 	"crypto/x509"
 	"encoding/pem"
 	"sync"
 )
 // server pub keys registry
 var (
 	serverPubKeyLock     sync.RWMutex
 	serverPubKeyRegistry map[string]*rsa.PublicKey
 )
 // RegisterServerPubKey registers a server RSA public key which can be used to
 // send data in a secure manner to the server without receiving the public key
 // in a potentially insecure way from the server first.
 // Registered keys can afterwards be used adding serverPubKey=<name> to the DSN.
 //
 // Note: The provided rsa.PublicKey instance is exclusively owned by the driver
 // after registering it and may not be modified.
 //
 //  data, err := ioutil.ReadFile("mykey.pem")
 //  if err != nil {
 //  	log.Fatal(err)
 //  }
 //
 //  block, _ := pem.Decode(data)
 //  if block == nil || block.Type != "PUBLIC KEY" {
 //  	log.Fatal("failed to decode PEM block containing public key")
 //  }
 //
 //  pub, err := x509.ParsePKIXPublicKey(block.Bytes)
 //  if err != nil {
 //  	log.Fatal(err)
 //  }
 //
 //  if rsaPubKey, ok := pub.(*rsa.PublicKey); ok {
 //  	mysql.RegisterServerPubKey("mykey", rsaPubKey)
 //  } else {
 //  	log.Fatal("not a RSA public key")
 //  }
 //
 func RegisterServerPubKey(name string, pubKey *rsa.PublicKey) {
 	serverPubKeyLock.Lock()
 	if serverPubKeyRegistry == nil {
 		serverPubKeyRegistry = make(map[string]*rsa.PublicKey)
 	}
 	serverPubKeyRegistry[name] = pubKey
 	serverPubKeyLock.Unlock()
 }
 // DeregisterServerPubKey removes the public key registered with the given name.
 func DeregisterServerPubKey(name string) {
 	serverPubKeyLock.Lock()
 	if serverPubKeyRegistry != nil {
 		delete(serverPubKeyRegistry, name)
 	}
 	serverPubKeyLock.Unlock()
 }
 func getServerPubKey(name string) (pubKey *rsa.PublicKey) {
 	serverPubKeyLock.RLock()
 	if v, ok := serverPubKeyRegistry[name]; ok {
 		pubKey = v
 	}
 	serverPubKeyLock.RUnlock()
 	return
 }
 // Hash password using pre 4.1 (old password) method
 // https://github.com/atcurtis/mariadb/blob/master/mysys/my_rnd.c
 type myRnd struct {
 	seed1, seed2 uint32
 }
 const myRndMaxVal = 0x3FFFFFFF
 // Pseudo random number generator
 func newMyRnd(seed1, seed2 uint32) *myRnd {
 	return &myRnd{
 		seed1: seed1 % myRndMaxVal,
 		seed2: seed2 % myRndMaxVal,
 	}
 }
 // Tested to be equivalent to MariaDB's floating point variant
 // http://play.golang.org/p/QHvhd4qved
 // http://play.golang.org/p/RG0q4ElWDx
 func (r *myRnd) NextByte() byte {
 	r.seed1 = (r.seed1*3 + r.seed2) % myRndMaxVal
 	r.seed2 = (r.seed1 + r.seed2 + 33) % myRndMaxVal
 	return byte(uint64(r.seed1) * 31 / myRndMaxVal)
 }
 // Generate binary hash from byte string using insecure pre 4.1 method
 func pwHash(password []byte) (result [2]uint32) {
 	var add uint32 = 7
 	var tmp uint32
 	result[0] = 1345345333
 	result[1] = 0x12345671
 	for _, c := range password {
 		// skip spaces and tabs in password
 		if c == ' ' || c == '\t' {
 			continue
 		}
 		tmp = uint32(c)
 		result[0] ^= (((result[0] & 63) + add) * tmp) + (result[0] << 8)
 		result[1] += (result[1] << 8) ^ result[0]
 		add += tmp
 	}
 	// Remove sign bit (1<<31)-1)
 	result[0] &= 0x7FFFFFFF
 	result[1] &= 0x7FFFFFFF
 	return
 }
 // Hash password using insecure pre 4.1 method
 func scrambleOldPassword(scramble []byte, password string) []byte {
 	if len(password) == 0 {
 		return nil
 	}
 	scramble = scramble[:8]
 	hashPw := pwHash([]byte(password))
 	hashSc := pwHash(scramble)
 	r := newMyRnd(hashPw[0]^hashSc[0], hashPw[1]^hashSc[1])
 	var out [8]byte
 	for i := range out {
 		out[i] = r.NextByte() + 64
 	}
 	mask := r.NextByte()
 	for i := range out {
 		out[i] ^= mask
 	}
 	return out[:]
 }
 // Hash password using 4.1+ method (SHA1)
 func scramblePassword(scramble []byte, password string) []byte {
 	if len(password) == 0 {
 		return nil
 	}
 	// stage1Hash = SHA1(password)
 	crypt := sha1.New()
 	crypt.Write([]byte(password))
 	stage1 := crypt.Sum(nil)
 	// scrambleHash = SHA1(scramble + SHA1(stage1Hash))
 	// inner Hash
 	crypt.Reset()
 	crypt.Write(stage1)
 	hash := crypt.Sum(nil)
 	// outer Hash
 	crypt.Reset()
 	crypt.Write(scramble)
 	crypt.Write(hash)
 	scramble = crypt.Sum(nil)
 	// token = scrambleHash XOR stage1Hash
 	for i := range scramble {
 		scramble[i] ^= stage1[i]
 	}
 	return scramble
 }
 // Hash password using MySQL 8+ method (SHA256)
 func scrambleSHA256Password(scramble []byte, password string) []byte {
 	if len(password) == 0 {
 		return nil
 	}
 	// XOR(SHA256(password), SHA256(SHA256(SHA256(password)), scramble))
 	crypt := sha256.New()
 	crypt.Write([]byte(password))
 	message1 := crypt.Sum(nil)
 	crypt.Reset()
 	crypt.Write(message1)
 	message1Hash := crypt.Sum(nil)
 	crypt.Reset()
 	crypt.Write(message1Hash)
 	crypt.Write(scramble)
 	message2 := crypt.Sum(nil)
 	for i := range message1 {
 		message1[i] ^= message2[i]
 	}
 	return message1
 }
 func encryptPassword(password string, seed []byte, pub *rsa.PublicKey) ([]byte, error) {
 	plain := make([]byte, len(password)+1)
 	copy(plain, password)
 	for i := range plain {
 		j := i % len(seed)
 		plain[i] ^= seed[j]
 	}
 	sha1 := sha1.New()
 	return rsa.EncryptOAEP(sha1, rand.Reader, pub, plain, nil)
 }
 func (mc *mysqlConn) sendEncryptedPassword(seed []byte, pub *rsa.PublicKey) error {
 	enc, err := encryptPassword(mc.cfg.Passwd, seed, pub)
 	if err != nil {
 		return err
 	}
 	return mc.writeAuthSwitchPacket(enc)
 }
 func (mc *mysqlConn) auth(authData []byte, plugin string) ([]byte, error) {
 	switch plugin {
 	case "caching_sha2_password":
 		authResp := scrambleSHA256Password(authData, mc.cfg.Passwd)
 		return authResp, nil
 	case "mysql_old_password":
 		if !mc.cfg.AllowOldPasswords {
 			return nil, ErrOldPassword
 		}
 		// Note: there are edge cases where this should work but doesn't;
 		// this is currently "wontfix":
 		// https://github.com/go-sql-driver/mysql/issues/184
 		authResp := append(scrambleOldPassword(authData[:8], mc.cfg.Passwd), 0)
 		return authResp, nil
 	case "mysql_clear_password":
 		if !mc.cfg.AllowCleartextPasswords {
 			return nil, ErrCleartextPassword
 		}
 		// http://dev.mysql.com/doc/refman/5.7/en/cleartext-authentication-plugin.html
 		// http://dev.mysql.com/doc/refman/5.7/en/pam-authentication-plugin.html
 		return append([]byte(mc.cfg.Passwd), 0), nil
 	case "mysql_native_password":
 		if !mc.cfg.AllowNativePasswords {
 			return nil, ErrNativePassword
 		}
 		// https://dev.mysql.com/doc/internals/en/secure-password-authentication.html
 		// Native password authentication only need and will need 20-byte challenge.
 		authResp := scramblePassword(authData[:20], mc.cfg.Passwd)
 		return authResp, nil
 	case "sha256_password":
 		if len(mc.cfg.Passwd) == 0 {
 			return []byte{0}, nil
 		}
 		if mc.cfg.tls != nil || mc.cfg.Net == "unix" {
 			// write cleartext auth packet
 			return append([]byte(mc.cfg.Passwd), 0), nil
 		}
 		pubKey := mc.cfg.pubKey
 		if pubKey == nil {
 			// request public key from server
 			return []byte{1}, nil
 		}
 		// encrypted password
 		enc, err := encryptPassword(mc.cfg.Passwd, authData, pubKey)
 		return enc, err
 	default:
 		errLog.Print("unknown auth plugin:", plugin)
 		return nil, ErrUnknownPlugin
 	}
 }
 func (mc *mysqlConn) handleAuthResult(oldAuthData []byte, plugin string) error {
 	// Read Result Packet
 	authData, newPlugin, err := mc.readAuthResult()
 	if err != nil {
 		return err
 	}
 	// handle auth plugin switch, if requested
 	if newPlugin != "" {
 		// If CLIENT_PLUGIN_AUTH capability is not supported, no new cipher is
 		// sent and we have to keep using the cipher sent in the init packet.
 		if authData == nil {
 			authData = oldAuthData
 		} else {
 			// copy data from read buffer to owned slice
 			copy(oldAuthData, authData)
 		}
 		plugin = newPlugin
 		authResp, err := mc.auth(authData, plugin)
 		if err != nil {
 			return err
 		}
 		if err = mc.writeAuthSwitchPacket(authResp); err != nil {
 			return err
 		}
 		// Read Result Packet
 		authData, newPlugin, err = mc.readAuthResult()
 		if err != nil {
 			return err
 		}
 		// Do not allow to change the auth plugin more than once
 		if newPlugin != "" {
 			return ErrMalformPkt
 		}
 	}
 	switch plugin {
 	// https://insidemysql.com/preparing-your-community-connector-for-mysql-8-part-2-sha256/
 	case "caching_sha2_password":
 		switch len(authData) {
 		case 0:
 			return nil // auth successful
 		case 1:
 			switch authData[0] {
 			case cachingSha2PasswordFastAuthSuccess:
 				if err = mc.readResultOK(); err == nil {
 					return nil // auth successful
 				}
 			case cachingSha2PasswordPerformFullAuthentication:
 				if mc.cfg.tls != nil || mc.cfg.Net == "unix" {
 					// write cleartext auth packet
 					err = mc.writeAuthSwitchPacket(append([]byte(mc.cfg.Passwd), 0))
 					if err != nil {
 						return err
 					}
 				} else {
 					pubKey := mc.cfg.pubKey
 					if pubKey == nil {
 						// request public key from server
 						data := mc.buf.takeSmallBuffer(4 + 1)
 						data[4] = cachingSha2PasswordRequestPublicKey
 						mc.writePacket(data)
 						// parse public key
 						data, err := mc.readPacket()
 						if err != nil {
 							return err
 						}
 						block, _ := pem.Decode(data[1:])
 						pkix, err := x509.ParsePKIXPublicKey(block.Bytes)
 						if err != nil {
 							return err
 						}
 						pubKey = pkix.(*rsa.PublicKey)
 					}
 					// send encrypted password
 					err = mc.sendEncryptedPassword(oldAuthData, pubKey)
 					if err != nil {
 						return err
 					}
 				}
 				return mc.readResultOK()
 			default:
 				return ErrMalformPkt
 			}
 		default:
 			return ErrMalformPkt
 		}
 	case "sha256_password":
 		switch len(authData) {
 		case 0:
 			return nil // auth successful
 		default:
 			block, _ := pem.Decode(authData)
 			pub, err := x509.ParsePKIXPublicKey(block.Bytes)
 			if err != nil {
 				return err
 			}
 			// send encrypted password
 			err = mc.sendEncryptedPassword(oldAuthData, pub.(*rsa.PublicKey))
 			if err != nil {
 				return err
 			}
 			return mc.readResultOK()
 		}
 	default:
 		return nil // auth successful
 	}
 	return err
 }
--- a/vendor/github.com/go-sql-driver/mysql/buffer.go
+++ b/vendor/github.com/go-sql-driver/mysql/buffer.go
@ -1,147 +0,0 @@
 // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
 //
 // Copyright 2013 The Go-MySQL-Driver Authors. All rights reserved.
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this file,
 // You can obtain one at http://mozilla.org/MPL/2.0/.
 package mysql
 import (
 	"io"
 	"net"
 	"time"
 )
 const defaultBufSize = 4096
 // A buffer which is used for both reading and writing.
 // This is possible since communication on each connection is synchronous.
 // In other words, we can't write and read simultaneously on the same connection.
 // The buffer is similar to bufio.Reader / Writer but zero-copy-ish
 // Also highly optimized for this particular use case.
 type buffer struct {
 	buf     []byte
 	nc      net.Conn
 	idx     int
 	length  int
 	timeout time.Duration
 }
 func newBuffer(nc net.Conn) buffer {
 	var b [defaultBufSize]byte
 	return buffer{
 		buf: b[:],
 		nc:  nc,
 	}
 }
 // fill reads into the buffer until at least _need_ bytes are in it
 func (b *buffer) fill(need int) error {
 	n := b.length
 	// move existing data to the beginning
 	if n > 0 && b.idx > 0 {
 		copy(b.buf[0:n], b.buf[b.idx:])
 	}
 	// grow buffer if necessary
 	// TODO: let the buffer shrink again at some point
 	//       Maybe keep the org buf slice and swap back?
 	if need > len(b.buf) {
 		// Round up to the next multiple of the default size
 		newBuf := make([]byte, ((need/defaultBufSize)+1)*defaultBufSize)
 		copy(newBuf, b.buf)
 		b.buf = newBuf
 	}
 	b.idx = 0
 	for {
 		if b.timeout > 0 {
 			if err := b.nc.SetReadDeadline(time.Now().Add(b.timeout)); err != nil {
 				return err
 			}
 		}
 		nn, err := b.nc.Read(b.buf[n:])
 		n += nn
 		switch err {
 		case nil:
 			if n < need {
 				continue
 			}
 			b.length = n
 			return nil
 		case io.EOF:
 			if n >= need {
 				b.length = n
 				return nil
 			}
 			return io.ErrUnexpectedEOF
 		default:
 			return err
 		}
 	}
 }
 // returns next N bytes from buffer.
 // The returned slice is only guaranteed to be valid until the next read
 func (b *buffer) readNext(need int) ([]byte, error) {
 	if b.length < need {
 		// refill
 		if err := b.fill(need); err != nil {
 			return nil, err
 		}
 	}
 	offset := b.idx
 	b.idx += need
 	b.length -= need
 	return b.buf[offset:b.idx], nil
 }
 // returns a buffer with the requested size.
 // If possible, a slice from the existing buffer is returned.
 // Otherwise a bigger buffer is made.
 // Only one buffer (total) can be used at a time.
 func (b *buffer) takeBuffer(length int) []byte {
 	if b.length > 0 {
 		return nil
 	}
 	// test (cheap) general case first
 	if length <= defaultBufSize || length <= cap(b.buf) {
 		return b.buf[:length]
 	}
 	if length < maxPacketSize {
 		b.buf = make([]byte, length)
 		return b.buf
 	}
 	return make([]byte, length)
 }
 // shortcut which can be used if the requested buffer is guaranteed to be
 // smaller than defaultBufSize
 // Only one buffer (total) can be used at a time.
 func (b *buffer) takeSmallBuffer(length int) []byte {
 	if b.length > 0 {
 		return nil
 	}
 	return b.buf[:length]
 }
 // takeCompleteBuffer returns the complete existing buffer.
 // This can be used if the necessary buffer size is unknown.
 // Only one buffer (total) can be used at a time.
 func (b *buffer) takeCompleteBuffer() []byte {
 	if b.length > 0 {
 		return nil
 	}
 	return b.buf
 }
--- a/vendor/github.com/go-sql-driver/mysql/collations.go
+++ b/vendor/github.com/go-sql-driver/mysql/collations.go
@ -1,251 +0,0 @@
 // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
 //
 // Copyright 2014 The Go-MySQL-Driver Authors. All rights reserved.
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this file,
 // You can obtain one at http://mozilla.org/MPL/2.0/.
 package mysql
 const defaultCollation = "utf8_general_ci"
 const binaryCollation = "binary"
 // A list of available collations mapped to the internal ID.
 // To update this map use the following MySQL query:
 //     SELECT COLLATION_NAME, ID FROM information_schema.COLLATIONS
 var collations = map[string]byte{
 	"big5_chinese_ci":          1,
 	"latin2_czech_cs":          2,
 	"dec8_swedish_ci":          3,
 	"cp850_general_ci":         4,
 	"latin1_german1_ci":        5,
 	"hp8_english_ci":           6,
 	"koi8r_general_ci":         7,
 	"latin1_swedish_ci":        8,
 	"latin2_general_ci":        9,
 	"swe7_swedish_ci":          10,
 	"ascii_general_ci":         11,
 	"ujis_japanese_ci":         12,
 	"sjis_japanese_ci":         13,
 	"cp1251_bulgarian_ci":      14,
 	"latin1_danish_ci":         15,
 	"hebrew_general_ci":        16,
 	"tis620_thai_ci":           18,
 	"euckr_korean_ci":          19,
 	"latin7_estonian_cs":       20,
 	"latin2_hungarian_ci":      21,
 	"koi8u_general_ci":         22,
 	"cp1251_ukrainian_ci":      23,
 	"gb2312_chinese_ci":        24,
 	"greek_general_ci":         25,
 	"cp1250_general_ci":        26,
 	"latin2_croatian_ci":       27,
 	"gbk_chinese_ci":           28,
 	"cp1257_lithuanian_ci":     29,
 	"latin5_turkish_ci":        30,
 	"latin1_german2_ci":        31,
 	"armscii8_general_ci":      32,
 	"utf8_general_ci":          33,
 	"cp1250_czech_cs":          34,
 	"ucs2_general_ci":          35,
 	"cp866_general_ci":         36,
 	"keybcs2_general_ci":       37,
 	"macce_general_ci":         38,
 	"macroman_general_ci":      39,
 	"cp852_general_ci":         40,
 	"latin7_general_ci":        41,
 	"latin7_general_cs":        42,
 	"macce_bin":                43,
 	"cp1250_croatian_ci":       44,
 	"utf8mb4_general_ci":       45,
 	"utf8mb4_bin":              46,
 	"latin1_bin":               47,
 	"latin1_general_ci":        48,
 	"latin1_general_cs":        49,
 	"cp1251_bin":               50,
 	"cp1251_general_ci":        51,
 	"cp1251_general_cs":        52,
 	"macroman_bin":             53,
 	"utf16_general_ci":         54,
 	"utf16_bin":                55,
 	"utf16le_general_ci":       56,
 	"cp1256_general_ci":        57,
 	"cp1257_bin":               58,
 	"cp1257_general_ci":        59,
 	"utf32_general_ci":         60,
 	"utf32_bin":                61,
 	"utf16le_bin":              62,
 	"binary":                   63,
 	"armscii8_bin":             64,
 	"ascii_bin":                65,
 	"cp1250_bin":               66,
 	"cp1256_bin":               67,
 	"cp866_bin":                68,
 	"dec8_bin":                 69,
 	"greek_bin":                70,
 	"hebrew_bin":               71,
 	"hp8_bin":                  72,
 	"keybcs2_bin":              73,
 	"koi8r_bin":                74,
 	"koi8u_bin":                75,
 	"latin2_bin":               77,
 	"latin5_bin":               78,
 	"latin7_bin":               79,
 	"cp850_bin":                80,
 	"cp852_bin":                81,
 	"swe7_bin":                 82,
 	"utf8_bin":                 83,
 	"big5_bin":                 84,
 	"euckr_bin":                85,
 	"gb2312_bin":               86,
 	"gbk_bin":                  87,
 	"sjis_bin":                 88,
 	"tis620_bin":               89,
 	"ucs2_bin":                 90,
 	"ujis_bin":                 91,
 	"geostd8_general_ci":       92,
 	"geostd8_bin":              93,
 	"latin1_spanish_ci":        94,
 	"cp932_japanese_ci":        95,
 	"cp932_bin":                96,
 	"eucjpms_japanese_ci":      97,
 	"eucjpms_bin":              98,
 	"cp1250_polish_ci":         99,
 	"utf16_unicode_ci":         101,
 	"utf16_icelandic_ci":       102,
 	"utf16_latvian_ci":         103,
 	"utf16_romanian_ci":        104,
 	"utf16_slovenian_ci":       105,
 	"utf16_polish_ci":          106,
 	"utf16_estonian_ci":        107,
 	"utf16_spanish_ci":         108,
 	"utf16_swedish_ci":         109,
 	"utf16_turkish_ci":         110,
 	"utf16_czech_ci":           111,
 	"utf16_danish_ci":          112,
 	"utf16_lithuanian_ci":      113,
 	"utf16_slovak_ci":          114,
 	"utf16_spanish2_ci":        115,
 	"utf16_roman_ci":           116,
 	"utf16_persian_ci":         117,
 	"utf16_esperanto_ci":       118,
 	"utf16_hungarian_ci":       119,
 	"utf16_sinhala_ci":         120,
 	"utf16_german2_ci":         121,
 	"utf16_croatian_ci":        122,
 	"utf16_unicode_520_ci":     123,
 	"utf16_vietnamese_ci":      124,
 	"ucs2_unicode_ci":          128,
 	"ucs2_icelandic_ci":        129,
 	"ucs2_latvian_ci":          130,
 	"ucs2_romanian_ci":         131,
 	"ucs2_slovenian_ci":        132,
 	"ucs2_polish_ci":           133,
 	"ucs2_estonian_ci":         134,
 	"ucs2_spanish_ci":          135,
 	"ucs2_swedish_ci":          136,
 	"ucs2_turkish_ci":          137,
 	"ucs2_czech_ci":            138,
 	"ucs2_danish_ci":           139,
 	"ucs2_lithuanian_ci":       140,
 	"ucs2_slovak_ci":           141,
 	"ucs2_spanish2_ci":         142,
 	"ucs2_roman_ci":            143,
 	"ucs2_persian_ci":          144,
 	"ucs2_esperanto_ci":        145,
 	"ucs2_hungarian_ci":        146,
 	"ucs2_sinhala_ci":          147,
 	"ucs2_german2_ci":          148,
 	"ucs2_croatian_ci":         149,
 	"ucs2_unicode_520_ci":      150,
 	"ucs2_vietnamese_ci":       151,
 	"ucs2_general_mysql500_ci": 159,
 	"utf32_unicode_ci":         160,
 	"utf32_icelandic_ci":       161,
 	"utf32_latvian_ci":         162,
 	"utf32_romanian_ci":        163,
 	"utf32_slovenian_ci":       164,
 	"utf32_polish_ci":          165,
 	"utf32_estonian_ci":        166,
 	"utf32_spanish_ci":         167,
 	"utf32_swedish_ci":         168,
 	"utf32_turkish_ci":         169,
 	"utf32_czech_ci":           170,
 	"utf32_danish_ci":          171,
 	"utf32_lithuanian_ci":      172,
 	"utf32_slovak_ci":          173,
 	"utf32_spanish2_ci":        174,
 	"utf32_roman_ci":           175,
 	"utf32_persian_ci":         176,
 	"utf32_esperanto_ci":       177,
 	"utf32_hungarian_ci":       178,
 	"utf32_sinhala_ci":         179,
 	"utf32_german2_ci":         180,
 	"utf32_croatian_ci":        181,
 	"utf32_unicode_520_ci":     182,
 	"utf32_vietnamese_ci":      183,
 	"utf8_unicode_ci":          192,
 	"utf8_icelandic_ci":        193,
 	"utf8_latvian_ci":          194,
 	"utf8_romanian_ci":         195,
 	"utf8_slovenian_ci":        196,
 	"utf8_polish_ci":           197,
 	"utf8_estonian_ci":         198,
 	"utf8_spanish_ci":          199,
 	"utf8_swedish_ci":          200,
 	"utf8_turkish_ci":          201,
 	"utf8_czech_ci":            202,
 	"utf8_danish_ci":           203,
 	"utf8_lithuanian_ci":       204,
 	"utf8_slovak_ci":           205,
 	"utf8_spanish2_ci":         206,
 	"utf8_roman_ci":            207,
 	"utf8_persian_ci":          208,
 	"utf8_esperanto_ci":        209,
 	"utf8_hungarian_ci":        210,
 	"utf8_sinhala_ci":          211,
 	"utf8_german2_ci":          212,
 	"utf8_croatian_ci":         213,
 	"utf8_unicode_520_ci":      214,
 	"utf8_vietnamese_ci":       215,
 	"utf8_general_mysql500_ci": 223,
 	"utf8mb4_unicode_ci":       224,
 	"utf8mb4_icelandic_ci":     225,
 	"utf8mb4_latvian_ci":       226,
 	"utf8mb4_romanian_ci":      227,
 	"utf8mb4_slovenian_ci":     228,
 	"utf8mb4_polish_ci":        229,
 	"utf8mb4_estonian_ci":      230,
 	"utf8mb4_spanish_ci":       231,
 	"utf8mb4_swedish_ci":       232,
 	"utf8mb4_turkish_ci":       233,
 	"utf8mb4_czech_ci":         234,
 	"utf8mb4_danish_ci":        235,
 	"utf8mb4_lithuanian_ci":    236,
 	"utf8mb4_slovak_ci":        237,
 	"utf8mb4_spanish2_ci":      238,
 	"utf8mb4_roman_ci":         239,
 	"utf8mb4_persian_ci":       240,
 	"utf8mb4_esperanto_ci":     241,
 	"utf8mb4_hungarian_ci":     242,
 	"utf8mb4_sinhala_ci":       243,
 	"utf8mb4_german2_ci":       244,
 	"utf8mb4_croatian_ci":      245,
 	"utf8mb4_unicode_520_ci":   246,
 	"utf8mb4_vietnamese_ci":    247,
 }
 // A blacklist of collations which is unsafe to interpolate parameters.
 // These multibyte encodings may contains 0x5c (`\`) in their trailing bytes.
 var unsafeCollations = map[string]bool{
 	"big5_chinese_ci":   true,
 	"sjis_japanese_ci":  true,
 	"gbk_chinese_ci":    true,
 	"big5_bin":          true,
 	"gb2312_bin":        true,
 	"gbk_bin":           true,
 	"sjis_bin":          true,
 	"cp932_japanese_ci": true,
 	"cp932_bin":         true,
 }
--- a/vendor/github.com/go-sql-driver/mysql/connection.go
+++ b/vendor/github.com/go-sql-driver/mysql/connection.go
@ -1,461 +0,0 @@
 // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
 //
 // Copyright 2012 The Go-MySQL-Driver Authors. All rights reserved.
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this file,
 // You can obtain one at http://mozilla.org/MPL/2.0/.
 package mysql
 import (
 	"database/sql/driver"
 	"io"
 	"net"
 	"strconv"
 	"strings"
 	"time"
 )
 // a copy of context.Context for Go 1.7 and earlier
 type mysqlContext interface {
 	Done() <-chan struct{}
 	Err() error
 	// defined in context.Context, but not used in this driver:
 	// Deadline() (deadline time.Time, ok bool)
 	// Value(key interface{}) interface{}
 }
 type mysqlConn struct {
 	buf              buffer
 	netConn          net.Conn
 	affectedRows     uint64
 	insertId         uint64
 	cfg              *Config
 	maxAllowedPacket int
 	maxWriteSize     int
 	writeTimeout     time.Duration
 	flags            clientFlag
 	status           statusFlag
 	sequence         uint8
 	parseTime        bool
 	// for context support (Go 1.8+)
 	watching bool
 	watcher  chan<- mysqlContext
 	closech  chan struct{}
 	finished chan<- struct{}
 	canceled atomicError // set non-nil if conn is canceled
 	closed   atomicBool  // set when conn is closed, before closech is closed
 }
 // Handles parameters set in DSN after the connection is established
 func (mc *mysqlConn) handleParams() (err error) {
 	for param, val := range mc.cfg.Params {
 		switch param {
 		// Charset
 		case "charset":
 			charsets := strings.Split(val, ",")
 			for i := range charsets {
 				// ignore errors here - a charset may not exist
 				err = mc.exec("SET NAMES " + charsets[i])
 				if err == nil {
 					break
 				}
 			}
 			if err != nil {
 				return
 			}
 		// System Vars
 		default:
 			err = mc.exec("SET " + param + "=" + val + "")
 			if err != nil {
 				return
 			}
 		}
 	}
 	return
 }
 func (mc *mysqlConn) markBadConn(err error) error {
 	if mc == nil {
 		return err
 	}
 	if err != errBadConnNoWrite {
 		return err
 	}
 	return driver.ErrBadConn
 }
 func (mc *mysqlConn) Begin() (driver.Tx, error) {
 	return mc.begin(false)
 }
 func (mc *mysqlConn) begin(readOnly bool) (driver.Tx, error) {
 	if mc.closed.IsSet() {
 		errLog.Print(ErrInvalidConn)
 		return nil, driver.ErrBadConn
 	}
 	var q string
 	if readOnly {
 		q = "START TRANSACTION READ ONLY"
 	} else {
 		q = "START TRANSACTION"
 	}
 	err := mc.exec(q)
 	if err == nil {
 		return &mysqlTx{mc}, err
 	}
 	return nil, mc.markBadConn(err)
 }
 func (mc *mysqlConn) Close() (err error) {
 	// Makes Close idempotent
 	if !mc.closed.IsSet() {
 		err = mc.writeCommandPacket(comQuit)
 	}
 	mc.cleanup()
 	return
 }
 // Closes the network connection and unsets internal variables. Do not call this
 // function after successfully authentication, call Close instead. This function
 // is called before auth or on auth failure because MySQL will have already
 // closed the network connection.
 func (mc *mysqlConn) cleanup() {
 	if !mc.closed.TrySet(true) {
 		return
 	}
 	// Makes cleanup idempotent
 	close(mc.closech)
 	if mc.netConn == nil {
 		return
 	}
 	if err := mc.netConn.Close(); err != nil {
 		errLog.Print(err)
 	}
 }
 func (mc *mysqlConn) error() error {
 	if mc.closed.IsSet() {
 		if err := mc.canceled.Value(); err != nil {
 			return err
 		}
 		return ErrInvalidConn
 	}
 	return nil
 }
 func (mc *mysqlConn) Prepare(query string) (driver.Stmt, error) {
 	if mc.closed.IsSet() {
 		errLog.Print(ErrInvalidConn)
 		return nil, driver.ErrBadConn
 	}
 	// Send command
 	err := mc.writeCommandPacketStr(comStmtPrepare, query)
 	if err != nil {
 		return nil, mc.markBadConn(err)
 	}
 	stmt := &mysqlStmt{
 		mc: mc,
 	}
 	// Read Result
 	columnCount, err := stmt.readPrepareResultPacket()
 	if err == nil {
 		if stmt.paramCount > 0 {
 			if err = mc.readUntilEOF(); err != nil {
 				return nil, err
 			}
 		}
 		if columnCount > 0 {
 			err = mc.readUntilEOF()
 		}
 	}
 	return stmt, err
 }
 func (mc *mysqlConn) interpolateParams(query string, args []driver.Value) (string, error) {
 	// Number of ? should be same to len(args)
 	if strings.Count(query, "?") != len(args) {
 		return "", driver.ErrSkip
 	}
 	buf := mc.buf.takeCompleteBuffer()
 	if buf == nil {
 		// can not take the buffer. Something must be wrong with the connection
 		errLog.Print(ErrBusyBuffer)
 		return "", ErrInvalidConn
 	}
 	buf = buf[:0]
 	argPos := 0
 	for i := 0; i < len(query); i++ {
 		q := strings.IndexByte(query[i:], '?')
 		if q == -1 {
 			buf = append(buf, query[i:]...)
 			break
 		}
 		buf = append(buf, query[i:i+q]...)
 		i += q
 		arg := args[argPos]
 		argPos++
 		if arg == nil {
 			buf = append(buf, "NULL"...)
 			continue
 		}
 		switch v := arg.(type) {
 		case int64:
 			buf = strconv.AppendInt(buf, v, 10)
 		case float64:
 			buf = strconv.AppendFloat(buf, v, 'g', -1, 64)
 		case bool:
 			if v {
 				buf = append(buf, '1')
 			} else {
 				buf = append(buf, '0')
 			}
 		case time.Time:
 			if v.IsZero() {
 				buf = append(buf, "'0000-00-00'"...)
 			} else {
 				v := v.In(mc.cfg.Loc)
 				v = v.Add(time.Nanosecond * 500) // To round under microsecond
 				year := v.Year()
 				year100 := year / 100
 				year1 := year % 100
 				month := v.Month()
 				day := v.Day()
 				hour := v.Hour()
 				minute := v.Minute()
 				second := v.Second()
 				micro := v.Nanosecond() / 1000
 				buf = append(buf, []byte{
 					'\'',
 					digits10[year100], digits01[year100],
 					digits10[year1], digits01[year1],
 					'-',
 					digits10[month], digits01[month],
 					'-',
 					digits10[day], digits01[day],
 					' ',
 					digits10[hour], digits01[hour],
 					':',
 					digits10[minute], digits01[minute],
 					':',
 					digits10[second], digits01[second],
 				}...)
 				if micro != 0 {
 					micro10000 := micro / 10000
 					micro100 := micro / 100 % 100
 					micro1 := micro % 100
 					buf = append(buf, []byte{
 						'.',
 						digits10[micro10000], digits01[micro10000],
 						digits10[micro100], digits01[micro100],
 						digits10[micro1], digits01[micro1],
 					}...)
 				}
 				buf = append(buf, '\'')
 			}
 		case []byte:
 			if v == nil {
 				buf = append(buf, "NULL"...)
 			} else {
 				buf = append(buf, "_binary'"...)
 				if mc.status&statusNoBackslashEscapes == 0 {
 					buf = escapeBytesBackslash(buf, v)
 				} else {
 					buf = escapeBytesQuotes(buf, v)
 				}
 				buf = append(buf, '\'')
 			}
 		case string:
 			buf = append(buf, '\'')
 			if mc.status&statusNoBackslashEscapes == 0 {
 				buf = escapeStringBackslash(buf, v)
 			} else {
 				buf = escapeStringQuotes(buf, v)
 			}
 			buf = append(buf, '\'')
 		default:
 			return "", driver.ErrSkip
 		}
 		if len(buf)+4 > mc.maxAllowedPacket {
 			return "", driver.ErrSkip
 		}
 	}
 	if argPos != len(args) {
 		return "", driver.ErrSkip
 	}
 	return string(buf), nil
 }
 func (mc *mysqlConn) Exec(query string, args []driver.Value) (driver.Result, error) {
 	if mc.closed.IsSet() {
 		errLog.Print(ErrInvalidConn)
 		return nil, driver.ErrBadConn
 	}
 	if len(args) != 0 {
 		if !mc.cfg.InterpolateParams {
 			return nil, driver.ErrSkip
 		}
 		// try to interpolate the parameters to save extra roundtrips for preparing and closing a statement
 		prepared, err := mc.interpolateParams(query, args)
 		if err != nil {
 			return nil, err
 		}
 		query = prepared
 	}
 	mc.affectedRows = 0
 	mc.insertId = 0
 	err := mc.exec(query)
 	if err == nil {
 		return &mysqlResult{
 			affectedRows: int64(mc.affectedRows),
 			insertId:     int64(mc.insertId),
 		}, err
 	}
 	return nil, mc.markBadConn(err)
 }
 // Internal function to execute commands
 func (mc *mysqlConn) exec(query string) error {
 	// Send command
 	if err := mc.writeCommandPacketStr(comQuery, query); err != nil {
 		return mc.markBadConn(err)
 	}
 	// Read Result
 	resLen, err := mc.readResultSetHeaderPacket()
 	if err != nil {
 		return err
 	}
 	if resLen > 0 {
 		// columns
 		if err := mc.readUntilEOF(); err != nil {
 			return err
 		}
 		// rows
 		if err := mc.readUntilEOF(); err != nil {
 			return err
 		}
 	}
 	return mc.discardResults()
 }
 func (mc *mysqlConn) Query(query string, args []driver.Value) (driver.Rows, error) {
 	return mc.query(query, args)
 }
 func (mc *mysqlConn) query(query string, args []driver.Value) (*textRows, error) {
 	if mc.closed.IsSet() {
 		errLog.Print(ErrInvalidConn)
 		return nil, driver.ErrBadConn
 	}
 	if len(args) != 0 {
 		if !mc.cfg.InterpolateParams {
 			return nil, driver.ErrSkip
 		}
 		// try client-side prepare to reduce roundtrip
 		prepared, err := mc.interpolateParams(query, args)
 		if err != nil {
 			return nil, err
 		}
 		query = prepared
 	}
 	// Send command
 	err := mc.writeCommandPacketStr(comQuery, query)
 	if err == nil {
 		// Read Result
 		var resLen int
 		resLen, err = mc.readResultSetHeaderPacket()
 		if err == nil {
 			rows := new(textRows)
 			rows.mc = mc
 			if resLen == 0 {
 				rows.rs.done = true
 				switch err := rows.NextResultSet(); err {
 				case nil, io.EOF:
 					return rows, nil
 				default:
 					return nil, err
 				}
 			}
 			// Columns
 			rows.rs.columns, err = mc.readColumns(resLen)
 			return rows, err
 		}
 	}
 	return nil, mc.markBadConn(err)
 }
 // Gets the value of the given MySQL System Variable
 // The returned byte slice is only valid until the next read
 func (mc *mysqlConn) getSystemVar(name string) ([]byte, error) {
 	// Send command
 	if err := mc.writeCommandPacketStr(comQuery, "SELECT @@"+name); err != nil {
 		return nil, err
 	}
 	// Read Result
 	resLen, err := mc.readResultSetHeaderPacket()
 	if err == nil {
 		rows := new(textRows)
 		rows.mc = mc
 		rows.rs.columns = []mysqlField{{fieldType: fieldTypeVarChar}}
 		if resLen > 0 {
 			// Columns
 			if err := mc.readUntilEOF(); err != nil {
 				return nil, err
 			}
 		}
 		dest := make([]driver.Value, resLen)
 		if err = rows.readRow(dest); err == nil {
 			return dest[0].([]byte), mc.readUntilEOF()
 		}
 	}
 	return nil, err
 }
 // finish is called when the query has canceled.
 func (mc *mysqlConn) cancel(err error) {
 	mc.canceled.Set(err)
 	mc.cleanup()
 }
 // finish is called when the query has succeeded.
 func (mc *mysqlConn) finish() {
 	if !mc.watching || mc.finished == nil {
 		return
 	}
 	select {
 	case mc.finished <- struct{}{}:
 		mc.watching = false
 	case <-mc.closech:
 	}
 }
--- a/vendor/github.com/go-sql-driver/mysql/connection_go18.go
+++ b/vendor/github.com/go-sql-driver/mysql/connection_go18.go
@ -1,207 +0,0 @@
 // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
 //
 // Copyright 2012 The Go-MySQL-Driver Authors. All rights reserved.
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this file,
 // You can obtain one at http://mozilla.org/MPL/2.0/.
 // +build go1.8
 package mysql
 import (
 	"context"
 	"database/sql"
 	"database/sql/driver"
 )
 // Ping implements driver.Pinger interface
 func (mc *mysqlConn) Ping(ctx context.Context) (err error) {
 	if mc.closed.IsSet() {
 		errLog.Print(ErrInvalidConn)
 		return driver.ErrBadConn
 	}
 	if err = mc.watchCancel(ctx); err != nil {
 		return
 	}
 	defer mc.finish()
 	if err = mc.writeCommandPacket(comPing); err != nil {
 		return
 	}
 	return mc.readResultOK()
 }
 // BeginTx implements driver.ConnBeginTx interface
 func (mc *mysqlConn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) {
 	if err := mc.watchCancel(ctx); err != nil {
 		return nil, err
 	}
 	defer mc.finish()
 	if sql.IsolationLevel(opts.Isolation) != sql.LevelDefault {
 		level, err := mapIsolationLevel(opts.Isolation)
 		if err != nil {
 			return nil, err
 		}
 		err = mc.exec("SET TRANSACTION ISOLATION LEVEL " + level)
 		if err != nil {
 			return nil, err
 		}
 	}
 	return mc.begin(opts.ReadOnly)
 }
 func (mc *mysqlConn) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) {
 	dargs, err := namedValueToValue(args)
 	if err != nil {
 		return nil, err
 	}
 	if err := mc.watchCancel(ctx); err != nil {
 		return nil, err
 	}
 	rows, err := mc.query(query, dargs)
 	if err != nil {
 		mc.finish()
 		return nil, err
 	}
 	rows.finish = mc.finish
 	return rows, err
 }
 func (mc *mysqlConn) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) {
 	dargs, err := namedValueToValue(args)
 	if err != nil {
 		return nil, err
 	}
 	if err := mc.watchCancel(ctx); err != nil {
 		return nil, err
 	}
 	defer mc.finish()
 	return mc.Exec(query, dargs)
 }
 func (mc *mysqlConn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) {
 	if err := mc.watchCancel(ctx); err != nil {
 		return nil, err
 	}
 	stmt, err := mc.Prepare(query)
 	mc.finish()
 	if err != nil {
 		return nil, err
 	}
 	select {
 	default:
 	case <-ctx.Done():
 		stmt.Close()
 		return nil, ctx.Err()
 	}
 	return stmt, nil
 }
 func (stmt *mysqlStmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) {
 	dargs, err := namedValueToValue(args)
 	if err != nil {
 		return nil, err
 	}
 	if err := stmt.mc.watchCancel(ctx); err != nil {
 		return nil, err
 	}
 	rows, err := stmt.query(dargs)
 	if err != nil {
 		stmt.mc.finish()
 		return nil, err
 	}
 	rows.finish = stmt.mc.finish
 	return rows, err
 }
 func (stmt *mysqlStmt) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error) {
 	dargs, err := namedValueToValue(args)
 	if err != nil {
 		return nil, err
 	}
 	if err := stmt.mc.watchCancel(ctx); err != nil {
 		return nil, err
 	}
 	defer stmt.mc.finish()
 	return stmt.Exec(dargs)
 }
 func (mc *mysqlConn) watchCancel(ctx context.Context) error {
 	if mc.watching {
 		// Reach here if canceled,
 		// so the connection is already invalid
 		mc.cleanup()
 		return nil
 	}
 	// When ctx is already cancelled, don't watch it.
 	if err := ctx.Err(); err != nil {
 		return err
 	}
 	// When ctx is not cancellable, don't watch it.
 	if ctx.Done() == nil {
 		return nil
 	}
 	// When watcher is not alive, can't watch it.
 	if mc.watcher == nil {
 		return nil
 	}
 	mc.watching = true
 	mc.watcher <- ctx
 	return nil
 }
 func (mc *mysqlConn) startWatcher() {
 	watcher := make(chan mysqlContext, 1)
 	mc.watcher = watcher
 	finished := make(chan struct{})
 	mc.finished = finished
 	go func() {
 		for {
 			var ctx mysqlContext
 			select {
 			case ctx = <-watcher:
 			case <-mc.closech:
 				return
 			}
 			select {
 			case <-ctx.Done():
 				mc.cancel(ctx.Err())
 			case <-finished:
 			case <-mc.closech:
 				return
 			}
 		}
 	}()
 }
 func (mc *mysqlConn) CheckNamedValue(nv *driver.NamedValue) (err error) {
 	nv.Value, err = converter{}.ConvertValue(nv.Value)
 	return
 }
 // ResetSession implements driver.SessionResetter.
 // (From Go 1.10)
 func (mc *mysqlConn) ResetSession(ctx context.Context) error {
 	if mc.closed.IsSet() {
 		return driver.ErrBadConn
 	}
 	return nil
 }
--- a/vendor/github.com/go-sql-driver/mysql/const.go
+++ b/vendor/github.com/go-sql-driver/mysql/const.go
@ -1,174 +0,0 @@
 // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
 //
 // Copyright 2012 The Go-MySQL-Driver Authors. All rights reserved.
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this file,
 // You can obtain one at http://mozilla.org/MPL/2.0/.
 package mysql
 const (
 	defaultAuthPlugin       = "mysql_native_password"
 	defaultMaxAllowedPacket = 4 << 20 // 4 MiB
 	minProtocolVersion      = 10
 	maxPacketSize           = 1<<24 - 1
 	timeFormat              = "2006-01-02 15:04:05.999999"
 )
 // MySQL constants documentation:
 // http://dev.mysql.com/doc/internals/en/client-server-protocol.html
 const (
 	iOK           byte = 0x00
 	iAuthMoreData byte = 0x01
 	iLocalInFile  byte = 0xfb
 	iEOF          byte = 0xfe
 	iERR          byte = 0xff
 )
 // https://dev.mysql.com/doc/internals/en/capability-flags.html#packet-Protocol::CapabilityFlags
 type clientFlag uint32
 const (
 	clientLongPassword clientFlag = 1 << iota
 	clientFoundRows
 	clientLongFlag
 	clientConnectWithDB
 	clientNoSchema
 	clientCompress
 	clientODBC
 	clientLocalFiles
 	clientIgnoreSpace
 	clientProtocol41
 	clientInteractive
 	clientSSL
 	clientIgnoreSIGPIPE
 	clientTransactions
 	clientReserved
 	clientSecureConn
 	clientMultiStatements
 	clientMultiResults
 	clientPSMultiResults
 	clientPluginAuth
 	clientConnectAttrs
 	clientPluginAuthLenEncClientData
 	clientCanHandleExpiredPasswords
 	clientSessionTrack
 	clientDeprecateEOF
 )
 const (
 	comQuit byte = iota + 1
 	comInitDB
 	comQuery
 	comFieldList
 	comCreateDB
 	comDropDB
 	comRefresh
 	comShutdown
 	comStatistics
 	comProcessInfo
 	comConnect
 	comProcessKill
 	comDebug
 	comPing
 	comTime
 	comDelayedInsert
 	comChangeUser
 	comBinlogDump
 	comTableDump
 	comConnectOut
 	comRegisterSlave
 	comStmtPrepare
 	comStmtExecute
 	comStmtSendLongData
 	comStmtClose
 	comStmtReset
 	comSetOption
 	comStmtFetch
 )
 // https://dev.mysql.com/doc/internals/en/com-query-response.html#packet-Protocol::ColumnType
 type fieldType byte
 const (
 	fieldTypeDecimal fieldType = iota
 	fieldTypeTiny
 	fieldTypeShort
 	fieldTypeLong
 	fieldTypeFloat
 	fieldTypeDouble
 	fieldTypeNULL
 	fieldTypeTimestamp
 	fieldTypeLongLong
 	fieldTypeInt24
 	fieldTypeDate
 	fieldTypeTime
 	fieldTypeDateTime
 	fieldTypeYear
 	fieldTypeNewDate
 	fieldTypeVarChar
 	fieldTypeBit
 )
 const (
 	fieldTypeJSON fieldType = iota + 0xf5
 	fieldTypeNewDecimal
 	fieldTypeEnum
 	fieldTypeSet
 	fieldTypeTinyBLOB
 	fieldTypeMediumBLOB
 	fieldTypeLongBLOB
 	fieldTypeBLOB
 	fieldTypeVarString
 	fieldTypeString
 	fieldTypeGeometry
 )
 type fieldFlag uint16
 const (
 	flagNotNULL fieldFlag = 1 << iota
 	flagPriKey
 	flagUniqueKey
 	flagMultipleKey
 	flagBLOB
 	flagUnsigned
 	flagZeroFill
 	flagBinary
 	flagEnum
 	flagAutoIncrement
 	flagTimestamp
 	flagSet
 	flagUnknown1
 	flagUnknown2
 	flagUnknown3
 	flagUnknown4
 )
 // http://dev.mysql.com/doc/internals/en/status-flags.html
 type statusFlag uint16
 const (
 	statusInTrans statusFlag = 1 << iota
 	statusInAutocommit
 	statusReserved // Not in documentation
 	statusMoreResultsExists
 	statusNoGoodIndexUsed
 	statusNoIndexUsed
 	statusCursorExists
 	statusLastRowSent
 	statusDbDropped
 	statusNoBackslashEscapes
 	statusMetadataChanged
 	statusQueryWasSlow
 	statusPsOutParams
 	statusInTransReadonly
 	statusSessionStateChanged
 )
 const (
 	cachingSha2PasswordRequestPublicKey          = 2
 	cachingSha2PasswordFastAuthSuccess           = 3
 	cachingSha2PasswordPerformFullAuthentication = 4
 )
--- a/vendor/github.com/go-sql-driver/mysql/driver.go
+++ b/vendor/github.com/go-sql-driver/mysql/driver.go
@ -1,172 +0,0 @@
 // Copyright 2012 The Go-MySQL-Driver Authors. All rights reserved.
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this file,
 // You can obtain one at http://mozilla.org/MPL/2.0/.
 // Package mysql provides a MySQL driver for Go's database/sql package.
 //
 // The driver should be used via the database/sql package:
 //
 //  import "database/sql"
 //  import _ "github.com/go-sql-driver/mysql"
 //
 //  db, err := sql.Open("mysql", "user:password@/dbname")
 //
 // See https://github.com/go-sql-driver/mysql#usage for details
 package mysql
 import (
 	"database/sql"
 	"database/sql/driver"
 	"net"
 	"sync"
 )
 // watcher interface is used for context support (From Go 1.8)
 type watcher interface {
 	startWatcher()
 }
 // MySQLDriver is exported to make the driver directly accessible.
 // In general the driver is used via the database/sql package.
 type MySQLDriver struct{}
 // DialFunc is a function which can be used to establish the network connection.
 // Custom dial functions must be registered with RegisterDial
 type DialFunc func(addr string) (net.Conn, error)
 var (
 	dialsLock sync.RWMutex
 	dials     map[string]DialFunc
 )
 // RegisterDial registers a custom dial function. It can then be used by the
 // network address mynet(addr), where mynet is the registered new network.
 // addr is passed as a parameter to the dial function.
 func RegisterDial(net string, dial DialFunc) {
 	dialsLock.Lock()
 	defer dialsLock.Unlock()
 	if dials == nil {
 		dials = make(map[string]DialFunc)
 	}
 	dials[net] = dial
 }
 // Open new Connection.
 // See https://github.com/go-sql-driver/mysql#dsn-data-source-name for how
 // the DSN string is formated
 func (d MySQLDriver) Open(dsn string) (driver.Conn, error) {
 	var err error
 	// New mysqlConn
 	mc := &mysqlConn{
 		maxAllowedPacket: maxPacketSize,
 		maxWriteSize:     maxPacketSize - 1,
 		closech:          make(chan struct{}),
 	}
 	mc.cfg, err = ParseDSN(dsn)
 	if err != nil {
 		return nil, err
 	}
 	mc.parseTime = mc.cfg.ParseTime
 	// Connect to Server
 	dialsLock.RLock()
 	dial, ok := dials[mc.cfg.Net]
 	dialsLock.RUnlock()
 	if ok {
 		mc.netConn, err = dial(mc.cfg.Addr)
 	} else {
 		nd := net.Dialer{Timeout: mc.cfg.Timeout}
 		mc.netConn, err = nd.Dial(mc.cfg.Net, mc.cfg.Addr)
 	}
 	if err != nil {
 		return nil, err
 	}
 	// Enable TCP Keepalives on TCP connections
 	if tc, ok := mc.netConn.(*net.TCPConn); ok {
 		if err := tc.SetKeepAlive(true); err != nil {
 			// Don't send COM_QUIT before handshake.
 			mc.netConn.Close()
 			mc.netConn = nil
 			return nil, err
 		}
 	}
 	// Call startWatcher for context support (From Go 1.8)
 	if s, ok := interface{}(mc).(watcher); ok {
 		s.startWatcher()
 	}
 	mc.buf = newBuffer(mc.netConn)
 	// Set I/O timeouts
 	mc.buf.timeout = mc.cfg.ReadTimeout
 	mc.writeTimeout = mc.cfg.WriteTimeout
 	// Reading Handshake Initialization Packet
 	authData, plugin, err := mc.readHandshakePacket()
 	if err != nil {
 		mc.cleanup()
 		return nil, err
 	}
 	if plugin == "" {
 		plugin = defaultAuthPlugin
 	}
 	// Send Client Authentication Packet
 	authResp, err := mc.auth(authData, plugin)
 	if err != nil {
 		// try the default auth plugin, if using the requested plugin failed
 		errLog.Print("could not use requested auth plugin '"+plugin+"': ", err.Error())
 		plugin = defaultAuthPlugin
 		authResp, err = mc.auth(authData, plugin)
 		if err != nil {
 			mc.cleanup()
 			return nil, err
 		}
 	}
 	if err = mc.writeHandshakeResponsePacket(authResp, plugin); err != nil {
 		mc.cleanup()
 		return nil, err
 	}
 	// Handle response to auth packet, switch methods if possible
 	if err = mc.handleAuthResult(authData, plugin); err != nil {
 		// Authentication failed and MySQL has already closed the connection
 		// (https://dev.mysql.com/doc/internals/en/authentication-fails.html).
 		// Do not send COM_QUIT, just cleanup and return the error.
 		mc.cleanup()
 		return nil, err
 	}
 	if mc.cfg.MaxAllowedPacket > 0 {
 		mc.maxAllowedPacket = mc.cfg.MaxAllowedPacket
 	} else {
 		// Get max allowed packet size
 		maxap, err := mc.getSystemVar("max_allowed_packet")
 		if err != nil {
 			mc.Close()
 			return nil, err
 		}
 		mc.maxAllowedPacket = stringToInt(maxap) - 1
 	}
 	if mc.maxAllowedPacket < maxPacketSize {
 		mc.maxWriteSize = mc.maxAllowedPacket
 	}
 	// Handle DSN Params
 	err = mc.handleParams()
 	if err != nil {
 		mc.Close()
 		return nil, err
 	}
 	return mc, nil
 }
 func init() {
 	sql.Register("mysql", &MySQLDriver{})
 }
--- a/vendor/github.com/go-sql-driver/mysql/dsn.go
+++ b/vendor/github.com/go-sql-driver/mysql/dsn.go
@ -1,611 +0,0 @@
 // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
 //
 // Copyright 2016 The Go-MySQL-Driver Authors. All rights reserved.
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this file,
 // You can obtain one at http://mozilla.org/MPL/2.0/.
 package mysql
 import (
 	"bytes"
 	"crypto/rsa"
 	"crypto/tls"
 	"errors"
 	"fmt"
 	"net"
 	"net/url"
 	"sort"
 	"strconv"
 	"strings"
 	"time"
 )
 var (
 	errInvalidDSNUnescaped       = errors.New("invalid DSN: did you forget to escape a param value?")
 	errInvalidDSNAddr            = errors.New("invalid DSN: network address not terminated (missing closing brace)")
 	errInvalidDSNNoSlash         = errors.New("invalid DSN: missing the slash separating the database name")
 	errInvalidDSNUnsafeCollation = errors.New("invalid DSN: interpolateParams can not be used with unsafe collations")
 )
 // Config is a configuration parsed from a DSN string.
 // If a new Config is created instead of being parsed from a DSN string,
 // the NewConfig function should be used, which sets default values.
 type Config struct {
 	User             string            // Username
 	Passwd           string            // Password (requires User)
 	Net              string            // Network type
 	Addr             string            // Network address (requires Net)
 	DBName           string            // Database name
 	Params           map[string]string // Connection parameters
 	Collation        string            // Connection collation
 	Loc              *time.Location    // Location for time.Time values
 	MaxAllowedPacket int               // Max packet size allowed
 	ServerPubKey     string            // Server public key name
 	pubKey           *rsa.PublicKey    // Server public key
 	TLSConfig        string            // TLS configuration name
 	tls              *tls.Config       // TLS configuration
 	Timeout          time.Duration     // Dial timeout
 	ReadTimeout      time.Duration     // I/O read timeout
 	WriteTimeout     time.Duration     // I/O write timeout
 	AllowAllFiles           bool // Allow all files to be used with LOAD DATA LOCAL INFILE
 	AllowCleartextPasswords bool // Allows the cleartext client side plugin
 	AllowNativePasswords    bool // Allows the native password authentication method
 	AllowOldPasswords       bool // Allows the old insecure password method
 	ClientFoundRows         bool // Return number of matching rows instead of rows changed
 	ColumnsWithAlias        bool // Prepend table alias to column names
 	InterpolateParams       bool // Interpolate placeholders into query string
 	MultiStatements         bool // Allow multiple statements in one query
 	ParseTime               bool // Parse time values to time.Time
 	RejectReadOnly          bool // Reject read-only connections
 }
 // NewConfig creates a new Config and sets default values.
 func NewConfig() *Config {
 	return &Config{
 		Collation:            defaultCollation,
 		Loc:                  time.UTC,
 		MaxAllowedPacket:     defaultMaxAllowedPacket,
 		AllowNativePasswords: true,
 	}
 }
 func (cfg *Config) normalize() error {
 	if cfg.InterpolateParams && unsafeCollations[cfg.Collation] {
 		return errInvalidDSNUnsafeCollation
 	}
 	// Set default network if empty
 	if cfg.Net == "" {
 		cfg.Net = "tcp"
 	}
 	// Set default address if empty
 	if cfg.Addr == "" {
 		switch cfg.Net {
 		case "tcp":
 			cfg.Addr = "127.0.0.1:3306"
 		case "unix":
 			cfg.Addr = "/tmp/mysql.sock"
 		default:
 			return errors.New("default addr for network '" + cfg.Net + "' unknown")
 		}
 	} else if cfg.Net == "tcp" {
 		cfg.Addr = ensureHavePort(cfg.Addr)
 	}
 	if cfg.tls != nil {
 		if cfg.tls.ServerName == "" && !cfg.tls.InsecureSkipVerify {
 			host, _, err := net.SplitHostPort(cfg.Addr)
 			if err == nil {
 				cfg.tls.ServerName = host
 			}
 		}
 	}
 	return nil
 }
 // FormatDSN formats the given Config into a DSN string which can be passed to
 // the driver.
 func (cfg *Config) FormatDSN() string {
 	var buf bytes.Buffer
 	// [username[:password]@]
 	if len(cfg.User) > 0 {
 		buf.WriteString(cfg.User)
 		if len(cfg.Passwd) > 0 {
 			buf.WriteByte(':')
 			buf.WriteString(cfg.Passwd)
 		}
 		buf.WriteByte('@')
 	}
 	// [protocol[(address)]]
 	if len(cfg.Net) > 0 {
 		buf.WriteString(cfg.Net)
 		if len(cfg.Addr) > 0 {
 			buf.WriteByte('(')
 			buf.WriteString(cfg.Addr)
 			buf.WriteByte(')')
 		}
 	}
 	// /dbname
 	buf.WriteByte('/')
 	buf.WriteString(cfg.DBName)
 	// [?param1=value1&...&paramN=valueN]
 	hasParam := false
 	if cfg.AllowAllFiles {
 		hasParam = true
 		buf.WriteString("?allowAllFiles=true")
 	}
 	if cfg.AllowCleartextPasswords {
 		if hasParam {
 			buf.WriteString("&allowCleartextPasswords=true")
 		} else {
 			hasParam = true
 			buf.WriteString("?allowCleartextPasswords=true")
 		}
 	}
 	if !cfg.AllowNativePasswords {
 		if hasParam {
 			buf.WriteString("&allowNativePasswords=false")
 		} else {
 			hasParam = true
 			buf.WriteString("?allowNativePasswords=false")
 		}
 	}
 	if cfg.AllowOldPasswords {
 		if hasParam {
 			buf.WriteString("&allowOldPasswords=true")
 		} else {
 			hasParam = true
 			buf.WriteString("?allowOldPasswords=true")
 		}
 	}
 	if cfg.ClientFoundRows {
 		if hasParam {
 			buf.WriteString("&clientFoundRows=true")
 		} else {
 			hasParam = true
 			buf.WriteString("?clientFoundRows=true")
 		}
 	}
 	if col := cfg.Collation; col != defaultCollation && len(col) > 0 {
 		if hasParam {
 			buf.WriteString("&collation=")
 		} else {
 			hasParam = true
 			buf.WriteString("?collation=")
 		}
 		buf.WriteString(col)
 	}
 	if cfg.ColumnsWithAlias {
 		if hasParam {
 			buf.WriteString("&columnsWithAlias=true")
 		} else {
 			hasParam = true
 			buf.WriteString("?columnsWithAlias=true")
 		}
 	}
 	if cfg.InterpolateParams {
 		if hasParam {
 			buf.WriteString("&interpolateParams=true")
 		} else {
 			hasParam = true
 			buf.WriteString("?interpolateParams=true")
 		}
 	}
 	if cfg.Loc != time.UTC && cfg.Loc != nil {
 		if hasParam {
 			buf.WriteString("&loc=")
 		} else {
 			hasParam = true
 			buf.WriteString("?loc=")
 		}
 		buf.WriteString(url.QueryEscape(cfg.Loc.String()))
 	}
 	if cfg.MultiStatements {
 		if hasParam {
 			buf.WriteString("&multiStatements=true")
 		} else {
 			hasParam = true
 			buf.WriteString("?multiStatements=true")
 		}
 	}
 	if cfg.ParseTime {
 		if hasParam {
 			buf.WriteString("&parseTime=true")
 		} else {
 			hasParam = true
 			buf.WriteString("?parseTime=true")
 		}
 	}
 	if cfg.ReadTimeout > 0 {
 		if hasParam {
 			buf.WriteString("&readTimeout=")
 		} else {
 			hasParam = true
 			buf.WriteString("?readTimeout=")
 		}
 		buf.WriteString(cfg.ReadTimeout.String())
 	}
 	if cfg.RejectReadOnly {
 		if hasParam {
 			buf.WriteString("&rejectReadOnly=true")
 		} else {
 			hasParam = true
 			buf.WriteString("?rejectReadOnly=true")
 		}
 	}
 	if len(cfg.ServerPubKey) > 0 {
 		if hasParam {
 			buf.WriteString("&serverPubKey=")
 		} else {
 			hasParam = true
 			buf.WriteString("?serverPubKey=")
 		}
 		buf.WriteString(url.QueryEscape(cfg.ServerPubKey))
 	}
 	if cfg.Timeout > 0 {
 		if hasParam {
 			buf.WriteString("&timeout=")
 		} else {
 			hasParam = true
 			buf.WriteString("?timeout=")
 		}
 		buf.WriteString(cfg.Timeout.String())
 	}
 	if len(cfg.TLSConfig) > 0 {
 		if hasParam {
 			buf.WriteString("&tls=")
 		} else {
 			hasParam = true
 			buf.WriteString("?tls=")
 		}
 		buf.WriteString(url.QueryEscape(cfg.TLSConfig))
 	}
 	if cfg.WriteTimeout > 0 {
 		if hasParam {
 			buf.WriteString("&writeTimeout=")
 		} else {
 			hasParam = true
 			buf.WriteString("?writeTimeout=")
 		}
 		buf.WriteString(cfg.WriteTimeout.String())
 	}
 	if cfg.MaxAllowedPacket != defaultMaxAllowedPacket {
 		if hasParam {
 			buf.WriteString("&maxAllowedPacket=")
 		} else {
 			hasParam = true
 			buf.WriteString("?maxAllowedPacket=")
 		}
 		buf.WriteString(strconv.Itoa(cfg.MaxAllowedPacket))
 	}
 	// other params
 	if cfg.Params != nil {
 		var params []string
 		for param := range cfg.Params {
 			params = append(params, param)
 		}
 		sort.Strings(params)
 		for _, param := range params {
 			if hasParam {
 				buf.WriteByte('&')
 			} else {
 				hasParam = true
 				buf.WriteByte('?')
 			}
 			buf.WriteString(param)
 			buf.WriteByte('=')
 			buf.WriteString(url.QueryEscape(cfg.Params[param]))
 		}
 	}
 	return buf.String()
 }
 // ParseDSN parses the DSN string to a Config
 func ParseDSN(dsn string) (cfg *Config, err error) {
 	// New config with some default values
 	cfg = NewConfig()
 	// [user[:password]@][net[(addr)]]/dbname[?param1=value1&paramN=valueN]
 	// Find the last '/' (since the password or the net addr might contain a '/')
 	foundSlash := false
 	for i := len(dsn) - 1; i >= 0; i-- {
 		if dsn[i] == '/' {
 			foundSlash = true
 			var j, k int
 			// left part is empty if i <= 0
 			if i > 0 {
 				// [username[:password]@][protocol[(address)]]
 				// Find the last '@' in dsn[:i]
 				for j = i; j >= 0; j-- {
 					if dsn[j] == '@' {
 						// username[:password]
 						// Find the first ':' in dsn[:j]
 						for k = 0; k < j; k++ {
 							if dsn[k] == ':' {
 								cfg.Passwd = dsn[k+1 : j]
 								break
 							}
 						}
 						cfg.User = dsn[:k]
 						break
 					}
 				}
 				// [protocol[(address)]]
 				// Find the first '(' in dsn[j+1:i]
 				for k = j + 1; k < i; k++ {
 					if dsn[k] == '(' {
 						// dsn[i-1] must be == ')' if an address is specified
 						if dsn[i-1] != ')' {
 							if strings.ContainsRune(dsn[k+1:i], ')') {
 								return nil, errInvalidDSNUnescaped
 							}
 							return nil, errInvalidDSNAddr
 						}
 						cfg.Addr = dsn[k+1 : i-1]
 						break
 					}
 				}
 				cfg.Net = dsn[j+1 : k]
 			}
 			// dbname[?param1=value1&...&paramN=valueN]
 			// Find the first '?' in dsn[i+1:]
 			for j = i + 1; j < len(dsn); j++ {
 				if dsn[j] == '?' {
 					if err = parseDSNParams(cfg, dsn[j+1:]); err != nil {
 						return
 					}
 					break
 				}
 			}
 			cfg.DBName = dsn[i+1 : j]
 			break
 		}
 	}
 	if !foundSlash && len(dsn) > 0 {
 		return nil, errInvalidDSNNoSlash
 	}
 	if err = cfg.normalize(); err != nil {
 		return nil, err
 	}
 	return
 }
 // parseDSNParams parses the DSN "query string"
 // Values must be url.QueryEscape'ed
 func parseDSNParams(cfg *Config, params string) (err error) {
 	for _, v := range strings.Split(params, "&") {
 		param := strings.SplitN(v, "=", 2)
 		if len(param) != 2 {
 			continue
 		}
 		// cfg params
 		switch value := param[1]; param[0] {
 		// Disable INFILE whitelist / enable all files
 		case "allowAllFiles":
 			var isBool bool
 			cfg.AllowAllFiles, isBool = readBool(value)
 			if !isBool {
 				return errors.New("invalid bool value: " + value)
 			}
 		// Use cleartext authentication mode (MySQL 5.5.10+)
 		case "allowCleartextPasswords":
 			var isBool bool
 			cfg.AllowCleartextPasswords, isBool = readBool(value)
 			if !isBool {
 				return errors.New("invalid bool value: " + value)
 			}
 		// Use native password authentication
 		case "allowNativePasswords":
 			var isBool bool
 			cfg.AllowNativePasswords, isBool = readBool(value)
 			if !isBool {
 				return errors.New("invalid bool value: " + value)
 			}
 		// Use old authentication mode (pre MySQL 4.1)
 		case "allowOldPasswords":
 			var isBool bool
 			cfg.AllowOldPasswords, isBool = readBool(value)
 			if !isBool {
 				return errors.New("invalid bool value: " + value)
 			}
 		// Switch "rowsAffected" mode
 		case "clientFoundRows":
 			var isBool bool
 			cfg.ClientFoundRows, isBool = readBool(value)
 			if !isBool {
 				return errors.New("invalid bool value: " + value)
 			}
 		// Collation
 		case "collation":
 			cfg.Collation = value
 			break
 		case "columnsWithAlias":
 			var isBool bool
 			cfg.ColumnsWithAlias, isBool = readBool(value)
 			if !isBool {
 				return errors.New("invalid bool value: " + value)
 			}
 		// Compression
 		case "compress":
 			return errors.New("compression not implemented yet")
 		// Enable client side placeholder substitution
 		case "interpolateParams":
 			var isBool bool
 			cfg.InterpolateParams, isBool = readBool(value)
 			if !isBool {
 				return errors.New("invalid bool value: " + value)
 			}
 		// Time Location
 		case "loc":
 			if value, err = url.QueryUnescape(value); err != nil {
 				return
 			}
 			cfg.Loc, err = time.LoadLocation(value)
 			if err != nil {
 				return
 			}
 		// multiple statements in one query
 		case "multiStatements":
 			var isBool bool
 			cfg.MultiStatements, isBool = readBool(value)
 			if !isBool {
 				return errors.New("invalid bool value: " + value)
 			}
 		// time.Time parsing
 		case "parseTime":
 			var isBool bool
 			cfg.ParseTime, isBool = readBool(value)
 			if !isBool {
 				return errors.New("invalid bool value: " + value)
 			}
 		// I/O read Timeout
 		case "readTimeout":
 			cfg.ReadTimeout, err = time.ParseDuration(value)
 			if err != nil {
 				return
 			}
 		// Reject read-only connections
 		case "rejectReadOnly":
 			var isBool bool
 			cfg.RejectReadOnly, isBool = readBool(value)
 			if !isBool {
 				return errors.New("invalid bool value: " + value)
 			}
 		// Server public key
 		case "serverPubKey":
 			name, err := url.QueryUnescape(value)
 			if err != nil {
 				return fmt.Errorf("invalid value for server pub key name: %v", err)
 			}
 			if pubKey := getServerPubKey(name); pubKey != nil {
 				cfg.ServerPubKey = name
 				cfg.pubKey = pubKey
 			} else {
 				return errors.New("invalid value / unknown server pub key name: " + name)
 			}
 		// Strict mode
 		case "strict":
 			panic("strict mode has been removed. See https://github.com/go-sql-driver/mysql/wiki/strict-mode")
 		// Dial Timeout
 		case "timeout":
 			cfg.Timeout, err = time.ParseDuration(value)
 			if err != nil {
 				return
 			}
 		// TLS-Encryption
 		case "tls":
 			boolValue, isBool := readBool(value)
 			if isBool {
 				if boolValue {
 					cfg.TLSConfig = "true"
 					cfg.tls = &tls.Config{}
 				} else {
 					cfg.TLSConfig = "false"
 				}
 			} else if vl := strings.ToLower(value); vl == "skip-verify" {
 				cfg.TLSConfig = vl
 				cfg.tls = &tls.Config{InsecureSkipVerify: true}
 			} else {
 				name, err := url.QueryUnescape(value)
 				if err != nil {
 					return fmt.Errorf("invalid value for TLS config name: %v", err)
 				}
 				if tlsConfig := getTLSConfigClone(name); tlsConfig != nil {
 					cfg.TLSConfig = name
 					cfg.tls = tlsConfig
 				} else {
 					return errors.New("invalid value / unknown config name: " + name)
 				}
 			}
 		// I/O write Timeout
 		case "writeTimeout":
 			cfg.WriteTimeout, err = time.ParseDuration(value)
 			if err != nil {
 				return
 			}
 		case "maxAllowedPacket":
 			cfg.MaxAllowedPacket, err = strconv.Atoi(value)
 			if err != nil {
 				return
 			}
 		default:
 			// lazy init
 			if cfg.Params == nil {
 				cfg.Params = make(map[string]string)
 			}
 			if cfg.Params[param[0]], err = url.QueryUnescape(value); err != nil {
 				return
 			}
 		}
 	}
 	return
 }
 func ensureHavePort(addr string) string {
 	if _, _, err := net.SplitHostPort(addr); err != nil {
 		return net.JoinHostPort(addr, "3306")
 	}
 	return addr
 }
--- a/vendor/github.com/go-sql-driver/mysql/errors.go
+++ b/vendor/github.com/go-sql-driver/mysql/errors.go
@ -1,65 +0,0 @@
 // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
 //
 // Copyright 2013 The Go-MySQL-Driver Authors. All rights reserved.
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this file,
 // You can obtain one at http://mozilla.org/MPL/2.0/.
 package mysql
 import (
 	"errors"
 	"fmt"
 	"log"
 	"os"
 )
 // Various errors the driver might return. Can change between driver versions.
 var (
 	ErrInvalidConn       = errors.New("invalid connection")
 	ErrMalformPkt        = errors.New("malformed packet")
 	ErrNoTLS             = errors.New("TLS requested but server does not support TLS")
 	ErrCleartextPassword = errors.New("this user requires clear text authentication. If you still want to use it, please add 'allowCleartextPasswords=1' to your DSN")
 	ErrNativePassword    = errors.New("this user requires mysql native password authentication.")
 	ErrOldPassword       = errors.New("this user requires old password authentication. If you still want to use it, please add 'allowOldPasswords=1' to your DSN. See also https://github.com/go-sql-driver/mysql/wiki/old_passwords")
 	ErrUnknownPlugin     = errors.New("this authentication plugin is not supported")
 	ErrOldProtocol       = errors.New("MySQL server does not support required protocol 41+")
 	ErrPktSync           = errors.New("commands out of sync. You can't run this command now")
 	ErrPktSyncMul        = errors.New("commands out of sync. Did you run multiple statements at once?")
 	ErrPktTooLarge       = errors.New("packet for query is too large. Try adjusting the 'max_allowed_packet' variable on the server")
 	ErrBusyBuffer        = errors.New("busy buffer")
 	// errBadConnNoWrite is used for connection errors where nothing was sent to the database yet.
 	// If this happens first in a function starting a database interaction, it should be replaced by driver.ErrBadConn
 	// to trigger a resend.
 	// See https://github.com/go-sql-driver/mysql/pull/302
 	errBadConnNoWrite = errors.New("bad connection")
 )
 var errLog = Logger(log.New(os.Stderr, "[mysql] ", log.Ldate|log.Ltime|log.Lshortfile))
 // Logger is used to log critical error messages.
 type Logger interface {
 	Print(v ...interface{})
 }
 // SetLogger is used to set the logger for critical errors.
 // The initial logger is os.Stderr.
 func SetLogger(logger Logger) error {
 	if logger == nil {
 		return errors.New("logger is nil")
 	}
 	errLog = logger
 	return nil
 }
 // MySQLError is an error type which represents a single MySQL error
 type MySQLError struct {
 	Number  uint16
 	Message string
 }
 func (me *MySQLError) Error() string {
 	return fmt.Sprintf("Error %d: %s", me.Number, me.Message)
 }
--- a/vendor/github.com/go-sql-driver/mysql/fields.go
+++ b/vendor/github.com/go-sql-driver/mysql/fields.go
@ -1,194 +0,0 @@
 // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
 //
 // Copyright 2017 The Go-MySQL-Driver Authors. All rights reserved.
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this file,
 // You can obtain one at http://mozilla.org/MPL/2.0/.
 package mysql
 import (
 	"database/sql"
 	"reflect"
 )
 func (mf *mysqlField) typeDatabaseName() string {
 	switch mf.fieldType {
 	case fieldTypeBit:
 		return "BIT"
 	case fieldTypeBLOB:
 		if mf.charSet != collations[binaryCollation] {
 			return "TEXT"
 		}
 		return "BLOB"
 	case fieldTypeDate:
 		return "DATE"
 	case fieldTypeDateTime:
 		return "DATETIME"
 	case fieldTypeDecimal:
 		return "DECIMAL"
 	case fieldTypeDouble:
 		return "DOUBLE"
 	case fieldTypeEnum:
 		return "ENUM"
 	case fieldTypeFloat:
 		return "FLOAT"
 	case fieldTypeGeometry:
 		return "GEOMETRY"
 	case fieldTypeInt24:
 		return "MEDIUMINT"
 	case fieldTypeJSON:
 		return "JSON"
 	case fieldTypeLong:
 		return "INT"
 	case fieldTypeLongBLOB:
 		if mf.charSet != collations[binaryCollation] {
 			return "LONGTEXT"
 		}
 		return "LONGBLOB"
 	case fieldTypeLongLong:
 		return "BIGINT"
 	case fieldTypeMediumBLOB:
 		if mf.charSet != collations[binaryCollation] {
 			return "MEDIUMTEXT"
 		}
 		return "MEDIUMBLOB"
 	case fieldTypeNewDate:
 		return "DATE"
 	case fieldTypeNewDecimal:
 		return "DECIMAL"
 	case fieldTypeNULL:
 		return "NULL"
 	case fieldTypeSet:
 		return "SET"
 	case fieldTypeShort:
 		return "SMALLINT"
 	case fieldTypeString:
 		if mf.charSet == collations[binaryCollation] {
 			return "BINARY"
 		}
 		return "CHAR"
 	case fieldTypeTime:
 		return "TIME"
 	case fieldTypeTimestamp:
 		return "TIMESTAMP"
 	case fieldTypeTiny:
 		return "TINYINT"
 	case fieldTypeTinyBLOB:
 		if mf.charSet != collations[binaryCollation] {
 			return "TINYTEXT"
 		}
 		return "TINYBLOB"
 	case fieldTypeVarChar:
 		if mf.charSet == collations[binaryCollation] {
 			return "VARBINARY"
 		}
 		return "VARCHAR"
 	case fieldTypeVarString:
 		if mf.charSet == collations[binaryCollation] {
 			return "VARBINARY"
 		}
 		return "VARCHAR"
 	case fieldTypeYear:
 		return "YEAR"
 	default:
 		return ""
 	}
 }
 var (
 	scanTypeFloat32   = reflect.TypeOf(float32(0))
 	scanTypeFloat64   = reflect.TypeOf(float64(0))
 	scanTypeInt8      = reflect.TypeOf(int8(0))
 	scanTypeInt16     = reflect.TypeOf(int16(0))
 	scanTypeInt32     = reflect.TypeOf(int32(0))
 	scanTypeInt64     = reflect.TypeOf(int64(0))
 	scanTypeNullFloat = reflect.TypeOf(sql.NullFloat64{})
 	scanTypeNullInt   = reflect.TypeOf(sql.NullInt64{})
 	scanTypeNullTime  = reflect.TypeOf(NullTime{})
 	scanTypeUint8     = reflect.TypeOf(uint8(0))
 	scanTypeUint16    = reflect.TypeOf(uint16(0))
 	scanTypeUint32    = reflect.TypeOf(uint32(0))
 	scanTypeUint64    = reflect.TypeOf(uint64(0))
 	scanTypeRawBytes  = reflect.TypeOf(sql.RawBytes{})
 	scanTypeUnknown   = reflect.TypeOf(new(interface{}))
 )
 type mysqlField struct {
 	tableName string
 	name      string
 	length    uint32
 	flags     fieldFlag
 	fieldType fieldType
 	decimals  byte
 	charSet   uint8
 }
 func (mf *mysqlField) scanType() reflect.Type {
 	switch mf.fieldType {
 	case fieldTypeTiny:
 		if mf.flags&flagNotNULL != 0 {
 			if mf.flags&flagUnsigned != 0 {
 				return scanTypeUint8
 			}
 			return scanTypeInt8
 		}
 		return scanTypeNullInt
 	case fieldTypeShort, fieldTypeYear:
 		if mf.flags&flagNotNULL != 0 {
 			if mf.flags&flagUnsigned != 0 {
 				return scanTypeUint16
 			}
 			return scanTypeInt16
 		}
 		return scanTypeNullInt
 	case fieldTypeInt24, fieldTypeLong:
 		if mf.flags&flagNotNULL != 0 {
 			if mf.flags&flagUnsigned != 0 {
 				return scanTypeUint32
 			}
 			return scanTypeInt32
 		}
 		return scanTypeNullInt
 	case fieldTypeLongLong:
 		if mf.flags&flagNotNULL != 0 {
 			if mf.flags&flagUnsigned != 0 {
 				return scanTypeUint64
 			}
 			return scanTypeInt64
 		}
 		return scanTypeNullInt
 	case fieldTypeFloat:
 		if mf.flags&flagNotNULL != 0 {
 			return scanTypeFloat32
 		}
 		return scanTypeNullFloat
 	case fieldTypeDouble:
 		if mf.flags&flagNotNULL != 0 {
 			return scanTypeFloat64
 		}
 		return scanTypeNullFloat
 	case fieldTypeDecimal, fieldTypeNewDecimal, fieldTypeVarChar,
 		fieldTypeBit, fieldTypeEnum, fieldTypeSet, fieldTypeTinyBLOB,
 		fieldTypeMediumBLOB, fieldTypeLongBLOB, fieldTypeBLOB,
 		fieldTypeVarString, fieldTypeString, fieldTypeGeometry, fieldTypeJSON,
 		fieldTypeTime:
 		return scanTypeRawBytes
 	case fieldTypeDate, fieldTypeNewDate,
 		fieldTypeTimestamp, fieldTypeDateTime:
 		// NullTime is always returned for more consistent behavior as it can
 		// handle both cases of parseTime regardless if the field is nullable.
 		return scanTypeNullTime
 	default:
 		return scanTypeUnknown
 	}
 }
--- a/vendor/github.com/go-sql-driver/mysql/infile.go
+++ b/vendor/github.com/go-sql-driver/mysql/infile.go
@ -1,182 +0,0 @@
 // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
 //
 // Copyright 2013 The Go-MySQL-Driver Authors. All rights reserved.
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this file,
 // You can obtain one at http://mozilla.org/MPL/2.0/.
 package mysql
 import (
 	"fmt"
 	"io"
 	"os"
 	"strings"
 	"sync"
 )
 var (
 	fileRegister       map[string]bool
 	fileRegisterLock   sync.RWMutex
 	readerRegister     map[string]func() io.Reader
 	readerRegisterLock sync.RWMutex
 )
 // RegisterLocalFile adds the given file to the file whitelist,
 // so that it can be used by "LOAD DATA LOCAL INFILE <filepath>".
 // Alternatively you can allow the use of all local files with
 // the DSN parameter 'allowAllFiles=true'
 //
 //  filePath := "/home/gopher/data.csv"
 //  mysql.RegisterLocalFile(filePath)
 //  err := db.Exec("LOAD DATA LOCAL INFILE '" + filePath + "' INTO TABLE foo")
 //  if err != nil {
 //  ...
 //
 func RegisterLocalFile(filePath string) {
 	fileRegisterLock.Lock()
 	// lazy map init
 	if fileRegister == nil {
 		fileRegister = make(map[string]bool)
 	}
 	fileRegister[strings.Trim(filePath, `"`)] = true
 	fileRegisterLock.Unlock()
 }
 // DeregisterLocalFile removes the given filepath from the whitelist.
 func DeregisterLocalFile(filePath string) {
 	fileRegisterLock.Lock()
 	delete(fileRegister, strings.Trim(filePath, `"`))
 	fileRegisterLock.Unlock()
 }
 // RegisterReaderHandler registers a handler function which is used
 // to receive a io.Reader.
 // The Reader can be used by "LOAD DATA LOCAL INFILE Reader::<name>".
 // If the handler returns a io.ReadCloser Close() is called when the
 // request is finished.
 //
 //  mysql.RegisterReaderHandler("data", func() io.Reader {
 //  	var csvReader io.Reader // Some Reader that returns CSV data
 //  	... // Open Reader here
 //  	return csvReader
 //  })
 //  err := db.Exec("LOAD DATA LOCAL INFILE 'Reader::data' INTO TABLE foo")
 //  if err != nil {
 //  ...
 //
 func RegisterReaderHandler(name string, handler func() io.Reader) {
 	readerRegisterLock.Lock()
 	// lazy map init
 	if readerRegister == nil {
 		readerRegister = make(map[string]func() io.Reader)
 	}
 	readerRegister[name] = handler
 	readerRegisterLock.Unlock()
 }
 // DeregisterReaderHandler removes the ReaderHandler function with
 // the given name from the registry.
 func DeregisterReaderHandler(name string) {
 	readerRegisterLock.Lock()
 	delete(readerRegister, name)
 	readerRegisterLock.Unlock()
 }
 func deferredClose(err *error, closer io.Closer) {
 	closeErr := closer.Close()
 	if *err == nil {
 		*err = closeErr
 	}
 }
 func (mc *mysqlConn) handleInFileRequest(name string) (err error) {
 	var rdr io.Reader
 	var data []byte
 	packetSize := 16 * 1024 // 16KB is small enough for disk readahead and large enough for TCP
 	if mc.maxWriteSize < packetSize {
 		packetSize = mc.maxWriteSize
 	}
 	if idx := strings.Index(name, "Reader::"); idx == 0 || (idx > 0 && name[idx-1] == '/') { // io.Reader
 		// The server might return an an absolute path. See issue #355.
 		name = name[idx+8:]
 		readerRegisterLock.RLock()
 		handler, inMap := readerRegister[name]
 		readerRegisterLock.RUnlock()
 		if inMap {
 			rdr = handler()
 			if rdr != nil {
 				if cl, ok := rdr.(io.Closer); ok {
 					defer deferredClose(&err, cl)
 				}
 			} else {
 				err = fmt.Errorf("Reader '%s' is <nil>", name)
 			}
 		} else {
 			err = fmt.Errorf("Reader '%s' is not registered", name)
 		}
 	} else { // File
 		name = strings.Trim(name, `"`)
 		fileRegisterLock.RLock()
 		fr := fileRegister[name]
 		fileRegisterLock.RUnlock()
 		if mc.cfg.AllowAllFiles || fr {
 			var file *os.File
 			var fi os.FileInfo
 			if file, err = os.Open(name); err == nil {
 				defer deferredClose(&err, file)
 				// get file size
 				if fi, err = file.Stat(); err == nil {
 					rdr = file
 					if fileSize := int(fi.Size()); fileSize < packetSize {
 						packetSize = fileSize
 					}
 				}
 			}
 		} else {
 			err = fmt.Errorf("local file '%s' is not registered", name)
 		}
 	}
 	// send content packets
 	// if packetSize == 0, the Reader contains no data
 	if err == nil && packetSize > 0 {
 		data := make([]byte, 4+packetSize)
 		var n int
 		for err == nil {
 			n, err = rdr.Read(data[4:])
 			if n > 0 {
 				if ioErr := mc.writePacket(data[:4+n]); ioErr != nil {
 					return ioErr
 				}
 			}
 		}
 		if err == io.EOF {
 			err = nil
 		}
 	}
 	// send empty packet (termination)
 	if data == nil {
 		data = make([]byte, 4)
 	}
 	if ioErr := mc.writePacket(data[:4]); ioErr != nil {
 		return ioErr
 	}
 	// read OK packet
 	if err == nil {
 		return mc.readResultOK()
 	}
 	mc.readPacket()
 	return err
 }
--- a/vendor/github.com/go-sql-driver/mysql/packets.go
+++ b/vendor/github.com/go-sql-driver/mysql/packets.go
--- a/vendor/github.com/go-sql-driver/mysql/result.go
+++ b/vendor/github.com/go-sql-driver/mysql/result.go
@ -1,22 +0,0 @@
 // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
 //
 // Copyright 2012 The Go-MySQL-Driver Authors. All rights reserved.
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this file,
 // You can obtain one at http://mozilla.org/MPL/2.0/.
 package mysql
 type mysqlResult struct {
 	affectedRows int64
 	insertId     int64
 }
 func (res *mysqlResult) LastInsertId() (int64, error) {
 	return res.insertId, nil
 }
 func (res *mysqlResult) RowsAffected() (int64, error) {
 	return res.affectedRows, nil
 }
--- a/vendor/github.com/go-sql-driver/mysql/rows.go
+++ b/vendor/github.com/go-sql-driver/mysql/rows.go
@ -1,216 +0,0 @@
 // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
 //
 // Copyright 2012 The Go-MySQL-Driver Authors. All rights reserved.
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this file,
 // You can obtain one at http://mozilla.org/MPL/2.0/.
 package mysql
 import (
 	"database/sql/driver"
 	"io"
 	"math"
 	"reflect"
 )
 type resultSet struct {
 	columns     []mysqlField
 	columnNames []string
 	done        bool
 }
 type mysqlRows struct {
 	mc     *mysqlConn
 	rs     resultSet
 	finish func()
 }
 type binaryRows struct {
 	mysqlRows
 }
 type textRows struct {
 	mysqlRows
 }
 func (rows *mysqlRows) Columns() []string {
 	if rows.rs.columnNames != nil {
 		return rows.rs.columnNames
 	}
 	columns := make([]string, len(rows.rs.columns))
 	if rows.mc != nil && rows.mc.cfg.ColumnsWithAlias {
 		for i := range columns {
 			if tableName := rows.rs.columns[i].tableName; len(tableName) > 0 {
 				columns[i] = tableName + "." + rows.rs.columns[i].name
 			} else {
 				columns[i] = rows.rs.columns[i].name
 			}
 		}
 	} else {
 		for i := range columns {
 			columns[i] = rows.rs.columns[i].name
 		}
 	}
 	rows.rs.columnNames = columns
 	return columns
 }
 func (rows *mysqlRows) ColumnTypeDatabaseTypeName(i int) string {
 	return rows.rs.columns[i].typeDatabaseName()
 }
 // func (rows *mysqlRows) ColumnTypeLength(i int) (length int64, ok bool) {
 // 	return int64(rows.rs.columns[i].length), true
 // }
 func (rows *mysqlRows) ColumnTypeNullable(i int) (nullable, ok bool) {
 	return rows.rs.columns[i].flags&flagNotNULL == 0, true
 }
 func (rows *mysqlRows) ColumnTypePrecisionScale(i int) (int64, int64, bool) {
 	column := rows.rs.columns[i]
 	decimals := int64(column.decimals)
 	switch column.fieldType {
 	case fieldTypeDecimal, fieldTypeNewDecimal:
 		if decimals > 0 {
 			return int64(column.length) - 2, decimals, true
 		}
 		return int64(column.length) - 1, decimals, true
 	case fieldTypeTimestamp, fieldTypeDateTime, fieldTypeTime:
 		return decimals, decimals, true
 	case fieldTypeFloat, fieldTypeDouble:
 		if decimals == 0x1f {
 			return math.MaxInt64, math.MaxInt64, true
 		}
 		return math.MaxInt64, decimals, true
 	}
 	return 0, 0, false
 }
 func (rows *mysqlRows) ColumnTypeScanType(i int) reflect.Type {
 	return rows.rs.columns[i].scanType()
 }
 func (rows *mysqlRows) Close() (err error) {
 	if f := rows.finish; f != nil {
 		f()
 		rows.finish = nil
 	}
 	mc := rows.mc
 	if mc == nil {
 		return nil
 	}
 	if err := mc.error(); err != nil {
 		return err
 	}
 	// Remove unread packets from stream
 	if !rows.rs.done {
 		err = mc.readUntilEOF()
 	}
 	if err == nil {
 		if err = mc.discardResults(); err != nil {
 			return err
 		}
 	}
 	rows.mc = nil
 	return err
 }
 func (rows *mysqlRows) HasNextResultSet() (b bool) {
 	if rows.mc == nil {
 		return false
 	}
 	return rows.mc.status&statusMoreResultsExists != 0
 }
 func (rows *mysqlRows) nextResultSet() (int, error) {
 	if rows.mc == nil {
 		return 0, io.EOF
 	}
 	if err := rows.mc.error(); err != nil {
 		return 0, err
 	}
 	// Remove unread packets from stream
 	if !rows.rs.done {
 		if err := rows.mc.readUntilEOF(); err != nil {
 			return 0, err
 		}
 		rows.rs.done = true
 	}
 	if !rows.HasNextResultSet() {
 		rows.mc = nil
 		return 0, io.EOF
 	}
 	rows.rs = resultSet{}
 	return rows.mc.readResultSetHeaderPacket()
 }
 func (rows *mysqlRows) nextNotEmptyResultSet() (int, error) {
 	for {
 		resLen, err := rows.nextResultSet()
 		if err != nil {
 			return 0, err
 		}
 		if resLen > 0 {
 			return resLen, nil
 		}
 		rows.rs.done = true
 	}
 }
 func (rows *binaryRows) NextResultSet() error {
 	resLen, err := rows.nextNotEmptyResultSet()
 	if err != nil {
 		return err
 	}
 	rows.rs.columns, err = rows.mc.readColumns(resLen)
 	return err
 }
 func (rows *binaryRows) Next(dest []driver.Value) error {
 	if mc := rows.mc; mc != nil {
 		if err := mc.error(); err != nil {
 			return err
 		}
 		// Fetch next row from stream
 		return rows.readRow(dest)
 	}
 	return io.EOF
 }
 func (rows *textRows) NextResultSet() (err error) {
 	resLen, err := rows.nextNotEmptyResultSet()
 	if err != nil {
 		return err
 	}
 	rows.rs.columns, err = rows.mc.readColumns(resLen)
 	return err
 }
 func (rows *textRows) Next(dest []driver.Value) error {
 	if mc := rows.mc; mc != nil {
 		if err := mc.error(); err != nil {
 			return err
 		}
 		// Fetch next row from stream
 		return rows.readRow(dest)
 	}
 	return io.EOF
 }
--- a/vendor/github.com/go-sql-driver/mysql/statement.go
+++ b/vendor/github.com/go-sql-driver/mysql/statement.go
@ -1,211 +0,0 @@
 // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
 //
 // Copyright 2012 The Go-MySQL-Driver Authors. All rights reserved.
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this file,
 // You can obtain one at http://mozilla.org/MPL/2.0/.
 package mysql
 import (
 	"database/sql/driver"
 	"fmt"
 	"io"
 	"reflect"
 	"strconv"
 )
 type mysqlStmt struct {
 	mc         *mysqlConn
 	id         uint32
 	paramCount int
 }
 func (stmt *mysqlStmt) Close() error {
 	if stmt.mc == nil || stmt.mc.closed.IsSet() {
 		// driver.Stmt.Close can be called more than once, thus this function
 		// has to be idempotent.
 		// See also Issue #450 and golang/go#16019.
 		//errLog.Print(ErrInvalidConn)
 		return driver.ErrBadConn
 	}
 	err := stmt.mc.writeCommandPacketUint32(comStmtClose, stmt.id)
 	stmt.mc = nil
 	return err
 }
 func (stmt *mysqlStmt) NumInput() int {
 	return stmt.paramCount
 }
 func (stmt *mysqlStmt) ColumnConverter(idx int) driver.ValueConverter {
 	return converter{}
 }
 func (stmt *mysqlStmt) Exec(args []driver.Value) (driver.Result, error) {
 	if stmt.mc.closed.IsSet() {
 		errLog.Print(ErrInvalidConn)
 		return nil, driver.ErrBadConn
 	}
 	// Send command
 	err := stmt.writeExecutePacket(args)
 	if err != nil {
 		return nil, stmt.mc.markBadConn(err)
 	}
 	mc := stmt.mc
 	mc.affectedRows = 0
 	mc.insertId = 0
 	// Read Result
 	resLen, err := mc.readResultSetHeaderPacket()
 	if err != nil {
 		return nil, err
 	}
 	if resLen > 0 {
 		// Columns
 		if err = mc.readUntilEOF(); err != nil {
 			return nil, err
 		}
 		// Rows
 		if err := mc.readUntilEOF(); err != nil {
 			return nil, err
 		}
 	}
 	if err := mc.discardResults(); err != nil {
 		return nil, err
 	}
 	return &mysqlResult{
 		affectedRows: int64(mc.affectedRows),
 		insertId:     int64(mc.insertId),
 	}, nil
 }
 func (stmt *mysqlStmt) Query(args []driver.Value) (driver.Rows, error) {
 	return stmt.query(args)
 }
 func (stmt *mysqlStmt) query(args []driver.Value) (*binaryRows, error) {
 	if stmt.mc.closed.IsSet() {
 		errLog.Print(ErrInvalidConn)
 		return nil, driver.ErrBadConn
 	}
 	// Send command
 	err := stmt.writeExecutePacket(args)
 	if err != nil {
 		return nil, stmt.mc.markBadConn(err)
 	}
 	mc := stmt.mc
 	// Read Result
 	resLen, err := mc.readResultSetHeaderPacket()
 	if err != nil {
 		return nil, err
 	}
 	rows := new(binaryRows)
 	if resLen > 0 {
 		rows.mc = mc
 		rows.rs.columns, err = mc.readColumns(resLen)
 	} else {
 		rows.rs.done = true
 		switch err := rows.NextResultSet(); err {
 		case nil, io.EOF:
 			return rows, nil
 		default:
 			return nil, err
 		}
 	}
 	return rows, err
 }
 type converter struct{}
 // ConvertValue mirrors the reference/default converter in database/sql/driver
 // with _one_ exception.  We support uint64 with their high bit and the default
 // implementation does not.  This function should be kept in sync with
 // database/sql/driver defaultConverter.ConvertValue() except for that
 // deliberate difference.
 func (c converter) ConvertValue(v interface{}) (driver.Value, error) {
 	if driver.IsValue(v) {
 		return v, nil
 	}
 	if vr, ok := v.(driver.Valuer); ok {
 		sv, err := callValuerValue(vr)
 		if err != nil {
 			return nil, err
 		}
 		if !driver.IsValue(sv) {
 			return nil, fmt.Errorf("non-Value type %T returned from Value", sv)
 		}
 		return sv, nil
 	}
 	rv := reflect.ValueOf(v)
 	switch rv.Kind() {
 	case reflect.Ptr:
 		// indirect pointers
 		if rv.IsNil() {
 			return nil, nil
 		} else {
 			return c.ConvertValue(rv.Elem().Interface())
 		}
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 		return rv.Int(), nil
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32:
 		return int64(rv.Uint()), nil
 	case reflect.Uint64:
 		u64 := rv.Uint()
 		if u64 >= 1<<63 {
 			return strconv.FormatUint(u64, 10), nil
 		}
 		return int64(u64), nil
 	case reflect.Float32, reflect.Float64:
 		return rv.Float(), nil
 	case reflect.Bool:
 		return rv.Bool(), nil
 	case reflect.Slice:
 		ek := rv.Type().Elem().Kind()
 		if ek == reflect.Uint8 {
 			return rv.Bytes(), nil
 		}
 		return nil, fmt.Errorf("unsupported type %T, a slice of %s", v, ek)
 	case reflect.String:
 		return rv.String(), nil
 	}
 	return nil, fmt.Errorf("unsupported type %T, a %s", v, rv.Kind())
 }
 var valuerReflectType = reflect.TypeOf((*driver.Valuer)(nil)).Elem()
 // callValuerValue returns vr.Value(), with one exception:
 // If vr.Value is an auto-generated method on a pointer type and the
 // pointer is nil, it would panic at runtime in the panicwrap
 // method. Treat it like nil instead.
 //
 // This is so people can implement driver.Value on value types and
 // still use nil pointers to those types to mean nil/NULL, just like
 // string/*string.
 //
 // This is an exact copy of the same-named unexported function from the
 // database/sql package.
 func callValuerValue(vr driver.Valuer) (v driver.Value, err error) {
 	if rv := reflect.ValueOf(vr); rv.Kind() == reflect.Ptr &&
 		rv.IsNil() &&
 		rv.Type().Elem().Implements(valuerReflectType) {
 		return nil, nil
 	}
 	return vr.Value()
 }
--- a/vendor/github.com/go-sql-driver/mysql/transaction.go
+++ b/vendor/github.com/go-sql-driver/mysql/transaction.go
@ -1,31 +0,0 @@
 // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
 //
 // Copyright 2012 The Go-MySQL-Driver Authors. All rights reserved.
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this file,
 // You can obtain one at http://mozilla.org/MPL/2.0/.
 package mysql
 type mysqlTx struct {
 	mc *mysqlConn
 }
 func (tx *mysqlTx) Commit() (err error) {
 	if tx.mc == nil || tx.mc.closed.IsSet() {
 		return ErrInvalidConn
 	}
 	err = tx.mc.exec("COMMIT")
 	tx.mc = nil
 	return
 }
 func (tx *mysqlTx) Rollback() (err error) {
 	if tx.mc == nil || tx.mc.closed.IsSet() {
 		return ErrInvalidConn
 	}
 	err = tx.mc.exec("ROLLBACK")
 	tx.mc = nil
 	return
 }
--- a/vendor/github.com/go-sql-driver/mysql/utils.go
+++ b/vendor/github.com/go-sql-driver/mysql/utils.go
@ -1,726 +0,0 @@
 // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
 //
 // Copyright 2012 The Go-MySQL-Driver Authors. All rights reserved.
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this file,
 // You can obtain one at http://mozilla.org/MPL/2.0/.
 package mysql
 import (
 	"crypto/tls"
 	"database/sql/driver"
 	"encoding/binary"
 	"fmt"
 	"io"
 	"strconv"
 	"strings"
 	"sync"
 	"sync/atomic"
 	"time"
 )
 // Registry for custom tls.Configs
 var (
 	tlsConfigLock     sync.RWMutex
 	tlsConfigRegistry map[string]*tls.Config
 )
 // RegisterTLSConfig registers a custom tls.Config to be used with sql.Open.
 // Use the key as a value in the DSN where tls=value.
 //
 // Note: The provided tls.Config is exclusively owned by the driver after
 // registering it.
 //
 //  rootCertPool := x509.NewCertPool()
 //  pem, err := ioutil.ReadFile("/path/ca-cert.pem")
 //  if err != nil {
 //      log.Fatal(err)
 //  }
 //  if ok := rootCertPool.AppendCertsFromPEM(pem); !ok {
 //      log.Fatal("Failed to append PEM.")
 //  }
 //  clientCert := make([]tls.Certificate, 0, 1)
 //  certs, err := tls.LoadX509KeyPair("/path/client-cert.pem", "/path/client-key.pem")
 //  if err != nil {
 //      log.Fatal(err)
 //  }
 //  clientCert = append(clientCert, certs)
 //  mysql.RegisterTLSConfig("custom", &tls.Config{
 //      RootCAs: rootCertPool,
 //      Certificates: clientCert,
 //  })
 //  db, err := sql.Open("mysql", "user@tcp(localhost:3306)/test?tls=custom")
 //
 func RegisterTLSConfig(key string, config *tls.Config) error {
 	if _, isBool := readBool(key); isBool || strings.ToLower(key) == "skip-verify" {
 		return fmt.Errorf("key '%s' is reserved", key)
 	}
 	tlsConfigLock.Lock()
 	if tlsConfigRegistry == nil {
 		tlsConfigRegistry = make(map[string]*tls.Config)
 	}
 	tlsConfigRegistry[key] = config
 	tlsConfigLock.Unlock()
 	return nil
 }
 // DeregisterTLSConfig removes the tls.Config associated with key.
 func DeregisterTLSConfig(key string) {
 	tlsConfigLock.Lock()
 	if tlsConfigRegistry != nil {
 		delete(tlsConfigRegistry, key)
 	}
 	tlsConfigLock.Unlock()
 }
 func getTLSConfigClone(key string) (config *tls.Config) {
 	tlsConfigLock.RLock()
 	if v, ok := tlsConfigRegistry[key]; ok {
 		config = cloneTLSConfig(v)
 	}
 	tlsConfigLock.RUnlock()
 	return
 }
 // Returns the bool value of the input.
 // The 2nd return value indicates if the input was a valid bool value
 func readBool(input string) (value bool, valid bool) {
 	switch input {
 	case "1", "true", "TRUE", "True":
 		return true, true
 	case "0", "false", "FALSE", "False":
 		return false, true
 	}
 	// Not a valid bool value
 	return
 }
 /******************************************************************************
 *                           Time related utils                                *
 ******************************************************************************/
 // NullTime represents a time.Time that may be NULL.
 // NullTime implements the Scanner interface so
 // it can be used as a scan destination:
 //
 //  var nt NullTime
 //  err := db.QueryRow("SELECT time FROM foo WHERE id=?", id).Scan(&nt)
 //  ...
 //  if nt.Valid {
 //     // use nt.Time
 //  } else {
 //     // NULL value
 //  }
 //
 // This NullTime implementation is not driver-specific
 type NullTime struct {
 	Time  time.Time
 	Valid bool // Valid is true if Time is not NULL
 }
 // Scan implements the Scanner interface.
 // The value type must be time.Time or string / []byte (formatted time-string),
 // otherwise Scan fails.
 func (nt *NullTime) Scan(value interface{}) (err error) {
 	if value == nil {
 		nt.Time, nt.Valid = time.Time{}, false
 		return
 	}
 	switch v := value.(type) {
 	case time.Time:
 		nt.Time, nt.Valid = v, true
 		return
 	case []byte:
 		nt.Time, err = parseDateTime(string(v), time.UTC)
 		nt.Valid = (err == nil)
 		return
 	case string:
 		nt.Time, err = parseDateTime(v, time.UTC)
 		nt.Valid = (err == nil)
 		return
 	}
 	nt.Valid = false
 	return fmt.Errorf("Can't convert %T to time.Time", value)
 }
 // Value implements the driver Valuer interface.
 func (nt NullTime) Value() (driver.Value, error) {
 	if !nt.Valid {
 		return nil, nil
 	}
 	return nt.Time, nil
 }
 func parseDateTime(str string, loc *time.Location) (t time.Time, err error) {
 	base := "0000-00-00 00:00:00.0000000"
 	switch len(str) {
 	case 10, 19, 21, 22, 23, 24, 25, 26: // up to "YYYY-MM-DD HH:MM:SS.MMMMMM"
 		if str == base[:len(str)] {
 			return
 		}
 		t, err = time.Parse(timeFormat[:len(str)], str)
 	default:
 		err = fmt.Errorf("invalid time string: %s", str)
 		return
 	}
 	// Adjust location
 	if err == nil && loc != time.UTC {
 		y, mo, d := t.Date()
 		h, mi, s := t.Clock()
 		t, err = time.Date(y, mo, d, h, mi, s, t.Nanosecond(), loc), nil
 	}
 	return
 }
 func parseBinaryDateTime(num uint64, data []byte, loc *time.Location) (driver.Value, error) {
 	switch num {
 	case 0:
 		return time.Time{}, nil
 	case 4:
 		return time.Date(
 			int(binary.LittleEndian.Uint16(data[:2])), // year
 			time.Month(data[2]),                       // month
 			int(data[3]),                              // day
 			0, 0, 0, 0,
 			loc,
 		), nil
 	case 7:
 		return time.Date(
 			int(binary.LittleEndian.Uint16(data[:2])), // year
 			time.Month(data[2]),                       // month
 			int(data[3]),                              // day
 			int(data[4]),                              // hour
 			int(data[5]),                              // minutes
 			int(data[6]),                              // seconds
 			0,
 			loc,
 		), nil
 	case 11:
 		return time.Date(
 			int(binary.LittleEndian.Uint16(data[:2])), // year
 			time.Month(data[2]),                       // month
 			int(data[3]),                              // day
 			int(data[4]),                              // hour
 			int(data[5]),                              // minutes
 			int(data[6]),                              // seconds
 			int(binary.LittleEndian.Uint32(data[7:11]))*1000, // nanoseconds
 			loc,
 		), nil
 	}
 	return nil, fmt.Errorf("invalid DATETIME packet length %d", num)
 }
 // zeroDateTime is used in formatBinaryDateTime to avoid an allocation
 // if the DATE or DATETIME has the zero value.
 // It must never be changed.
 // The current behavior depends on database/sql copying the result.
 var zeroDateTime = []byte("0000-00-00 00:00:00.000000")
 const digits01 = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"
 const digits10 = "0000000000111111111122222222223333333333444444444455555555556666666666777777777788888888889999999999"
 func appendMicrosecs(dst, src []byte, decimals int) []byte {
 	if decimals <= 0 {
 		return dst
 	}
 	if len(src) == 0 {
 		return append(dst, ".000000"[:decimals+1]...)
 	}
 	microsecs := binary.LittleEndian.Uint32(src[:4])
 	p1 := byte(microsecs / 10000)
 	microsecs -= 10000 * uint32(p1)
 	p2 := byte(microsecs / 100)
 	microsecs -= 100 * uint32(p2)
 	p3 := byte(microsecs)
 	switch decimals {
 	default:
 		return append(dst, '.',
 			digits10[p1], digits01[p1],
 			digits10[p2], digits01[p2],
 			digits10[p3], digits01[p3],
 		)
 	case 1:
 		return append(dst, '.',
 			digits10[p1],
 		)
 	case 2:
 		return append(dst, '.',
 			digits10[p1], digits01[p1],
 		)
 	case 3:
 		return append(dst, '.',
 			digits10[p1], digits01[p1],
 			digits10[p2],
 		)
 	case 4:
 		return append(dst, '.',
 			digits10[p1], digits01[p1],
 			digits10[p2], digits01[p2],
 		)
 	case 5:
 		return append(dst, '.',
 			digits10[p1], digits01[p1],
 			digits10[p2], digits01[p2],
 			digits10[p3],
 		)
 	}
 }
 func formatBinaryDateTime(src []byte, length uint8) (driver.Value, error) {
 	// length expects the deterministic length of the zero value,
 	// negative time and 100+ hours are automatically added if needed
 	if len(src) == 0 {
 		return zeroDateTime[:length], nil
 	}
 	var dst []byte      // return value
 	var p1, p2, p3 byte // current digit pair
 	switch length {
 	case 10, 19, 21, 22, 23, 24, 25, 26:
 	default:
 		t := "DATE"
 		if length > 10 {
 			t += "TIME"
 		}
 		return nil, fmt.Errorf("illegal %s length %d", t, length)
 	}
 	switch len(src) {
 	case 4, 7, 11:
 	default:
 		t := "DATE"
 		if length > 10 {
 			t += "TIME"
 		}
 		return nil, fmt.Errorf("illegal %s packet length %d", t, len(src))
 	}
 	dst = make([]byte, 0, length)
 	// start with the date
 	year := binary.LittleEndian.Uint16(src[:2])
 	pt := year / 100
 	p1 = byte(year - 100*uint16(pt))
 	p2, p3 = src[2], src[3]
 	dst = append(dst,
 		digits10[pt], digits01[pt],
 		digits10[p1], digits01[p1], '-',
 		digits10[p2], digits01[p2], '-',
 		digits10[p3], digits01[p3],
 	)
 	if length == 10 {
 		return dst, nil
 	}
 	if len(src) == 4 {
 		return append(dst, zeroDateTime[10:length]...), nil
 	}
 	dst = append(dst, ' ')
 	p1 = src[4] // hour
 	src = src[5:]
 	// p1 is 2-digit hour, src is after hour
 	p2, p3 = src[0], src[1]
 	dst = append(dst,
 		digits10[p1], digits01[p1], ':',
 		digits10[p2], digits01[p2], ':',
 		digits10[p3], digits01[p3],
 	)
 	return appendMicrosecs(dst, src[2:], int(length)-20), nil
 }
 func formatBinaryTime(src []byte, length uint8) (driver.Value, error) {
 	// length expects the deterministic length of the zero value,
 	// negative time and 100+ hours are automatically added if needed
 	if len(src) == 0 {
 		return zeroDateTime[11 : 11+length], nil
 	}
 	var dst []byte // return value
 	switch length {
 	case
 		8,                      // time (can be up to 10 when negative and 100+ hours)
 		10, 11, 12, 13, 14, 15: // time with fractional seconds
 	default:
 		return nil, fmt.Errorf("illegal TIME length %d", length)
 	}
 	switch len(src) {
 	case 8, 12:
 	default:
 		return nil, fmt.Errorf("invalid TIME packet length %d", len(src))
 	}
 	// +2 to enable negative time and 100+ hours
 	dst = make([]byte, 0, length+2)
 	if src[0] == 1 {
 		dst = append(dst, '-')
 	}
 	days := binary.LittleEndian.Uint32(src[1:5])
 	hours := int64(days)*24 + int64(src[5])
 	if hours >= 100 {
 		dst = strconv.AppendInt(dst, hours, 10)
 	} else {
 		dst = append(dst, digits10[hours], digits01[hours])
 	}
 	min, sec := src[6], src[7]
 	dst = append(dst, ':',
 		digits10[min], digits01[min], ':',
 		digits10[sec], digits01[sec],
 	)
 	return appendMicrosecs(dst, src[8:], int(length)-9), nil
 }
 /******************************************************************************
 *                       Convert from and to bytes                             *
 ******************************************************************************/
 func uint64ToBytes(n uint64) []byte {
 	return []byte{
 		byte(n),
 		byte(n >> 8),
 		byte(n >> 16),
 		byte(n >> 24),
 		byte(n >> 32),
 		byte(n >> 40),
 		byte(n >> 48),
 		byte(n >> 56),
 	}
 }
 func uint64ToString(n uint64) []byte {
 	var a [20]byte
 	i := 20
 	// U+0030 = 0
 	// ...
 	// U+0039 = 9
 	var q uint64
 	for n >= 10 {
 		i--
 		q = n / 10
 		a[i] = uint8(n-q*10) + 0x30
 		n = q
 	}
 	i--
 	a[i] = uint8(n) + 0x30
 	return a[i:]
 }
 // treats string value as unsigned integer representation
 func stringToInt(b []byte) int {
 	val := 0
 	for i := range b {
 		val *= 10
 		val += int(b[i] - 0x30)
 	}
 	return val
 }
 // returns the string read as a bytes slice, wheter the value is NULL,
 // the number of bytes read and an error, in case the string is longer than
 // the input slice
 func readLengthEncodedString(b []byte) ([]byte, bool, int, error) {
 	// Get length
 	num, isNull, n := readLengthEncodedInteger(b)
 	if num < 1 {
 		return b[n:n], isNull, n, nil
 	}
 	n += int(num)
 	// Check data length
 	if len(b) >= n {
 		return b[n-int(num) : n : n], false, n, nil
 	}
 	return nil, false, n, io.EOF
 }
 // returns the number of bytes skipped and an error, in case the string is
 // longer than the input slice
 func skipLengthEncodedString(b []byte) (int, error) {
 	// Get length
 	num, _, n := readLengthEncodedInteger(b)
 	if num < 1 {
 		return n, nil
 	}
 	n += int(num)
 	// Check data length
 	if len(b) >= n {
 		return n, nil
 	}
 	return n, io.EOF
 }
 // returns the number read, whether the value is NULL and the number of bytes read
 func readLengthEncodedInteger(b []byte) (uint64, bool, int) {
 	// See issue #349
 	if len(b) == 0 {
 		return 0, true, 1
 	}
 	switch b[0] {
 	// 251: NULL
 	case 0xfb:
 		return 0, true, 1
 	// 252: value of following 2
 	case 0xfc:
 		return uint64(b[1]) | uint64(b[2])<<8, false, 3
 	// 253: value of following 3
 	case 0xfd:
 		return uint64(b[1]) | uint64(b[2])<<8 | uint64(b[3])<<16, false, 4
 	// 254: value of following 8
 	case 0xfe:
 		return uint64(b[1]) | uint64(b[2])<<8 | uint64(b[3])<<16 |
 				uint64(b[4])<<24 | uint64(b[5])<<32 | uint64(b[6])<<40 |
 				uint64(b[7])<<48 | uint64(b[8])<<56,
 			false, 9
 	}
 	// 0-250: value of first byte
 	return uint64(b[0]), false, 1
 }
 // encodes a uint64 value and appends it to the given bytes slice
 func appendLengthEncodedInteger(b []byte, n uint64) []byte {
 	switch {
 	case n <= 250:
 		return append(b, byte(n))
 	case n <= 0xffff:
 		return append(b, 0xfc, byte(n), byte(n>>8))
 	case n <= 0xffffff:
 		return append(b, 0xfd, byte(n), byte(n>>8), byte(n>>16))
 	}
 	return append(b, 0xfe, byte(n), byte(n>>8), byte(n>>16), byte(n>>24),
 		byte(n>>32), byte(n>>40), byte(n>>48), byte(n>>56))
 }
 // reserveBuffer checks cap(buf) and expand buffer to len(buf) + appendSize.
 // If cap(buf) is not enough, reallocate new buffer.
 func reserveBuffer(buf []byte, appendSize int) []byte {
 	newSize := len(buf) + appendSize
 	if cap(buf) < newSize {
 		// Grow buffer exponentially
 		newBuf := make([]byte, len(buf)*2+appendSize)
 		copy(newBuf, buf)
 		buf = newBuf
 	}
 	return buf[:newSize]
 }
 // escapeBytesBackslash escapes []byte with backslashes (\)
 // This escapes the contents of a string (provided as []byte) by adding backslashes before special
 // characters, and turning others into specific escape sequences, such as
 // turning newlines into \n and null bytes into \0.
 // https://github.com/mysql/mysql-server/blob/mysql-5.7.5/mysys/charset.c#L823-L932
 func escapeBytesBackslash(buf, v []byte) []byte {
 	pos := len(buf)
 	buf = reserveBuffer(buf, len(v)*2)
 	for _, c := range v {
 		switch c {
 		case '\x00':
 			buf[pos] = '\\'
 			buf[pos+1] = '0'
 			pos += 2
 		case '\n':
 			buf[pos] = '\\'
 			buf[pos+1] = 'n'
 			pos += 2
 		case '\r':
 			buf[pos] = '\\'
 			buf[pos+1] = 'r'
 			pos += 2
 		case '\x1a':
 			buf[pos] = '\\'
 			buf[pos+1] = 'Z'
 			pos += 2
 		case '\'':
 			buf[pos] = '\\'
 			buf[pos+1] = '\''
 			pos += 2
 		case '"':
 			buf[pos] = '\\'
 			buf[pos+1] = '"'
 			pos += 2
 		case '\\':
 			buf[pos] = '\\'
 			buf[pos+1] = '\\'
 			pos += 2
 		default:
 			buf[pos] = c
 			pos++
 		}
 	}
 	return buf[:pos]
 }
 // escapeStringBackslash is similar to escapeBytesBackslash but for string.
 func escapeStringBackslash(buf []byte, v string) []byte {
 	pos := len(buf)
 	buf = reserveBuffer(buf, len(v)*2)
 	for i := 0; i < len(v); i++ {
 		c := v[i]
 		switch c {
 		case '\x00':
 			buf[pos] = '\\'
 			buf[pos+1] = '0'
 			pos += 2
 		case '\n':
 			buf[pos] = '\\'
 			buf[pos+1] = 'n'
 			pos += 2
 		case '\r':
 			buf[pos] = '\\'
 			buf[pos+1] = 'r'
 			pos += 2
 		case '\x1a':
 			buf[pos] = '\\'
 			buf[pos+1] = 'Z'
 			pos += 2
 		case '\'':
 			buf[pos] = '\\'
 			buf[pos+1] = '\''
 			pos += 2
 		case '"':
 			buf[pos] = '\\'
 			buf[pos+1] = '"'
 			pos += 2
 		case '\\':
 			buf[pos] = '\\'
 			buf[pos+1] = '\\'
 			pos += 2
 		default:
 			buf[pos] = c
 			pos++
 		}
 	}
 	return buf[:pos]
 }
 // escapeBytesQuotes escapes apostrophes in []byte by doubling them up.
 // This escapes the contents of a string by doubling up any apostrophes that
 // it contains. This is used when the NO_BACKSLASH_ESCAPES SQL_MODE is in
 // effect on the server.
 // https://github.com/mysql/mysql-server/blob/mysql-5.7.5/mysys/charset.c#L963-L1038
 func escapeBytesQuotes(buf, v []byte) []byte {
 	pos := len(buf)
 	buf = reserveBuffer(buf, len(v)*2)
 	for _, c := range v {
 		if c == '\'' {
 			buf[pos] = '\''
 			buf[pos+1] = '\''
 			pos += 2
 		} else {
 			buf[pos] = c
 			pos++
 		}
 	}
 	return buf[:pos]
 }
 // escapeStringQuotes is similar to escapeBytesQuotes but for string.
 func escapeStringQuotes(buf []byte, v string) []byte {
 	pos := len(buf)
 	buf = reserveBuffer(buf, len(v)*2)
 	for i := 0; i < len(v); i++ {
 		c := v[i]
 		if c == '\'' {
 			buf[pos] = '\''
 			buf[pos+1] = '\''
 			pos += 2
 		} else {
 			buf[pos] = c
 			pos++
 		}
 	}
 	return buf[:pos]
 }
 /******************************************************************************
 *                               Sync utils                                    *
 ******************************************************************************/
 // noCopy may be embedded into structs which must not be copied
 // after the first use.
 //
 // See https://github.com/golang/go/issues/8005#issuecomment-190753527
 // for details.
 type noCopy struct{}
 // Lock is a no-op used by -copylocks checker from `go vet`.
 func (*noCopy) Lock() {}
 // atomicBool is a wrapper around uint32 for usage as a boolean value with
 // atomic access.
 type atomicBool struct {
 	_noCopy noCopy
 	value   uint32
 }
 // IsSet returns wether the current boolean value is true
 func (ab *atomicBool) IsSet() bool {
 	return atomic.LoadUint32(&ab.value) > 0
 }
 // Set sets the value of the bool regardless of the previous value
 func (ab *atomicBool) Set(value bool) {
 	if value {
 		atomic.StoreUint32(&ab.value, 1)
 	} else {
 		atomic.StoreUint32(&ab.value, 0)
 	}
 }
 // TrySet sets the value of the bool and returns wether the value changed
 func (ab *atomicBool) TrySet(value bool) bool {
 	if value {
 		return atomic.SwapUint32(&ab.value, 1) == 0
 	}
 	return atomic.SwapUint32(&ab.value, 0) > 0
 }
 // atomicError is a wrapper for atomically accessed error values
 type atomicError struct {
 	_noCopy noCopy
 	value   atomic.Value
 }
 // Set sets the error value regardless of the previous value.
 // The value must not be nil
 func (ae *atomicError) Set(value error) {
 	ae.value.Store(value)
 }
 // Value returns the current error value
 func (ae *atomicError) Value() error {
 	if v := ae.value.Load(); v != nil {
 		// this will panic if the value doesn't implement the error interface
 		return v.(error)
 	}
 	return nil
 }
--- a/vendor/github.com/go-sql-driver/mysql/utils_go17.go
+++ b/vendor/github.com/go-sql-driver/mysql/utils_go17.go
@ -1,40 +0,0 @@
 // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
 //
 // Copyright 2017 The Go-MySQL-Driver Authors. All rights reserved.
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this file,
 // You can obtain one at http://mozilla.org/MPL/2.0/.
 // +build go1.7
 // +build !go1.8
 package mysql
 import "crypto/tls"
 func cloneTLSConfig(c *tls.Config) *tls.Config {
 	return &tls.Config{
 		Rand:                        c.Rand,
 		Time:                        c.Time,
 		Certificates:                c.Certificates,
 		NameToCertificate:           c.NameToCertificate,
 		GetCertificate:              c.GetCertificate,
 		RootCAs:                     c.RootCAs,
 		NextProtos:                  c.NextProtos,
 		ServerName:                  c.ServerName,
 		ClientAuth:                  c.ClientAuth,
 		ClientCAs:                   c.ClientCAs,
 		InsecureSkipVerify:          c.InsecureSkipVerify,
 		CipherSuites:                c.CipherSuites,
 		PreferServerCipherSuites:    c.PreferServerCipherSuites,
 		SessionTicketsDisabled:      c.SessionTicketsDisabled,
 		SessionTicketKey:            c.SessionTicketKey,
 		ClientSessionCache:          c.ClientSessionCache,
 		MinVersion:                  c.MinVersion,
 		MaxVersion:                  c.MaxVersion,
 		CurvePreferences:            c.CurvePreferences,
 		DynamicRecordSizingDisabled: c.DynamicRecordSizingDisabled,
 		Renegotiation:               c.Renegotiation,
 	}
 }
--- a/vendor/github.com/go-sql-driver/mysql/utils_go18.go
+++ b/vendor/github.com/go-sql-driver/mysql/utils_go18.go
@ -1,50 +0,0 @@
 // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
 //
 // Copyright 2017 The Go-MySQL-Driver Authors. All rights reserved.
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this file,
 // You can obtain one at http://mozilla.org/MPL/2.0/.
 // +build go1.8
 package mysql
 import (
 	"crypto/tls"
 	"database/sql"
 	"database/sql/driver"
 	"errors"
 	"fmt"
 )
 func cloneTLSConfig(c *tls.Config) *tls.Config {
 	return c.Clone()
 }
 func namedValueToValue(named []driver.NamedValue) ([]driver.Value, error) {
 	dargs := make([]driver.Value, len(named))
 	for n, param := range named {
 		if len(param.Name) > 0 {
 			// TODO: support the use of Named Parameters #561
 			return nil, errors.New("mysql: driver does not support the use of Named Parameters")
 		}
 		dargs[n] = param.Value
 	}
 	return dargs, nil
 }
 func mapIsolationLevel(level driver.IsolationLevel) (string, error) {
 	switch sql.IsolationLevel(level) {
 	case sql.LevelRepeatableRead:
 		return "REPEATABLE READ", nil
 	case sql.LevelReadCommitted:
 		return "READ COMMITTED", nil
 	case sql.LevelReadUncommitted:
 		return "READ UNCOMMITTED", nil
 	case sql.LevelSerializable:
 		return "SERIALIZABLE", nil
 	default:
 		return "", fmt.Errorf("mysql: unsupported isolation level: %v", level)
 	}
 }
--- a/vendor/github.com/jinzhu/gorm/.gitignore
+++ b/vendor/github.com/jinzhu/gorm/.gitignore
@ -0,0 +1,3 @@
 documents
 coverage.txt
 _book
--- a/vendor/github.com/jinzhu/gorm/License
+++ b/vendor/github.com/jinzhu/gorm/License
@ -0,0 +1,21 @@
 The MIT License (MIT)
 Copyright (c) 2013-NOW  Jinzhu <wosmvp@gmail.com>
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
--- a/vendor/github.com/jinzhu/gorm/README.md
+++ b/vendor/github.com/jinzhu/gorm/README.md
@ -0,0 +1,41 @@
 # GORM
 The fantastic ORM library for Golang, aims to be developer friendly.
 [![go report card](https://goreportcard.com/badge/github.com/jinzhu/gorm "go report card")](https://goreportcard.com/report/github.com/jinzhu/gorm)
 [![wercker status](https://app.wercker.com/status/8596cace912c9947dd9c8542ecc8cb8b/s/master "wercker status")](https://app.wercker.com/project/byKey/8596cace912c9947dd9c8542ecc8cb8b)
 [![codecov](https://codecov.io/gh/jinzhu/gorm/branch/master/graph/badge.svg)](https://codecov.io/gh/jinzhu/gorm)
 [![Join the chat at https://gitter.im/jinzhu/gorm](https://img.shields.io/gitter/room/jinzhu/gorm.svg)](https://gitter.im/jinzhu/gorm?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![Open Collective Backer](https://opencollective.com/gorm/tiers/backer/badge.svg?label=backer&color=brightgreen "Open Collective Backer")](https://opencollective.com/gorm)
 [![Open Collective Sponsor](https://opencollective.com/gorm/tiers/sponsor/badge.svg?label=sponsor&color=brightgreen "Open Collective Sponsor")](https://opencollective.com/gorm)
 [![MIT license](https://img.shields.io/badge/license-MIT-brightgreen.svg)](https://opensource.org/licenses/MIT)
 [![GoDoc](https://godoc.org/github.com/jinzhu/gorm?status.svg)](https://godoc.org/github.com/jinzhu/gorm)
 ## Overview
 * Full-Featured ORM (almost)
 * Associations (Has One, Has Many, Belongs To, Many To Many, Polymorphism)
 * Hooks (Before/After Create/Save/Update/Delete/Find)
 * Preloading (eager loading)
 * Transactions
 * Composite Primary Key
 * SQL Builder
 * Auto Migrations
 * Logger
 * Extendable, write Plugins based on GORM callbacks
 * Every feature comes with tests
 * Developer Friendly
 ## Getting Started
 * GORM Guides [https://gorm.io](https://gorm.io)
 ## Contributing
 [You can help to deliver a better GORM, check out things you can do](https://gorm.io/contribute.html)
 ## License
 © Jinzhu, 2013~time.Now
 Released under the [MIT License](https://github.com/jinzhu/gorm/blob/master/License)
--- a/vendor/github.com/jinzhu/gorm/association.go
+++ b/vendor/github.com/jinzhu/gorm/association.go
@ -0,0 +1,377 @@
 package gorm
 import (
 	"errors"
 	"fmt"
 	"reflect"
 )
 // Association Mode contains some helper methods to handle relationship things easily.
 type Association struct {
 	Error  error
 	scope  *Scope
 	column string
 	field  *Field
 }
 // Find find out all related associations
 func (association *Association) Find(value interface{}) *Association {
 	association.scope.related(value, association.column)
 	return association.setErr(association.scope.db.Error)
 }
 // Append append new associations for many2many, has_many, replace current association for has_one, belongs_to
 func (association *Association) Append(values ...interface{}) *Association {
 	if association.Error != nil {
 		return association
 	}
 	if relationship := association.field.Relationship; relationship.Kind == "has_one" {
 		return association.Replace(values...)
 	}
 	return association.saveAssociations(values...)
 }
 // Replace replace current associations with new one
 func (association *Association) Replace(values ...interface{}) *Association {
 	if association.Error != nil {
 		return association
 	}
 	var (
 		relationship = association.field.Relationship
 		scope        = association.scope
 		field        = association.field.Field
 		newDB        = scope.NewDB()
 	)
 	// Append new values
 	association.field.Set(reflect.Zero(association.field.Field.Type()))
 	association.saveAssociations(values...)
 	// Belongs To
 	if relationship.Kind == "belongs_to" {
 		// Set foreign key to be null when clearing value (length equals 0)
 		if len(values) == 0 {
 			// Set foreign key to be nil
 			var foreignKeyMap = map[string]interface{}{}
 			for _, foreignKey := range relationship.ForeignDBNames {
 				foreignKeyMap[foreignKey] = nil
 			}
 			association.setErr(newDB.Model(scope.Value).UpdateColumn(foreignKeyMap).Error)
 		}
 	} else {
 		// Polymorphic Relations
 		if relationship.PolymorphicDBName != "" {
 			newDB = newDB.Where(fmt.Sprintf("%v = ?", scope.Quote(relationship.PolymorphicDBName)), relationship.PolymorphicValue)
 		}
 		// Delete Relations except new created
 		if len(values) > 0 {
 			var associationForeignFieldNames, associationForeignDBNames []string
 			if relationship.Kind == "many_to_many" {
 				// if many to many relations, get association fields name from association foreign keys
 				associationScope := scope.New(reflect.New(field.Type()).Interface())
 				for idx, dbName := range relationship.AssociationForeignFieldNames {
 					if field, ok := associationScope.FieldByName(dbName); ok {
 						associationForeignFieldNames = append(associationForeignFieldNames, field.Name)
 						associationForeignDBNames = append(associationForeignDBNames, relationship.AssociationForeignDBNames[idx])
 					}
 				}
 			} else {
 				// If has one/many relations, use primary keys
 				for _, field := range scope.New(reflect.New(field.Type()).Interface()).PrimaryFields() {
 					associationForeignFieldNames = append(associationForeignFieldNames, field.Name)
 					associationForeignDBNames = append(associationForeignDBNames, field.DBName)
 				}
 			}
 			newPrimaryKeys := scope.getColumnAsArray(associationForeignFieldNames, field.Interface())
 			if len(newPrimaryKeys) > 0 {
 				sql := fmt.Sprintf("%v NOT IN (%v)", toQueryCondition(scope, associationForeignDBNames), toQueryMarks(newPrimaryKeys))
 				newDB = newDB.Where(sql, toQueryValues(newPrimaryKeys)...)
 			}
 		}
 		if relationship.Kind == "many_to_many" {
 			// if many to many relations, delete related relations from join table
 			var sourceForeignFieldNames []string
 			for _, dbName := range relationship.ForeignFieldNames {
 				if field, ok := scope.FieldByName(dbName); ok {
 					sourceForeignFieldNames = append(sourceForeignFieldNames, field.Name)
 				}
 			}
 			if sourcePrimaryKeys := scope.getColumnAsArray(sourceForeignFieldNames, scope.Value); len(sourcePrimaryKeys) > 0 {
 				newDB = newDB.Where(fmt.Sprintf("%v IN (%v)", toQueryCondition(scope, relationship.ForeignDBNames), toQueryMarks(sourcePrimaryKeys)), toQueryValues(sourcePrimaryKeys)...)
 				association.setErr(relationship.JoinTableHandler.Delete(relationship.JoinTableHandler, newDB))
 			}
 		} else if relationship.Kind == "has_one" || relationship.Kind == "has_many" {
 			// has_one or has_many relations, set foreign key to be nil (TODO or delete them?)
 			var foreignKeyMap = map[string]interface{}{}
 			for idx, foreignKey := range relationship.ForeignDBNames {
 				foreignKeyMap[foreignKey] = nil
 				if field, ok := scope.FieldByName(relationship.AssociationForeignFieldNames[idx]); ok {
 					newDB = newDB.Where(fmt.Sprintf("%v = ?", scope.Quote(foreignKey)), field.Field.Interface())
 				}
 			}
 			fieldValue := reflect.New(association.field.Field.Type()).Interface()
 			association.setErr(newDB.Model(fieldValue).UpdateColumn(foreignKeyMap).Error)
 		}
 	}
 	return association
 }
 // Delete remove relationship between source & passed arguments, but won't delete those arguments
 func (association *Association) Delete(values ...interface{}) *Association {
 	if association.Error != nil {
 		return association
 	}
 	var (
 		relationship = association.field.Relationship
 		scope        = association.scope
 		field        = association.field.Field
 		newDB        = scope.NewDB()
 	)
 	if len(values) == 0 {
 		return association
 	}
 	var deletingResourcePrimaryFieldNames, deletingResourcePrimaryDBNames []string
 	for _, field := range scope.New(reflect.New(field.Type()).Interface()).PrimaryFields() {
 		deletingResourcePrimaryFieldNames = append(deletingResourcePrimaryFieldNames, field.Name)
 		deletingResourcePrimaryDBNames = append(deletingResourcePrimaryDBNames, field.DBName)
 	}
 	deletingPrimaryKeys := scope.getColumnAsArray(deletingResourcePrimaryFieldNames, values...)
 	if relationship.Kind == "many_to_many" {
 		// source value's foreign keys
 		for idx, foreignKey := range relationship.ForeignDBNames {
 			if field, ok := scope.FieldByName(relationship.ForeignFieldNames[idx]); ok {
 				newDB = newDB.Where(fmt.Sprintf("%v = ?", scope.Quote(foreignKey)), field.Field.Interface())
 			}
 		}
 		// get association's foreign fields name
 		var associationScope = scope.New(reflect.New(field.Type()).Interface())
 		var associationForeignFieldNames []string
 		for _, associationDBName := range relationship.AssociationForeignFieldNames {
 			if field, ok := associationScope.FieldByName(associationDBName); ok {
 				associationForeignFieldNames = append(associationForeignFieldNames, field.Name)
 			}
 		}
 		// association value's foreign keys
 		deletingPrimaryKeys := scope.getColumnAsArray(associationForeignFieldNames, values...)
 		sql := fmt.Sprintf("%v IN (%v)", toQueryCondition(scope, relationship.AssociationForeignDBNames), toQueryMarks(deletingPrimaryKeys))
 		newDB = newDB.Where(sql, toQueryValues(deletingPrimaryKeys)...)
 		association.setErr(relationship.JoinTableHandler.Delete(relationship.JoinTableHandler, newDB))
 	} else {
 		var foreignKeyMap = map[string]interface{}{}
 		for _, foreignKey := range relationship.ForeignDBNames {
 			foreignKeyMap[foreignKey] = nil
 		}
 		if relationship.Kind == "belongs_to" {
 			// find with deleting relation's foreign keys
 			primaryKeys := scope.getColumnAsArray(relationship.AssociationForeignFieldNames, values...)
 			newDB = newDB.Where(
 				fmt.Sprintf("%v IN (%v)", toQueryCondition(scope, relationship.ForeignDBNames), toQueryMarks(primaryKeys)),
 				toQueryValues(primaryKeys)...,
 			)
 			// set foreign key to be null if there are some records affected
 			modelValue := reflect.New(scope.GetModelStruct().ModelType).Interface()
 			if results := newDB.Model(modelValue).UpdateColumn(foreignKeyMap); results.Error == nil {
 				if results.RowsAffected > 0 {
 					scope.updatedAttrsWithValues(foreignKeyMap)
 				}
 			} else {
 				association.setErr(results.Error)
 			}
 		} else if relationship.Kind == "has_one" || relationship.Kind == "has_many" {
 			// find all relations
 			primaryKeys := scope.getColumnAsArray(relationship.AssociationForeignFieldNames, scope.Value)
 			newDB = newDB.Where(
 				fmt.Sprintf("%v IN (%v)", toQueryCondition(scope, relationship.ForeignDBNames), toQueryMarks(primaryKeys)),
 				toQueryValues(primaryKeys)...,
 			)
 			// only include those deleting relations
 			newDB = newDB.Where(
 				fmt.Sprintf("%v IN (%v)", toQueryCondition(scope, deletingResourcePrimaryDBNames), toQueryMarks(deletingPrimaryKeys)),
 				toQueryValues(deletingPrimaryKeys)...,
 			)
 			// set matched relation's foreign key to be null
 			fieldValue := reflect.New(association.field.Field.Type()).Interface()
 			association.setErr(newDB.Model(fieldValue).UpdateColumn(foreignKeyMap).Error)
 		}
 	}
 	// Remove deleted records from source's field
 	if association.Error == nil {
 		if field.Kind() == reflect.Slice {
 			leftValues := reflect.Zero(field.Type())
 			for i := 0; i < field.Len(); i++ {
 				reflectValue := field.Index(i)
 				primaryKey := scope.getColumnAsArray(deletingResourcePrimaryFieldNames, reflectValue.Interface())[0]
 				var isDeleted = false
 				for _, pk := range deletingPrimaryKeys {
 					if equalAsString(primaryKey, pk) {
 						isDeleted = true
 						break
 					}
 				}
 				if !isDeleted {
 					leftValues = reflect.Append(leftValues, reflectValue)
 				}
 			}
 			association.field.Set(leftValues)
 		} else if field.Kind() == reflect.Struct {
 			primaryKey := scope.getColumnAsArray(deletingResourcePrimaryFieldNames, field.Interface())[0]
 			for _, pk := range deletingPrimaryKeys {
 				if equalAsString(primaryKey, pk) {
 					association.field.Set(reflect.Zero(field.Type()))
 					break
 				}
 			}
 		}
 	}
 	return association
 }
 // Clear remove relationship between source & current associations, won't delete those associations
 func (association *Association) Clear() *Association {
 	return association.Replace()
 }
 // Count return the count of current associations
 func (association *Association) Count() int {
 	var (
 		count        = 0
 		relationship = association.field.Relationship
 		scope        = association.scope
 		fieldValue   = association.field.Field.Interface()
 		query        = scope.DB()
 	)
 	switch relationship.Kind {
 	case "many_to_many":
 		query = relationship.JoinTableHandler.JoinWith(relationship.JoinTableHandler, query, scope.Value)
 	case "has_many", "has_one":
 		primaryKeys := scope.getColumnAsArray(relationship.AssociationForeignFieldNames, scope.Value)
 		query = query.Where(
 			fmt.Sprintf("%v IN (%v)", toQueryCondition(scope, relationship.ForeignDBNames), toQueryMarks(primaryKeys)),
 			toQueryValues(primaryKeys)...,
 		)
 	case "belongs_to":
 		primaryKeys := scope.getColumnAsArray(relationship.ForeignFieldNames, scope.Value)
 		query = query.Where(
 			fmt.Sprintf("%v IN (%v)", toQueryCondition(scope, relationship.AssociationForeignDBNames), toQueryMarks(primaryKeys)),
 			toQueryValues(primaryKeys)...,
 		)
 	}
 	if relationship.PolymorphicType != "" {
 		query = query.Where(
 			fmt.Sprintf("%v.%v = ?", scope.New(fieldValue).QuotedTableName(), scope.Quote(relationship.PolymorphicDBName)),
 			relationship.PolymorphicValue,
 		)
 	}
 	if err := query.Model(fieldValue).Count(&count).Error; err != nil {
 		association.Error = err
 	}
 	return count
 }
 // saveAssociations save passed values as associations
 func (association *Association) saveAssociations(values ...interface{}) *Association {
 	var (
 		scope        = association.scope
 		field        = association.field
 		relationship = field.Relationship
 	)
 	saveAssociation := func(reflectValue reflect.Value) {
 		// value has to been pointer
 		if reflectValue.Kind() != reflect.Ptr {
 			reflectPtr := reflect.New(reflectValue.Type())
 			reflectPtr.Elem().Set(reflectValue)
 			reflectValue = reflectPtr
 		}
 		// value has to been saved for many2many
 		if relationship.Kind == "many_to_many" {
 			if scope.New(reflectValue.Interface()).PrimaryKeyZero() {
 				association.setErr(scope.NewDB().Save(reflectValue.Interface()).Error)
 			}
 		}
 		// Assign Fields
 		var fieldType = field.Field.Type()
 		var setFieldBackToValue, setSliceFieldBackToValue bool
 		if reflectValue.Type().AssignableTo(fieldType) {
 			field.Set(reflectValue)
 		} else if reflectValue.Type().Elem().AssignableTo(fieldType) {
 			// if field's type is struct, then need to set value back to argument after save
 			setFieldBackToValue = true
 			field.Set(reflectValue.Elem())
 		} else if fieldType.Kind() == reflect.Slice {
 			if reflectValue.Type().AssignableTo(fieldType.Elem()) {
 				field.Set(reflect.Append(field.Field, reflectValue))
 			} else if reflectValue.Type().Elem().AssignableTo(fieldType.Elem()) {
 				// if field's type is slice of struct, then need to set value back to argument after save
 				setSliceFieldBackToValue = true
 				field.Set(reflect.Append(field.Field, reflectValue.Elem()))
 			}
 		}
 		if relationship.Kind == "many_to_many" {
 			association.setErr(relationship.JoinTableHandler.Add(relationship.JoinTableHandler, scope.NewDB(), scope.Value, reflectValue.Interface()))
 		} else {
 			association.setErr(scope.NewDB().Select(field.Name).Save(scope.Value).Error)
 			if setFieldBackToValue {
 				reflectValue.Elem().Set(field.Field)
 			} else if setSliceFieldBackToValue {
 				reflectValue.Elem().Set(field.Field.Index(field.Field.Len() - 1))
 			}
 		}
 	}
 	for _, value := range values {
 		reflectValue := reflect.ValueOf(value)
 		indirectReflectValue := reflect.Indirect(reflectValue)
 		if indirectReflectValue.Kind() == reflect.Struct {
 			saveAssociation(reflectValue)
 		} else if indirectReflectValue.Kind() == reflect.Slice {
 			for i := 0; i < indirectReflectValue.Len(); i++ {
 				saveAssociation(indirectReflectValue.Index(i))
 			}
 		} else {
 			association.setErr(errors.New("invalid value type"))
 		}
 	}
 	return association
 }
 // setErr set error when the error is not nil. And return Association.
 func (association *Association) setErr(err error) *Association {
 	if err != nil {
 		association.Error = err
 	}
 	return association
 }
--- a/vendor/github.com/jinzhu/gorm/callback.go
+++ b/vendor/github.com/jinzhu/gorm/callback.go
@ -0,0 +1,250 @@
 package gorm
 import "fmt"
 // DefaultCallback default callbacks defined by gorm
 var DefaultCallback = &Callback{logger: nopLogger{}}
 // Callback is a struct that contains all CRUD callbacks
 //   Field `creates` contains callbacks will be call when creating object
 //   Field `updates` contains callbacks will be call when updating object
 //   Field `deletes` contains callbacks will be call when deleting object
 //   Field `queries` contains callbacks will be call when querying object with query methods like Find, First, Related, Association...
 //   Field `rowQueries` contains callbacks will be call when querying object with Row, Rows...
 //   Field `processors` contains all callback processors, will be used to generate above callbacks in order
 type Callback struct {
 	logger     logger
 	creates    []*func(scope *Scope)
 	updates    []*func(scope *Scope)
 	deletes    []*func(scope *Scope)
 	queries    []*func(scope *Scope)
 	rowQueries []*func(scope *Scope)
 	processors []*CallbackProcessor
 }
 // CallbackProcessor contains callback informations
 type CallbackProcessor struct {
 	logger    logger
 	name      string              // current callback's name
 	before    string              // register current callback before a callback
 	after     string              // register current callback after a callback
 	replace   bool                // replace callbacks with same name
 	remove    bool                // delete callbacks with same name
 	kind      string              // callback type: create, update, delete, query, row_query
 	processor *func(scope *Scope) // callback handler
 	parent    *Callback
 }
 func (c *Callback) clone(logger logger) *Callback {
 	return &Callback{
 		logger:     logger,
 		creates:    c.creates,
 		updates:    c.updates,
 		deletes:    c.deletes,
 		queries:    c.queries,
 		rowQueries: c.rowQueries,
 		processors: c.processors,
 	}
 }
 // Create could be used to register callbacks for creating object
 //     db.Callback().Create().After("gorm:create").Register("plugin:run_after_create", func(*Scope) {
 //       // business logic
 //       ...
 //
 //       // set error if some thing wrong happened, will rollback the creating
 //       scope.Err(errors.New("error"))
 //     })
 func (c *Callback) Create() *CallbackProcessor {
 	return &CallbackProcessor{logger: c.logger, kind: "create", parent: c}
 }
 // Update could be used to register callbacks for updating object, refer `Create` for usage
 func (c *Callback) Update() *CallbackProcessor {
 	return &CallbackProcessor{logger: c.logger, kind: "update", parent: c}
 }
 // Delete could be used to register callbacks for deleting object, refer `Create` for usage
 func (c *Callback) Delete() *CallbackProcessor {
 	return &CallbackProcessor{logger: c.logger, kind: "delete", parent: c}
 }
 // Query could be used to register callbacks for querying objects with query methods like `Find`, `First`, `Related`, `Association`...
 // Refer `Create` for usage
 func (c *Callback) Query() *CallbackProcessor {
 	return &CallbackProcessor{logger: c.logger, kind: "query", parent: c}
 }
 // RowQuery could be used to register callbacks for querying objects with `Row`, `Rows`, refer `Create` for usage
 func (c *Callback) RowQuery() *CallbackProcessor {
 	return &CallbackProcessor{logger: c.logger, kind: "row_query", parent: c}
 }
 // After insert a new callback after callback `callbackName`, refer `Callbacks.Create`
 func (cp *CallbackProcessor) After(callbackName string) *CallbackProcessor {
 	cp.after = callbackName
 	return cp
 }
 // Before insert a new callback before callback `callbackName`, refer `Callbacks.Create`
 func (cp *CallbackProcessor) Before(callbackName string) *CallbackProcessor {
 	cp.before = callbackName
 	return cp
 }
 // Register a new callback, refer `Callbacks.Create`
 func (cp *CallbackProcessor) Register(callbackName string, callback func(scope *Scope)) {
 	if cp.kind == "row_query" {
 		if cp.before == "" && cp.after == "" && callbackName != "gorm:row_query" {
 			cp.logger.Print("info", fmt.Sprintf("Registering RowQuery callback %v without specify order with Before(), After(), applying Before('gorm:row_query') by default for compatibility...", callbackName))
 			cp.before = "gorm:row_query"
 		}
 	}
 	cp.logger.Print("info", fmt.Sprintf("[info] registering callback `%v` from %v", callbackName, fileWithLineNum()))
 	cp.name = callbackName
 	cp.processor = &callback
 	cp.parent.processors = append(cp.parent.processors, cp)
 	cp.parent.reorder()
 }
 // Remove a registered callback
 //     db.Callback().Create().Remove("gorm:update_time_stamp_when_create")
 func (cp *CallbackProcessor) Remove(callbackName string) {
 	cp.logger.Print("info", fmt.Sprintf("[info] removing callback `%v` from %v", callbackName, fileWithLineNum()))
 	cp.name = callbackName
 	cp.remove = true
 	cp.parent.processors = append(cp.parent.processors, cp)
 	cp.parent.reorder()
 }
 // Replace a registered callback with new callback
 //     db.Callback().Create().Replace("gorm:update_time_stamp_when_create", func(*Scope) {
 //		   scope.SetColumn("CreatedAt", now)
 //		   scope.SetColumn("UpdatedAt", now)
 //     })
 func (cp *CallbackProcessor) Replace(callbackName string, callback func(scope *Scope)) {
 	cp.logger.Print("info", fmt.Sprintf("[info] replacing callback `%v` from %v", callbackName, fileWithLineNum()))
 	cp.name = callbackName
 	cp.processor = &callback
 	cp.replace = true
 	cp.parent.processors = append(cp.parent.processors, cp)
 	cp.parent.reorder()
 }
 // Get registered callback
 //    db.Callback().Create().Get("gorm:create")
 func (cp *CallbackProcessor) Get(callbackName string) (callback func(scope *Scope)) {
 	for _, p := range cp.parent.processors {
 		if p.name == callbackName && p.kind == cp.kind {
 			if p.remove {
 				callback = nil
 			} else {
 				callback = *p.processor
 			}
 		}
 	}
 	return
 }
 // getRIndex get right index from string slice
 func getRIndex(strs []string, str string) int {
 	for i := len(strs) - 1; i >= 0; i-- {
 		if strs[i] == str {
 			return i
 		}
 	}
 	return -1
 }
 // sortProcessors sort callback processors based on its before, after, remove, replace
 func sortProcessors(cps []*CallbackProcessor) []*func(scope *Scope) {
 	var (
 		allNames, sortedNames []string
 		sortCallbackProcessor func(c *CallbackProcessor)
 	)
 	for _, cp := range cps {
 		// show warning message the callback name already exists
 		if index := getRIndex(allNames, cp.name); index > -1 && !cp.replace && !cp.remove {
 			cp.logger.Print("warning", fmt.Sprintf("[warning] duplicated callback `%v` from %v", cp.name, fileWithLineNum()))
 		}
 		allNames = append(allNames, cp.name)
 	}
 	sortCallbackProcessor = func(c *CallbackProcessor) {
 		if getRIndex(sortedNames, c.name) == -1 { // if not sorted
 			if c.before != "" { // if defined before callback
 				if index := getRIndex(sortedNames, c.before); index != -1 {
 					// if before callback already sorted, append current callback just after it
 					sortedNames = append(sortedNames[:index], append([]string{c.name}, sortedNames[index:]...)...)
 				} else if index := getRIndex(allNames, c.before); index != -1 {
 					// if before callback exists but haven't sorted, append current callback to last
 					sortedNames = append(sortedNames, c.name)
 					sortCallbackProcessor(cps[index])
 				}
 			}
 			if c.after != "" { // if defined after callback
 				if index := getRIndex(sortedNames, c.after); index != -1 {
 					// if after callback already sorted, append current callback just before it
 					sortedNames = append(sortedNames[:index+1], append([]string{c.name}, sortedNames[index+1:]...)...)
 				} else if index := getRIndex(allNames, c.after); index != -1 {
 					// if after callback exists but haven't sorted
 					cp := cps[index]
 					// set after callback's before callback to current callback
 					if cp.before == "" {
 						cp.before = c.name
 					}
 					sortCallbackProcessor(cp)
 				}
 			}
 			// if current callback haven't been sorted, append it to last
 			if getRIndex(sortedNames, c.name) == -1 {
 				sortedNames = append(sortedNames, c.name)
 			}
 		}
 	}
 	for _, cp := range cps {
 		sortCallbackProcessor(cp)
 	}
 	var sortedFuncs []*func(scope *Scope)
 	for _, name := range sortedNames {
 		if index := getRIndex(allNames, name); !cps[index].remove {
 			sortedFuncs = append(sortedFuncs, cps[index].processor)
 		}
 	}
 	return sortedFuncs
 }
 // reorder all registered processors, and reset CRUD callbacks
 func (c *Callback) reorder() {
 	var creates, updates, deletes, queries, rowQueries []*CallbackProcessor
 	for _, processor := range c.processors {
 		if processor.name != "" {
 			switch processor.kind {
 			case "create":
 				creates = append(creates, processor)
 			case "update":
 				updates = append(updates, processor)
 			case "delete":
 				deletes = append(deletes, processor)
 			case "query":
 				queries = append(queries, processor)
 			case "row_query":
 				rowQueries = append(rowQueries, processor)
 			}
 		}
 	}
 	c.creates = sortProcessors(creates)
 	c.updates = sortProcessors(updates)
 	c.deletes = sortProcessors(deletes)
 	c.queries = sortProcessors(queries)
 	c.rowQueries = sortProcessors(rowQueries)
 }
--- a/vendor/github.com/jinzhu/gorm/callback_create.go
+++ b/vendor/github.com/jinzhu/gorm/callback_create.go
@ -0,0 +1,197 @@
 package gorm
 import (
 	"fmt"
 	"strings"
 )
 // Define callbacks for creating
 func init() {
 	DefaultCallback.Create().Register("gorm:begin_transaction", beginTransactionCallback)
 	DefaultCallback.Create().Register("gorm:before_create", beforeCreateCallback)
 	DefaultCallback.Create().Register("gorm:save_before_associations", saveBeforeAssociationsCallback)
 	DefaultCallback.Create().Register("gorm:update_time_stamp", updateTimeStampForCreateCallback)
 	DefaultCallback.Create().Register("gorm:create", createCallback)
 	DefaultCallback.Create().Register("gorm:force_reload_after_create", forceReloadAfterCreateCallback)
 	DefaultCallback.Create().Register("gorm:save_after_associations", saveAfterAssociationsCallback)
 	DefaultCallback.Create().Register("gorm:after_create", afterCreateCallback)
 	DefaultCallback.Create().Register("gorm:commit_or_rollback_transaction", commitOrRollbackTransactionCallback)
 }
 // beforeCreateCallback will invoke `BeforeSave`, `BeforeCreate` method before creating
 func beforeCreateCallback(scope *Scope) {
 	if !scope.HasError() {
 		scope.CallMethod("BeforeSave")
 	}
 	if !scope.HasError() {
 		scope.CallMethod("BeforeCreate")
 	}
 }
 // updateTimeStampForCreateCallback will set `CreatedAt`, `UpdatedAt` when creating
 func updateTimeStampForCreateCallback(scope *Scope) {
 	if !scope.HasError() {
 		now := scope.db.nowFunc()
 		if createdAtField, ok := scope.FieldByName("CreatedAt"); ok {
 			if createdAtField.IsBlank {
 				createdAtField.Set(now)
 			}
 		}
 		if updatedAtField, ok := scope.FieldByName("UpdatedAt"); ok {
 			if updatedAtField.IsBlank {
 				updatedAtField.Set(now)
 			}
 		}
 	}
 }
 // createCallback the callback used to insert data into database
 func createCallback(scope *Scope) {
 	if !scope.HasError() {
 		defer scope.trace(NowFunc())
 		var (
 			columns, placeholders        []string
 			blankColumnsWithDefaultValue []string
 		)
 		for _, field := range scope.Fields() {
 			if scope.changeableField(field) {
 				if field.IsNormal && !field.IsIgnored {
 					if field.IsBlank && field.HasDefaultValue {
 						blankColumnsWithDefaultValue = append(blankColumnsWithDefaultValue, scope.Quote(field.DBName))
 						scope.InstanceSet("gorm:blank_columns_with_default_value", blankColumnsWithDefaultValue)
 					} else if !field.IsPrimaryKey || !field.IsBlank {
 						columns = append(columns, scope.Quote(field.DBName))
 						placeholders = append(placeholders, scope.AddToVars(field.Field.Interface()))
 					}
 				} else if field.Relationship != nil && field.Relationship.Kind == "belongs_to" {
 					for _, foreignKey := range field.Relationship.ForeignDBNames {
 						if foreignField, ok := scope.FieldByName(foreignKey); ok && !scope.changeableField(foreignField) {
 							columns = append(columns, scope.Quote(foreignField.DBName))
 							placeholders = append(placeholders, scope.AddToVars(foreignField.Field.Interface()))
 						}
 					}
 				}
 			}
 		}
 		var (
 			returningColumn = "*"
 			quotedTableName = scope.QuotedTableName()
 			primaryField    = scope.PrimaryField()
 			extraOption     string
 			insertModifier  string
 		)
 		if str, ok := scope.Get("gorm:insert_option"); ok {
 			extraOption = fmt.Sprint(str)
 		}
 		if str, ok := scope.Get("gorm:insert_modifier"); ok {
 			insertModifier = strings.ToUpper(fmt.Sprint(str))
 			if insertModifier == "INTO" {
 				insertModifier = ""
 			}
 		}
 		if primaryField != nil {
 			returningColumn = scope.Quote(primaryField.DBName)
 		}
 		lastInsertIDOutputInterstitial := scope.Dialect().LastInsertIDOutputInterstitial(quotedTableName, returningColumn, columns)
 		var lastInsertIDReturningSuffix string
 		if lastInsertIDOutputInterstitial == "" {
 			lastInsertIDReturningSuffix = scope.Dialect().LastInsertIDReturningSuffix(quotedTableName, returningColumn)
 		}
 		if len(columns) == 0 {
 			scope.Raw(fmt.Sprintf(
 				"INSERT%v INTO %v %v%v%v",
 				addExtraSpaceIfExist(insertModifier),
 				quotedTableName,
 				scope.Dialect().DefaultValueStr(),
 				addExtraSpaceIfExist(extraOption),
 				addExtraSpaceIfExist(lastInsertIDReturningSuffix),
 			))
 		} else {
 			scope.Raw(fmt.Sprintf(
 				"INSERT%v INTO %v (%v)%v VALUES (%v)%v%v",
 				addExtraSpaceIfExist(insertModifier),
 				scope.QuotedTableName(),
 				strings.Join(columns, ","),
 				addExtraSpaceIfExist(lastInsertIDOutputInterstitial),
 				strings.Join(placeholders, ","),
 				addExtraSpaceIfExist(extraOption),
 				addExtraSpaceIfExist(lastInsertIDReturningSuffix),
 			))
 		}
 		// execute create sql: no primaryField
 		if primaryField == nil {
 			if result, err := scope.SQLDB().Exec(scope.SQL, scope.SQLVars...); scope.Err(err) == nil {
 				// set rows affected count
 				scope.db.RowsAffected, _ = result.RowsAffected()
 				// set primary value to primary field
 				if primaryField != nil && primaryField.IsBlank {
 					if primaryValue, err := result.LastInsertId(); scope.Err(err) == nil {
 						scope.Err(primaryField.Set(primaryValue))
 					}
 				}
 			}
 			return
 		}
 		// execute create sql: lastInsertID implemention for majority of dialects
 		if lastInsertIDReturningSuffix == "" && lastInsertIDOutputInterstitial == "" {
 			if result, err := scope.SQLDB().Exec(scope.SQL, scope.SQLVars...); scope.Err(err) == nil {
 				// set rows affected count
 				scope.db.RowsAffected, _ = result.RowsAffected()
 				// set primary value to primary field
 				if primaryField != nil && primaryField.IsBlank {
 					if primaryValue, err := result.LastInsertId(); scope.Err(err) == nil {
 						scope.Err(primaryField.Set(primaryValue))
 					}
 				}
 			}
 			return
 		}
 		// execute create sql: dialects with additional lastInsertID requirements (currently postgres & mssql)
 		if primaryField.Field.CanAddr() {
 			if err := scope.SQLDB().QueryRow(scope.SQL, scope.SQLVars...).Scan(primaryField.Field.Addr().Interface()); scope.Err(err) == nil {
 				primaryField.IsBlank = false
 				scope.db.RowsAffected = 1
 			}
 		} else {
 			scope.Err(ErrUnaddressable)
 		}
 		return
 	}
 }
 // forceReloadAfterCreateCallback will reload columns that having default value, and set it back to current object
 func forceReloadAfterCreateCallback(scope *Scope) {
 	if blankColumnsWithDefaultValue, ok := scope.InstanceGet("gorm:blank_columns_with_default_value"); ok {
 		db := scope.DB().New().Table(scope.TableName()).Select(blankColumnsWithDefaultValue.([]string))
 		for _, field := range scope.Fields() {
 			if field.IsPrimaryKey && !field.IsBlank {
 				db = db.Where(fmt.Sprintf("%v = ?", field.DBName), field.Field.Interface())
 			}
 		}
 		db.Scan(scope.Value)
 	}
 }
 // afterCreateCallback will invoke `AfterCreate`, `AfterSave` method after creating
 func afterCreateCallback(scope *Scope) {
 	if !scope.HasError() {
 		scope.CallMethod("AfterCreate")
 	}
 	if !scope.HasError() {
 		scope.CallMethod("AfterSave")
 	}
 }
--- a/vendor/github.com/jinzhu/gorm/callback_delete.go
+++ b/vendor/github.com/jinzhu/gorm/callback_delete.go
@ -0,0 +1,63 @@
 package gorm
 import (
 	"errors"
 	"fmt"
 )
 // Define callbacks for deleting
 func init() {
 	DefaultCallback.Delete().Register("gorm:begin_transaction", beginTransactionCallback)
 	DefaultCallback.Delete().Register("gorm:before_delete", beforeDeleteCallback)
 	DefaultCallback.Delete().Register("gorm:delete", deleteCallback)
 	DefaultCallback.Delete().Register("gorm:after_delete", afterDeleteCallback)
 	DefaultCallback.Delete().Register("gorm:commit_or_rollback_transaction", commitOrRollbackTransactionCallback)
 }
 // beforeDeleteCallback will invoke `BeforeDelete` method before deleting
 func beforeDeleteCallback(scope *Scope) {
 	if scope.DB().HasBlockGlobalUpdate() && !scope.hasConditions() {
 		scope.Err(errors.New("missing WHERE clause while deleting"))
 		return
 	}
 	if !scope.HasError() {
 		scope.CallMethod("BeforeDelete")
 	}
 }
 // deleteCallback used to delete data from database or set deleted_at to current time (when using with soft delete)
 func deleteCallback(scope *Scope) {
 	if !scope.HasError() {
 		var extraOption string
 		if str, ok := scope.Get("gorm:delete_option"); ok {
 			extraOption = fmt.Sprint(str)
 		}
 		deletedAtField, hasDeletedAtField := scope.FieldByName("DeletedAt")
 		if !scope.Search.Unscoped && hasDeletedAtField {
 			scope.Raw(fmt.Sprintf(
 				"UPDATE %v SET %v=%v%v%v",
 				scope.QuotedTableName(),
 				scope.Quote(deletedAtField.DBName),
 				scope.AddToVars(scope.db.nowFunc()),
 				addExtraSpaceIfExist(scope.CombinedConditionSql()),
 				addExtraSpaceIfExist(extraOption),
 			)).Exec()
 		} else {
 			scope.Raw(fmt.Sprintf(
 				"DELETE FROM %v%v%v",
 				scope.QuotedTableName(),
 				addExtraSpaceIfExist(scope.CombinedConditionSql()),
 				addExtraSpaceIfExist(extraOption),
 			)).Exec()
 		}
 	}
 }
 // afterDeleteCallback will invoke `AfterDelete` method after deleting
 func afterDeleteCallback(scope *Scope) {
 	if !scope.HasError() {
 		scope.CallMethod("AfterDelete")
 	}
 }
--- a/vendor/github.com/jinzhu/gorm/callback_query.go
+++ b/vendor/github.com/jinzhu/gorm/callback_query.go
@ -0,0 +1,109 @@
 package gorm
 import (
 	"errors"
 	"fmt"
 	"reflect"
 )
 // Define callbacks for querying
 func init() {
 	DefaultCallback.Query().Register("gorm:query", queryCallback)
 	DefaultCallback.Query().Register("gorm:preload", preloadCallback)
 	DefaultCallback.Query().Register("gorm:after_query", afterQueryCallback)
 }
 // queryCallback used to query data from database
 func queryCallback(scope *Scope) {
 	if _, skip := scope.InstanceGet("gorm:skip_query_callback"); skip {
 		return
 	}
 	//we are only preloading relations, dont touch base model
 	if _, skip := scope.InstanceGet("gorm:only_preload"); skip {
 		return
 	}
 	defer scope.trace(NowFunc())
 	var (
 		isSlice, isPtr bool
 		resultType     reflect.Type
 		results        = scope.IndirectValue()
 	)
 	if orderBy, ok := scope.Get("gorm:order_by_primary_key"); ok {
 		if primaryField := scope.PrimaryField(); primaryField != nil {
 			scope.Search.Order(fmt.Sprintf("%v.%v %v", scope.QuotedTableName(), scope.Quote(primaryField.DBName), orderBy))
 		}
 	}
 	if value, ok := scope.Get("gorm:query_destination"); ok {
 		results = indirect(reflect.ValueOf(value))
 	}
 	if kind := results.Kind(); kind == reflect.Slice {
 		isSlice = true
 		resultType = results.Type().Elem()
 		results.Set(reflect.MakeSlice(results.Type(), 0, 0))
 		if resultType.Kind() == reflect.Ptr {
 			isPtr = true
 			resultType = resultType.Elem()
 		}
 	} else if kind != reflect.Struct {
 		scope.Err(errors.New("unsupported destination, should be slice or struct"))
 		return
 	}
 	scope.prepareQuerySQL()
 	if !scope.HasError() {
 		scope.db.RowsAffected = 0
 		if str, ok := scope.Get("gorm:query_hint"); ok {
 			scope.SQL = fmt.Sprint(str) + scope.SQL
 		}
 		if str, ok := scope.Get("gorm:query_option"); ok {
 			scope.SQL += addExtraSpaceIfExist(fmt.Sprint(str))
 		}
 		if rows, err := scope.SQLDB().Query(scope.SQL, scope.SQLVars...); scope.Err(err) == nil {
 			defer rows.Close()
 			columns, _ := rows.Columns()
 			for rows.Next() {
 				scope.db.RowsAffected++
 				elem := results
 				if isSlice {
 					elem = reflect.New(resultType).Elem()
 				}
 				scope.scan(rows, columns, scope.New(elem.Addr().Interface()).Fields())
 				if isSlice {
 					if isPtr {
 						results.Set(reflect.Append(results, elem.Addr()))
 					} else {
 						results.Set(reflect.Append(results, elem))
 					}
 				}
 			}
 			if err := rows.Err(); err != nil {
 				scope.Err(err)
 			} else if scope.db.RowsAffected == 0 && !isSlice {
 				scope.Err(ErrRecordNotFound)
 			}
 		}
 	}
 }
 // afterQueryCallback will invoke `AfterFind` method after querying
 func afterQueryCallback(scope *Scope) {
 	if !scope.HasError() {
 		scope.CallMethod("AfterFind")
 	}
 }
--- a/vendor/github.com/jinzhu/gorm/callback_query_preload.go
+++ b/vendor/github.com/jinzhu/gorm/callback_query_preload.go
@ -0,0 +1,410 @@
 package gorm
 import (
 	"errors"
 	"fmt"
 	"reflect"
 	"strconv"
 	"strings"
 )
 // preloadCallback used to preload associations
 func preloadCallback(scope *Scope) {
 	if _, skip := scope.InstanceGet("gorm:skip_query_callback"); skip {
 		return
 	}
 	if ap, ok := scope.Get("gorm:auto_preload"); ok {
 		// If gorm:auto_preload IS NOT a bool then auto preload.
 		// Else if it IS a bool, use the value
 		if apb, ok := ap.(bool); !ok {
 			autoPreload(scope)
 		} else if apb {
 			autoPreload(scope)
 		}
 	}
 	if scope.Search.preload == nil || scope.HasError() {
 		return
 	}
 	var (
 		preloadedMap = map[string]bool{}
 		fields       = scope.Fields()
 	)
 	for _, preload := range scope.Search.preload {
 		var (
 			preloadFields = strings.Split(preload.schema, ".")
 			currentScope  = scope
 			currentFields = fields
 		)
 		for idx, preloadField := range preloadFields {
 			var currentPreloadConditions []interface{}
 			if currentScope == nil {
 				continue
 			}
 			// if not preloaded
 			if preloadKey := strings.Join(preloadFields[:idx+1], "."); !preloadedMap[preloadKey] {
 				// assign search conditions to last preload
 				if idx == len(preloadFields)-1 {
 					currentPreloadConditions = preload.conditions
 				}
 				for _, field := range currentFields {
 					if field.Name != preloadField || field.Relationship == nil {
 						continue
 					}
 					switch field.Relationship.Kind {
 					case "has_one":
 						currentScope.handleHasOnePreload(field, currentPreloadConditions)
 					case "has_many":
 						currentScope.handleHasManyPreload(field, currentPreloadConditions)
 					case "belongs_to":
 						currentScope.handleBelongsToPreload(field, currentPreloadConditions)
 					case "many_to_many":
 						currentScope.handleManyToManyPreload(field, currentPreloadConditions)
 					default:
 						scope.Err(errors.New("unsupported relation"))
 					}
 					preloadedMap[preloadKey] = true
 					break
 				}
 				if !preloadedMap[preloadKey] {
 					scope.Err(fmt.Errorf("can't preload field %s for %s", preloadField, currentScope.GetModelStruct().ModelType))
 					return
 				}
 			}
 			// preload next level
 			if idx < len(preloadFields)-1 {
 				currentScope = currentScope.getColumnAsScope(preloadField)
 				if currentScope != nil {
 					currentFields = currentScope.Fields()
 				}
 			}
 		}
 	}
 }
 func autoPreload(scope *Scope) {
 	for _, field := range scope.Fields() {
 		if field.Relationship == nil {
 			continue
 		}
 		if val, ok := field.TagSettingsGet("PRELOAD"); ok {
 			if preload, err := strconv.ParseBool(val); err != nil {
 				scope.Err(errors.New("invalid preload option"))
 				return
 			} else if !preload {
 				continue
 			}
 		}
 		scope.Search.Preload(field.Name)
 	}
 }
 func (scope *Scope) generatePreloadDBWithConditions(conditions []interface{}) (*DB, []interface{}) {
 	var (
 		preloadDB         = scope.NewDB()
 		preloadConditions []interface{}
 	)
 	for _, condition := range conditions {
 		if scopes, ok := condition.(func(*DB) *DB); ok {
 			preloadDB = scopes(preloadDB)
 		} else {
 			preloadConditions = append(preloadConditions, condition)
 		}
 	}
 	return preloadDB, preloadConditions
 }
 // handleHasOnePreload used to preload has one associations
 func (scope *Scope) handleHasOnePreload(field *Field, conditions []interface{}) {
 	relation := field.Relationship
 	// get relations's primary keys
 	primaryKeys := scope.getColumnAsArray(relation.AssociationForeignFieldNames, scope.Value)
 	if len(primaryKeys) == 0 {
 		return
 	}
 	// preload conditions
 	preloadDB, preloadConditions := scope.generatePreloadDBWithConditions(conditions)
 	// find relations
 	query := fmt.Sprintf("%v IN (%v)", toQueryCondition(scope, relation.ForeignDBNames), toQueryMarks(primaryKeys))
 	values := toQueryValues(primaryKeys)
 	if relation.PolymorphicType != "" {
 		query += fmt.Sprintf(" AND %v = ?", scope.Quote(relation.PolymorphicDBName))
 		values = append(values, relation.PolymorphicValue)
 	}
 	results := makeSlice(field.Struct.Type)
 	scope.Err(preloadDB.Where(query, values...).Find(results, preloadConditions...).Error)
 	// assign find results
 	var (
 		resultsValue       = indirect(reflect.ValueOf(results))
 		indirectScopeValue = scope.IndirectValue()
 	)
 	if indirectScopeValue.Kind() == reflect.Slice {
 		foreignValuesToResults := make(map[string]reflect.Value)
 		for i := 0; i < resultsValue.Len(); i++ {
 			result := resultsValue.Index(i)
 			foreignValues := toString(getValueFromFields(result, relation.ForeignFieldNames))
 			foreignValuesToResults[foreignValues] = result
 		}
 		for j := 0; j < indirectScopeValue.Len(); j++ {
 			indirectValue := indirect(indirectScopeValue.Index(j))
 			valueString := toString(getValueFromFields(indirectValue, relation.AssociationForeignFieldNames))
 			if result, found := foreignValuesToResults[valueString]; found {
 				indirectValue.FieldByName(field.Name).Set(result)
 			}
 		}
 	} else {
 		for i := 0; i < resultsValue.Len(); i++ {
 			result := resultsValue.Index(i)
 			scope.Err(field.Set(result))
 		}
 	}
 }
 // handleHasManyPreload used to preload has many associations
 func (scope *Scope) handleHasManyPreload(field *Field, conditions []interface{}) {
 	relation := field.Relationship
 	// get relations's primary keys
 	primaryKeys := scope.getColumnAsArray(relation.AssociationForeignFieldNames, scope.Value)
 	if len(primaryKeys) == 0 {
 		return
 	}
 	// preload conditions
 	preloadDB, preloadConditions := scope.generatePreloadDBWithConditions(conditions)
 	// find relations
 	query := fmt.Sprintf("%v IN (%v)", toQueryCondition(scope, relation.ForeignDBNames), toQueryMarks(primaryKeys))
 	values := toQueryValues(primaryKeys)
 	if relation.PolymorphicType != "" {
 		query += fmt.Sprintf(" AND %v = ?", scope.Quote(relation.PolymorphicDBName))
 		values = append(values, relation.PolymorphicValue)
 	}
 	results := makeSlice(field.Struct.Type)
 	scope.Err(preloadDB.Where(query, values...).Find(results, preloadConditions...).Error)
 	// assign find results
 	var (
 		resultsValue       = indirect(reflect.ValueOf(results))
 		indirectScopeValue = scope.IndirectValue()
 	)
 	if indirectScopeValue.Kind() == reflect.Slice {
 		preloadMap := make(map[string][]reflect.Value)
 		for i := 0; i < resultsValue.Len(); i++ {
 			result := resultsValue.Index(i)
 			foreignValues := getValueFromFields(result, relation.ForeignFieldNames)
 			preloadMap[toString(foreignValues)] = append(preloadMap[toString(foreignValues)], result)
 		}
 		for j := 0; j < indirectScopeValue.Len(); j++ {
 			object := indirect(indirectScopeValue.Index(j))
 			objectRealValue := getValueFromFields(object, relation.AssociationForeignFieldNames)
 			f := object.FieldByName(field.Name)
 			if results, ok := preloadMap[toString(objectRealValue)]; ok {
 				f.Set(reflect.Append(f, results...))
 			} else {
 				f.Set(reflect.MakeSlice(f.Type(), 0, 0))
 			}
 		}
 	} else {
 		scope.Err(field.Set(resultsValue))
 	}
 }
 // handleBelongsToPreload used to preload belongs to associations
 func (scope *Scope) handleBelongsToPreload(field *Field, conditions []interface{}) {
 	relation := field.Relationship
 	// preload conditions
 	preloadDB, preloadConditions := scope.generatePreloadDBWithConditions(conditions)
 	// get relations's primary keys
 	primaryKeys := scope.getColumnAsArray(relation.ForeignFieldNames, scope.Value)
 	if len(primaryKeys) == 0 {
 		return
 	}
 	// find relations
 	results := makeSlice(field.Struct.Type)
 	scope.Err(preloadDB.Where(fmt.Sprintf("%v IN (%v)", toQueryCondition(scope, relation.AssociationForeignDBNames), toQueryMarks(primaryKeys)), toQueryValues(primaryKeys)...).Find(results, preloadConditions...).Error)
 	// assign find results
 	var (
 		resultsValue       = indirect(reflect.ValueOf(results))
 		indirectScopeValue = scope.IndirectValue()
 	)
 	foreignFieldToObjects := make(map[string][]*reflect.Value)
 	if indirectScopeValue.Kind() == reflect.Slice {
 		for j := 0; j < indirectScopeValue.Len(); j++ {
 			object := indirect(indirectScopeValue.Index(j))
 			valueString := toString(getValueFromFields(object, relation.ForeignFieldNames))
 			foreignFieldToObjects[valueString] = append(foreignFieldToObjects[valueString], &object)
 		}
 	}
 	for i := 0; i < resultsValue.Len(); i++ {
 		result := resultsValue.Index(i)
 		if indirectScopeValue.Kind() == reflect.Slice {
 			valueString := toString(getValueFromFields(result, relation.AssociationForeignFieldNames))
 			if objects, found := foreignFieldToObjects[valueString]; found {
 				for _, object := range objects {
 					object.FieldByName(field.Name).Set(result)
 				}
 			}
 		} else {
 			scope.Err(field.Set(result))
 		}
 	}
 }
 // handleManyToManyPreload used to preload many to many associations
 func (scope *Scope) handleManyToManyPreload(field *Field, conditions []interface{}) {
 	var (
 		relation         = field.Relationship
 		joinTableHandler = relation.JoinTableHandler
 		fieldType        = field.Struct.Type.Elem()
 		foreignKeyValue  interface{}
 		foreignKeyType   = reflect.ValueOf(&foreignKeyValue).Type()
 		linkHash         = map[string][]reflect.Value{}
 		isPtr            bool
 	)
 	if fieldType.Kind() == reflect.Ptr {
 		isPtr = true
 		fieldType = fieldType.Elem()
 	}
 	var sourceKeys = []string{}
 	for _, key := range joinTableHandler.SourceForeignKeys() {
 		sourceKeys = append(sourceKeys, key.DBName)
 	}
 	// preload conditions
 	preloadDB, preloadConditions := scope.generatePreloadDBWithConditions(conditions)
 	// generate query with join table
 	newScope := scope.New(reflect.New(fieldType).Interface())
 	preloadDB = preloadDB.Table(newScope.TableName()).Model(newScope.Value)
 	if len(preloadDB.search.selects) == 0 {
 		preloadDB = preloadDB.Select("*")
 	}
 	preloadDB = joinTableHandler.JoinWith(joinTableHandler, preloadDB, scope.Value)
 	// preload inline conditions
 	if len(preloadConditions) > 0 {
 		preloadDB = preloadDB.Where(preloadConditions[0], preloadConditions[1:]...)
 	}
 	rows, err := preloadDB.Rows()
 	if scope.Err(err) != nil {
 		return
 	}
 	defer rows.Close()
 	columns, _ := rows.Columns()
 	for rows.Next() {
 		var (
 			elem   = reflect.New(fieldType).Elem()
 			fields = scope.New(elem.Addr().Interface()).Fields()
 		)
 		// register foreign keys in join tables
 		var joinTableFields []*Field
 		for _, sourceKey := range sourceKeys {
 			joinTableFields = append(joinTableFields, &Field{StructField: &StructField{DBName: sourceKey, IsNormal: true}, Field: reflect.New(foreignKeyType).Elem()})
 		}
 		scope.scan(rows, columns, append(fields, joinTableFields...))
 		scope.New(elem.Addr().Interface()).
 			InstanceSet("gorm:skip_query_callback", true).
 			callCallbacks(scope.db.parent.callbacks.queries)
 		var foreignKeys = make([]interface{}, len(sourceKeys))
 		// generate hashed forkey keys in join table
 		for idx, joinTableField := range joinTableFields {
 			if !joinTableField.Field.IsNil() {
 				foreignKeys[idx] = joinTableField.Field.Elem().Interface()
 			}
 		}
 		hashedSourceKeys := toString(foreignKeys)
 		if isPtr {
 			linkHash[hashedSourceKeys] = append(linkHash[hashedSourceKeys], elem.Addr())
 		} else {
 			linkHash[hashedSourceKeys] = append(linkHash[hashedSourceKeys], elem)
 		}
 	}
 	if err := rows.Err(); err != nil {
 		scope.Err(err)
 	}
 	// assign find results
 	var (
 		indirectScopeValue = scope.IndirectValue()
 		fieldsSourceMap    = map[string][]reflect.Value{}
 		foreignFieldNames  = []string{}
 	)
 	for _, dbName := range relation.ForeignFieldNames {
 		if field, ok := scope.FieldByName(dbName); ok {
 			foreignFieldNames = append(foreignFieldNames, field.Name)
 		}
 	}
 	if indirectScopeValue.Kind() == reflect.Slice {
 		for j := 0; j < indirectScopeValue.Len(); j++ {
 			object := indirect(indirectScopeValue.Index(j))
 			key := toString(getValueFromFields(object, foreignFieldNames))
 			fieldsSourceMap[key] = append(fieldsSourceMap[key], object.FieldByName(field.Name))
 		}
 	} else if indirectScopeValue.IsValid() {
 		key := toString(getValueFromFields(indirectScopeValue, foreignFieldNames))
 		fieldsSourceMap[key] = append(fieldsSourceMap[key], indirectScopeValue.FieldByName(field.Name))
 	}
 	for source, fields := range fieldsSourceMap {
 		for _, f := range fields {
 			//If not 0 this means Value is a pointer and we already added preloaded models to it
 			if f.Len() != 0 {
 				continue
 			}
 			v := reflect.MakeSlice(f.Type(), 0, 0)
 			if len(linkHash[source]) > 0 {
 				v = reflect.Append(f, linkHash[source]...)
 			}
 			f.Set(v)
 		}
 	}
 }
--- a/vendor/github.com/jinzhu/gorm/callback_row_query.go
+++ b/vendor/github.com/jinzhu/gorm/callback_row_query.go
@ -0,0 +1,41 @@
 package gorm
 import (
 	"database/sql"
 	"fmt"
 )
 // Define callbacks for row query
 func init() {
 	DefaultCallback.RowQuery().Register("gorm:row_query", rowQueryCallback)
 }
 type RowQueryResult struct {
 	Row *sql.Row
 }
 type RowsQueryResult struct {
 	Rows  *sql.Rows
 	Error error
 }
 // queryCallback used to query data from database
 func rowQueryCallback(scope *Scope) {
 	if result, ok := scope.InstanceGet("row_query_result"); ok {
 		scope.prepareQuerySQL()
 		if str, ok := scope.Get("gorm:query_hint"); ok {
 			scope.SQL = fmt.Sprint(str) + scope.SQL
 		}
 		if str, ok := scope.Get("gorm:query_option"); ok {
 			scope.SQL += addExtraSpaceIfExist(fmt.Sprint(str))
 		}
 		if rowResult, ok := result.(*RowQueryResult); ok {
 			rowResult.Row = scope.SQLDB().QueryRow(scope.SQL, scope.SQLVars...)
 		} else if rowsResult, ok := result.(*RowsQueryResult); ok {
 			rowsResult.Rows, rowsResult.Error = scope.SQLDB().Query(scope.SQL, scope.SQLVars...)
 		}
 	}
 }
--- a/vendor/github.com/jinzhu/gorm/callback_save.go
+++ b/vendor/github.com/jinzhu/gorm/callback_save.go
@ -0,0 +1,170 @@
 package gorm
 import (
 	"reflect"
 	"strings"
 )
 func beginTransactionCallback(scope *Scope) {
 	scope.Begin()
 }
 func commitOrRollbackTransactionCallback(scope *Scope) {
 	scope.CommitOrRollback()
 }
 func saveAssociationCheck(scope *Scope, field *Field) (autoUpdate bool, autoCreate bool, saveReference bool, r *Relationship) {
 	checkTruth := func(value interface{}) bool {
 		if v, ok := value.(bool); ok && !v {
 			return false
 		}
 		if v, ok := value.(string); ok {
 			v = strings.ToLower(v)
 			return v == "true"
 		}
 		return true
 	}
 	if scope.changeableField(field) && !field.IsBlank && !field.IsIgnored {
 		if r = field.Relationship; r != nil {
 			autoUpdate, autoCreate, saveReference = true, true, true
 			if value, ok := scope.Get("gorm:save_associations"); ok {
 				autoUpdate = checkTruth(value)
 				autoCreate = autoUpdate
 				saveReference = autoUpdate
 			} else if value, ok := field.TagSettingsGet("SAVE_ASSOCIATIONS"); ok {
 				autoUpdate = checkTruth(value)
 				autoCreate = autoUpdate
 				saveReference = autoUpdate
 			}
 			if value, ok := scope.Get("gorm:association_autoupdate"); ok {
 				autoUpdate = checkTruth(value)
 			} else if value, ok := field.TagSettingsGet("ASSOCIATION_AUTOUPDATE"); ok {
 				autoUpdate = checkTruth(value)
 			}
 			if value, ok := scope.Get("gorm:association_autocreate"); ok {
 				autoCreate = checkTruth(value)
 			} else if value, ok := field.TagSettingsGet("ASSOCIATION_AUTOCREATE"); ok {
 				autoCreate = checkTruth(value)
 			}
 			if value, ok := scope.Get("gorm:association_save_reference"); ok {
 				saveReference = checkTruth(value)
 			} else if value, ok := field.TagSettingsGet("ASSOCIATION_SAVE_REFERENCE"); ok {
 				saveReference = checkTruth(value)
 			}
 		}
 	}
 	return
 }
 func saveBeforeAssociationsCallback(scope *Scope) {
 	for _, field := range scope.Fields() {
 		autoUpdate, autoCreate, saveReference, relationship := saveAssociationCheck(scope, field)
 		if relationship != nil && relationship.Kind == "belongs_to" {
 			fieldValue := field.Field.Addr().Interface()
 			newScope := scope.New(fieldValue)
 			if newScope.PrimaryKeyZero() {
 				if autoCreate {
 					scope.Err(scope.NewDB().Save(fieldValue).Error)
 				}
 			} else if autoUpdate {
 				scope.Err(scope.NewDB().Save(fieldValue).Error)
 			}
 			if saveReference {
 				if len(relationship.ForeignFieldNames) != 0 {
 					// set value's foreign key
 					for idx, fieldName := range relationship.ForeignFieldNames {
 						associationForeignName := relationship.AssociationForeignDBNames[idx]
 						if foreignField, ok := scope.New(fieldValue).FieldByName(associationForeignName); ok {
 							scope.Err(scope.SetColumn(fieldName, foreignField.Field.Interface()))
 						}
 					}
 				}
 			}
 		}
 	}
 }
 func saveAfterAssociationsCallback(scope *Scope) {
 	for _, field := range scope.Fields() {
 		autoUpdate, autoCreate, saveReference, relationship := saveAssociationCheck(scope, field)
 		if relationship != nil && (relationship.Kind == "has_one" || relationship.Kind == "has_many" || relationship.Kind == "many_to_many") {
 			value := field.Field
 			switch value.Kind() {
 			case reflect.Slice:
 				for i := 0; i < value.Len(); i++ {
 					newDB := scope.NewDB()
 					elem := value.Index(i).Addr().Interface()
 					newScope := newDB.NewScope(elem)
 					if saveReference {
 						if relationship.JoinTableHandler == nil && len(relationship.ForeignFieldNames) != 0 {
 							for idx, fieldName := range relationship.ForeignFieldNames {
 								associationForeignName := relationship.AssociationForeignDBNames[idx]
 								if f, ok := scope.FieldByName(associationForeignName); ok {
 									scope.Err(newScope.SetColumn(fieldName, f.Field.Interface()))
 								}
 							}
 						}
 						if relationship.PolymorphicType != "" {
 							scope.Err(newScope.SetColumn(relationship.PolymorphicType, relationship.PolymorphicValue))
 						}
 					}
 					if newScope.PrimaryKeyZero() {
 						if autoCreate {
 							scope.Err(newDB.Save(elem).Error)
 						}
 					} else if autoUpdate {
 						scope.Err(newDB.Save(elem).Error)
 					}
 					if !scope.New(newScope.Value).PrimaryKeyZero() && saveReference {
 						if joinTableHandler := relationship.JoinTableHandler; joinTableHandler != nil {
 							scope.Err(joinTableHandler.Add(joinTableHandler, newDB, scope.Value, newScope.Value))
 						}
 					}
 				}
 			default:
 				elem := value.Addr().Interface()
 				newScope := scope.New(elem)
 				if saveReference {
 					if len(relationship.ForeignFieldNames) != 0 {
 						for idx, fieldName := range relationship.ForeignFieldNames {
 							associationForeignName := relationship.AssociationForeignDBNames[idx]
 							if f, ok := scope.FieldByName(associationForeignName); ok {
 								scope.Err(newScope.SetColumn(fieldName, f.Field.Interface()))
 							}
 						}
 					}
 					if relationship.PolymorphicType != "" {
 						scope.Err(newScope.SetColumn(relationship.PolymorphicType, relationship.PolymorphicValue))
 					}
 				}
 				if newScope.PrimaryKeyZero() {
 					if autoCreate {
 						scope.Err(scope.NewDB().Save(elem).Error)
 					}
 				} else if autoUpdate {
 					scope.Err(scope.NewDB().Save(elem).Error)
 				}
 			}
 		}
 	}
 }
--- a/vendor/github.com/jinzhu/gorm/callback_update.go
+++ b/vendor/github.com/jinzhu/gorm/callback_update.go
@ -0,0 +1,121 @@
 package gorm
 import (
 	"errors"
 	"fmt"
 	"sort"
 	"strings"
 )
 // Define callbacks for updating
 func init() {
 	DefaultCallback.Update().Register("gorm:assign_updating_attributes", assignUpdatingAttributesCallback)
 	DefaultCallback.Update().Register("gorm:begin_transaction", beginTransactionCallback)
 	DefaultCallback.Update().Register("gorm:before_update", beforeUpdateCallback)
 	DefaultCallback.Update().Register("gorm:save_before_associations", saveBeforeAssociationsCallback)
 	DefaultCallback.Update().Register("gorm:update_time_stamp", updateTimeStampForUpdateCallback)
 	DefaultCallback.Update().Register("gorm:update", updateCallback)
 	DefaultCallback.Update().Register("gorm:save_after_associations", saveAfterAssociationsCallback)
 	DefaultCallback.Update().Register("gorm:after_update", afterUpdateCallback)
 	DefaultCallback.Update().Register("gorm:commit_or_rollback_transaction", commitOrRollbackTransactionCallback)
 }
 // assignUpdatingAttributesCallback assign updating attributes to model
 func assignUpdatingAttributesCallback(scope *Scope) {
 	if attrs, ok := scope.InstanceGet("gorm:update_interface"); ok {
 		if updateMaps, hasUpdate := scope.updatedAttrsWithValues(attrs); hasUpdate {
 			scope.InstanceSet("gorm:update_attrs", updateMaps)
 		} else {
 			scope.SkipLeft()
 		}
 	}
 }
 // beforeUpdateCallback will invoke `BeforeSave`, `BeforeUpdate` method before updating
 func beforeUpdateCallback(scope *Scope) {
 	if scope.DB().HasBlockGlobalUpdate() && !scope.hasConditions() {
 		scope.Err(errors.New("missing WHERE clause while updating"))
 		return
 	}
 	if _, ok := scope.Get("gorm:update_column"); !ok {
 		if !scope.HasError() {
 			scope.CallMethod("BeforeSave")
 		}
 		if !scope.HasError() {
 			scope.CallMethod("BeforeUpdate")
 		}
 	}
 }
 // updateTimeStampForUpdateCallback will set `UpdatedAt` when updating
 func updateTimeStampForUpdateCallback(scope *Scope) {
 	if _, ok := scope.Get("gorm:update_column"); !ok {
 		scope.SetColumn("UpdatedAt", scope.db.nowFunc())
 	}
 }
 // updateCallback the callback used to update data to database
 func updateCallback(scope *Scope) {
 	if !scope.HasError() {
 		var sqls []string
 		if updateAttrs, ok := scope.InstanceGet("gorm:update_attrs"); ok {
 			// Sort the column names so that the generated SQL is the same every time.
 			updateMap := updateAttrs.(map[string]interface{})
 			var columns []string
 			for c := range updateMap {
 				columns = append(columns, c)
 			}
 			sort.Strings(columns)
 			for _, column := range columns {
 				value := updateMap[column]
 				sqls = append(sqls, fmt.Sprintf("%v = %v", scope.Quote(column), scope.AddToVars(value)))
 			}
 		} else {
 			for _, field := range scope.Fields() {
 				if scope.changeableField(field) {
 					if !field.IsPrimaryKey && field.IsNormal && (field.Name != "CreatedAt" || !field.IsBlank) {
 						if !field.IsForeignKey || !field.IsBlank || !field.HasDefaultValue {
 							sqls = append(sqls, fmt.Sprintf("%v = %v", scope.Quote(field.DBName), scope.AddToVars(field.Field.Interface())))
 						}
 					} else if relationship := field.Relationship; relationship != nil && relationship.Kind == "belongs_to" {
 						for _, foreignKey := range relationship.ForeignDBNames {
 							if foreignField, ok := scope.FieldByName(foreignKey); ok && !scope.changeableField(foreignField) {
 								sqls = append(sqls,
 									fmt.Sprintf("%v = %v", scope.Quote(foreignField.DBName), scope.AddToVars(foreignField.Field.Interface())))
 							}
 						}
 					}
 				}
 			}
 		}
 		var extraOption string
 		if str, ok := scope.Get("gorm:update_option"); ok {
 			extraOption = fmt.Sprint(str)
 		}
 		if len(sqls) > 0 {
 			scope.Raw(fmt.Sprintf(
 				"UPDATE %v SET %v%v%v",
 				scope.QuotedTableName(),
 				strings.Join(sqls, ", "),
 				addExtraSpaceIfExist(scope.CombinedConditionSql()),
 				addExtraSpaceIfExist(extraOption),
 			)).Exec()
 		}
 	}
 }
 // afterUpdateCallback will invoke `AfterUpdate`, `AfterSave` method after updating
 func afterUpdateCallback(scope *Scope) {
 	if _, ok := scope.Get("gorm:update_column"); !ok {
 		if !scope.HasError() {
 			scope.CallMethod("AfterUpdate")
 		}
 		if !scope.HasError() {
 			scope.CallMethod("AfterSave")
 		}
 	}
 }
--- a/vendor/github.com/jinzhu/gorm/dialect.go
+++ b/vendor/github.com/jinzhu/gorm/dialect.go
@ -0,0 +1,147 @@
 package gorm
 import (
 	"database/sql"
 	"fmt"
 	"reflect"
 	"strconv"
 	"strings"
 )
 // Dialect interface contains behaviors that differ across SQL database
 type Dialect interface {
 	// GetName get dialect's name
 	GetName() string
 	// SetDB set db for dialect
 	SetDB(db SQLCommon)
 	// BindVar return the placeholder for actual values in SQL statements, in many dbs it is "?", Postgres using $1
 	BindVar(i int) string
 	// Quote quotes field name to avoid SQL parsing exceptions by using a reserved word as a field name
 	Quote(key string) string
 	// DataTypeOf return data's sql type
 	DataTypeOf(field *StructField) string
 	// HasIndex check has index or not
 	HasIndex(tableName string, indexName string) bool
 	// HasForeignKey check has foreign key or not
 	HasForeignKey(tableName string, foreignKeyName string) bool
 	// RemoveIndex remove index
 	RemoveIndex(tableName string, indexName string) error
 	// HasTable check has table or not
 	HasTable(tableName string) bool
 	// HasColumn check has column or not
 	HasColumn(tableName string, columnName string) bool
 	// ModifyColumn modify column's type
 	ModifyColumn(tableName string, columnName string, typ string) error
 	// LimitAndOffsetSQL return generated SQL with Limit and Offset, as mssql has special case
 	LimitAndOffsetSQL(limit, offset interface{}) (string, error)
 	// SelectFromDummyTable return select values, for most dbs, `SELECT values` just works, mysql needs `SELECT value FROM DUAL`
 	SelectFromDummyTable() string
 	// LastInsertIDOutputInterstitial most dbs support LastInsertId, but mssql needs to use `OUTPUT`
 	LastInsertIDOutputInterstitial(tableName, columnName string, columns []string) string
 	// LastInsertIdReturningSuffix most dbs support LastInsertId, but postgres needs to use `RETURNING`
 	LastInsertIDReturningSuffix(tableName, columnName string) string
 	// DefaultValueStr
 	DefaultValueStr() string
 	// BuildKeyName returns a valid key name (foreign key, index key) for the given table, field and reference
 	BuildKeyName(kind, tableName string, fields ...string) string
 	// NormalizeIndexAndColumn returns valid index name and column name depending on each dialect
 	NormalizeIndexAndColumn(indexName, columnName string) (string, string)
 	// CurrentDatabase return current database name
 	CurrentDatabase() string
 }
 var dialectsMap = map[string]Dialect{}
 func newDialect(name string, db SQLCommon) Dialect {
 	if value, ok := dialectsMap[name]; ok {
 		dialect := reflect.New(reflect.TypeOf(value).Elem()).Interface().(Dialect)
 		dialect.SetDB(db)
 		return dialect
 	}
 	fmt.Printf("`%v` is not officially supported, running under compatibility mode.\n", name)
 	commontDialect := &commonDialect{}
 	commontDialect.SetDB(db)
 	return commontDialect
 }
 // RegisterDialect register new dialect
 func RegisterDialect(name string, dialect Dialect) {
 	dialectsMap[name] = dialect
 }
 // GetDialect gets the dialect for the specified dialect name
 func GetDialect(name string) (dialect Dialect, ok bool) {
 	dialect, ok = dialectsMap[name]
 	return
 }
 // ParseFieldStructForDialect get field's sql data type
 var ParseFieldStructForDialect = func(field *StructField, dialect Dialect) (fieldValue reflect.Value, sqlType string, size int, additionalType string) {
 	// Get redirected field type
 	var (
 		reflectType = field.Struct.Type
 		dataType, _ = field.TagSettingsGet("TYPE")
 	)
 	for reflectType.Kind() == reflect.Ptr {
 		reflectType = reflectType.Elem()
 	}
 	// Get redirected field value
 	fieldValue = reflect.Indirect(reflect.New(reflectType))
 	if gormDataType, ok := fieldValue.Interface().(interface {
 		GormDataType(Dialect) string
 	}); ok {
 		dataType = gormDataType.GormDataType(dialect)
 	}
 	// Get scanner's real value
 	if dataType == "" {
 		var getScannerValue func(reflect.Value)
 		getScannerValue = func(value reflect.Value) {
 			fieldValue = value
 			if _, isScanner := reflect.New(fieldValue.Type()).Interface().(sql.Scanner); isScanner && fieldValue.Kind() == reflect.Struct {
 				getScannerValue(fieldValue.Field(0))
 			}
 		}
 		getScannerValue(fieldValue)
 	}
 	// Default Size
 	if num, ok := field.TagSettingsGet("SIZE"); ok {
 		size, _ = strconv.Atoi(num)
 	} else {
 		size = 255
 	}
 	// Default type from tag setting
 	notNull, _ := field.TagSettingsGet("NOT NULL")
 	unique, _ := field.TagSettingsGet("UNIQUE")
 	additionalType = notNull + " " + unique
 	if value, ok := field.TagSettingsGet("DEFAULT"); ok {
 		additionalType = additionalType + " DEFAULT " + value
 	}
 	if value, ok := field.TagSettingsGet("COMMENT"); ok {
 		additionalType = additionalType + " COMMENT " + value
 	}
 	return fieldValue, dataType, size, strings.TrimSpace(additionalType)
 }
 func currentDatabaseAndTable(dialect Dialect, tableName string) (string, string) {
 	if strings.Contains(tableName, ".") {
 		splitStrings := strings.SplitN(tableName, ".", 2)
 		return splitStrings[0], splitStrings[1]
 	}
 	return dialect.CurrentDatabase(), tableName
 }
--- a/vendor/github.com/jinzhu/gorm/dialect_common.go
+++ b/vendor/github.com/jinzhu/gorm/dialect_common.go
@ -0,0 +1,196 @@
 package gorm
 import (
 	"fmt"
 	"reflect"
 	"regexp"
 	"strconv"
 	"strings"
 	"time"
 )
 var keyNameRegex = regexp.MustCompile("[^a-zA-Z0-9]+")
 // DefaultForeignKeyNamer contains the default foreign key name generator method
 type DefaultForeignKeyNamer struct {
 }
 type commonDialect struct {
 	db SQLCommon
 	DefaultForeignKeyNamer
 }
 func init() {
 	RegisterDialect("common", &commonDialect{})
 }
 func (commonDialect) GetName() string {
 	return "common"
 }
 func (s *commonDialect) SetDB(db SQLCommon) {
 	s.db = db
 }
 func (commonDialect) BindVar(i int) string {
 	return "$$$" // ?
 }
 func (commonDialect) Quote(key string) string {
 	return fmt.Sprintf(`"%s"`, key)
 }
 func (s *commonDialect) fieldCanAutoIncrement(field *StructField) bool {
 	if value, ok := field.TagSettingsGet("AUTO_INCREMENT"); ok {
 		return strings.ToLower(value) != "false"
 	}
 	return field.IsPrimaryKey
 }
 func (s *commonDialect) DataTypeOf(field *StructField) string {
 	var dataValue, sqlType, size, additionalType = ParseFieldStructForDialect(field, s)
 	if sqlType == "" {
 		switch dataValue.Kind() {
 		case reflect.Bool:
 			sqlType = "BOOLEAN"
 		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uintptr:
 			if s.fieldCanAutoIncrement(field) {
 				sqlType = "INTEGER AUTO_INCREMENT"
 			} else {
 				sqlType = "INTEGER"
 			}
 		case reflect.Int64, reflect.Uint64:
 			if s.fieldCanAutoIncrement(field) {
 				sqlType = "BIGINT AUTO_INCREMENT"
 			} else {
 				sqlType = "BIGINT"
 			}
 		case reflect.Float32, reflect.Float64:
 			sqlType = "FLOAT"
 		case reflect.String:
 			if size > 0 && size < 65532 {
 				sqlType = fmt.Sprintf("VARCHAR(%d)", size)
 			} else {
 				sqlType = "VARCHAR(65532)"
 			}
 		case reflect.Struct:
 			if _, ok := dataValue.Interface().(time.Time); ok {
 				sqlType = "TIMESTAMP"
 			}
 		default:
 			if _, ok := dataValue.Interface().([]byte); ok {
 				if size > 0 && size < 65532 {
 					sqlType = fmt.Sprintf("BINARY(%d)", size)
 				} else {
 					sqlType = "BINARY(65532)"
 				}
 			}
 		}
 	}
 	if sqlType == "" {
 		panic(fmt.Sprintf("invalid sql type %s (%s) for commonDialect", dataValue.Type().Name(), dataValue.Kind().String()))
 	}
 	if strings.TrimSpace(additionalType) == "" {
 		return sqlType
 	}
 	return fmt.Sprintf("%v %v", sqlType, additionalType)
 }
 func (s commonDialect) HasIndex(tableName string, indexName string) bool {
 	var count int
 	currentDatabase, tableName := currentDatabaseAndTable(&s, tableName)
 	s.db.QueryRow("SELECT count(*) FROM INFORMATION_SCHEMA.STATISTICS WHERE table_schema = ? AND table_name = ? AND index_name = ?", currentDatabase, tableName, indexName).Scan(&count)
 	return count > 0
 }
 func (s commonDialect) RemoveIndex(tableName string, indexName string) error {
 	_, err := s.db.Exec(fmt.Sprintf("DROP INDEX %v", indexName))
 	return err
 }
 func (s commonDialect) HasForeignKey(tableName string, foreignKeyName string) bool {
 	return false
 }
 func (s commonDialect) HasTable(tableName string) bool {
 	var count int
 	currentDatabase, tableName := currentDatabaseAndTable(&s, tableName)
 	s.db.QueryRow("SELECT count(*) FROM INFORMATION_SCHEMA.TABLES WHERE table_schema = ? AND table_name = ?", currentDatabase, tableName).Scan(&count)
 	return count > 0
 }
 func (s commonDialect) HasColumn(tableName string, columnName string) bool {
 	var count int
 	currentDatabase, tableName := currentDatabaseAndTable(&s, tableName)
 	s.db.QueryRow("SELECT count(*) FROM INFORMATION_SCHEMA.COLUMNS WHERE table_schema = ? AND table_name = ? AND column_name = ?", currentDatabase, tableName, columnName).Scan(&count)
 	return count > 0
 }
 func (s commonDialect) ModifyColumn(tableName string, columnName string, typ string) error {
 	_, err := s.db.Exec(fmt.Sprintf("ALTER TABLE %v ALTER COLUMN %v TYPE %v", tableName, columnName, typ))
 	return err
 }
 func (s commonDialect) CurrentDatabase() (name string) {
 	s.db.QueryRow("SELECT DATABASE()").Scan(&name)
 	return
 }
 // LimitAndOffsetSQL return generated SQL with Limit and Offset
 func (s commonDialect) LimitAndOffsetSQL(limit, offset interface{}) (sql string, err error) {
 	if limit != nil {
 		if parsedLimit, err := s.parseInt(limit); err != nil {
 			return "", err
 		} else if parsedLimit >= 0 {
 			sql += fmt.Sprintf(" LIMIT %d", parsedLimit)
 		}
 	}
 	if offset != nil {
 		if parsedOffset, err := s.parseInt(offset); err != nil {
 			return "", err
 		} else if parsedOffset >= 0 {
 			sql += fmt.Sprintf(" OFFSET %d", parsedOffset)
 		}
 	}
 	return
 }
 func (commonDialect) SelectFromDummyTable() string {
 	return ""
 }
 func (commonDialect) LastInsertIDOutputInterstitial(tableName, columnName string, columns []string) string {
 	return ""
 }
 func (commonDialect) LastInsertIDReturningSuffix(tableName, columnName string) string {
 	return ""
 }
 func (commonDialect) DefaultValueStr() string {
 	return "DEFAULT VALUES"
 }
 // BuildKeyName returns a valid key name (foreign key, index key) for the given table, field and reference
 func (DefaultForeignKeyNamer) BuildKeyName(kind, tableName string, fields ...string) string {
 	keyName := fmt.Sprintf("%s_%s_%s", kind, tableName, strings.Join(fields, "_"))
 	keyName = keyNameRegex.ReplaceAllString(keyName, "_")
 	return keyName
 }
 // NormalizeIndexAndColumn returns argument's index name and column name without doing anything
 func (commonDialect) NormalizeIndexAndColumn(indexName, columnName string) (string, string) {
 	return indexName, columnName
 }
 func (commonDialect) parseInt(value interface{}) (int64, error) {
 	return strconv.ParseInt(fmt.Sprint(value), 0, 0)
 }
 // IsByteArrayOrSlice returns true of the reflected value is an array or slice
 func IsByteArrayOrSlice(value reflect.Value) bool {
 	return (value.Kind() == reflect.Array || value.Kind() == reflect.Slice) && value.Type().Elem() == reflect.TypeOf(uint8(0))
 }
--- a/vendor/github.com/jinzhu/gorm/dialect_mysql.go
+++ b/vendor/github.com/jinzhu/gorm/dialect_mysql.go
@ -0,0 +1,246 @@
 package gorm
 import (
 	"crypto/sha1"
 	"database/sql"
 	"fmt"
 	"reflect"
 	"regexp"
 	"strings"
 	"time"
 	"unicode/utf8"
 )
 var mysqlIndexRegex = regexp.MustCompile(`^(.+)\((\d+)\)$`)
 type mysql struct {
 	commonDialect
 }
 func init() {
 	RegisterDialect("mysql", &mysql{})
 }
 func (mysql) GetName() string {
 	return "mysql"
 }
 func (mysql) Quote(key string) string {
 	return fmt.Sprintf("`%s`", key)
 }
 // Get Data Type for MySQL Dialect
 func (s *mysql) DataTypeOf(field *StructField) string {
 	var dataValue, sqlType, size, additionalType = ParseFieldStructForDialect(field, s)
 	// MySQL allows only one auto increment column per table, and it must
 	// be a KEY column.
 	if _, ok := field.TagSettingsGet("AUTO_INCREMENT"); ok {
 		if _, ok = field.TagSettingsGet("INDEX"); !ok && !field.IsPrimaryKey {
 			field.TagSettingsDelete("AUTO_INCREMENT")
 		}
 	}
 	if sqlType == "" {
 		switch dataValue.Kind() {
 		case reflect.Bool:
 			sqlType = "boolean"
 		case reflect.Int8:
 			if s.fieldCanAutoIncrement(field) {
 				field.TagSettingsSet("AUTO_INCREMENT", "AUTO_INCREMENT")
 				sqlType = "tinyint AUTO_INCREMENT"
 			} else {
 				sqlType = "tinyint"
 			}
 		case reflect.Int, reflect.Int16, reflect.Int32:
 			if s.fieldCanAutoIncrement(field) {
 				field.TagSettingsSet("AUTO_INCREMENT", "AUTO_INCREMENT")
 				sqlType = "int AUTO_INCREMENT"
 			} else {
 				sqlType = "int"
 			}
 		case reflect.Uint8:
 			if s.fieldCanAutoIncrement(field) {
 				field.TagSettingsSet("AUTO_INCREMENT", "AUTO_INCREMENT")
 				sqlType = "tinyint unsigned AUTO_INCREMENT"
 			} else {
 				sqlType = "tinyint unsigned"
 			}
 		case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uintptr:
 			if s.fieldCanAutoIncrement(field) {
 				field.TagSettingsSet("AUTO_INCREMENT", "AUTO_INCREMENT")
 				sqlType = "int unsigned AUTO_INCREMENT"
 			} else {
 				sqlType = "int unsigned"
 			}
 		case reflect.Int64:
 			if s.fieldCanAutoIncrement(field) {
 				field.TagSettingsSet("AUTO_INCREMENT", "AUTO_INCREMENT")
 				sqlType = "bigint AUTO_INCREMENT"
 			} else {
 				sqlType = "bigint"
 			}
 		case reflect.Uint64:
 			if s.fieldCanAutoIncrement(field) {
 				field.TagSettingsSet("AUTO_INCREMENT", "AUTO_INCREMENT")
 				sqlType = "bigint unsigned AUTO_INCREMENT"
 			} else {
 				sqlType = "bigint unsigned"
 			}
 		case reflect.Float32, reflect.Float64:
 			sqlType = "double"
 		case reflect.String:
 			if size > 0 && size < 65532 {
 				sqlType = fmt.Sprintf("varchar(%d)", size)
 			} else {
 				sqlType = "longtext"
 			}
 		case reflect.Struct:
 			if _, ok := dataValue.Interface().(time.Time); ok {
 				precision := ""
 				if p, ok := field.TagSettingsGet("PRECISION"); ok {
 					precision = fmt.Sprintf("(%s)", p)
 				}
 				if _, ok := field.TagSettings["NOT NULL"]; ok || field.IsPrimaryKey {
 					sqlType = fmt.Sprintf("DATETIME%v", precision)
 				} else {
 					sqlType = fmt.Sprintf("DATETIME%v NULL", precision)
 				}
 			}
 		default:
 			if IsByteArrayOrSlice(dataValue) {
 				if size > 0 && size < 65532 {
 					sqlType = fmt.Sprintf("varbinary(%d)", size)
 				} else {
 					sqlType = "longblob"
 				}
 			}
 		}
 	}
 	if sqlType == "" {
 		panic(fmt.Sprintf("invalid sql type %s (%s) in field %s for mysql", dataValue.Type().Name(), dataValue.Kind().String(), field.Name))
 	}
 	if strings.TrimSpace(additionalType) == "" {
 		return sqlType
 	}
 	return fmt.Sprintf("%v %v", sqlType, additionalType)
 }
 func (s mysql) RemoveIndex(tableName string, indexName string) error {
 	_, err := s.db.Exec(fmt.Sprintf("DROP INDEX %v ON %v", indexName, s.Quote(tableName)))
 	return err
 }
 func (s mysql) ModifyColumn(tableName string, columnName string, typ string) error {
 	_, err := s.db.Exec(fmt.Sprintf("ALTER TABLE %v MODIFY COLUMN %v %v", tableName, columnName, typ))
 	return err
 }
 func (s mysql) LimitAndOffsetSQL(limit, offset interface{}) (sql string, err error) {
 	if limit != nil {
 		parsedLimit, err := s.parseInt(limit)
 		if err != nil {
 			return "", err
 		}
 		if parsedLimit >= 0 {
 			sql += fmt.Sprintf(" LIMIT %d", parsedLimit)
 			if offset != nil {
 				parsedOffset, err := s.parseInt(offset)
 				if err != nil {
 					return "", err
 				}
 				if parsedOffset >= 0 {
 					sql += fmt.Sprintf(" OFFSET %d", parsedOffset)
 				}
 			}
 		}
 	}
 	return
 }
 func (s mysql) HasForeignKey(tableName string, foreignKeyName string) bool {
 	var count int
 	currentDatabase, tableName := currentDatabaseAndTable(&s, tableName)
 	s.db.QueryRow("SELECT count(*) FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE CONSTRAINT_SCHEMA=? AND TABLE_NAME=? AND CONSTRAINT_NAME=? AND CONSTRAINT_TYPE='FOREIGN KEY'", currentDatabase, tableName, foreignKeyName).Scan(&count)
 	return count > 0
 }
 func (s mysql) HasTable(tableName string) bool {
 	currentDatabase, tableName := currentDatabaseAndTable(&s, tableName)
 	var name string
 	// allow mysql database name with '-' character
 	if err := s.db.QueryRow(fmt.Sprintf("SHOW TABLES FROM `%s` WHERE `Tables_in_%s` = ?", currentDatabase, currentDatabase), tableName).Scan(&name); err != nil {
 		if err == sql.ErrNoRows {
 			return false
 		}
 		panic(err)
 	} else {
 		return true
 	}
 }
 func (s mysql) HasIndex(tableName string, indexName string) bool {
 	currentDatabase, tableName := currentDatabaseAndTable(&s, tableName)
 	if rows, err := s.db.Query(fmt.Sprintf("SHOW INDEXES FROM `%s` FROM `%s` WHERE Key_name = ?", tableName, currentDatabase), indexName); err != nil {
 		panic(err)
 	} else {
 		defer rows.Close()
 		return rows.Next()
 	}
 }
 func (s mysql) HasColumn(tableName string, columnName string) bool {
 	currentDatabase, tableName := currentDatabaseAndTable(&s, tableName)
 	if rows, err := s.db.Query(fmt.Sprintf("SHOW COLUMNS FROM `%s` FROM `%s` WHERE Field = ?", tableName, currentDatabase), columnName); err != nil {
 		panic(err)
 	} else {
 		defer rows.Close()
 		return rows.Next()
 	}
 }
 func (s mysql) CurrentDatabase() (name string) {
 	s.db.QueryRow("SELECT DATABASE()").Scan(&name)
 	return
 }
 func (mysql) SelectFromDummyTable() string {
 	return "FROM DUAL"
 }
 func (s mysql) BuildKeyName(kind, tableName string, fields ...string) string {
 	keyName := s.commonDialect.BuildKeyName(kind, tableName, fields...)
 	if utf8.RuneCountInString(keyName) <= 64 {
 		return keyName
 	}
 	h := sha1.New()
 	h.Write([]byte(keyName))
 	bs := h.Sum(nil)
 	// sha1 is 40 characters, keep first 24 characters of destination
 	destRunes := []rune(keyNameRegex.ReplaceAllString(fields[0], "_"))
 	if len(destRunes) > 24 {
 		destRunes = destRunes[:24]
 	}
 	return fmt.Sprintf("%s%x", string(destRunes), bs)
 }
 // NormalizeIndexAndColumn returns index name and column name for specify an index prefix length if needed
 func (mysql) NormalizeIndexAndColumn(indexName, columnName string) (string, string) {
 	submatch := mysqlIndexRegex.FindStringSubmatch(indexName)
 	if len(submatch) != 3 {
 		return indexName, columnName
 	}
 	indexName = submatch[1]
 	columnName = fmt.Sprintf("%s(%s)", columnName, submatch[2])
 	return indexName, columnName
 }
 func (mysql) DefaultValueStr() string {
 	return "VALUES()"
 }
--- a/vendor/github.com/jinzhu/gorm/dialect_postgres.go
+++ b/vendor/github.com/jinzhu/gorm/dialect_postgres.go
@ -0,0 +1,147 @@
 package gorm
 import (
 	"encoding/json"
 	"fmt"
 	"reflect"
 	"strings"
 	"time"
 )
 type postgres struct {
 	commonDialect
 }
 func init() {
 	RegisterDialect("postgres", &postgres{})
 	RegisterDialect("cloudsqlpostgres", &postgres{})
 }
 func (postgres) GetName() string {
 	return "postgres"
 }
 func (postgres) BindVar(i int) string {
 	return fmt.Sprintf("$%v", i)
 }
 func (s *postgres) DataTypeOf(field *StructField) string {
 	var dataValue, sqlType, size, additionalType = ParseFieldStructForDialect(field, s)
 	if sqlType == "" {
 		switch dataValue.Kind() {
 		case reflect.Bool:
 			sqlType = "boolean"
 		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uintptr:
 			if s.fieldCanAutoIncrement(field) {
 				field.TagSettingsSet("AUTO_INCREMENT", "AUTO_INCREMENT")
 				sqlType = "serial"
 			} else {
 				sqlType = "integer"
 			}
 		case reflect.Int64, reflect.Uint32, reflect.Uint64:
 			if s.fieldCanAutoIncrement(field) {
 				field.TagSettingsSet("AUTO_INCREMENT", "AUTO_INCREMENT")
 				sqlType = "bigserial"
 			} else {
 				sqlType = "bigint"
 			}
 		case reflect.Float32, reflect.Float64:
 			sqlType = "numeric"
 		case reflect.String:
 			if _, ok := field.TagSettingsGet("SIZE"); !ok {
 				size = 0 // if SIZE haven't been set, use `text` as the default type, as there are no performance different
 			}
 			if size > 0 && size < 65532 {
 				sqlType = fmt.Sprintf("varchar(%d)", size)
 			} else {
 				sqlType = "text"
 			}
 		case reflect.Struct:
 			if _, ok := dataValue.Interface().(time.Time); ok {
 				sqlType = "timestamp with time zone"
 			}
 		case reflect.Map:
 			if dataValue.Type().Name() == "Hstore" {
 				sqlType = "hstore"
 			}
 		default:
 			if IsByteArrayOrSlice(dataValue) {
 				sqlType = "bytea"
 				if isUUID(dataValue) {
 					sqlType = "uuid"
 				}
 				if isJSON(dataValue) {
 					sqlType = "jsonb"
 				}
 			}
 		}
 	}
 	if sqlType == "" {
 		panic(fmt.Sprintf("invalid sql type %s (%s) for postgres", dataValue.Type().Name(), dataValue.Kind().String()))
 	}
 	if strings.TrimSpace(additionalType) == "" {
 		return sqlType
 	}
 	return fmt.Sprintf("%v %v", sqlType, additionalType)
 }
 func (s postgres) HasIndex(tableName string, indexName string) bool {
 	var count int
 	s.db.QueryRow("SELECT count(*) FROM pg_indexes WHERE tablename = $1 AND indexname = $2 AND schemaname = CURRENT_SCHEMA()", tableName, indexName).Scan(&count)
 	return count > 0
 }
 func (s postgres) HasForeignKey(tableName string, foreignKeyName string) bool {
 	var count int
 	s.db.QueryRow("SELECT count(con.conname) FROM pg_constraint con WHERE $1::regclass::oid = con.conrelid AND con.conname = $2 AND con.contype='f'", tableName, foreignKeyName).Scan(&count)
 	return count > 0
 }
 func (s postgres) HasTable(tableName string) bool {
 	var count int
 	s.db.QueryRow("SELECT count(*) FROM INFORMATION_SCHEMA.tables WHERE table_name = $1 AND table_type = 'BASE TABLE' AND table_schema = CURRENT_SCHEMA()", tableName).Scan(&count)
 	return count > 0
 }
 func (s postgres) HasColumn(tableName string, columnName string) bool {
 	var count int
 	s.db.QueryRow("SELECT count(*) FROM INFORMATION_SCHEMA.columns WHERE table_name = $1 AND column_name = $2 AND table_schema = CURRENT_SCHEMA()", tableName, columnName).Scan(&count)
 	return count > 0
 }
 func (s postgres) CurrentDatabase() (name string) {
 	s.db.QueryRow("SELECT CURRENT_DATABASE()").Scan(&name)
 	return
 }
 func (s postgres) LastInsertIDOutputInterstitial(tableName, key string, columns []string) string {
 	return ""
 }
 func (s postgres) LastInsertIDReturningSuffix(tableName, key string) string {
 	return fmt.Sprintf("RETURNING %v.%v", tableName, key)
 }
 func (postgres) SupportLastInsertID() bool {
 	return false
 }
 func isUUID(value reflect.Value) bool {
 	if value.Kind() != reflect.Array || value.Type().Len() != 16 {
 		return false
 	}
 	typename := value.Type().Name()
 	lower := strings.ToLower(typename)
 	return "uuid" == lower || "guid" == lower
 }
 func isJSON(value reflect.Value) bool {
 	_, ok := value.Interface().(json.RawMessage)
 	return ok
 }
--- a/vendor/github.com/jinzhu/gorm/dialect_sqlite3.go
+++ b/vendor/github.com/jinzhu/gorm/dialect_sqlite3.go
@ -0,0 +1,107 @@
 package gorm
 import (
 	"fmt"
 	"reflect"
 	"strings"
 	"time"
 )
 type sqlite3 struct {
 	commonDialect
 }
 func init() {
 	RegisterDialect("sqlite3", &sqlite3{})
 }
 func (sqlite3) GetName() string {
 	return "sqlite3"
 }
 // Get Data Type for Sqlite Dialect
 func (s *sqlite3) DataTypeOf(field *StructField) string {
 	var dataValue, sqlType, size, additionalType = ParseFieldStructForDialect(field, s)
 	if sqlType == "" {
 		switch dataValue.Kind() {
 		case reflect.Bool:
 			sqlType = "bool"
 		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uintptr:
 			if s.fieldCanAutoIncrement(field) {
 				field.TagSettingsSet("AUTO_INCREMENT", "AUTO_INCREMENT")
 				sqlType = "integer primary key autoincrement"
 			} else {
 				sqlType = "integer"
 			}
 		case reflect.Int64, reflect.Uint64:
 			if s.fieldCanAutoIncrement(field) {
 				field.TagSettingsSet("AUTO_INCREMENT", "AUTO_INCREMENT")
 				sqlType = "integer primary key autoincrement"
 			} else {
 				sqlType = "bigint"
 			}
 		case reflect.Float32, reflect.Float64:
 			sqlType = "real"
 		case reflect.String:
 			if size > 0 && size < 65532 {
 				sqlType = fmt.Sprintf("varchar(%d)", size)
 			} else {
 				sqlType = "text"
 			}
 		case reflect.Struct:
 			if _, ok := dataValue.Interface().(time.Time); ok {
 				sqlType = "datetime"
 			}
 		default:
 			if IsByteArrayOrSlice(dataValue) {
 				sqlType = "blob"
 			}
 		}
 	}
 	if sqlType == "" {
 		panic(fmt.Sprintf("invalid sql type %s (%s) for sqlite3", dataValue.Type().Name(), dataValue.Kind().String()))
 	}
 	if strings.TrimSpace(additionalType) == "" {
 		return sqlType
 	}
 	return fmt.Sprintf("%v %v", sqlType, additionalType)
 }
 func (s sqlite3) HasIndex(tableName string, indexName string) bool {
 	var count int
 	s.db.QueryRow(fmt.Sprintf("SELECT count(*) FROM sqlite_master WHERE tbl_name = ? AND sql LIKE '%%INDEX %v ON%%'", indexName), tableName).Scan(&count)
 	return count > 0
 }
 func (s sqlite3) HasTable(tableName string) bool {
 	var count int
 	s.db.QueryRow("SELECT count(*) FROM sqlite_master WHERE type='table' AND name=?", tableName).Scan(&count)
 	return count > 0
 }
 func (s sqlite3) HasColumn(tableName string, columnName string) bool {
 	var count int
 	s.db.QueryRow(fmt.Sprintf("SELECT count(*) FROM sqlite_master WHERE tbl_name = ? AND (sql LIKE '%%\"%v\" %%' OR sql LIKE '%%%v %%');\n", columnName, columnName), tableName).Scan(&count)
 	return count > 0
 }
 func (s sqlite3) CurrentDatabase() (name string) {
 	var (
 		ifaces   = make([]interface{}, 3)
 		pointers = make([]*string, 3)
 		i        int
 	)
 	for i = 0; i < 3; i++ {
 		ifaces[i] = &pointers[i]
 	}
 	if err := s.db.QueryRow("PRAGMA database_list").Scan(ifaces...); err != nil {
 		return
 	}
 	if pointers[1] != nil {
 		name = *pointers[1]
 	}
 	return
 }
--- a/vendor/github.com/jinzhu/gorm/docker-compose.yml
+++ b/vendor/github.com/jinzhu/gorm/docker-compose.yml
@ -0,0 +1,30 @@
 version: '3'
 services:
  mysql:
    image: 'mysql:latest'
    ports:
      - 9910:3306
    environment:
      - MYSQL_DATABASE=gorm
      - MYSQL_USER=gorm
      - MYSQL_PASSWORD=gorm
      - MYSQL_RANDOM_ROOT_PASSWORD="yes"
  postgres:
    image: 'postgres:latest'
    ports:
      - 9920:5432
    environment:
      - POSTGRES_USER=gorm
      - POSTGRES_DB=gorm
      - POSTGRES_PASSWORD=gorm
  mssql:
    image: 'mcmoe/mssqldocker:latest'
    ports:
      - 9930:1433
    environment:
      - ACCEPT_EULA=Y
      - SA_PASSWORD=LoremIpsum86
      - MSSQL_DB=gorm
      - MSSQL_USER=gorm
      - MSSQL_PASSWORD=LoremIpsum86
--- a/vendor/github.com/jinzhu/gorm/errors.go
+++ b/vendor/github.com/jinzhu/gorm/errors.go
@ -0,0 +1,72 @@
 package gorm
 import (
 	"errors"
 	"strings"
 )
 var (
 	// ErrRecordNotFound returns a "record not found error". Occurs only when attempting to query the database with a struct; querying with a slice won't return this error
 	ErrRecordNotFound = errors.New("record not found")
 	// ErrInvalidSQL occurs when you attempt a query with invalid SQL
 	ErrInvalidSQL = errors.New("invalid SQL")
 	// ErrInvalidTransaction occurs when you are trying to `Commit` or `Rollback`
 	ErrInvalidTransaction = errors.New("no valid transaction")
 	// ErrCantStartTransaction can't start transaction when you are trying to start one with `Begin`
 	ErrCantStartTransaction = errors.New("can't start transaction")
 	// ErrUnaddressable unaddressable value
 	ErrUnaddressable = errors.New("using unaddressable value")
 )
 // Errors contains all happened errors
 type Errors []error
 // IsRecordNotFoundError returns true if error contains a RecordNotFound error
 func IsRecordNotFoundError(err error) bool {
 	if errs, ok := err.(Errors); ok {
 		for _, err := range errs {
 			if err == ErrRecordNotFound {
 				return true
 			}
 		}
 	}
 	return err == ErrRecordNotFound
 }
 // GetErrors gets all errors that have occurred and returns a slice of errors (Error type)
 func (errs Errors) GetErrors() []error {
 	return errs
 }
 // Add adds an error to a given slice of errors
 func (errs Errors) Add(newErrors ...error) Errors {
 	for _, err := range newErrors {
 		if err == nil {
 			continue
 		}
 		if errors, ok := err.(Errors); ok {
 			errs = errs.Add(errors...)
 		} else {
 			ok = true
 			for _, e := range errs {
 				if err == e {
 					ok = false
 				}
 			}
 			if ok {
 				errs = append(errs, err)
 			}
 		}
 	}
 	return errs
 }
 // Error takes a slice of all errors that have occurred and returns it as a formatted string
 func (errs Errors) Error() string {
 	var errors = []string{}
 	for _, e := range errs {
 		errors = append(errors, e.Error())
 	}
 	return strings.Join(errors, "; ")
 }
--- a/vendor/github.com/jinzhu/gorm/field.go
+++ b/vendor/github.com/jinzhu/gorm/field.go
@ -0,0 +1,66 @@
 package gorm
 import (
 	"database/sql"
 	"database/sql/driver"
 	"errors"
 	"fmt"
 	"reflect"
 )
 // Field model field definition
 type Field struct {
 	*StructField
 	IsBlank bool
 	Field   reflect.Value
 }
 // Set set a value to the field
 func (field *Field) Set(value interface{}) (err error) {
 	if !field.Field.IsValid() {
 		return errors.New("field value not valid")
 	}
 	if !field.Field.CanAddr() {
 		return ErrUnaddressable
 	}
 	reflectValue, ok := value.(reflect.Value)
 	if !ok {
 		reflectValue = reflect.ValueOf(value)
 	}
 	fieldValue := field.Field
 	if reflectValue.IsValid() {
 		if reflectValue.Type().ConvertibleTo(fieldValue.Type()) {
 			fieldValue.Set(reflectValue.Convert(fieldValue.Type()))
 		} else {
 			if fieldValue.Kind() == reflect.Ptr {
 				if fieldValue.IsNil() {
 					fieldValue.Set(reflect.New(field.Struct.Type.Elem()))
 				}
 				fieldValue = fieldValue.Elem()
 			}
 			if reflectValue.Type().ConvertibleTo(fieldValue.Type()) {
 				fieldValue.Set(reflectValue.Convert(fieldValue.Type()))
 			} else if scanner, ok := fieldValue.Addr().Interface().(sql.Scanner); ok {
 				v := reflectValue.Interface()
 				if valuer, ok := v.(driver.Valuer); ok {
 					if v, err = valuer.Value(); err == nil {
 						err = scanner.Scan(v)
 					}
 				} else {
 					err = scanner.Scan(v)
 				}
 			} else {
 				err = fmt.Errorf("could not convert argument of field %s from %s to %s", field.Name, reflectValue.Type(), fieldValue.Type())
 			}
 		}
 	} else {
 		field.Field.Set(reflect.Zero(field.Field.Type()))
 	}
 	field.IsBlank = isBlank(field.Field)
 	return err
 }
--- a/vendor/github.com/jinzhu/gorm/go.mod
+++ b/vendor/github.com/jinzhu/gorm/go.mod
@ -0,0 +1,15 @@
 module github.com/jinzhu/gorm
 go 1.12
 require (
 	github.com/denisenkom/go-mssqldb v0.0.0-20191124224453-732737034ffd
 	github.com/erikstmartin/go-testdb v0.0.0-20160219214506-8d10e4a1bae5
 	github.com/go-sql-driver/mysql v1.4.1
 	github.com/jinzhu/inflection v1.0.0
 	github.com/jinzhu/now v1.0.1
 	github.com/lib/pq v1.1.1
 	github.com/mattn/go-sqlite3 v2.0.1+incompatible
 	golang.org/x/crypto v0.0.0-20191205180655-e7c4368fe9dd // indirect
 	google.golang.org/appengine v1.4.0 // indirect
 )
--- a/vendor/github.com/jinzhu/gorm/go.sum
+++ b/vendor/github.com/jinzhu/gorm/go.sum
@ -0,0 +1,29 @@
 github.com/denisenkom/go-mssqldb v0.0.0-20191124224453-732737034ffd h1:83Wprp6ROGeiHFAP8WJdI2RoxALQYgdllERc3N5N2DM=
 github.com/denisenkom/go-mssqldb v0.0.0-20191124224453-732737034ffd/go.mod h1:xbL0rPBG9cCiLr28tMa8zpbdarY27NDyej4t/EjAShU=
 github.com/erikstmartin/go-testdb v0.0.0-20160219214506-8d10e4a1bae5 h1:Yzb9+7DPaBjB8zlTR87/ElzFsnQfuHnVUVqpZZIcV5Y=
 github.com/erikstmartin/go-testdb v0.0.0-20160219214506-8d10e4a1bae5/go.mod h1:a2zkGnVExMxdzMo3M0Hi/3sEU+cWnZpSni0O6/Yb/P0=
 github.com/go-sql-driver/mysql v1.4.1 h1:g24URVg0OFbNUTx9qqY1IRZ9D9z3iPyi5zKhQZpNwpA=
 github.com/go-sql-driver/mysql v1.4.1/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
 github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe h1:lXe2qZdvpiX5WZkZR4hgp4KJVfY3nMkvmwbVkpv1rVY=
 github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
 github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
 github.com/jinzhu/now v1.0.1 h1:HjfetcXq097iXP0uoPCdnM4Efp5/9MsM0/M+XOTeR3M=
 github.com/jinzhu/now v1.0.1/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
 github.com/lib/pq v1.1.1 h1:sJZmqHoEaY7f+NPP8pgLB/WxulyR3fewgCM2qaSlBb4=
 github.com/lib/pq v1.1.1/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 github.com/mattn/go-sqlite3 v2.0.1+incompatible h1:xQ15muvnzGBHpIpdrNi1DA5x0+TcBZzsIDwmw9uTHzw=
 github.com/mattn/go-sqlite3 v2.0.1+incompatible/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190325154230-a5d413f7728c h1:Vj5n4GlwjmQteupaxJ9+0FNOmBrHfq7vN4btdGoDZgI=
 golang.org/x/crypto v0.0.0-20190325154230-a5d413f7728c/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191205180655-e7c4368fe9dd h1:GGJVjV8waZKRHrgwvtH66z9ZGVurTD1MT0n1Bb+q4aM=
 golang.org/x/crypto v0.0.0-20191205180655-e7c4368fe9dd/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 google.golang.org/appengine v1.4.0 h1:/wp5JvzpHIxhs/dumFmF7BXTf3Z+dd4uXta4kVyO508=
 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
--- a/vendor/github.com/jinzhu/gorm/interface.go
+++ b/vendor/github.com/jinzhu/gorm/interface.go
@ -0,0 +1,24 @@
 package gorm
 import (
 	"context"
 	"database/sql"
 )
 // SQLCommon is the minimal database connection functionality gorm requires.  Implemented by *sql.DB.
 type SQLCommon interface {
 	Exec(query string, args ...interface{}) (sql.Result, error)
 	Prepare(query string) (*sql.Stmt, error)
 	Query(query string, args ...interface{}) (*sql.Rows, error)
 	QueryRow(query string, args ...interface{}) *sql.Row
 }
 type sqlDb interface {
 	Begin() (*sql.Tx, error)
 	BeginTx(ctx context.Context, opts *sql.TxOptions) (*sql.Tx, error)
 }
 type sqlTx interface {
 	Commit() error
 	Rollback() error
 }
--- a/vendor/github.com/jinzhu/gorm/join_table_handler.go
+++ b/vendor/github.com/jinzhu/gorm/join_table_handler.go
@ -0,0 +1,211 @@
 package gorm
 import (
 	"errors"
 	"fmt"
 	"reflect"
 	"strings"
 )
 // JoinTableHandlerInterface is an interface for how to handle many2many relations
 type JoinTableHandlerInterface interface {
 	// initialize join table handler
 	Setup(relationship *Relationship, tableName string, source reflect.Type, destination reflect.Type)
 	// Table return join table's table name
 	Table(db *DB) string
 	// Add create relationship in join table for source and destination
 	Add(handler JoinTableHandlerInterface, db *DB, source interface{}, destination interface{}) error
 	// Delete delete relationship in join table for sources
 	Delete(handler JoinTableHandlerInterface, db *DB, sources ...interface{}) error
 	// JoinWith query with `Join` conditions
 	JoinWith(handler JoinTableHandlerInterface, db *DB, source interface{}) *DB
 	// SourceForeignKeys return source foreign keys
 	SourceForeignKeys() []JoinTableForeignKey
 	// DestinationForeignKeys return destination foreign keys
 	DestinationForeignKeys() []JoinTableForeignKey
 }
 // JoinTableForeignKey join table foreign key struct
 type JoinTableForeignKey struct {
 	DBName            string
 	AssociationDBName string
 }
 // JoinTableSource is a struct that contains model type and foreign keys
 type JoinTableSource struct {
 	ModelType   reflect.Type
 	ForeignKeys []JoinTableForeignKey
 }
 // JoinTableHandler default join table handler
 type JoinTableHandler struct {
 	TableName   string          `sql:"-"`
 	Source      JoinTableSource `sql:"-"`
 	Destination JoinTableSource `sql:"-"`
 }
 // SourceForeignKeys return source foreign keys
 func (s *JoinTableHandler) SourceForeignKeys() []JoinTableForeignKey {
 	return s.Source.ForeignKeys
 }
 // DestinationForeignKeys return destination foreign keys
 func (s *JoinTableHandler) DestinationForeignKeys() []JoinTableForeignKey {
 	return s.Destination.ForeignKeys
 }
 // Setup initialize a default join table handler
 func (s *JoinTableHandler) Setup(relationship *Relationship, tableName string, source reflect.Type, destination reflect.Type) {
 	s.TableName = tableName
 	s.Source = JoinTableSource{ModelType: source}
 	s.Source.ForeignKeys = []JoinTableForeignKey{}
 	for idx, dbName := range relationship.ForeignFieldNames {
 		s.Source.ForeignKeys = append(s.Source.ForeignKeys, JoinTableForeignKey{
 			DBName:            relationship.ForeignDBNames[idx],
 			AssociationDBName: dbName,
 		})
 	}
 	s.Destination = JoinTableSource{ModelType: destination}
 	s.Destination.ForeignKeys = []JoinTableForeignKey{}
 	for idx, dbName := range relationship.AssociationForeignFieldNames {
 		s.Destination.ForeignKeys = append(s.Destination.ForeignKeys, JoinTableForeignKey{
 			DBName:            relationship.AssociationForeignDBNames[idx],
 			AssociationDBName: dbName,
 		})
 	}
 }
 // Table return join table's table name
 func (s JoinTableHandler) Table(db *DB) string {
 	return DefaultTableNameHandler(db, s.TableName)
 }
 func (s JoinTableHandler) updateConditionMap(conditionMap map[string]interface{}, db *DB, joinTableSources []JoinTableSource, sources ...interface{}) {
 	for _, source := range sources {
 		scope := db.NewScope(source)
 		modelType := scope.GetModelStruct().ModelType
 		for _, joinTableSource := range joinTableSources {
 			if joinTableSource.ModelType == modelType {
 				for _, foreignKey := range joinTableSource.ForeignKeys {
 					if field, ok := scope.FieldByName(foreignKey.AssociationDBName); ok {
 						conditionMap[foreignKey.DBName] = field.Field.Interface()
 					}
 				}
 				break
 			}
 		}
 	}
 }
 // Add create relationship in join table for source and destination
 func (s JoinTableHandler) Add(handler JoinTableHandlerInterface, db *DB, source interface{}, destination interface{}) error {
 	var (
 		scope        = db.NewScope("")
 		conditionMap = map[string]interface{}{}
 	)
 	// Update condition map for source
 	s.updateConditionMap(conditionMap, db, []JoinTableSource{s.Source}, source)
 	// Update condition map for destination
 	s.updateConditionMap(conditionMap, db, []JoinTableSource{s.Destination}, destination)
 	var assignColumns, binVars, conditions []string
 	var values []interface{}
 	for key, value := range conditionMap {
 		assignColumns = append(assignColumns, scope.Quote(key))
 		binVars = append(binVars, `?`)
 		conditions = append(conditions, fmt.Sprintf("%v = ?", scope.Quote(key)))
 		values = append(values, value)
 	}
 	for _, value := range values {
 		values = append(values, value)
 	}
 	quotedTable := scope.Quote(handler.Table(db))
 	sql := fmt.Sprintf(
 		"INSERT INTO %v (%v) SELECT %v %v WHERE NOT EXISTS (SELECT * FROM %v WHERE %v)",
 		quotedTable,
 		strings.Join(assignColumns, ","),
 		strings.Join(binVars, ","),
 		scope.Dialect().SelectFromDummyTable(),
 		quotedTable,
 		strings.Join(conditions, " AND "),
 	)
 	return db.Exec(sql, values...).Error
 }
 // Delete delete relationship in join table for sources
 func (s JoinTableHandler) Delete(handler JoinTableHandlerInterface, db *DB, sources ...interface{}) error {
 	var (
 		scope        = db.NewScope(nil)
 		conditions   []string
 		values       []interface{}
 		conditionMap = map[string]interface{}{}
 	)
 	s.updateConditionMap(conditionMap, db, []JoinTableSource{s.Source, s.Destination}, sources...)
 	for key, value := range conditionMap {
 		conditions = append(conditions, fmt.Sprintf("%v = ?", scope.Quote(key)))
 		values = append(values, value)
 	}
 	return db.Table(handler.Table(db)).Where(strings.Join(conditions, " AND "), values...).Delete("").Error
 }
 // JoinWith query with `Join` conditions
 func (s JoinTableHandler) JoinWith(handler JoinTableHandlerInterface, db *DB, source interface{}) *DB {
 	var (
 		scope           = db.NewScope(source)
 		tableName       = handler.Table(db)
 		quotedTableName = scope.Quote(tableName)
 		joinConditions  []string
 		values          []interface{}
 	)
 	if s.Source.ModelType == scope.GetModelStruct().ModelType {
 		destinationTableName := db.NewScope(reflect.New(s.Destination.ModelType).Interface()).QuotedTableName()
 		for _, foreignKey := range s.Destination.ForeignKeys {
 			joinConditions = append(joinConditions, fmt.Sprintf("%v.%v = %v.%v", quotedTableName, scope.Quote(foreignKey.DBName), destinationTableName, scope.Quote(foreignKey.AssociationDBName)))
 		}
 		var foreignDBNames []string
 		var foreignFieldNames []string
 		for _, foreignKey := range s.Source.ForeignKeys {
 			foreignDBNames = append(foreignDBNames, foreignKey.DBName)
 			if field, ok := scope.FieldByName(foreignKey.AssociationDBName); ok {
 				foreignFieldNames = append(foreignFieldNames, field.Name)
 			}
 		}
 		foreignFieldValues := scope.getColumnAsArray(foreignFieldNames, scope.Value)
 		var condString string
 		if len(foreignFieldValues) > 0 {
 			var quotedForeignDBNames []string
 			for _, dbName := range foreignDBNames {
 				quotedForeignDBNames = append(quotedForeignDBNames, tableName+"."+dbName)
 			}
 			condString = fmt.Sprintf("%v IN (%v)", toQueryCondition(scope, quotedForeignDBNames), toQueryMarks(foreignFieldValues))
 			keys := scope.getColumnAsArray(foreignFieldNames, scope.Value)
 			values = append(values, toQueryValues(keys))
 		} else {
 			condString = fmt.Sprintf("1 <> 1")
 		}
 		return db.Joins(fmt.Sprintf("INNER JOIN %v ON %v", quotedTableName, strings.Join(joinConditions, " AND "))).
 			Where(condString, toQueryValues(foreignFieldValues)...)
 	}
 	db.Error = errors.New("wrong source type for join table handler")
 	return db
 }
--- a/vendor/github.com/jinzhu/gorm/logger.go
+++ b/vendor/github.com/jinzhu/gorm/logger.go
@ -0,0 +1,141 @@
 package gorm
 import (
 	"database/sql/driver"
 	"fmt"
 	"log"
 	"os"
 	"reflect"
 	"regexp"
 	"strconv"
 	"time"
 	"unicode"
 )
 var (
 	defaultLogger            = Logger{log.New(os.Stdout, "\r\n", 0)}
 	sqlRegexp                = regexp.MustCompile(`\?`)
 	numericPlaceHolderRegexp = regexp.MustCompile(`\$\d+`)
 )
 func isPrintable(s string) bool {
 	for _, r := range s {
 		if !unicode.IsPrint(r) {
 			return false
 		}
 	}
 	return true
 }
 var LogFormatter = func(values ...interface{}) (messages []interface{}) {
 	if len(values) > 1 {
 		var (
 			sql             string
 			formattedValues []string
 			level           = values[0]
 			currentTime     = "\n\033[33m[" + NowFunc().Format("2006-01-02 15:04:05") + "]\033[0m"
 			source          = fmt.Sprintf("\033[35m(%v)\033[0m", values[1])
 		)
 		messages = []interface{}{source, currentTime}
 		if len(values) == 2 {
 			//remove the line break
 			currentTime = currentTime[1:]
 			//remove the brackets
 			source = fmt.Sprintf("\033[35m%v\033[0m", values[1])
 			messages = []interface{}{currentTime, source}
 		}
 		if level == "sql" {
 			// duration
 			messages = append(messages, fmt.Sprintf(" \033[36;1m[%.2fms]\033[0m ", float64(values[2].(time.Duration).Nanoseconds()/1e4)/100.0))
 			// sql
 			for _, value := range values[4].([]interface{}) {
 				indirectValue := reflect.Indirect(reflect.ValueOf(value))
 				if indirectValue.IsValid() {
 					value = indirectValue.Interface()
 					if t, ok := value.(time.Time); ok {
 						if t.IsZero() {
 							formattedValues = append(formattedValues, fmt.Sprintf("'%v'", "0000-00-00 00:00:00"))
 						} else {
 							formattedValues = append(formattedValues, fmt.Sprintf("'%v'", t.Format("2006-01-02 15:04:05")))
 						}
 					} else if b, ok := value.([]byte); ok {
 						if str := string(b); isPrintable(str) {
 							formattedValues = append(formattedValues, fmt.Sprintf("'%v'", str))
 						} else {
 							formattedValues = append(formattedValues, "'<binary>'")
 						}
 					} else if r, ok := value.(driver.Valuer); ok {
 						if value, err := r.Value(); err == nil && value != nil {
 							formattedValues = append(formattedValues, fmt.Sprintf("'%v'", value))
 						} else {
 							formattedValues = append(formattedValues, "NULL")
 						}
 					} else {
 						switch value.(type) {
 						case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64, bool:
 							formattedValues = append(formattedValues, fmt.Sprintf("%v", value))
 						default:
 							formattedValues = append(formattedValues, fmt.Sprintf("'%v'", value))
 						}
 					}
 				} else {
 					formattedValues = append(formattedValues, "NULL")
 				}
 			}
 			// differentiate between $n placeholders or else treat like ?
 			if numericPlaceHolderRegexp.MatchString(values[3].(string)) {
 				sql = values[3].(string)
 				for index, value := range formattedValues {
 					placeholder := fmt.Sprintf(`\$%d([^\d]|$)`, index+1)
 					sql = regexp.MustCompile(placeholder).ReplaceAllString(sql, value+"$1")
 				}
 			} else {
 				formattedValuesLength := len(formattedValues)
 				for index, value := range sqlRegexp.Split(values[3].(string), -1) {
 					sql += value
 					if index < formattedValuesLength {
 						sql += formattedValues[index]
 					}
 				}
 			}
 			messages = append(messages, sql)
 			messages = append(messages, fmt.Sprintf(" \n\033[36;31m[%v]\033[0m ", strconv.FormatInt(values[5].(int64), 10)+" rows affected or returned "))
 		} else {
 			messages = append(messages, "\033[31;1m")
 			messages = append(messages, values[2:]...)
 			messages = append(messages, "\033[0m")
 		}
 	}
 	return
 }
 type logger interface {
 	Print(v ...interface{})
 }
 // LogWriter log writer interface
 type LogWriter interface {
 	Println(v ...interface{})
 }
 // Logger default logger
 type Logger struct {
 	LogWriter
 }
 // Print format & print log
 func (logger Logger) Print(values ...interface{}) {
 	logger.Println(LogFormatter(values...)...)
 }
 type nopLogger struct{}
 func (nopLogger) Print(values ...interface{}) {}
--- a/vendor/github.com/jinzhu/gorm/main.go
+++ b/vendor/github.com/jinzhu/gorm/main.go
@ -0,0 +1,881 @@
 package gorm
 import (
 	"context"
 	"database/sql"
 	"errors"
 	"fmt"
 	"reflect"
 	"strings"
 	"sync"
 	"time"
 )
 // DB contains information for current db connection
 type DB struct {
 	sync.RWMutex
 	Value        interface{}
 	Error        error
 	RowsAffected int64
 	// single db
 	db                SQLCommon
 	blockGlobalUpdate bool
 	logMode           logModeValue
 	logger            logger
 	search            *search
 	values            sync.Map
 	// global db
 	parent        *DB
 	callbacks     *Callback
 	dialect       Dialect
 	singularTable bool
 	// function to be used to override the creating of a new timestamp
 	nowFuncOverride func() time.Time
 }
 type logModeValue int
 const (
 	defaultLogMode logModeValue = iota
 	noLogMode
 	detailedLogMode
 )
 // Open initialize a new db connection, need to import driver first, e.g:
 //
 //     import _ "github.com/go-sql-driver/mysql"
 //     func main() {
 //       db, err := gorm.Open("mysql", "user:password@/dbname?charset=utf8&parseTime=True&loc=Local")
 //     }
 // GORM has wrapped some drivers, for easier to remember driver's import path, so you could import the mysql driver with
 //    import _ "github.com/jinzhu/gorm/dialects/mysql"
 //    // import _ "github.com/jinzhu/gorm/dialects/postgres"
 //    // import _ "github.com/jinzhu/gorm/dialects/sqlite"
 //    // import _ "github.com/jinzhu/gorm/dialects/mssql"
 func Open(dialect string, args ...interface{}) (db *DB, err error) {
 	if len(args) == 0 {
 		err = errors.New("invalid database source")
 		return nil, err
 	}
 	var source string
 	var dbSQL SQLCommon
 	var ownDbSQL bool
 	switch value := args[0].(type) {
 	case string:
 		var driver = dialect
 		if len(args) == 1 {
 			source = value
 		} else if len(args) >= 2 {
 			driver = value
 			source = args[1].(string)
 		}
 		dbSQL, err = sql.Open(driver, source)
 		ownDbSQL = true
 	case SQLCommon:
 		dbSQL = value
 		ownDbSQL = false
 	default:
 		return nil, fmt.Errorf("invalid database source: %v is not a valid type", value)
 	}
 	db = &DB{
 		db:        dbSQL,
 		logger:    defaultLogger,
 		callbacks: DefaultCallback,
 		dialect:   newDialect(dialect, dbSQL),
 	}
 	db.parent = db
 	if err != nil {
 		return
 	}
 	// Send a ping to make sure the database connection is alive.
 	if d, ok := dbSQL.(*sql.DB); ok {
 		if err = d.Ping(); err != nil && ownDbSQL {
 			d.Close()
 		}
 	}
 	return
 }
 // New clone a new db connection without search conditions
 func (s *DB) New() *DB {
 	clone := s.clone()
 	clone.search = nil
 	clone.Value = nil
 	return clone
 }
 type closer interface {
 	Close() error
 }
 // Close close current db connection.  If database connection is not an io.Closer, returns an error.
 func (s *DB) Close() error {
 	if db, ok := s.parent.db.(closer); ok {
 		return db.Close()
 	}
 	return errors.New("can't close current db")
 }
 // DB get `*sql.DB` from current connection
 // If the underlying database connection is not a *sql.DB, returns nil
 func (s *DB) DB() *sql.DB {
 	db, ok := s.db.(*sql.DB)
 	if !ok {
 		panic("can't support full GORM on currently status, maybe this is a TX instance.")
 	}
 	return db
 }
 // CommonDB return the underlying `*sql.DB` or `*sql.Tx` instance, mainly intended to allow coexistence with legacy non-GORM code.
 func (s *DB) CommonDB() SQLCommon {
 	return s.db
 }
 // Dialect get dialect
 func (s *DB) Dialect() Dialect {
 	return s.dialect
 }
 // Callback return `Callbacks` container, you could add/change/delete callbacks with it
 //     db.Callback().Create().Register("update_created_at", updateCreated)
 // Refer https://jinzhu.github.io/gorm/development.html#callbacks
 func (s *DB) Callback() *Callback {
 	s.parent.callbacks = s.parent.callbacks.clone(s.logger)
 	return s.parent.callbacks
 }
 // SetLogger replace default logger
 func (s *DB) SetLogger(log logger) {
 	s.logger = log
 }
 // LogMode set log mode, `true` for detailed logs, `false` for no log, default, will only print error logs
 func (s *DB) LogMode(enable bool) *DB {
 	if enable {
 		s.logMode = detailedLogMode
 	} else {
 		s.logMode = noLogMode
 	}
 	return s
 }
 // SetNowFuncOverride set the function to be used when creating a new timestamp
 func (s *DB) SetNowFuncOverride(nowFuncOverride func() time.Time) *DB {
 	s.nowFuncOverride = nowFuncOverride
 	return s
 }
 // Get a new timestamp, using the provided nowFuncOverride on the DB instance if set,
 // otherwise defaults to the global NowFunc()
 func (s *DB) nowFunc() time.Time {
 	if s.nowFuncOverride != nil {
 		return s.nowFuncOverride()
 	}
 	return NowFunc()
 }
 // BlockGlobalUpdate if true, generates an error on update/delete without where clause.
 // This is to prevent eventual error with empty objects updates/deletions
 func (s *DB) BlockGlobalUpdate(enable bool) *DB {
 	s.blockGlobalUpdate = enable
 	return s
 }
 // HasBlockGlobalUpdate return state of block
 func (s *DB) HasBlockGlobalUpdate() bool {
 	return s.blockGlobalUpdate
 }
 // SingularTable use singular table by default
 func (s *DB) SingularTable(enable bool) {
 	s.parent.Lock()
 	defer s.parent.Unlock()
 	s.parent.singularTable = enable
 }
 // NewScope create a scope for current operation
 func (s *DB) NewScope(value interface{}) *Scope {
 	dbClone := s.clone()
 	dbClone.Value = value
 	scope := &Scope{db: dbClone, Value: value}
 	if s.search != nil {
 		scope.Search = s.search.clone()
 	} else {
 		scope.Search = &search{}
 	}
 	return scope
 }
 // QueryExpr returns the query as SqlExpr object
 func (s *DB) QueryExpr() *SqlExpr {
 	scope := s.NewScope(s.Value)
 	scope.InstanceSet("skip_bindvar", true)
 	scope.prepareQuerySQL()
 	return Expr(scope.SQL, scope.SQLVars...)
 }
 // SubQuery returns the query as sub query
 func (s *DB) SubQuery() *SqlExpr {
 	scope := s.NewScope(s.Value)
 	scope.InstanceSet("skip_bindvar", true)
 	scope.prepareQuerySQL()
 	return Expr(fmt.Sprintf("(%v)", scope.SQL), scope.SQLVars...)
 }
 // Where return a new relation, filter records with given conditions, accepts `map`, `struct` or `string` as conditions, refer http://jinzhu.github.io/gorm/crud.html#query
 func (s *DB) Where(query interface{}, args ...interface{}) *DB {
 	return s.clone().search.Where(query, args...).db
 }
 // Or filter records that match before conditions or this one, similar to `Where`
 func (s *DB) Or(query interface{}, args ...interface{}) *DB {
 	return s.clone().search.Or(query, args...).db
 }
 // Not filter records that don't match current conditions, similar to `Where`
 func (s *DB) Not(query interface{}, args ...interface{}) *DB {
 	return s.clone().search.Not(query, args...).db
 }
 // Limit specify the number of records to be retrieved
 func (s *DB) Limit(limit interface{}) *DB {
 	return s.clone().search.Limit(limit).db
 }
 // Offset specify the number of records to skip before starting to return the records
 func (s *DB) Offset(offset interface{}) *DB {
 	return s.clone().search.Offset(offset).db
 }
 // Order specify order when retrieve records from database, set reorder to `true` to overwrite defined conditions
 //     db.Order("name DESC")
 //     db.Order("name DESC", true) // reorder
 //     db.Order(gorm.Expr("name = ? DESC", "first")) // sql expression
 func (s *DB) Order(value interface{}, reorder ...bool) *DB {
 	return s.clone().search.Order(value, reorder...).db
 }
 // Select specify fields that you want to retrieve from database when querying, by default, will select all fields;
 // When creating/updating, specify fields that you want to save to database
 func (s *DB) Select(query interface{}, args ...interface{}) *DB {
 	return s.clone().search.Select(query, args...).db
 }
 // Omit specify fields that you want to ignore when saving to database for creating, updating
 func (s *DB) Omit(columns ...string) *DB {
 	return s.clone().search.Omit(columns...).db
 }
 // Group specify the group method on the find
 func (s *DB) Group(query string) *DB {
 	return s.clone().search.Group(query).db
 }
 // Having specify HAVING conditions for GROUP BY
 func (s *DB) Having(query interface{}, values ...interface{}) *DB {
 	return s.clone().search.Having(query, values...).db
 }
 // Joins specify Joins conditions
 //     db.Joins("JOIN emails ON emails.user_id = users.id AND emails.email = ?", "jinzhu@example.org").Find(&user)
 func (s *DB) Joins(query string, args ...interface{}) *DB {
 	return s.clone().search.Joins(query, args...).db
 }
 // Scopes pass current database connection to arguments `func(*DB) *DB`, which could be used to add conditions dynamically
 //     func AmountGreaterThan1000(db *gorm.DB) *gorm.DB {
 //         return db.Where("amount > ?", 1000)
 //     }
 //
 //     func OrderStatus(status []string) func (db *gorm.DB) *gorm.DB {
 //         return func (db *gorm.DB) *gorm.DB {
 //             return db.Scopes(AmountGreaterThan1000).Where("status in (?)", status)
 //         }
 //     }
 //
 //     db.Scopes(AmountGreaterThan1000, OrderStatus([]string{"paid", "shipped"})).Find(&orders)
 // Refer https://jinzhu.github.io/gorm/crud.html#scopes
 func (s *DB) Scopes(funcs ...func(*DB) *DB) *DB {
 	for _, f := range funcs {
 		s = f(s)
 	}
 	return s
 }
 // Unscoped return all record including deleted record, refer Soft Delete https://jinzhu.github.io/gorm/crud.html#soft-delete
 func (s *DB) Unscoped() *DB {
 	return s.clone().search.unscoped().db
 }
 // Attrs initialize struct with argument if record not found with `FirstOrInit` https://jinzhu.github.io/gorm/crud.html#firstorinit or `FirstOrCreate` https://jinzhu.github.io/gorm/crud.html#firstorcreate
 func (s *DB) Attrs(attrs ...interface{}) *DB {
 	return s.clone().search.Attrs(attrs...).db
 }
 // Assign assign result with argument regardless it is found or not with `FirstOrInit` https://jinzhu.github.io/gorm/crud.html#firstorinit or `FirstOrCreate` https://jinzhu.github.io/gorm/crud.html#firstorcreate
 func (s *DB) Assign(attrs ...interface{}) *DB {
 	return s.clone().search.Assign(attrs...).db
 }
 // First find first record that match given conditions, order by primary key
 func (s *DB) First(out interface{}, where ...interface{}) *DB {
 	newScope := s.NewScope(out)
 	newScope.Search.Limit(1)
 	return newScope.Set("gorm:order_by_primary_key", "ASC").
 		inlineCondition(where...).callCallbacks(s.parent.callbacks.queries).db
 }
 // Take return a record that match given conditions, the order will depend on the database implementation
 func (s *DB) Take(out interface{}, where ...interface{}) *DB {
 	newScope := s.NewScope(out)
 	newScope.Search.Limit(1)
 	return newScope.inlineCondition(where...).callCallbacks(s.parent.callbacks.queries).db
 }
 // Last find last record that match given conditions, order by primary key
 func (s *DB) Last(out interface{}, where ...interface{}) *DB {
 	newScope := s.NewScope(out)
 	newScope.Search.Limit(1)
 	return newScope.Set("gorm:order_by_primary_key", "DESC").
 		inlineCondition(where...).callCallbacks(s.parent.callbacks.queries).db
 }
 // Find find records that match given conditions
 func (s *DB) Find(out interface{}, where ...interface{}) *DB {
 	return s.NewScope(out).inlineCondition(where...).callCallbacks(s.parent.callbacks.queries).db
 }
 //Preloads preloads relations, don`t touch out
 func (s *DB) Preloads(out interface{}) *DB {
 	return s.NewScope(out).InstanceSet("gorm:only_preload", 1).callCallbacks(s.parent.callbacks.queries).db
 }
 // Scan scan value to a struct
 func (s *DB) Scan(dest interface{}) *DB {
 	return s.NewScope(s.Value).Set("gorm:query_destination", dest).callCallbacks(s.parent.callbacks.queries).db
 }
 // Row return `*sql.Row` with given conditions
 func (s *DB) Row() *sql.Row {
 	return s.NewScope(s.Value).row()
 }
 // Rows return `*sql.Rows` with given conditions
 func (s *DB) Rows() (*sql.Rows, error) {
 	return s.NewScope(s.Value).rows()
 }
 // ScanRows scan `*sql.Rows` to give struct
 func (s *DB) ScanRows(rows *sql.Rows, result interface{}) error {
 	var (
 		scope        = s.NewScope(result)
 		clone        = scope.db
 		columns, err = rows.Columns()
 	)
 	if clone.AddError(err) == nil {
 		scope.scan(rows, columns, scope.Fields())
 	}
 	return clone.Error
 }
 // Pluck used to query single column from a model as a map
 //     var ages []int64
 //     db.Find(&users).Pluck("age", &ages)
 func (s *DB) Pluck(column string, value interface{}) *DB {
 	return s.NewScope(s.Value).pluck(column, value).db
 }
 // Count get how many records for a model
 func (s *DB) Count(value interface{}) *DB {
 	return s.NewScope(s.Value).count(value).db
 }
 // Related get related associations
 func (s *DB) Related(value interface{}, foreignKeys ...string) *DB {
 	return s.NewScope(s.Value).related(value, foreignKeys...).db
 }
 // FirstOrInit find first matched record or initialize a new one with given conditions (only works with struct, map conditions)
 // https://jinzhu.github.io/gorm/crud.html#firstorinit
 func (s *DB) FirstOrInit(out interface{}, where ...interface{}) *DB {
 	c := s.clone()
 	if result := c.First(out, where...); result.Error != nil {
 		if !result.RecordNotFound() {
 			return result
 		}
 		c.NewScope(out).inlineCondition(where...).initialize()
 	} else {
 		c.NewScope(out).updatedAttrsWithValues(c.search.assignAttrs)
 	}
 	return c
 }
 // FirstOrCreate find first matched record or create a new one with given conditions (only works with struct, map conditions)
 // https://jinzhu.github.io/gorm/crud.html#firstorcreate
 func (s *DB) FirstOrCreate(out interface{}, where ...interface{}) *DB {
 	c := s.clone()
 	if result := s.First(out, where...); result.Error != nil {
 		if !result.RecordNotFound() {
 			return result
 		}
 		return c.NewScope(out).inlineCondition(where...).initialize().callCallbacks(c.parent.callbacks.creates).db
 	} else if len(c.search.assignAttrs) > 0 {
 		return c.NewScope(out).InstanceSet("gorm:update_interface", c.search.assignAttrs).callCallbacks(c.parent.callbacks.updates).db
 	}
 	return c
 }
 // Update update attributes with callbacks, refer: https://jinzhu.github.io/gorm/crud.html#update
 // WARNING when update with struct, GORM will not update fields that with zero value
 func (s *DB) Update(attrs ...interface{}) *DB {
 	return s.Updates(toSearchableMap(attrs...), true)
 }
 // Updates update attributes with callbacks, refer: https://jinzhu.github.io/gorm/crud.html#update
 func (s *DB) Updates(values interface{}, ignoreProtectedAttrs ...bool) *DB {
 	return s.NewScope(s.Value).
 		Set("gorm:ignore_protected_attrs", len(ignoreProtectedAttrs) > 0).
 		InstanceSet("gorm:update_interface", values).
 		callCallbacks(s.parent.callbacks.updates).db
 }
 // UpdateColumn update attributes without callbacks, refer: https://jinzhu.github.io/gorm/crud.html#update
 func (s *DB) UpdateColumn(attrs ...interface{}) *DB {
 	return s.UpdateColumns(toSearchableMap(attrs...))
 }
 // UpdateColumns update attributes without callbacks, refer: https://jinzhu.github.io/gorm/crud.html#update
 func (s *DB) UpdateColumns(values interface{}) *DB {
 	return s.NewScope(s.Value).
 		Set("gorm:update_column", true).
 		Set("gorm:save_associations", false).
 		InstanceSet("gorm:update_interface", values).
 		callCallbacks(s.parent.callbacks.updates).db
 }
 // Save update value in database, if the value doesn't have primary key, will insert it
 func (s *DB) Save(value interface{}) *DB {
 	scope := s.NewScope(value)
 	if !scope.PrimaryKeyZero() {
 		newDB := scope.callCallbacks(s.parent.callbacks.updates).db
 		if newDB.Error == nil && newDB.RowsAffected == 0 {
 			return s.New().Table(scope.TableName()).FirstOrCreate(value)
 		}
 		return newDB
 	}
 	return scope.callCallbacks(s.parent.callbacks.creates).db
 }
 // Create insert the value into database
 func (s *DB) Create(value interface{}) *DB {
 	scope := s.NewScope(value)
 	return scope.callCallbacks(s.parent.callbacks.creates).db
 }
 // Delete delete value match given conditions, if the value has primary key, then will including the primary key as condition
 // WARNING If model has DeletedAt field, GORM will only set field DeletedAt's value to current time
 func (s *DB) Delete(value interface{}, where ...interface{}) *DB {
 	return s.NewScope(value).inlineCondition(where...).callCallbacks(s.parent.callbacks.deletes).db
 }
 // Raw use raw sql as conditions, won't run it unless invoked by other methods
 //    db.Raw("SELECT name, age FROM users WHERE name = ?", 3).Scan(&result)
 func (s *DB) Raw(sql string, values ...interface{}) *DB {
 	return s.clone().search.Raw(true).Where(sql, values...).db
 }
 // Exec execute raw sql
 func (s *DB) Exec(sql string, values ...interface{}) *DB {
 	scope := s.NewScope(nil)
 	generatedSQL := scope.buildCondition(map[string]interface{}{"query": sql, "args": values}, true)
 	generatedSQL = strings.TrimSuffix(strings.TrimPrefix(generatedSQL, "("), ")")
 	scope.Raw(generatedSQL)
 	return scope.Exec().db
 }
 // Model specify the model you would like to run db operations
 //    // update all users's name to `hello`
 //    db.Model(&User{}).Update("name", "hello")
 //    // if user's primary key is non-blank, will use it as condition, then will only update the user's name to `hello`
 //    db.Model(&user).Update("name", "hello")
 func (s *DB) Model(value interface{}) *DB {
 	c := s.clone()
 	c.Value = value
 	return c
 }
 // Table specify the table you would like to run db operations
 func (s *DB) Table(name string) *DB {
 	clone := s.clone()
 	clone.search.Table(name)
 	clone.Value = nil
 	return clone
 }
 // Debug start debug mode
 func (s *DB) Debug() *DB {
 	return s.clone().LogMode(true)
 }
 // Transaction start a transaction as a block,
 // return error will rollback, otherwise to commit.
 func (s *DB) Transaction(fc func(tx *DB) error) (err error) {
 	panicked := true
 	tx := s.Begin()
 	defer func() {
 		// Make sure to rollback when panic, Block error or Commit error
 		if panicked || err != nil {
 			tx.Rollback()
 		}
 	}()
 	err = fc(tx)
 	if err == nil {
 		err = tx.Commit().Error
 	}
 	panicked = false
 	return
 }
 // Begin begins a transaction
 func (s *DB) Begin() *DB {
 	return s.BeginTx(context.Background(), &sql.TxOptions{})
 }
 // BeginTx begins a transaction with options
 func (s *DB) BeginTx(ctx context.Context, opts *sql.TxOptions) *DB {
 	c := s.clone()
 	if db, ok := c.db.(sqlDb); ok && db != nil {
 		tx, err := db.BeginTx(ctx, opts)
 		c.db = interface{}(tx).(SQLCommon)
 		c.dialect.SetDB(c.db)
 		c.AddError(err)
 	} else {
 		c.AddError(ErrCantStartTransaction)
 	}
 	return c
 }
 // Commit commit a transaction
 func (s *DB) Commit() *DB {
 	var emptySQLTx *sql.Tx
 	if db, ok := s.db.(sqlTx); ok && db != nil && db != emptySQLTx {
 		s.AddError(db.Commit())
 	} else {
 		s.AddError(ErrInvalidTransaction)
 	}
 	return s
 }
 // Rollback rollback a transaction
 func (s *DB) Rollback() *DB {
 	var emptySQLTx *sql.Tx
 	if db, ok := s.db.(sqlTx); ok && db != nil && db != emptySQLTx {
 		if err := db.Rollback(); err != nil && err != sql.ErrTxDone {
 			s.AddError(err)
 		}
 	} else {
 		s.AddError(ErrInvalidTransaction)
 	}
 	return s
 }
 // RollbackUnlessCommitted rollback a transaction if it has not yet been
 // committed.
 func (s *DB) RollbackUnlessCommitted() *DB {
 	var emptySQLTx *sql.Tx
 	if db, ok := s.db.(sqlTx); ok && db != nil && db != emptySQLTx {
 		err := db.Rollback()
 		// Ignore the error indicating that the transaction has already
 		// been committed.
 		if err != sql.ErrTxDone {
 			s.AddError(err)
 		}
 	} else {
 		s.AddError(ErrInvalidTransaction)
 	}
 	return s
 }
 // NewRecord check if value's primary key is blank
 func (s *DB) NewRecord(value interface{}) bool {
 	return s.NewScope(value).PrimaryKeyZero()
 }
 // RecordNotFound check if returning ErrRecordNotFound error
 func (s *DB) RecordNotFound() bool {
 	for _, err := range s.GetErrors() {
 		if err == ErrRecordNotFound {
 			return true
 		}
 	}
 	return false
 }
 // CreateTable create table for models
 func (s *DB) CreateTable(models ...interface{}) *DB {
 	db := s.Unscoped()
 	for _, model := range models {
 		db = db.NewScope(model).createTable().db
 	}
 	return db
 }
 // DropTable drop table for models
 func (s *DB) DropTable(values ...interface{}) *DB {
 	db := s.clone()
 	for _, value := range values {
 		if tableName, ok := value.(string); ok {
 			db = db.Table(tableName)
 		}
 		db = db.NewScope(value).dropTable().db
 	}
 	return db
 }
 // DropTableIfExists drop table if it is exist
 func (s *DB) DropTableIfExists(values ...interface{}) *DB {
 	db := s.clone()
 	for _, value := range values {
 		if s.HasTable(value) {
 			db.AddError(s.DropTable(value).Error)
 		}
 	}
 	return db
 }
 // HasTable check has table or not
 func (s *DB) HasTable(value interface{}) bool {
 	var (
 		scope     = s.NewScope(value)
 		tableName string
 	)
 	if name, ok := value.(string); ok {
 		tableName = name
 	} else {
 		tableName = scope.TableName()
 	}
 	has := scope.Dialect().HasTable(tableName)
 	s.AddError(scope.db.Error)
 	return has
 }
 // AutoMigrate run auto migration for given models, will only add missing fields, won't delete/change current data
 func (s *DB) AutoMigrate(values ...interface{}) *DB {
 	db := s.Unscoped()
 	for _, value := range values {
 		db = db.NewScope(value).autoMigrate().db
 	}
 	return db
 }
 // ModifyColumn modify column to type
 func (s *DB) ModifyColumn(column string, typ string) *DB {
 	scope := s.NewScope(s.Value)
 	scope.modifyColumn(column, typ)
 	return scope.db
 }
 // DropColumn drop a column
 func (s *DB) DropColumn(column string) *DB {
 	scope := s.NewScope(s.Value)
 	scope.dropColumn(column)
 	return scope.db
 }
 // AddIndex add index for columns with given name
 func (s *DB) AddIndex(indexName string, columns ...string) *DB {
 	scope := s.Unscoped().NewScope(s.Value)
 	scope.addIndex(false, indexName, columns...)
 	return scope.db
 }
 // AddUniqueIndex add unique index for columns with given name
 func (s *DB) AddUniqueIndex(indexName string, columns ...string) *DB {
 	scope := s.Unscoped().NewScope(s.Value)
 	scope.addIndex(true, indexName, columns...)
 	return scope.db
 }
 // RemoveIndex remove index with name
 func (s *DB) RemoveIndex(indexName string) *DB {
 	scope := s.NewScope(s.Value)
 	scope.removeIndex(indexName)
 	return scope.db
 }
 // AddForeignKey Add foreign key to the given scope, e.g:
 //     db.Model(&User{}).AddForeignKey("city_id", "cities(id)", "RESTRICT", "RESTRICT")
 func (s *DB) AddForeignKey(field string, dest string, onDelete string, onUpdate string) *DB {
 	scope := s.NewScope(s.Value)
 	scope.addForeignKey(field, dest, onDelete, onUpdate)
 	return scope.db
 }
 // RemoveForeignKey Remove foreign key from the given scope, e.g:
 //     db.Model(&User{}).RemoveForeignKey("city_id", "cities(id)")
 func (s *DB) RemoveForeignKey(field string, dest string) *DB {
 	scope := s.clone().NewScope(s.Value)
 	scope.removeForeignKey(field, dest)
 	return scope.db
 }
 // Association start `Association Mode` to handler relations things easir in that mode, refer: https://jinzhu.github.io/gorm/associations.html#association-mode
 func (s *DB) Association(column string) *Association {
 	var err error
 	var scope = s.Set("gorm:association:source", s.Value).NewScope(s.Value)
 	if primaryField := scope.PrimaryField(); primaryField.IsBlank {
 		err = errors.New("primary key can't be nil")
 	} else {
 		if field, ok := scope.FieldByName(column); ok {
 			if field.Relationship == nil || len(field.Relationship.ForeignFieldNames) == 0 {
 				err = fmt.Errorf("invalid association %v for %v", column, scope.IndirectValue().Type())
 			} else {
 				return &Association{scope: scope, column: column, field: field}
 			}
 		} else {
 			err = fmt.Errorf("%v doesn't have column %v", scope.IndirectValue().Type(), column)
 		}
 	}
 	return &Association{Error: err}
 }
 // Preload preload associations with given conditions
 //    db.Preload("Orders", "state NOT IN (?)", "cancelled").Find(&users)
 func (s *DB) Preload(column string, conditions ...interface{}) *DB {
 	return s.clone().search.Preload(column, conditions...).db
 }
 // Set set setting by name, which could be used in callbacks, will clone a new db, and update its setting
 func (s *DB) Set(name string, value interface{}) *DB {
 	return s.clone().InstantSet(name, value)
 }
 // InstantSet instant set setting, will affect current db
 func (s *DB) InstantSet(name string, value interface{}) *DB {
 	s.values.Store(name, value)
 	return s
 }
 // Get get setting by name
 func (s *DB) Get(name string) (value interface{}, ok bool) {
 	value, ok = s.values.Load(name)
 	return
 }
 // SetJoinTableHandler set a model's join table handler for a relation
 func (s *DB) SetJoinTableHandler(source interface{}, column string, handler JoinTableHandlerInterface) {
 	scope := s.NewScope(source)
 	for _, field := range scope.GetModelStruct().StructFields {
 		if field.Name == column || field.DBName == column {
 			if many2many, _ := field.TagSettingsGet("MANY2MANY"); many2many != "" {
 				source := (&Scope{Value: source}).GetModelStruct().ModelType
 				destination := (&Scope{Value: reflect.New(field.Struct.Type).Interface()}).GetModelStruct().ModelType
 				handler.Setup(field.Relationship, many2many, source, destination)
 				field.Relationship.JoinTableHandler = handler
 				if table := handler.Table(s); scope.Dialect().HasTable(table) {
 					s.Table(table).AutoMigrate(handler)
 				}
 			}
 		}
 	}
 }
 // AddError add error to the db
 func (s *DB) AddError(err error) error {
 	if err != nil {
 		if err != ErrRecordNotFound {
 			if s.logMode == defaultLogMode {
 				go s.print("error", fileWithLineNum(), err)
 			} else {
 				s.log(err)
 			}
 			errors := Errors(s.GetErrors())
 			errors = errors.Add(err)
 			if len(errors) > 1 {
 				err = errors
 			}
 		}
 		s.Error = err
 	}
 	return err
 }
 // GetErrors get happened errors from the db
 func (s *DB) GetErrors() []error {
 	if errs, ok := s.Error.(Errors); ok {
 		return errs
 	} else if s.Error != nil {
 		return []error{s.Error}
 	}
 	return []error{}
 }
 ////////////////////////////////////////////////////////////////////////////////
 // Private Methods For DB
 ////////////////////////////////////////////////////////////////////////////////
 func (s *DB) clone() *DB {
 	db := &DB{
 		db:                s.db,
 		parent:            s.parent,
 		logger:            s.logger,
 		logMode:           s.logMode,
 		Value:             s.Value,
 		Error:             s.Error,
 		blockGlobalUpdate: s.blockGlobalUpdate,
 		dialect:           newDialect(s.dialect.GetName(), s.db),
 		nowFuncOverride:   s.nowFuncOverride,
 	}
 	s.values.Range(func(k, v interface{}) bool {
 		db.values.Store(k, v)
 		return true
 	})
 	if s.search == nil {
 		db.search = &search{limit: -1, offset: -1}
 	} else {
 		db.search = s.search.clone()
 	}
 	db.search.db = db
 	return db
 }
 func (s *DB) print(v ...interface{}) {
 	s.logger.Print(v...)
 }
 func (s *DB) log(v ...interface{}) {
 	if s != nil && s.logMode == detailedLogMode {
 		s.print(append([]interface{}{"log", fileWithLineNum()}, v...)...)
 	}
 }
 func (s *DB) slog(sql string, t time.Time, vars ...interface{}) {
 	if s.logMode == detailedLogMode {
 		s.print("sql", fileWithLineNum(), NowFunc().Sub(t), sql, vars, s.RowsAffected)
 	}
 }
--- a/vendor/github.com/jinzhu/gorm/model.go
+++ b/vendor/github.com/jinzhu/gorm/model.go
@ -0,0 +1,14 @@
 package gorm
 import "time"
 // Model base model definition, including fields `ID`, `CreatedAt`, `UpdatedAt`, `DeletedAt`, which could be embedded in your models
 //    type User struct {
 //      gorm.Model
 //    }
 type Model struct {
 	ID        uint `gorm:"primary_key"`
 	CreatedAt time.Time
 	UpdatedAt time.Time
 	DeletedAt *time.Time `sql:"index"`
 }
--- a/vendor/github.com/jinzhu/gorm/model_struct.go
+++ b/vendor/github.com/jinzhu/gorm/model_struct.go
@ -0,0 +1,671 @@
 package gorm
 import (
 	"database/sql"
 	"errors"
 	"go/ast"
 	"reflect"
 	"strings"
 	"sync"
 	"time"
 	"github.com/jinzhu/inflection"
 )
 // DefaultTableNameHandler default table name handler
 var DefaultTableNameHandler = func(db *DB, defaultTableName string) string {
 	return defaultTableName
 }
 // lock for mutating global cached model metadata
 var structsLock sync.Mutex
 // global cache of model metadata
 var modelStructsMap sync.Map
 // ModelStruct model definition
 type ModelStruct struct {
 	PrimaryFields []*StructField
 	StructFields  []*StructField
 	ModelType     reflect.Type
 	defaultTableName string
 	l                sync.Mutex
 }
 // TableName returns model's table name
 func (s *ModelStruct) TableName(db *DB) string {
 	s.l.Lock()
 	defer s.l.Unlock()
 	if s.defaultTableName == "" && db != nil && s.ModelType != nil {
 		// Set default table name
 		if tabler, ok := reflect.New(s.ModelType).Interface().(tabler); ok {
 			s.defaultTableName = tabler.TableName()
 		} else {
 			tableName := ToTableName(s.ModelType.Name())
 			db.parent.RLock()
 			if db == nil || (db.parent != nil && !db.parent.singularTable) {
 				tableName = inflection.Plural(tableName)
 			}
 			db.parent.RUnlock()
 			s.defaultTableName = tableName
 		}
 	}
 	return DefaultTableNameHandler(db, s.defaultTableName)
 }
 // StructField model field's struct definition
 type StructField struct {
 	DBName          string
 	Name            string
 	Names           []string
 	IsPrimaryKey    bool
 	IsNormal        bool
 	IsIgnored       bool
 	IsScanner       bool
 	HasDefaultValue bool
 	Tag             reflect.StructTag
 	TagSettings     map[string]string
 	Struct          reflect.StructField
 	IsForeignKey    bool
 	Relationship    *Relationship
 	tagSettingsLock sync.RWMutex
 }
 // TagSettingsSet Sets a tag in the tag settings map
 func (sf *StructField) TagSettingsSet(key, val string) {
 	sf.tagSettingsLock.Lock()
 	defer sf.tagSettingsLock.Unlock()
 	sf.TagSettings[key] = val
 }
 // TagSettingsGet returns a tag from the tag settings
 func (sf *StructField) TagSettingsGet(key string) (string, bool) {
 	sf.tagSettingsLock.RLock()
 	defer sf.tagSettingsLock.RUnlock()
 	val, ok := sf.TagSettings[key]
 	return val, ok
 }
 // TagSettingsDelete deletes a tag
 func (sf *StructField) TagSettingsDelete(key string) {
 	sf.tagSettingsLock.Lock()
 	defer sf.tagSettingsLock.Unlock()
 	delete(sf.TagSettings, key)
 }
 func (sf *StructField) clone() *StructField {
 	clone := &StructField{
 		DBName:          sf.DBName,
 		Name:            sf.Name,
 		Names:           sf.Names,
 		IsPrimaryKey:    sf.IsPrimaryKey,
 		IsNormal:        sf.IsNormal,
 		IsIgnored:       sf.IsIgnored,
 		IsScanner:       sf.IsScanner,
 		HasDefaultValue: sf.HasDefaultValue,
 		Tag:             sf.Tag,
 		TagSettings:     map[string]string{},
 		Struct:          sf.Struct,
 		IsForeignKey:    sf.IsForeignKey,
 	}
 	if sf.Relationship != nil {
 		relationship := *sf.Relationship
 		clone.Relationship = &relationship
 	}
 	// copy the struct field tagSettings, they should be read-locked while they are copied
 	sf.tagSettingsLock.Lock()
 	defer sf.tagSettingsLock.Unlock()
 	for key, value := range sf.TagSettings {
 		clone.TagSettings[key] = value
 	}
 	return clone
 }
 // Relationship described the relationship between models
 type Relationship struct {
 	Kind                         string
 	PolymorphicType              string
 	PolymorphicDBName            string
 	PolymorphicValue             string
 	ForeignFieldNames            []string
 	ForeignDBNames               []string
 	AssociationForeignFieldNames []string
 	AssociationForeignDBNames    []string
 	JoinTableHandler             JoinTableHandlerInterface
 }
 func getForeignField(column string, fields []*StructField) *StructField {
 	for _, field := range fields {
 		if field.Name == column || field.DBName == column || field.DBName == ToColumnName(column) {
 			return field
 		}
 	}
 	return nil
 }
 // GetModelStruct get value's model struct, relationships based on struct and tag definition
 func (scope *Scope) GetModelStruct() *ModelStruct {
 	var modelStruct ModelStruct
 	// Scope value can't be nil
 	if scope.Value == nil {
 		return &modelStruct
 	}
 	reflectType := reflect.ValueOf(scope.Value).Type()
 	for reflectType.Kind() == reflect.Slice || reflectType.Kind() == reflect.Ptr {
 		reflectType = reflectType.Elem()
 	}
 	// Scope value need to be a struct
 	if reflectType.Kind() != reflect.Struct {
 		return &modelStruct
 	}
 	// Get Cached model struct
 	isSingularTable := false
 	if scope.db != nil && scope.db.parent != nil {
 		scope.db.parent.RLock()
 		isSingularTable = scope.db.parent.singularTable
 		scope.db.parent.RUnlock()
 	}
 	hashKey := struct {
 		singularTable bool
 		reflectType   reflect.Type
 	}{isSingularTable, reflectType}
 	if value, ok := modelStructsMap.Load(hashKey); ok && value != nil {
 		return value.(*ModelStruct)
 	}
 	modelStruct.ModelType = reflectType
 	// Get all fields
 	for i := 0; i < reflectType.NumField(); i++ {
 		if fieldStruct := reflectType.Field(i); ast.IsExported(fieldStruct.Name) {
 			field := &StructField{
 				Struct:      fieldStruct,
 				Name:        fieldStruct.Name,
 				Names:       []string{fieldStruct.Name},
 				Tag:         fieldStruct.Tag,
 				TagSettings: parseTagSetting(fieldStruct.Tag),
 			}
 			// is ignored field
 			if _, ok := field.TagSettingsGet("-"); ok {
 				field.IsIgnored = true
 			} else {
 				if _, ok := field.TagSettingsGet("PRIMARY_KEY"); ok {
 					field.IsPrimaryKey = true
 					modelStruct.PrimaryFields = append(modelStruct.PrimaryFields, field)
 				}
 				if _, ok := field.TagSettingsGet("DEFAULT"); ok && !field.IsPrimaryKey {
 					field.HasDefaultValue = true
 				}
 				if _, ok := field.TagSettingsGet("AUTO_INCREMENT"); ok && !field.IsPrimaryKey {
 					field.HasDefaultValue = true
 				}
 				indirectType := fieldStruct.Type
 				for indirectType.Kind() == reflect.Ptr {
 					indirectType = indirectType.Elem()
 				}
 				fieldValue := reflect.New(indirectType).Interface()
 				if _, isScanner := fieldValue.(sql.Scanner); isScanner {
 					// is scanner
 					field.IsScanner, field.IsNormal = true, true
 					if indirectType.Kind() == reflect.Struct {
 						for i := 0; i < indirectType.NumField(); i++ {
 							for key, value := range parseTagSetting(indirectType.Field(i).Tag) {
 								if _, ok := field.TagSettingsGet(key); !ok {
 									field.TagSettingsSet(key, value)
 								}
 							}
 						}
 					}
 				} else if _, isTime := fieldValue.(*time.Time); isTime {
 					// is time
 					field.IsNormal = true
 				} else if _, ok := field.TagSettingsGet("EMBEDDED"); ok || fieldStruct.Anonymous {
 					// is embedded struct
 					for _, subField := range scope.New(fieldValue).GetModelStruct().StructFields {
 						subField = subField.clone()
 						subField.Names = append([]string{fieldStruct.Name}, subField.Names...)
 						if prefix, ok := field.TagSettingsGet("EMBEDDED_PREFIX"); ok {
 							subField.DBName = prefix + subField.DBName
 						}
 						if subField.IsPrimaryKey {
 							if _, ok := subField.TagSettingsGet("PRIMARY_KEY"); ok {
 								modelStruct.PrimaryFields = append(modelStruct.PrimaryFields, subField)
 							} else {
 								subField.IsPrimaryKey = false
 							}
 						}
 						if subField.Relationship != nil && subField.Relationship.JoinTableHandler != nil {
 							if joinTableHandler, ok := subField.Relationship.JoinTableHandler.(*JoinTableHandler); ok {
 								newJoinTableHandler := &JoinTableHandler{}
 								newJoinTableHandler.Setup(subField.Relationship, joinTableHandler.TableName, reflectType, joinTableHandler.Destination.ModelType)
 								subField.Relationship.JoinTableHandler = newJoinTableHandler
 							}
 						}
 						modelStruct.StructFields = append(modelStruct.StructFields, subField)
 					}
 					continue
 				} else {
 					// build relationships
 					switch indirectType.Kind() {
 					case reflect.Slice:
 						defer func(field *StructField) {
 							var (
 								relationship           = &Relationship{}
 								toScope                = scope.New(reflect.New(field.Struct.Type).Interface())
 								foreignKeys            []string
 								associationForeignKeys []string
 								elemType               = field.Struct.Type
 							)
 							if foreignKey, _ := field.TagSettingsGet("FOREIGNKEY"); foreignKey != "" {
 								foreignKeys = strings.Split(foreignKey, ",")
 							}
 							if foreignKey, _ := field.TagSettingsGet("ASSOCIATION_FOREIGNKEY"); foreignKey != "" {
 								associationForeignKeys = strings.Split(foreignKey, ",")
 							} else if foreignKey, _ := field.TagSettingsGet("ASSOCIATIONFOREIGNKEY"); foreignKey != "" {
 								associationForeignKeys = strings.Split(foreignKey, ",")
 							}
 							for elemType.Kind() == reflect.Slice || elemType.Kind() == reflect.Ptr {
 								elemType = elemType.Elem()
 							}
 							if elemType.Kind() == reflect.Struct {
 								if many2many, _ := field.TagSettingsGet("MANY2MANY"); many2many != "" {
 									relationship.Kind = "many_to_many"
 									{ // Foreign Keys for Source
 										joinTableDBNames := []string{}
 										if foreignKey, _ := field.TagSettingsGet("JOINTABLE_FOREIGNKEY"); foreignKey != "" {
 											joinTableDBNames = strings.Split(foreignKey, ",")
 										}
 										// if no foreign keys defined with tag
 										if len(foreignKeys) == 0 {
 											for _, field := range modelStruct.PrimaryFields {
 												foreignKeys = append(foreignKeys, field.DBName)
 											}
 										}
 										for idx, foreignKey := range foreignKeys {
 											if foreignField := getForeignField(foreignKey, modelStruct.StructFields); foreignField != nil {
 												// source foreign keys (db names)
 												relationship.ForeignFieldNames = append(relationship.ForeignFieldNames, foreignField.DBName)
 												// setup join table foreign keys for source
 												if len(joinTableDBNames) > idx {
 													// if defined join table's foreign key
 													relationship.ForeignDBNames = append(relationship.ForeignDBNames, joinTableDBNames[idx])
 												} else {
 													defaultJointableForeignKey := ToColumnName(reflectType.Name()) + "_" + foreignField.DBName
 													relationship.ForeignDBNames = append(relationship.ForeignDBNames, defaultJointableForeignKey)
 												}
 											}
 										}
 									}
 									{ // Foreign Keys for Association (Destination)
 										associationJoinTableDBNames := []string{}
 										if foreignKey, _ := field.TagSettingsGet("ASSOCIATION_JOINTABLE_FOREIGNKEY"); foreignKey != "" {
 											associationJoinTableDBNames = strings.Split(foreignKey, ",")
 										}
 										// if no association foreign keys defined with tag
 										if len(associationForeignKeys) == 0 {
 											for _, field := range toScope.PrimaryFields() {
 												associationForeignKeys = append(associationForeignKeys, field.DBName)
 											}
 										}
 										for idx, name := range associationForeignKeys {
 											if field, ok := toScope.FieldByName(name); ok {
 												// association foreign keys (db names)
 												relationship.AssociationForeignFieldNames = append(relationship.AssociationForeignFieldNames, field.DBName)
 												// setup join table foreign keys for association
 												if len(associationJoinTableDBNames) > idx {
 													relationship.AssociationForeignDBNames = append(relationship.AssociationForeignDBNames, associationJoinTableDBNames[idx])
 												} else {
 													// join table foreign keys for association
 													joinTableDBName := ToColumnName(elemType.Name()) + "_" + field.DBName
 													relationship.AssociationForeignDBNames = append(relationship.AssociationForeignDBNames, joinTableDBName)
 												}
 											}
 										}
 									}
 									joinTableHandler := JoinTableHandler{}
 									joinTableHandler.Setup(relationship, many2many, reflectType, elemType)
 									relationship.JoinTableHandler = &joinTableHandler
 									field.Relationship = relationship
 								} else {
 									// User has many comments, associationType is User, comment use UserID as foreign key
 									var associationType = reflectType.Name()
 									var toFields = toScope.GetStructFields()
 									relationship.Kind = "has_many"
 									if polymorphic, _ := field.TagSettingsGet("POLYMORPHIC"); polymorphic != "" {
 										// Dog has many toys, tag polymorphic is Owner, then associationType is Owner
 										// Toy use OwnerID, OwnerType ('dogs') as foreign key
 										if polymorphicType := getForeignField(polymorphic+"Type", toFields); polymorphicType != nil {
 											associationType = polymorphic
 											relationship.PolymorphicType = polymorphicType.Name
 											relationship.PolymorphicDBName = polymorphicType.DBName
 											// if Dog has multiple set of toys set name of the set (instead of default 'dogs')
 											if value, ok := field.TagSettingsGet("POLYMORPHIC_VALUE"); ok {
 												relationship.PolymorphicValue = value
 											} else {
 												relationship.PolymorphicValue = scope.TableName()
 											}
 											polymorphicType.IsForeignKey = true
 										}
 									}
 									// if no foreign keys defined with tag
 									if len(foreignKeys) == 0 {
 										// if no association foreign keys defined with tag
 										if len(associationForeignKeys) == 0 {
 											for _, field := range modelStruct.PrimaryFields {
 												foreignKeys = append(foreignKeys, associationType+field.Name)
 												associationForeignKeys = append(associationForeignKeys, field.Name)
 											}
 										} else {
 											// generate foreign keys from defined association foreign keys
 											for _, scopeFieldName := range associationForeignKeys {
 												if foreignField := getForeignField(scopeFieldName, modelStruct.StructFields); foreignField != nil {
 													foreignKeys = append(foreignKeys, associationType+foreignField.Name)
 													associationForeignKeys = append(associationForeignKeys, foreignField.Name)
 												}
 											}
 										}
 									} else {
 										// generate association foreign keys from foreign keys
 										if len(associationForeignKeys) == 0 {
 											for _, foreignKey := range foreignKeys {
 												if strings.HasPrefix(foreignKey, associationType) {
 													associationForeignKey := strings.TrimPrefix(foreignKey, associationType)
 													if foreignField := getForeignField(associationForeignKey, modelStruct.StructFields); foreignField != nil {
 														associationForeignKeys = append(associationForeignKeys, associationForeignKey)
 													}
 												}
 											}
 											if len(associationForeignKeys) == 0 && len(foreignKeys) == 1 {
 												associationForeignKeys = []string{scope.PrimaryKey()}
 											}
 										} else if len(foreignKeys) != len(associationForeignKeys) {
 											scope.Err(errors.New("invalid foreign keys, should have same length"))
 											return
 										}
 									}
 									for idx, foreignKey := range foreignKeys {
 										if foreignField := getForeignField(foreignKey, toFields); foreignField != nil {
 											if associationField := getForeignField(associationForeignKeys[idx], modelStruct.StructFields); associationField != nil {
 												// mark field as foreignkey, use global lock to avoid race
 												structsLock.Lock()
 												foreignField.IsForeignKey = true
 												structsLock.Unlock()
 												// association foreign keys
 												relationship.AssociationForeignFieldNames = append(relationship.AssociationForeignFieldNames, associationField.Name)
 												relationship.AssociationForeignDBNames = append(relationship.AssociationForeignDBNames, associationField.DBName)
 												// association foreign keys
 												relationship.ForeignFieldNames = append(relationship.ForeignFieldNames, foreignField.Name)
 												relationship.ForeignDBNames = append(relationship.ForeignDBNames, foreignField.DBName)
 											}
 										}
 									}
 									if len(relationship.ForeignFieldNames) != 0 {
 										field.Relationship = relationship
 									}
 								}
 							} else {
 								field.IsNormal = true
 							}
 						}(field)
 					case reflect.Struct:
 						defer func(field *StructField) {
 							var (
 								// user has one profile, associationType is User, profile use UserID as foreign key
 								// user belongs to profile, associationType is Profile, user use ProfileID as foreign key
 								associationType           = reflectType.Name()
 								relationship              = &Relationship{}
 								toScope                   = scope.New(reflect.New(field.Struct.Type).Interface())
 								toFields                  = toScope.GetStructFields()
 								tagForeignKeys            []string
 								tagAssociationForeignKeys []string
 							)
 							if foreignKey, _ := field.TagSettingsGet("FOREIGNKEY"); foreignKey != "" {
 								tagForeignKeys = strings.Split(foreignKey, ",")
 							}
 							if foreignKey, _ := field.TagSettingsGet("ASSOCIATION_FOREIGNKEY"); foreignKey != "" {
 								tagAssociationForeignKeys = strings.Split(foreignKey, ",")
 							} else if foreignKey, _ := field.TagSettingsGet("ASSOCIATIONFOREIGNKEY"); foreignKey != "" {
 								tagAssociationForeignKeys = strings.Split(foreignKey, ",")
 							}
 							if polymorphic, _ := field.TagSettingsGet("POLYMORPHIC"); polymorphic != "" {
 								// Cat has one toy, tag polymorphic is Owner, then associationType is Owner
 								// Toy use OwnerID, OwnerType ('cats') as foreign key
 								if polymorphicType := getForeignField(polymorphic+"Type", toFields); polymorphicType != nil {
 									associationType = polymorphic
 									relationship.PolymorphicType = polymorphicType.Name
 									relationship.PolymorphicDBName = polymorphicType.DBName
 									// if Cat has several different types of toys set name for each (instead of default 'cats')
 									if value, ok := field.TagSettingsGet("POLYMORPHIC_VALUE"); ok {
 										relationship.PolymorphicValue = value
 									} else {
 										relationship.PolymorphicValue = scope.TableName()
 									}
 									polymorphicType.IsForeignKey = true
 								}
 							}
 							// Has One
 							{
 								var foreignKeys = tagForeignKeys
 								var associationForeignKeys = tagAssociationForeignKeys
 								// if no foreign keys defined with tag
 								if len(foreignKeys) == 0 {
 									// if no association foreign keys defined with tag
 									if len(associationForeignKeys) == 0 {
 										for _, primaryField := range modelStruct.PrimaryFields {
 											foreignKeys = append(foreignKeys, associationType+primaryField.Name)
 											associationForeignKeys = append(associationForeignKeys, primaryField.Name)
 										}
 									} else {
 										// generate foreign keys form association foreign keys
 										for _, associationForeignKey := range tagAssociationForeignKeys {
 											if foreignField := getForeignField(associationForeignKey, modelStruct.StructFields); foreignField != nil {
 												foreignKeys = append(foreignKeys, associationType+foreignField.Name)
 												associationForeignKeys = append(associationForeignKeys, foreignField.Name)
 											}
 										}
 									}
 								} else {
 									// generate association foreign keys from foreign keys
 									if len(associationForeignKeys) == 0 {
 										for _, foreignKey := range foreignKeys {
 											if strings.HasPrefix(foreignKey, associationType) {
 												associationForeignKey := strings.TrimPrefix(foreignKey, associationType)
 												if foreignField := getForeignField(associationForeignKey, modelStruct.StructFields); foreignField != nil {
 													associationForeignKeys = append(associationForeignKeys, associationForeignKey)
 												}
 											}
 										}
 										if len(associationForeignKeys) == 0 && len(foreignKeys) == 1 {
 											associationForeignKeys = []string{scope.PrimaryKey()}
 										}
 									} else if len(foreignKeys) != len(associationForeignKeys) {
 										scope.Err(errors.New("invalid foreign keys, should have same length"))
 										return
 									}
 								}
 								for idx, foreignKey := range foreignKeys {
 									if foreignField := getForeignField(foreignKey, toFields); foreignField != nil {
 										if scopeField := getForeignField(associationForeignKeys[idx], modelStruct.StructFields); scopeField != nil {
 											// mark field as foreignkey, use global lock to avoid race
 											structsLock.Lock()
 											foreignField.IsForeignKey = true
 											structsLock.Unlock()
 											// association foreign keys
 											relationship.AssociationForeignFieldNames = append(relationship.AssociationForeignFieldNames, scopeField.Name)
 											relationship.AssociationForeignDBNames = append(relationship.AssociationForeignDBNames, scopeField.DBName)
 											// association foreign keys
 											relationship.ForeignFieldNames = append(relationship.ForeignFieldNames, foreignField.Name)
 											relationship.ForeignDBNames = append(relationship.ForeignDBNames, foreignField.DBName)
 										}
 									}
 								}
 							}
 							if len(relationship.ForeignFieldNames) != 0 {
 								relationship.Kind = "has_one"
 								field.Relationship = relationship
 							} else {
 								var foreignKeys = tagForeignKeys
 								var associationForeignKeys = tagAssociationForeignKeys
 								if len(foreignKeys) == 0 {
 									// generate foreign keys & association foreign keys
 									if len(associationForeignKeys) == 0 {
 										for _, primaryField := range toScope.PrimaryFields() {
 											foreignKeys = append(foreignKeys, field.Name+primaryField.Name)
 											associationForeignKeys = append(associationForeignKeys, primaryField.Name)
 										}
 									} else {
 										// generate foreign keys with association foreign keys
 										for _, associationForeignKey := range associationForeignKeys {
 											if foreignField := getForeignField(associationForeignKey, toFields); foreignField != nil {
 												foreignKeys = append(foreignKeys, field.Name+foreignField.Name)
 												associationForeignKeys = append(associationForeignKeys, foreignField.Name)
 											}
 										}
 									}
 								} else {
 									// generate foreign keys & association foreign keys
 									if len(associationForeignKeys) == 0 {
 										for _, foreignKey := range foreignKeys {
 											if strings.HasPrefix(foreignKey, field.Name) {
 												associationForeignKey := strings.TrimPrefix(foreignKey, field.Name)
 												if foreignField := getForeignField(associationForeignKey, toFields); foreignField != nil {
 													associationForeignKeys = append(associationForeignKeys, associationForeignKey)
 												}
 											}
 										}
 										if len(associationForeignKeys) == 0 && len(foreignKeys) == 1 {
 											associationForeignKeys = []string{toScope.PrimaryKey()}
 										}
 									} else if len(foreignKeys) != len(associationForeignKeys) {
 										scope.Err(errors.New("invalid foreign keys, should have same length"))
 										return
 									}
 								}
 								for idx, foreignKey := range foreignKeys {
 									if foreignField := getForeignField(foreignKey, modelStruct.StructFields); foreignField != nil {
 										if associationField := getForeignField(associationForeignKeys[idx], toFields); associationField != nil {
 											// mark field as foreignkey, use global lock to avoid race
 											structsLock.Lock()
 											foreignField.IsForeignKey = true
 											structsLock.Unlock()
 											// association foreign keys
 											relationship.AssociationForeignFieldNames = append(relationship.AssociationForeignFieldNames, associationField.Name)
 											relationship.AssociationForeignDBNames = append(relationship.AssociationForeignDBNames, associationField.DBName)
 											// source foreign keys
 											relationship.ForeignFieldNames = append(relationship.ForeignFieldNames, foreignField.Name)
 											relationship.ForeignDBNames = append(relationship.ForeignDBNames, foreignField.DBName)
 										}
 									}
 								}
 								if len(relationship.ForeignFieldNames) != 0 {
 									relationship.Kind = "belongs_to"
 									field.Relationship = relationship
 								}
 							}
 						}(field)
 					default:
 						field.IsNormal = true
 					}
 				}
 			}
 			// Even it is ignored, also possible to decode db value into the field
 			if value, ok := field.TagSettingsGet("COLUMN"); ok {
 				field.DBName = value
 			} else {
 				field.DBName = ToColumnName(fieldStruct.Name)
 			}
 			modelStruct.StructFields = append(modelStruct.StructFields, field)
 		}
 	}
 	if len(modelStruct.PrimaryFields) == 0 {
 		if field := getForeignField("id", modelStruct.StructFields); field != nil {
 			field.IsPrimaryKey = true
 			modelStruct.PrimaryFields = append(modelStruct.PrimaryFields, field)
 		}
 	}
 	modelStructsMap.Store(hashKey, &modelStruct)
 	return &modelStruct
 }
 // GetStructFields get model's field structs
 func (scope *Scope) GetStructFields() (fields []*StructField) {
 	return scope.GetModelStruct().StructFields
 }
 func parseTagSetting(tags reflect.StructTag) map[string]string {
 	setting := map[string]string{}
 	for _, str := range []string{tags.Get("sql"), tags.Get("gorm")} {
 		if str == "" {
 			continue
 		}
 		tags := strings.Split(str, ";")
 		for _, value := range tags {
 			v := strings.Split(value, ":")
 			k := strings.TrimSpace(strings.ToUpper(v[0]))
 			if len(v) >= 2 {
 				setting[k] = strings.Join(v[1:], ":")
 			} else {
 				setting[k] = k
 			}
 		}
 	}
 	return setting
 }
--- a/vendor/github.com/jinzhu/gorm/naming.go
+++ b/vendor/github.com/jinzhu/gorm/naming.go
@ -0,0 +1,124 @@
 package gorm
 import (
 	"bytes"
 	"strings"
 )
 // Namer is a function type which is given a string and return a string
 type Namer func(string) string
 // NamingStrategy represents naming strategies
 type NamingStrategy struct {
 	DB     Namer
 	Table  Namer
 	Column Namer
 }
 // TheNamingStrategy is being initialized with defaultNamingStrategy
 var TheNamingStrategy = &NamingStrategy{
 	DB:     defaultNamer,
 	Table:  defaultNamer,
 	Column: defaultNamer,
 }
 // AddNamingStrategy sets the naming strategy
 func AddNamingStrategy(ns *NamingStrategy) {
 	if ns.DB == nil {
 		ns.DB = defaultNamer
 	}
 	if ns.Table == nil {
 		ns.Table = defaultNamer
 	}
 	if ns.Column == nil {
 		ns.Column = defaultNamer
 	}
 	TheNamingStrategy = ns
 }
 // DBName alters the given name by DB
 func (ns *NamingStrategy) DBName(name string) string {
 	return ns.DB(name)
 }
 // TableName alters the given name by Table
 func (ns *NamingStrategy) TableName(name string) string {
 	return ns.Table(name)
 }
 // ColumnName alters the given name by Column
 func (ns *NamingStrategy) ColumnName(name string) string {
 	return ns.Column(name)
 }
 // ToDBName convert string to db name
 func ToDBName(name string) string {
 	return TheNamingStrategy.DBName(name)
 }
 // ToTableName convert string to table name
 func ToTableName(name string) string {
 	return TheNamingStrategy.TableName(name)
 }
 // ToColumnName convert string to db name
 func ToColumnName(name string) string {
 	return TheNamingStrategy.ColumnName(name)
 }
 var smap = newSafeMap()
 func defaultNamer(name string) string {
 	const (
 		lower = false
 		upper = true
 	)
 	if v := smap.Get(name); v != "" {
 		return v
 	}
 	if name == "" {
 		return ""
 	}
 	var (
 		value                                    = commonInitialismsReplacer.Replace(name)
 		buf                                      = bytes.NewBufferString("")
 		lastCase, currCase, nextCase, nextNumber bool
 	)
 	for i, v := range value[:len(value)-1] {
 		nextCase = bool(value[i+1] >= 'A' && value[i+1] <= 'Z')
 		nextNumber = bool(value[i+1] >= '0' && value[i+1] <= '9')
 		if i > 0 {
 			if currCase == upper {
 				if lastCase == upper && (nextCase == upper || nextNumber == upper) {
 					buf.WriteRune(v)
 				} else {
 					if value[i-1] != '_' && value[i+1] != '_' {
 						buf.WriteRune('_')
 					}
 					buf.WriteRune(v)
 				}
 			} else {
 				buf.WriteRune(v)
 				if i == len(value)-2 && (nextCase == upper && nextNumber == lower) {
 					buf.WriteRune('_')
 				}
 			}
 		} else {
 			currCase = upper
 			buf.WriteRune(v)
 		}
 		lastCase = currCase
 		currCase = nextCase
 	}
 	buf.WriteByte(value[len(value)-1])
 	s := strings.ToLower(buf.String())
 	smap.Set(name, s)
 	return s
 }
--- a/vendor/github.com/jinzhu/gorm/scope.go
+++ b/vendor/github.com/jinzhu/gorm/scope.go
--- a/vendor/github.com/jinzhu/gorm/search.go
+++ b/vendor/github.com/jinzhu/gorm/search.go
@ -0,0 +1,153 @@
 package gorm
 import (
 	"fmt"
 )
 type search struct {
 	db               *DB
 	whereConditions  []map[string]interface{}
 	orConditions     []map[string]interface{}
 	notConditions    []map[string]interface{}
 	havingConditions []map[string]interface{}
 	joinConditions   []map[string]interface{}
 	initAttrs        []interface{}
 	assignAttrs      []interface{}
 	selects          map[string]interface{}
 	omits            []string
 	orders           []interface{}
 	preload          []searchPreload
 	offset           interface{}
 	limit            interface{}
 	group            string
 	tableName        string
 	raw              bool
 	Unscoped         bool
 	ignoreOrderQuery bool
 }
 type searchPreload struct {
 	schema     string
 	conditions []interface{}
 }
 func (s *search) clone() *search {
 	clone := *s
 	return &clone
 }
 func (s *search) Where(query interface{}, values ...interface{}) *search {
 	s.whereConditions = append(s.whereConditions, map[string]interface{}{"query": query, "args": values})
 	return s
 }
 func (s *search) Not(query interface{}, values ...interface{}) *search {
 	s.notConditions = append(s.notConditions, map[string]interface{}{"query": query, "args": values})
 	return s
 }
 func (s *search) Or(query interface{}, values ...interface{}) *search {
 	s.orConditions = append(s.orConditions, map[string]interface{}{"query": query, "args": values})
 	return s
 }
 func (s *search) Attrs(attrs ...interface{}) *search {
 	s.initAttrs = append(s.initAttrs, toSearchableMap(attrs...))
 	return s
 }
 func (s *search) Assign(attrs ...interface{}) *search {
 	s.assignAttrs = append(s.assignAttrs, toSearchableMap(attrs...))
 	return s
 }
 func (s *search) Order(value interface{}, reorder ...bool) *search {
 	if len(reorder) > 0 && reorder[0] {
 		s.orders = []interface{}{}
 	}
 	if value != nil && value != "" {
 		s.orders = append(s.orders, value)
 	}
 	return s
 }
 func (s *search) Select(query interface{}, args ...interface{}) *search {
 	s.selects = map[string]interface{}{"query": query, "args": args}
 	return s
 }
 func (s *search) Omit(columns ...string) *search {
 	s.omits = columns
 	return s
 }
 func (s *search) Limit(limit interface{}) *search {
 	s.limit = limit
 	return s
 }
 func (s *search) Offset(offset interface{}) *search {
 	s.offset = offset
 	return s
 }
 func (s *search) Group(query string) *search {
 	s.group = s.getInterfaceAsSQL(query)
 	return s
 }
 func (s *search) Having(query interface{}, values ...interface{}) *search {
 	if val, ok := query.(*SqlExpr); ok {
 		s.havingConditions = append(s.havingConditions, map[string]interface{}{"query": val.expr, "args": val.args})
 	} else {
 		s.havingConditions = append(s.havingConditions, map[string]interface{}{"query": query, "args": values})
 	}
 	return s
 }
 func (s *search) Joins(query string, values ...interface{}) *search {
 	s.joinConditions = append(s.joinConditions, map[string]interface{}{"query": query, "args": values})
 	return s
 }
 func (s *search) Preload(schema string, values ...interface{}) *search {
 	var preloads []searchPreload
 	for _, preload := range s.preload {
 		if preload.schema != schema {
 			preloads = append(preloads, preload)
 		}
 	}
 	preloads = append(preloads, searchPreload{schema, values})
 	s.preload = preloads
 	return s
 }
 func (s *search) Raw(b bool) *search {
 	s.raw = b
 	return s
 }
 func (s *search) unscoped() *search {
 	s.Unscoped = true
 	return s
 }
 func (s *search) Table(name string) *search {
 	s.tableName = name
 	return s
 }
 func (s *search) getInterfaceAsSQL(value interface{}) (str string) {
 	switch value.(type) {
 	case string, int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
 		str = fmt.Sprintf("%v", value)
 	default:
 		s.db.AddError(ErrInvalidSQL)
 	}
 	if str == "-1" {
 		return ""
 	}
 	return
 }
--- a/vendor/github.com/jinzhu/gorm/test_all.sh
+++ b/vendor/github.com/jinzhu/gorm/test_all.sh
@ -0,0 +1,5 @@
 dialects=("postgres" "mysql" "mssql" "sqlite")
 for dialect in "${dialects[@]}" ; do
    DEBUG=false GORM_DIALECT=${dialect} go test
 done
--- a/vendor/github.com/jinzhu/gorm/utils.go
+++ b/vendor/github.com/jinzhu/gorm/utils.go
@ -0,0 +1,226 @@
 package gorm
 import (
 	"database/sql/driver"
 	"fmt"
 	"reflect"
 	"regexp"
 	"runtime"
 	"strings"
 	"sync"
 	"time"
 )
 // NowFunc returns current time, this function is exported in order to be able
 // to give the flexibility to the developer to customize it according to their
 // needs, e.g:
 //    gorm.NowFunc = func() time.Time {
 //      return time.Now().UTC()
 //    }
 var NowFunc = func() time.Time {
 	return time.Now()
 }
 // Copied from golint
 var commonInitialisms = []string{"API", "ASCII", "CPU", "CSS", "DNS", "EOF", "GUID", "HTML", "HTTP", "HTTPS", "ID", "IP", "JSON", "LHS", "QPS", "RAM", "RHS", "RPC", "SLA", "SMTP", "SSH", "TLS", "TTL", "UID", "UI", "UUID", "URI", "URL", "UTF8", "VM", "XML", "XSRF", "XSS"}
 var commonInitialismsReplacer *strings.Replacer
 var goSrcRegexp = regexp.MustCompile(`jinzhu/gorm(@.*)?/.*.go`)
 var goTestRegexp = regexp.MustCompile(`jinzhu/gorm(@.*)?/.*test.go`)
 func init() {
 	var commonInitialismsForReplacer []string
 	for _, initialism := range commonInitialisms {
 		commonInitialismsForReplacer = append(commonInitialismsForReplacer, initialism, strings.Title(strings.ToLower(initialism)))
 	}
 	commonInitialismsReplacer = strings.NewReplacer(commonInitialismsForReplacer...)
 }
 type safeMap struct {
 	m map[string]string
 	l *sync.RWMutex
 }
 func (s *safeMap) Set(key string, value string) {
 	s.l.Lock()
 	defer s.l.Unlock()
 	s.m[key] = value
 }
 func (s *safeMap) Get(key string) string {
 	s.l.RLock()
 	defer s.l.RUnlock()
 	return s.m[key]
 }
 func newSafeMap() *safeMap {
 	return &safeMap{l: new(sync.RWMutex), m: make(map[string]string)}
 }
 // SQL expression
 type SqlExpr struct {
 	expr string
 	args []interface{}
 }
 // Expr generate raw SQL expression, for example:
 //     DB.Model(&product).Update("price", gorm.Expr("price * ? + ?", 2, 100))
 func Expr(expression string, args ...interface{}) *SqlExpr {
 	return &SqlExpr{expr: expression, args: args}
 }
 func indirect(reflectValue reflect.Value) reflect.Value {
 	for reflectValue.Kind() == reflect.Ptr {
 		reflectValue = reflectValue.Elem()
 	}
 	return reflectValue
 }
 func toQueryMarks(primaryValues [][]interface{}) string {
 	var results []string
 	for _, primaryValue := range primaryValues {
 		var marks []string
 		for range primaryValue {
 			marks = append(marks, "?")
 		}
 		if len(marks) > 1 {
 			results = append(results, fmt.Sprintf("(%v)", strings.Join(marks, ",")))
 		} else {
 			results = append(results, strings.Join(marks, ""))
 		}
 	}
 	return strings.Join(results, ",")
 }
 func toQueryCondition(scope *Scope, columns []string) string {
 	var newColumns []string
 	for _, column := range columns {
 		newColumns = append(newColumns, scope.Quote(column))
 	}
 	if len(columns) > 1 {
 		return fmt.Sprintf("(%v)", strings.Join(newColumns, ","))
 	}
 	return strings.Join(newColumns, ",")
 }
 func toQueryValues(values [][]interface{}) (results []interface{}) {
 	for _, value := range values {
 		for _, v := range value {
 			results = append(results, v)
 		}
 	}
 	return
 }
 func fileWithLineNum() string {
 	for i := 2; i < 15; i++ {
 		_, file, line, ok := runtime.Caller(i)
 		if ok && (!goSrcRegexp.MatchString(file) || goTestRegexp.MatchString(file)) {
 			return fmt.Sprintf("%v:%v", file, line)
 		}
 	}
 	return ""
 }
 func isBlank(value reflect.Value) bool {
 	switch value.Kind() {
 	case reflect.String:
 		return value.Len() == 0
 	case reflect.Bool:
 		return !value.Bool()
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 		return value.Int() == 0
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
 		return value.Uint() == 0
 	case reflect.Float32, reflect.Float64:
 		return value.Float() == 0
 	case reflect.Interface, reflect.Ptr:
 		return value.IsNil()
 	}
 	return reflect.DeepEqual(value.Interface(), reflect.Zero(value.Type()).Interface())
 }
 func toSearchableMap(attrs ...interface{}) (result interface{}) {
 	if len(attrs) > 1 {
 		if str, ok := attrs[0].(string); ok {
 			result = map[string]interface{}{str: attrs[1]}
 		}
 	} else if len(attrs) == 1 {
 		if attr, ok := attrs[0].(map[string]interface{}); ok {
 			result = attr
 		}
 		if attr, ok := attrs[0].(interface{}); ok {
 			result = attr
 		}
 	}
 	return
 }
 func equalAsString(a interface{}, b interface{}) bool {
 	return toString(a) == toString(b)
 }
 func toString(str interface{}) string {
 	if values, ok := str.([]interface{}); ok {
 		var results []string
 		for _, value := range values {
 			results = append(results, toString(value))
 		}
 		return strings.Join(results, "_")
 	} else if bytes, ok := str.([]byte); ok {
 		return string(bytes)
 	} else if reflectValue := reflect.Indirect(reflect.ValueOf(str)); reflectValue.IsValid() {
 		return fmt.Sprintf("%v", reflectValue.Interface())
 	}
 	return ""
 }
 func makeSlice(elemType reflect.Type) interface{} {
 	if elemType.Kind() == reflect.Slice {
 		elemType = elemType.Elem()
 	}
 	sliceType := reflect.SliceOf(elemType)
 	slice := reflect.New(sliceType)
 	slice.Elem().Set(reflect.MakeSlice(sliceType, 0, 0))
 	return slice.Interface()
 }
 func strInSlice(a string, list []string) bool {
 	for _, b := range list {
 		if b == a {
 			return true
 		}
 	}
 	return false
 }
 // getValueFromFields return given fields's value
 func getValueFromFields(value reflect.Value, fieldNames []string) (results []interface{}) {
 	// If value is a nil pointer, Indirect returns a zero Value!
 	// Therefor we need to check for a zero value,
 	// as FieldByName could panic
 	if indirectValue := reflect.Indirect(value); indirectValue.IsValid() {
 		for _, fieldName := range fieldNames {
 			if fieldValue := reflect.Indirect(indirectValue.FieldByName(fieldName)); fieldValue.IsValid() {
 				result := fieldValue.Interface()
 				if r, ok := result.(driver.Valuer); ok {
 					result, _ = r.Value()
 				}
 				results = append(results, result)
 			}
 		}
 	}
 	return
 }
 func addExtraSpaceIfExist(str string) string {
 	if str != "" {
 		return " " + str
 	}
 	return ""
 }
--- a/vendor/github.com/jinzhu/gorm/wercker.yml
+++ b/vendor/github.com/jinzhu/gorm/wercker.yml
@ -0,0 +1,154 @@
 # use the default golang container from Docker Hub
 box: golang
 services:
    - name: mariadb
      id: mariadb:latest
      env:
          MYSQL_DATABASE: gorm
          MYSQL_USER: gorm
          MYSQL_PASSWORD: gorm
          MYSQL_RANDOM_ROOT_PASSWORD: "yes"
    - name: mysql
      id: mysql:latest
      env:
          MYSQL_DATABASE: gorm
          MYSQL_USER: gorm
          MYSQL_PASSWORD: gorm
          MYSQL_RANDOM_ROOT_PASSWORD: "yes"
    - name: mysql57
      id: mysql:5.7
      env:
          MYSQL_DATABASE: gorm
          MYSQL_USER: gorm
          MYSQL_PASSWORD: gorm
          MYSQL_RANDOM_ROOT_PASSWORD: "yes"
    - name: mysql56
      id: mysql:5.6
      env:
          MYSQL_DATABASE: gorm
          MYSQL_USER: gorm
          MYSQL_PASSWORD: gorm
          MYSQL_RANDOM_ROOT_PASSWORD: "yes"
    - name: postgres
      id: postgres:latest
      env:
          POSTGRES_USER: gorm
          POSTGRES_PASSWORD: gorm
          POSTGRES_DB: gorm
    - name: postgres96
      id: postgres:9.6
      env:
          POSTGRES_USER: gorm
          POSTGRES_PASSWORD: gorm
          POSTGRES_DB: gorm
    - name: postgres95
      id: postgres:9.5
      env:
          POSTGRES_USER: gorm
          POSTGRES_PASSWORD: gorm
          POSTGRES_DB: gorm
    - name: postgres94
      id: postgres:9.4
      env:
          POSTGRES_USER: gorm
          POSTGRES_PASSWORD: gorm
          POSTGRES_DB: gorm
    - name: postgres93
      id: postgres:9.3
      env:
          POSTGRES_USER: gorm
          POSTGRES_PASSWORD: gorm
          POSTGRES_DB: gorm
    - name: mssql
      id: mcmoe/mssqldocker:latest
      env:
        ACCEPT_EULA: Y
        SA_PASSWORD: LoremIpsum86
        MSSQL_DB: gorm
        MSSQL_USER: gorm
        MSSQL_PASSWORD: LoremIpsum86
 # The steps that will be executed in the build pipeline
 build:
    # The steps that will be executed on build
    steps:
        # Sets the go workspace and places you package
        # at the right place in the workspace tree
        - setup-go-workspace
        # Gets the dependencies
        - script:
                name: go get
                code: |
                    cd $WERCKER_SOURCE_DIR
                    go version
                    go get -t -v ./...
        # Build the project
        - script:
                name: go build
                code: |
                    go build ./...
        # Test the project
        - script:
                name: test sqlite
                code: |
                    go test -race -v ./...
        - script:
                name: test mariadb
                code: |
                    GORM_DIALECT=mysql GORM_DSN="gorm:gorm@tcp(mariadb:3306)/gorm?charset=utf8&parseTime=True" go test -race ./...
        - script:
                name: test mysql
                code: |
                    GORM_DIALECT=mysql GORM_DSN="gorm:gorm@tcp(mysql:3306)/gorm?charset=utf8&parseTime=True" go test -race ./...
        - script:
                name: test mysql5.7
                code: |
                    GORM_DIALECT=mysql GORM_DSN="gorm:gorm@tcp(mysql57:3306)/gorm?charset=utf8&parseTime=True" go test -race ./...
        - script:
                name: test mysql5.6
                code: |
                    GORM_DIALECT=mysql GORM_DSN="gorm:gorm@tcp(mysql56:3306)/gorm?charset=utf8&parseTime=True" go test -race ./...
        - script:
                name: test postgres
                code: |
                    GORM_DIALECT=postgres GORM_DSN="host=postgres user=gorm password=gorm DB.name=gorm port=5432 sslmode=disable" go test -race ./...
        - script:
                name: test postgres96
                code: |
                    GORM_DIALECT=postgres GORM_DSN="host=postgres96 user=gorm password=gorm DB.name=gorm port=5432 sslmode=disable" go test -race ./...
        - script:
                name: test postgres95
                code: |
                    GORM_DIALECT=postgres GORM_DSN="host=postgres95 user=gorm password=gorm DB.name=gorm port=5432 sslmode=disable" go test -race ./...
        - script:
                name: test postgres94
                code: |
                    GORM_DIALECT=postgres GORM_DSN="host=postgres94 user=gorm password=gorm DB.name=gorm port=5432 sslmode=disable" go test -race ./...
        - script:
                name: test postgres93
                code: |
                    GORM_DIALECT=postgres GORM_DSN="host=postgres93 user=gorm password=gorm DB.name=gorm port=5432 sslmode=disable" go test -race ./...
        - script:
                name: test mssql
                code: |
                    GORM_DIALECT=mssql GORM_DSN="sqlserver://gorm:LoremIpsum86@mssql:1433?database=gorm" go test -race ./...
        - script:
                name: codecov
                code: |
                    go test -race -coverprofile=coverage.txt -covermode=atomic ./...
                    bash <(curl -s https://codecov.io/bash)
--- a/vendor/github.com/jinzhu/inflection/LICENSE
+++ b/vendor/github.com/jinzhu/inflection/LICENSE
@ -0,0 +1,21 @@
 The MIT License (MIT)
 Copyright (c) 2015 - Jinzhu
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
--- a/vendor/github.com/jinzhu/inflection/README.md
+++ b/vendor/github.com/jinzhu/inflection/README.md
@ -0,0 +1,55 @@
 # Inflection
 Inflection pluralizes and singularizes English nouns
 [![wercker status](https://app.wercker.com/status/f8c7432b097d1f4ce636879670be0930/s/master "wercker status")](https://app.wercker.com/project/byKey/f8c7432b097d1f4ce636879670be0930)
 ## Basic Usage
 ```go
 inflection.Plural("person") => "people"
 inflection.Plural("Person") => "People"
 inflection.Plural("PERSON") => "PEOPLE"
 inflection.Plural("bus")    => "buses"
 inflection.Plural("BUS")    => "BUSES"
 inflection.Plural("Bus")    => "Buses"
 inflection.Singular("people") => "person"
 inflection.Singular("People") => "Person"
 inflection.Singular("PEOPLE") => "PERSON"
 inflection.Singular("buses")  => "bus"
 inflection.Singular("BUSES")  => "BUS"
 inflection.Singular("Buses")  => "Bus"
 inflection.Plural("FancyPerson") => "FancyPeople"
 inflection.Singular("FancyPeople") => "FancyPerson"
 ```
 ## Register Rules
 Standard rules are from Rails's ActiveSupport (https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflections.rb)
 If you want to register more rules, follow:
 ```
 inflection.AddUncountable("fish")
 inflection.AddIrregular("person", "people")
 inflection.AddPlural("(bu)s$", "${1}ses") # "bus" => "buses" / "BUS" => "BUSES" / "Bus" => "Buses"
 inflection.AddSingular("(bus)(es)?$", "${1}") # "buses" => "bus" / "Buses" => "Bus" / "BUSES" => "BUS"
 ```
 ## Contributing
 You can help to make the project better, check out [http://gorm.io/contribute.html](http://gorm.io/contribute.html) for things you can do.
 ## Author
 **jinzhu**
 * <http://github.com/jinzhu>
 * <wosmvp@gmail.com>
 * <http://twitter.com/zhangjinzhu>
 ## License
 Released under the [MIT License](http://www.opensource.org/licenses/MIT).
--- a/vendor/github.com/jinzhu/inflection/go.mod
+++ b/vendor/github.com/jinzhu/inflection/go.mod
@ -0,0 +1 @@
 module github.com/jinzhu/inflection
--- a/vendor/github.com/jinzhu/inflection/inflections.go
+++ b/vendor/github.com/jinzhu/inflection/inflections.go
@ -0,0 +1,273 @@
 /*
 Package inflection pluralizes and singularizes English nouns.
 		inflection.Plural("person") => "people"
 		inflection.Plural("Person") => "People"
 		inflection.Plural("PERSON") => "PEOPLE"
 		inflection.Singular("people") => "person"
 		inflection.Singular("People") => "Person"
 		inflection.Singular("PEOPLE") => "PERSON"
 		inflection.Plural("FancyPerson") => "FancydPeople"
 		inflection.Singular("FancyPeople") => "FancydPerson"
 Standard rules are from Rails's ActiveSupport (https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflections.rb)
 If you want to register more rules, follow:
 		inflection.AddUncountable("fish")
 		inflection.AddIrregular("person", "people")
 		inflection.AddPlural("(bu)s$", "${1}ses") # "bus" => "buses" / "BUS" => "BUSES" / "Bus" => "Buses"
 		inflection.AddSingular("(bus)(es)?$", "${1}") # "buses" => "bus" / "Buses" => "Bus" / "BUSES" => "BUS"
 */
 package inflection
 import (
 	"regexp"
 	"strings"
 )
 type inflection struct {
 	regexp  *regexp.Regexp
 	replace string
 }
 // Regular is a regexp find replace inflection
 type Regular struct {
 	find    string
 	replace string
 }
 // Irregular is a hard replace inflection,
 // containing both singular and plural forms
 type Irregular struct {
 	singular string
 	plural   string
 }
 // RegularSlice is a slice of Regular inflections
 type RegularSlice []Regular
 // IrregularSlice is a slice of Irregular inflections
 type IrregularSlice []Irregular
 var pluralInflections = RegularSlice{
 	{"([a-z])$", "${1}s"},
 	{"s$", "s"},
 	{"^(ax|test)is$", "${1}es"},
 	{"(octop|vir)us$", "${1}i"},
 	{"(octop|vir)i$", "${1}i"},
 	{"(alias|status)$", "${1}es"},
 	{"(bu)s$", "${1}ses"},
 	{"(buffal|tomat)o$", "${1}oes"},
 	{"([ti])um$", "${1}a"},
 	{"([ti])a$", "${1}a"},
 	{"sis$", "ses"},
 	{"(?:([^f])fe|([lr])f)$", "${1}${2}ves"},
 	{"(hive)$", "${1}s"},
 	{"([^aeiouy]|qu)y$", "${1}ies"},
 	{"(x|ch|ss|sh)$", "${1}es"},
 	{"(matr|vert|ind)(?:ix|ex)$", "${1}ices"},
 	{"^(m|l)ouse$", "${1}ice"},
 	{"^(m|l)ice$", "${1}ice"},
 	{"^(ox)$", "${1}en"},
 	{"^(oxen)$", "${1}"},
 	{"(quiz)$", "${1}zes"},
 }
 var singularInflections = RegularSlice{
 	{"s$", ""},
 	{"(ss)$", "${1}"},
 	{"(n)ews$", "${1}ews"},
 	{"([ti])a$", "${1}um"},
 	{"((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$", "${1}sis"},
 	{"(^analy)(sis|ses)$", "${1}sis"},
 	{"([^f])ves$", "${1}fe"},
 	{"(hive)s$", "${1}"},
 	{"(tive)s$", "${1}"},
 	{"([lr])ves$", "${1}f"},
 	{"([^aeiouy]|qu)ies$", "${1}y"},
 	{"(s)eries$", "${1}eries"},
 	{"(m)ovies$", "${1}ovie"},
 	{"(c)ookies$", "${1}ookie"},
 	{"(x|ch|ss|sh)es$", "${1}"},
 	{"^(m|l)ice$", "${1}ouse"},
 	{"(bus)(es)?$", "${1}"},
 	{"(o)es$", "${1}"},
 	{"(shoe)s$", "${1}"},
 	{"(cris|test)(is|es)$", "${1}is"},
 	{"^(a)x[ie]s$", "${1}xis"},
 	{"(octop|vir)(us|i)$", "${1}us"},
 	{"(alias|status)(es)?$", "${1}"},
 	{"^(ox)en", "${1}"},
 	{"(vert|ind)ices$", "${1}ex"},
 	{"(matr)ices$", "${1}ix"},
 	{"(quiz)zes$", "${1}"},
 	{"(database)s$", "${1}"},
 }
 var irregularInflections = IrregularSlice{
 	{"person", "people"},
 	{"man", "men"},
 	{"child", "children"},
 	{"sex", "sexes"},
 	{"move", "moves"},
 	{"mombie", "mombies"},
 }
 var uncountableInflections = []string{"equipment", "information", "rice", "money", "species", "series", "fish", "sheep", "jeans", "police"}
 var compiledPluralMaps []inflection
 var compiledSingularMaps []inflection
 func compile() {
 	compiledPluralMaps = []inflection{}
 	compiledSingularMaps = []inflection{}
 	for _, uncountable := range uncountableInflections {
 		inf := inflection{
 			regexp:  regexp.MustCompile("^(?i)(" + uncountable + ")$"),
 			replace: "${1}",
 		}
 		compiledPluralMaps = append(compiledPluralMaps, inf)
 		compiledSingularMaps = append(compiledSingularMaps, inf)
 	}
 	for _, value := range irregularInflections {
 		infs := []inflection{
 			inflection{regexp: regexp.MustCompile(strings.ToUpper(value.singular) + "$"), replace: strings.ToUpper(value.plural)},
 			inflection{regexp: regexp.MustCompile(strings.Title(value.singular) + "$"), replace: strings.Title(value.plural)},
 			inflection{regexp: regexp.MustCompile(value.singular + "$"), replace: value.plural},
 		}
 		compiledPluralMaps = append(compiledPluralMaps, infs...)
 	}
 	for _, value := range irregularInflections {
 		infs := []inflection{
 			inflection{regexp: regexp.MustCompile(strings.ToUpper(value.plural) + "$"), replace: strings.ToUpper(value.singular)},
 			inflection{regexp: regexp.MustCompile(strings.Title(value.plural) + "$"), replace: strings.Title(value.singular)},
 			inflection{regexp: regexp.MustCompile(value.plural + "$"), replace: value.singular},
 		}
 		compiledSingularMaps = append(compiledSingularMaps, infs...)
 	}
 	for i := len(pluralInflections) - 1; i >= 0; i-- {
 		value := pluralInflections[i]
 		infs := []inflection{
 			inflection{regexp: regexp.MustCompile(strings.ToUpper(value.find)), replace: strings.ToUpper(value.replace)},
 			inflection{regexp: regexp.MustCompile(value.find), replace: value.replace},
 			inflection{regexp: regexp.MustCompile("(?i)" + value.find), replace: value.replace},
 		}
 		compiledPluralMaps = append(compiledPluralMaps, infs...)
 	}
 	for i := len(singularInflections) - 1; i >= 0; i-- {
 		value := singularInflections[i]
 		infs := []inflection{
 			inflection{regexp: regexp.MustCompile(strings.ToUpper(value.find)), replace: strings.ToUpper(value.replace)},
 			inflection{regexp: regexp.MustCompile(value.find), replace: value.replace},
 			inflection{regexp: regexp.MustCompile("(?i)" + value.find), replace: value.replace},
 		}
 		compiledSingularMaps = append(compiledSingularMaps, infs...)
 	}
 }
 func init() {
 	compile()
 }
 // AddPlural adds a plural inflection
 func AddPlural(find, replace string) {
 	pluralInflections = append(pluralInflections, Regular{find, replace})
 	compile()
 }
 // AddSingular adds a singular inflection
 func AddSingular(find, replace string) {
 	singularInflections = append(singularInflections, Regular{find, replace})
 	compile()
 }
 // AddIrregular adds an irregular inflection
 func AddIrregular(singular, plural string) {
 	irregularInflections = append(irregularInflections, Irregular{singular, plural})
 	compile()
 }
 // AddUncountable adds an uncountable inflection
 func AddUncountable(values ...string) {
 	uncountableInflections = append(uncountableInflections, values...)
 	compile()
 }
 // GetPlural retrieves the plural inflection values
 func GetPlural() RegularSlice {
 	plurals := make(RegularSlice, len(pluralInflections))
 	copy(plurals, pluralInflections)
 	return plurals
 }
 // GetSingular retrieves the singular inflection values
 func GetSingular() RegularSlice {
 	singulars := make(RegularSlice, len(singularInflections))
 	copy(singulars, singularInflections)
 	return singulars
 }
 // GetIrregular retrieves the irregular inflection values
 func GetIrregular() IrregularSlice {
 	irregular := make(IrregularSlice, len(irregularInflections))
 	copy(irregular, irregularInflections)
 	return irregular
 }
 // GetUncountable retrieves the uncountable inflection values
 func GetUncountable() []string {
 	uncountables := make([]string, len(uncountableInflections))
 	copy(uncountables, uncountableInflections)
 	return uncountables
 }
 // SetPlural sets the plural inflections slice
 func SetPlural(inflections RegularSlice) {
 	pluralInflections = inflections
 	compile()
 }
 // SetSingular sets the singular inflections slice
 func SetSingular(inflections RegularSlice) {
 	singularInflections = inflections
 	compile()
 }
 // SetIrregular sets the irregular inflections slice
 func SetIrregular(inflections IrregularSlice) {
 	irregularInflections = inflections
 	compile()
 }
 // SetUncountable sets the uncountable inflections slice
 func SetUncountable(inflections []string) {
 	uncountableInflections = inflections
 	compile()
 }
 // Plural converts a word to its plural form
 func Plural(str string) string {
 	for _, inflection := range compiledPluralMaps {
 		if inflection.regexp.MatchString(str) {
 			return inflection.regexp.ReplaceAllString(str, inflection.replace)
 		}
 	}
 	return str
 }
 // Singular converts a word to its singular form
 func Singular(str string) string {
 	for _, inflection := range compiledSingularMaps {
 		if inflection.regexp.MatchString(str) {
 			return inflection.regexp.ReplaceAllString(str, inflection.replace)
 		}
 	}
 	return str
 }
--- a/vendor/github.com/jinzhu/inflection/wercker.yml
+++ b/vendor/github.com/jinzhu/inflection/wercker.yml
@ -0,0 +1,23 @@
 box: golang
 build:
  steps:
    - setup-go-workspace
    # Gets the dependencies
    - script:
        name: go get
        code: |
          go get
    # Build the project
    - script:
        name: go build
        code: |
          go build ./...
    # Test the project
    - script:
        name: go test
        code: |
          go test ./...
--- a/vendor/github.com/lib/pq/.gitignore
+++ b/vendor/github.com/lib/pq/.gitignore
@ -0,0 +1,4 @@
 .db
 *.test
 *~
 *.swp
--- a/vendor/github.com/lib/pq/.travis.sh
+++ b/vendor/github.com/lib/pq/.travis.sh
@ -0,0 +1,86 @@
 #!/bin/bash
 set -eu
 client_configure() {
 	sudo chmod 600 $PQSSLCERTTEST_PATH/postgresql.key
 }
 pgdg_repository() {
 	local sourcelist='sources.list.d/postgresql.list'
 	curl -sS 'https://www.postgresql.org/media/keys/ACCC4CF8.asc' | sudo apt-key add -
 	echo deb http://apt.postgresql.org/pub/repos/apt/ $(lsb_release -cs)-pgdg main $PGVERSION | sudo tee "/etc/apt/$sourcelist"
 	sudo apt-get -o Dir::Etc::sourcelist="$sourcelist" -o Dir::Etc::sourceparts='-' -o APT::Get::List-Cleanup='0' update
 }
 postgresql_configure() {
 	sudo tee /etc/postgresql/$PGVERSION/main/pg_hba.conf > /dev/null <<-config
 		local     all         all                               trust
 		hostnossl all         pqgossltest 127.0.0.1/32          reject
 		hostnossl all         pqgosslcert 127.0.0.1/32          reject
 		hostssl   all         pqgossltest 127.0.0.1/32          trust
 		hostssl   all         pqgosslcert 127.0.0.1/32          cert
 		host      all         all         127.0.0.1/32          trust
 		hostnossl all         pqgossltest ::1/128               reject
 		hostnossl all         pqgosslcert ::1/128               reject
 		hostssl   all         pqgossltest ::1/128               trust
 		hostssl   all         pqgosslcert ::1/128               cert
 		host      all         all         ::1/128               trust
 	config
 	xargs sudo install -o postgres -g postgres -m 600 -t /var/lib/postgresql/$PGVERSION/main/ <<-certificates
 		certs/root.crt
 		certs/server.crt
 		certs/server.key
 	certificates
 	sort -VCu <<-versions ||
 		$PGVERSION
 		9.2
 	versions
 	sudo tee -a /etc/postgresql/$PGVERSION/main/postgresql.conf > /dev/null <<-config
 		ssl_ca_file   = 'root.crt'
 		ssl_cert_file = 'server.crt'
 		ssl_key_file  = 'server.key'
 	config
 	echo 127.0.0.1 postgres | sudo tee -a /etc/hosts > /dev/null
 	sudo service postgresql restart
 }
 postgresql_install() {
 	xargs sudo apt-get -y -o Dpkg::Options::='--force-confdef' -o Dpkg::Options::='--force-confnew' install <<-packages
 		postgresql-$PGVERSION
 		postgresql-server-dev-$PGVERSION
 		postgresql-contrib-$PGVERSION
 	packages
 }
 postgresql_uninstall() {
 	sudo service postgresql stop
 	xargs sudo apt-get -y --purge remove <<-packages
 		libpq-dev
 		libpq5
 		postgresql
 		postgresql-client-common
 		postgresql-common
 	packages
 	sudo rm -rf /var/lib/postgresql
 }
 megacheck_install() {
 	# Lock megacheck version at $MEGACHECK_VERSION to prevent spontaneous
 	# new error messages in old code.
 	go get -d honnef.co/go/tools/...
 	git -C $GOPATH/src/honnef.co/go/tools/ checkout $MEGACHECK_VERSION
 	go install honnef.co/go/tools/cmd/megacheck
 	megacheck --version
 }
 golint_install() {
 	go get golang.org/x/lint/golint
 }
 $1
--- a/vendor/github.com/lib/pq/.travis.yml
+++ b/vendor/github.com/lib/pq/.travis.yml
@ -0,0 +1,50 @@
 language: go
 go:
  - 1.9.x
  - 1.10.x
  - 1.11.x
  - master
 sudo: true
 env:
  global:
    - PGUSER=postgres
    - PQGOSSLTESTS=1
    - PQSSLCERTTEST_PATH=$PWD/certs
    - PGHOST=127.0.0.1
    - MEGACHECK_VERSION=2017.2.2
  matrix:
    - PGVERSION=10
    - PGVERSION=9.6
    - PGVERSION=9.5
    - PGVERSION=9.4
    - PGVERSION=9.3
    - PGVERSION=9.2
    - PGVERSION=9.1
    - PGVERSION=9.0
 before_install:
  - ./.travis.sh postgresql_uninstall
  - ./.travis.sh pgdg_repository
  - ./.travis.sh postgresql_install
  - ./.travis.sh postgresql_configure
  - ./.travis.sh client_configure
  - ./.travis.sh megacheck_install
  - ./.travis.sh golint_install
  - go get golang.org/x/tools/cmd/goimports
 before_script:
  - createdb pqgotest
  - createuser -DRS pqgossltest
  - createuser -DRS pqgosslcert
 script:
  - >
    goimports -d -e $(find -name '*.go') | awk '{ print } END { exit NR == 0 ? 0 : 1 }'
  - go vet ./...
  - megacheck -go 1.9 ./...
  - golint ./...
  - PQTEST_BINARY_PARAMETERS=no  go test -race -v ./...
  - PQTEST_BINARY_PARAMETERS=yes go test -race -v ./...
--- a/vendor/github.com/lib/pq/CONTRIBUTING.md
+++ b/vendor/github.com/lib/pq/CONTRIBUTING.md
@ -0,0 +1,29 @@
 ## Contributing to pq
 `pq` has a backlog of pull requests, but contributions are still very
 much welcome. You can help with patch review, submitting bug reports,
 or adding new functionality. There is no formal style guide, but
 please conform to the style of existing code and general Go formatting
 conventions when submitting patches.
 ### Patch review
 Help review existing open pull requests by commenting on the code or
 proposed functionality.
 ### Bug reports
 We appreciate any bug reports, but especially ones with self-contained
 (doesn't depend on code outside of pq), minimal (can't be simplified
 further) test cases. It's especially helpful if you can submit a pull
 request with just the failing test case (you'll probably want to
 pattern it after the tests in
 [conn_test.go](https://github.com/lib/pq/blob/master/conn_test.go).
 ### New functionality
 There are a number of pending patches for new functionality, so
 additional feature patches will take a while to merge. Still, patches
 are generally reviewed based on usefulness and complexity in addition
 to time-in-queue, so if you have a knockout idea, take a shot. Feel
 free to open an issue discussion your proposed patch beforehand.
--- a/vendor/github.com/lib/pq/LICENSE.md
+++ b/vendor/github.com/lib/pq/LICENSE.md
@ -0,0 +1,8 @@
 Copyright (c) 2011-2013, 'pq' Contributors
 Portions Copyright (C) 2011 Blake Mizerany
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/vendor/github.com/lib/pq/README.md
+++ b/vendor/github.com/lib/pq/README.md
@ -0,0 +1,95 @@
 # pq - A pure Go postgres driver for Go's database/sql package
 [![GoDoc](https://godoc.org/github.com/lib/pq?status.svg)](https://godoc.org/github.com/lib/pq)
 [![Build Status](https://travis-ci.org/lib/pq.svg?branch=master)](https://travis-ci.org/lib/pq)
 ## Install
 	go get github.com/lib/pq
 ## Docs
 For detailed documentation and basic usage examples, please see the package
 documentation at <https://godoc.org/github.com/lib/pq>.
 ## Tests
 `go test` is used for testing.  See [TESTS.md](TESTS.md) for more details.
 ## Features
 * SSL
 * Handles bad connections for `database/sql`
 * Scan `time.Time` correctly (i.e. `timestamp[tz]`, `time[tz]`, `date`)
 * Scan binary blobs correctly (i.e. `bytea`)
 * Package for `hstore` support
 * COPY FROM support
 * pq.ParseURL for converting urls to connection strings for sql.Open.
 * Many libpq compatible environment variables
 * Unix socket support
 * Notifications: `LISTEN`/`NOTIFY`
 * pgpass support
 ## Future / Things you can help with
 * Better COPY FROM / COPY TO (see discussion in #181)
 ## Thank you (alphabetical)
 Some of these contributors are from the original library `bmizerany/pq.go` whose
 code still exists in here.
 * Andy Balholm (andybalholm)
 * Ben Berkert (benburkert)
 * Benjamin Heatwole (bheatwole)
 * Bill Mill (llimllib)
 * Bjørn Madsen (aeons)
 * Blake Gentry (bgentry)
 * Brad Fitzpatrick (bradfitz)
 * Charlie Melbye (cmelbye)
 * Chris Bandy (cbandy)
 * Chris Gilling (cgilling)
 * Chris Walsh (cwds)
 * Dan Sosedoff (sosedoff)
 * Daniel Farina (fdr)
 * Eric Chlebek (echlebek)
 * Eric Garrido (minusnine)
 * Eric Urban (hydrogen18)
 * Everyone at The Go Team
 * Evan Shaw (edsrzf)
 * Ewan Chou (coocood)
 * Fazal Majid (fazalmajid)
 * Federico Romero (federomero)
 * Fumin (fumin)
 * Gary Burd (garyburd)
 * Heroku (heroku)
 * James Pozdena (jpoz)
 * Jason McVetta (jmcvetta)
 * Jeremy Jay (pbnjay)
 * Joakim Sernbrant (serbaut)
 * John Gallagher (jgallagher)
 * Jonathan Rudenberg (titanous)
 * Joël Stemmer (jstemmer)
 * Kamil Kisiel (kisielk)
 * Kelly Dunn (kellydunn)
 * Keith Rarick (kr)
 * Kir Shatrov (kirs)
 * Lann Martin (lann)
 * Maciek Sakrejda (uhoh-itsmaciek)
 * Marc Brinkmann (mbr)
 * Marko Tiikkaja (johto)
 * Matt Newberry (MattNewberry)
 * Matt Robenolt (mattrobenolt)
 * Martin Olsen (martinolsen)
 * Mike Lewis (mikelikespie)
 * Nicolas Patry (Narsil)
 * Oliver Tonnhofer (olt)
 * Patrick Hayes (phayes)
 * Paul Hammond (paulhammond)
 * Ryan Smith (ryandotsmith)
 * Samuel Stauffer (samuel)
 * Timothée Peignier (cyberdelia)
 * Travis Cline (tmc)
 * TruongSinh Tran-Nguyen (truongsinh)
 * Yaismel Miranda (ympons)
 * notedit (notedit)
--- a/vendor/github.com/lib/pq/TESTS.md
+++ b/vendor/github.com/lib/pq/TESTS.md
@ -0,0 +1,33 @@
 # Tests
 ## Running Tests
 `go test` is used for testing. A running PostgreSQL
 server is required, with the ability to log in. The
 database to connect to test with is "pqgotest," on
 "localhost" but these can be overridden using [environment
 variables](https://www.postgresql.org/docs/9.3/static/libpq-envars.html).
 Example:
 	PGHOST=/run/postgresql go test
 ## Benchmarks
 A benchmark suite can be run as part of the tests:
 	go test -bench .
 ## Example setup (Docker)
 Run a postgres container:
 ```
 docker run --expose 5432:5432 postgres
 ```
 Run tests:
 ```
 PGHOST=localhost PGPORT=5432 PGUSER=postgres PGSSLMODE=disable PGDATABASE=postgres go test
 ```
--- a/vendor/github.com/lib/pq/array.go
+++ b/vendor/github.com/lib/pq/array.go
@ -0,0 +1,756 @@
 package pq
 import (
 	"bytes"
 	"database/sql"
 	"database/sql/driver"
 	"encoding/hex"
 	"fmt"
 	"reflect"
 	"strconv"
 	"strings"
 )
 var typeByteSlice = reflect.TypeOf([]byte{})
 var typeDriverValuer = reflect.TypeOf((*driver.Valuer)(nil)).Elem()
 var typeSQLScanner = reflect.TypeOf((*sql.Scanner)(nil)).Elem()
 // Array returns the optimal driver.Valuer and sql.Scanner for an array or
 // slice of any dimension.
 //
 // For example:
 //  db.Query(`SELECT * FROM t WHERE id = ANY($1)`, pq.Array([]int{235, 401}))
 //
 //  var x []sql.NullInt64
 //  db.QueryRow('SELECT ARRAY[235, 401]').Scan(pq.Array(&x))
 //
 // Scanning multi-dimensional arrays is not supported.  Arrays where the lower
 // bound is not one (such as `[0:0]={1}') are not supported.
 func Array(a interface{}) interface {
 	driver.Valuer
 	sql.Scanner
 } {
 	switch a := a.(type) {
 	case []bool:
 		return (*BoolArray)(&a)
 	case []float64:
 		return (*Float64Array)(&a)
 	case []int64:
 		return (*Int64Array)(&a)
 	case []string:
 		return (*StringArray)(&a)
 	case *[]bool:
 		return (*BoolArray)(a)
 	case *[]float64:
 		return (*Float64Array)(a)
 	case *[]int64:
 		return (*Int64Array)(a)
 	case *[]string:
 		return (*StringArray)(a)
 	}
 	return GenericArray{a}
 }
 // ArrayDelimiter may be optionally implemented by driver.Valuer or sql.Scanner
 // to override the array delimiter used by GenericArray.
 type ArrayDelimiter interface {
 	// ArrayDelimiter returns the delimiter character(s) for this element's type.
 	ArrayDelimiter() string
 }
 // BoolArray represents a one-dimensional array of the PostgreSQL boolean type.
 type BoolArray []bool
 // Scan implements the sql.Scanner interface.
 func (a *BoolArray) Scan(src interface{}) error {
 	switch src := src.(type) {
 	case []byte:
 		return a.scanBytes(src)
 	case string:
 		return a.scanBytes([]byte(src))
 	case nil:
 		*a = nil
 		return nil
 	}
 	return fmt.Errorf("pq: cannot convert %T to BoolArray", src)
 }
 func (a *BoolArray) scanBytes(src []byte) error {
 	elems, err := scanLinearArray(src, []byte{','}, "BoolArray")
 	if err != nil {
 		return err
 	}
 	if *a != nil && len(elems) == 0 {
 		*a = (*a)[:0]
 	} else {
 		b := make(BoolArray, len(elems))
 		for i, v := range elems {
 			if len(v) != 1 {
 				return fmt.Errorf("pq: could not parse boolean array index %d: invalid boolean %q", i, v)
 			}
 			switch v[0] {
 			case 't':
 				b[i] = true
 			case 'f':
 				b[i] = false
 			default:
 				return fmt.Errorf("pq: could not parse boolean array index %d: invalid boolean %q", i, v)
 			}
 		}
 		*a = b
 	}
 	return nil
 }
 // Value implements the driver.Valuer interface.
 func (a BoolArray) Value() (driver.Value, error) {
 	if a == nil {
 		return nil, nil
 	}
 	if n := len(a); n > 0 {
 		// There will be exactly two curly brackets, N bytes of values,
 		// and N-1 bytes of delimiters.
 		b := make([]byte, 1+2*n)
 		for i := 0; i < n; i++ {
 			b[2*i] = ','
 			if a[i] {
 				b[1+2*i] = 't'
 			} else {
 				b[1+2*i] = 'f'
 			}
 		}
 		b[0] = '{'
 		b[2*n] = '}'
 		return string(b), nil
 	}
 	return "{}", nil
 }
 // ByteaArray represents a one-dimensional array of the PostgreSQL bytea type.
 type ByteaArray [][]byte
 // Scan implements the sql.Scanner interface.
 func (a *ByteaArray) Scan(src interface{}) error {
 	switch src := src.(type) {
 	case []byte:
 		return a.scanBytes(src)
 	case string:
 		return a.scanBytes([]byte(src))
 	case nil:
 		*a = nil
 		return nil
 	}
 	return fmt.Errorf("pq: cannot convert %T to ByteaArray", src)
 }
 func (a *ByteaArray) scanBytes(src []byte) error {
 	elems, err := scanLinearArray(src, []byte{','}, "ByteaArray")
 	if err != nil {
 		return err
 	}
 	if *a != nil && len(elems) == 0 {
 		*a = (*a)[:0]
 	} else {
 		b := make(ByteaArray, len(elems))
 		for i, v := range elems {
 			b[i], err = parseBytea(v)
 			if err != nil {
 				return fmt.Errorf("could not parse bytea array index %d: %s", i, err.Error())
 			}
 		}
 		*a = b
 	}
 	return nil
 }
 // Value implements the driver.Valuer interface. It uses the "hex" format which
 // is only supported on PostgreSQL 9.0 or newer.
 func (a ByteaArray) Value() (driver.Value, error) {
 	if a == nil {
 		return nil, nil
 	}
 	if n := len(a); n > 0 {
 		// There will be at least two curly brackets, 2*N bytes of quotes,
 		// 3*N bytes of hex formatting, and N-1 bytes of delimiters.
 		size := 1 + 6*n
 		for _, x := range a {
 			size += hex.EncodedLen(len(x))
 		}
 		b := make([]byte, size)
 		for i, s := 0, b; i < n; i++ {
 			o := copy(s, `,"\\x`)
 			o += hex.Encode(s[o:], a[i])
 			s[o] = '"'
 			s = s[o+1:]
 		}
 		b[0] = '{'
 		b[size-1] = '}'
 		return string(b), nil
 	}
 	return "{}", nil
 }
 // Float64Array represents a one-dimensional array of the PostgreSQL double
 // precision type.
 type Float64Array []float64
 // Scan implements the sql.Scanner interface.
 func (a *Float64Array) Scan(src interface{}) error {
 	switch src := src.(type) {
 	case []byte:
 		return a.scanBytes(src)
 	case string:
 		return a.scanBytes([]byte(src))
 	case nil:
 		*a = nil
 		return nil
 	}
 	return fmt.Errorf("pq: cannot convert %T to Float64Array", src)
 }
 func (a *Float64Array) scanBytes(src []byte) error {
 	elems, err := scanLinearArray(src, []byte{','}, "Float64Array")
 	if err != nil {
 		return err
 	}
 	if *a != nil && len(elems) == 0 {
 		*a = (*a)[:0]
 	} else {
 		b := make(Float64Array, len(elems))
 		for i, v := range elems {
 			if b[i], err = strconv.ParseFloat(string(v), 64); err != nil {
 				return fmt.Errorf("pq: parsing array element index %d: %v", i, err)
 			}
 		}
 		*a = b
 	}
 	return nil
 }
 // Value implements the driver.Valuer interface.
 func (a Float64Array) Value() (driver.Value, error) {
 	if a == nil {
 		return nil, nil
 	}
 	if n := len(a); n > 0 {
 		// There will be at least two curly brackets, N bytes of values,
 		// and N-1 bytes of delimiters.
 		b := make([]byte, 1, 1+2*n)
 		b[0] = '{'
 		b = strconv.AppendFloat(b, a[0], 'f', -1, 64)
 		for i := 1; i < n; i++ {
 			b = append(b, ',')
 			b = strconv.AppendFloat(b, a[i], 'f', -1, 64)
 		}
 		return string(append(b, '}')), nil
 	}
 	return "{}", nil
 }
 // GenericArray implements the driver.Valuer and sql.Scanner interfaces for
 // an array or slice of any dimension.
 type GenericArray struct{ A interface{} }
 func (GenericArray) evaluateDestination(rt reflect.Type) (reflect.Type, func([]byte, reflect.Value) error, string) {
 	var assign func([]byte, reflect.Value) error
 	var del = ","
 	// TODO calculate the assign function for other types
 	// TODO repeat this section on the element type of arrays or slices (multidimensional)
 	{
 		if reflect.PtrTo(rt).Implements(typeSQLScanner) {
 			// dest is always addressable because it is an element of a slice.
 			assign = func(src []byte, dest reflect.Value) (err error) {
 				ss := dest.Addr().Interface().(sql.Scanner)
 				if src == nil {
 					err = ss.Scan(nil)
 				} else {
 					err = ss.Scan(src)
 				}
 				return
 			}
 			goto FoundType
 		}
 		assign = func([]byte, reflect.Value) error {
 			return fmt.Errorf("pq: scanning to %s is not implemented; only sql.Scanner", rt)
 		}
 	}
 FoundType:
 	if ad, ok := reflect.Zero(rt).Interface().(ArrayDelimiter); ok {
 		del = ad.ArrayDelimiter()
 	}
 	return rt, assign, del
 }
 // Scan implements the sql.Scanner interface.
 func (a GenericArray) Scan(src interface{}) error {
 	dpv := reflect.ValueOf(a.A)
 	switch {
 	case dpv.Kind() != reflect.Ptr:
 		return fmt.Errorf("pq: destination %T is not a pointer to array or slice", a.A)
 	case dpv.IsNil():
 		return fmt.Errorf("pq: destination %T is nil", a.A)
 	}
 	dv := dpv.Elem()
 	switch dv.Kind() {
 	case reflect.Slice:
 	case reflect.Array:
 	default:
 		return fmt.Errorf("pq: destination %T is not a pointer to array or slice", a.A)
 	}
 	switch src := src.(type) {
 	case []byte:
 		return a.scanBytes(src, dv)
 	case string:
 		return a.scanBytes([]byte(src), dv)
 	case nil:
 		if dv.Kind() == reflect.Slice {
 			dv.Set(reflect.Zero(dv.Type()))
 			return nil
 		}
 	}
 	return fmt.Errorf("pq: cannot convert %T to %s", src, dv.Type())
 }
 func (a GenericArray) scanBytes(src []byte, dv reflect.Value) error {
 	dtype, assign, del := a.evaluateDestination(dv.Type().Elem())
 	dims, elems, err := parseArray(src, []byte(del))
 	if err != nil {
 		return err
 	}
 	// TODO allow multidimensional
 	if len(dims) > 1 {
 		return fmt.Errorf("pq: scanning from multidimensional ARRAY%s is not implemented",
 			strings.Replace(fmt.Sprint(dims), " ", "][", -1))
 	}
 	// Treat a zero-dimensional array like an array with a single dimension of zero.
 	if len(dims) == 0 {
 		dims = append(dims, 0)
 	}
 	for i, rt := 0, dv.Type(); i < len(dims); i, rt = i+1, rt.Elem() {
 		switch rt.Kind() {
 		case reflect.Slice:
 		case reflect.Array:
 			if rt.Len() != dims[i] {
 				return fmt.Errorf("pq: cannot convert ARRAY%s to %s",
 					strings.Replace(fmt.Sprint(dims), " ", "][", -1), dv.Type())
 			}
 		default:
 			// TODO handle multidimensional
 		}
 	}
 	values := reflect.MakeSlice(reflect.SliceOf(dtype), len(elems), len(elems))
 	for i, e := range elems {
 		if err := assign(e, values.Index(i)); err != nil {
 			return fmt.Errorf("pq: parsing array element index %d: %v", i, err)
 		}
 	}
 	// TODO handle multidimensional
 	switch dv.Kind() {
 	case reflect.Slice:
 		dv.Set(values.Slice(0, dims[0]))
 	case reflect.Array:
 		for i := 0; i < dims[0]; i++ {
 			dv.Index(i).Set(values.Index(i))
 		}
 	}
 	return nil
 }
 // Value implements the driver.Valuer interface.
 func (a GenericArray) Value() (driver.Value, error) {
 	if a.A == nil {
 		return nil, nil
 	}
 	rv := reflect.ValueOf(a.A)
 	switch rv.Kind() {
 	case reflect.Slice:
 		if rv.IsNil() {
 			return nil, nil
 		}
 	case reflect.Array:
 	default:
 		return nil, fmt.Errorf("pq: Unable to convert %T to array", a.A)
 	}
 	if n := rv.Len(); n > 0 {
 		// There will be at least two curly brackets, N bytes of values,
 		// and N-1 bytes of delimiters.
 		b := make([]byte, 0, 1+2*n)
 		b, _, err := appendArray(b, rv, n)
 		return string(b), err
 	}
 	return "{}", nil
 }
 // Int64Array represents a one-dimensional array of the PostgreSQL integer types.
 type Int64Array []int64
 // Scan implements the sql.Scanner interface.
 func (a *Int64Array) Scan(src interface{}) error {
 	switch src := src.(type) {
 	case []byte:
 		return a.scanBytes(src)
 	case string:
 		return a.scanBytes([]byte(src))
 	case nil:
 		*a = nil
 		return nil
 	}
 	return fmt.Errorf("pq: cannot convert %T to Int64Array", src)
 }
 func (a *Int64Array) scanBytes(src []byte) error {
 	elems, err := scanLinearArray(src, []byte{','}, "Int64Array")
 	if err != nil {
 		return err
 	}
 	if *a != nil && len(elems) == 0 {
 		*a = (*a)[:0]
 	} else {
 		b := make(Int64Array, len(elems))
 		for i, v := range elems {
 			if b[i], err = strconv.ParseInt(string(v), 10, 64); err != nil {
 				return fmt.Errorf("pq: parsing array element index %d: %v", i, err)
 			}
 		}
 		*a = b
 	}
 	return nil
 }
 // Value implements the driver.Valuer interface.
 func (a Int64Array) Value() (driver.Value, error) {
 	if a == nil {
 		return nil, nil
 	}
 	if n := len(a); n > 0 {
 		// There will be at least two curly brackets, N bytes of values,
 		// and N-1 bytes of delimiters.
 		b := make([]byte, 1, 1+2*n)
 		b[0] = '{'
 		b = strconv.AppendInt(b, a[0], 10)
 		for i := 1; i < n; i++ {
 			b = append(b, ',')
 			b = strconv.AppendInt(b, a[i], 10)
 		}
 		return string(append(b, '}')), nil
 	}
 	return "{}", nil
 }
 // StringArray represents a one-dimensional array of the PostgreSQL character types.
 type StringArray []string
 // Scan implements the sql.Scanner interface.
 func (a *StringArray) Scan(src interface{}) error {
 	switch src := src.(type) {
 	case []byte:
 		return a.scanBytes(src)
 	case string:
 		return a.scanBytes([]byte(src))
 	case nil:
 		*a = nil
 		return nil
 	}
 	return fmt.Errorf("pq: cannot convert %T to StringArray", src)
 }
 func (a *StringArray) scanBytes(src []byte) error {
 	elems, err := scanLinearArray(src, []byte{','}, "StringArray")
 	if err != nil {
 		return err
 	}
 	if *a != nil && len(elems) == 0 {
 		*a = (*a)[:0]
 	} else {
 		b := make(StringArray, len(elems))
 		for i, v := range elems {
 			if b[i] = string(v); v == nil {
 				return fmt.Errorf("pq: parsing array element index %d: cannot convert nil to string", i)
 			}
 		}
 		*a = b
 	}
 	return nil
 }
 // Value implements the driver.Valuer interface.
 func (a StringArray) Value() (driver.Value, error) {
 	if a == nil {
 		return nil, nil
 	}
 	if n := len(a); n > 0 {
 		// There will be at least two curly brackets, 2*N bytes of quotes,
 		// and N-1 bytes of delimiters.
 		b := make([]byte, 1, 1+3*n)
 		b[0] = '{'
 		b = appendArrayQuotedBytes(b, []byte(a[0]))
 		for i := 1; i < n; i++ {
 			b = append(b, ',')
 			b = appendArrayQuotedBytes(b, []byte(a[i]))
 		}
 		return string(append(b, '}')), nil
 	}
 	return "{}", nil
 }
 // appendArray appends rv to the buffer, returning the extended buffer and
 // the delimiter used between elements.
 //
 // It panics when n <= 0 or rv's Kind is not reflect.Array nor reflect.Slice.
 func appendArray(b []byte, rv reflect.Value, n int) ([]byte, string, error) {
 	var del string
 	var err error
 	b = append(b, '{')
 	if b, del, err = appendArrayElement(b, rv.Index(0)); err != nil {
 		return b, del, err
 	}
 	for i := 1; i < n; i++ {
 		b = append(b, del...)
 		if b, del, err = appendArrayElement(b, rv.Index(i)); err != nil {
 			return b, del, err
 		}
 	}
 	return append(b, '}'), del, nil
 }
 // appendArrayElement appends rv to the buffer, returning the extended buffer
 // and the delimiter to use before the next element.
 //
 // When rv's Kind is neither reflect.Array nor reflect.Slice, it is converted
 // using driver.DefaultParameterConverter and the resulting []byte or string
 // is double-quoted.
 //
 // See http://www.postgresql.org/docs/current/static/arrays.html#ARRAYS-IO
 func appendArrayElement(b []byte, rv reflect.Value) ([]byte, string, error) {
 	if k := rv.Kind(); k == reflect.Array || k == reflect.Slice {
 		if t := rv.Type(); t != typeByteSlice && !t.Implements(typeDriverValuer) {
 			if n := rv.Len(); n > 0 {
 				return appendArray(b, rv, n)
 			}
 			return b, "", nil
 		}
 	}
 	var del = ","
 	var err error
 	var iv interface{} = rv.Interface()
 	if ad, ok := iv.(ArrayDelimiter); ok {
 		del = ad.ArrayDelimiter()
 	}
 	if iv, err = driver.DefaultParameterConverter.ConvertValue(iv); err != nil {
 		return b, del, err
 	}
 	switch v := iv.(type) {
 	case nil:
 		return append(b, "NULL"...), del, nil
 	case []byte:
 		return appendArrayQuotedBytes(b, v), del, nil
 	case string:
 		return appendArrayQuotedBytes(b, []byte(v)), del, nil
 	}
 	b, err = appendValue(b, iv)
 	return b, del, err
 }
 func appendArrayQuotedBytes(b, v []byte) []byte {
 	b = append(b, '"')
 	for {
 		i := bytes.IndexAny(v, `"\`)
 		if i < 0 {
 			b = append(b, v...)
 			break
 		}
 		if i > 0 {
 			b = append(b, v[:i]...)
 		}
 		b = append(b, '\\', v[i])
 		v = v[i+1:]
 	}
 	return append(b, '"')
 }
 func appendValue(b []byte, v driver.Value) ([]byte, error) {
 	return append(b, encode(nil, v, 0)...), nil
 }
 // parseArray extracts the dimensions and elements of an array represented in
 // text format. Only representations emitted by the backend are supported.
 // Notably, whitespace around brackets and delimiters is significant, and NULL
 // is case-sensitive.
 //
 // See http://www.postgresql.org/docs/current/static/arrays.html#ARRAYS-IO
 func parseArray(src, del []byte) (dims []int, elems [][]byte, err error) {
 	var depth, i int
 	if len(src) < 1 || src[0] != '{' {
 		return nil, nil, fmt.Errorf("pq: unable to parse array; expected %q at offset %d", '{', 0)
 	}
 Open:
 	for i < len(src) {
 		switch src[i] {
 		case '{':
 			depth++
 			i++
 		case '}':
 			elems = make([][]byte, 0)
 			goto Close
 		default:
 			break Open
 		}
 	}
 	dims = make([]int, i)
 Element:
 	for i < len(src) {
 		switch src[i] {
 		case '{':
 			if depth == len(dims) {
 				break Element
 			}
 			depth++
 			dims[depth-1] = 0
 			i++
 		case '"':
 			var elem = []byte{}
 			var escape bool
 			for i++; i < len(src); i++ {
 				if escape {
 					elem = append(elem, src[i])
 					escape = false
 				} else {
 					switch src[i] {
 					default:
 						elem = append(elem, src[i])
 					case '\\':
 						escape = true
 					case '"':
 						elems = append(elems, elem)
 						i++
 						break Element
 					}
 				}
 			}
 		default:
 			for start := i; i < len(src); i++ {
 				if bytes.HasPrefix(src[i:], del) || src[i] == '}' {
 					elem := src[start:i]
 					if len(elem) == 0 {
 						return nil, nil, fmt.Errorf("pq: unable to parse array; unexpected %q at offset %d", src[i], i)
 					}
 					if bytes.Equal(elem, []byte("NULL")) {
 						elem = nil
 					}
 					elems = append(elems, elem)
 					break Element
 				}
 			}
 		}
 	}
 	for i < len(src) {
 		if bytes.HasPrefix(src[i:], del) && depth > 0 {
 			dims[depth-1]++
 			i += len(del)
 			goto Element
 		} else if src[i] == '}' && depth > 0 {
 			dims[depth-1]++
 			depth--
 			i++
 		} else {
 			return nil, nil, fmt.Errorf("pq: unable to parse array; unexpected %q at offset %d", src[i], i)
 		}
 	}
 Close:
 	for i < len(src) {
 		if src[i] == '}' && depth > 0 {
 			depth--
 			i++
 		} else {
 			return nil, nil, fmt.Errorf("pq: unable to parse array; unexpected %q at offset %d", src[i], i)
 		}
 	}
 	if depth > 0 {
 		err = fmt.Errorf("pq: unable to parse array; expected %q at offset %d", '}', i)
 	}
 	if err == nil {
 		for _, d := range dims {
 			if (len(elems) % d) != 0 {
 				err = fmt.Errorf("pq: multidimensional arrays must have elements with matching dimensions")
 			}
 		}
 	}
 	return
 }
 func scanLinearArray(src, del []byte, typ string) (elems [][]byte, err error) {
 	dims, elems, err := parseArray(src, del)
 	if err != nil {
 		return nil, err
 	}
 	if len(dims) > 1 {
 		return nil, fmt.Errorf("pq: cannot convert ARRAY%s to %s", strings.Replace(fmt.Sprint(dims), " ", "][", -1), typ)
 	}
 	return elems, err
 }
--- a/vendor/github.com/lib/pq/buf.go
+++ b/vendor/github.com/lib/pq/buf.go
@ -0,0 +1,91 @@
 package pq
 import (
 	"bytes"
 	"encoding/binary"
 	"github.com/lib/pq/oid"
 )
 type readBuf []byte
 func (b *readBuf) int32() (n int) {
 	n = int(int32(binary.BigEndian.Uint32(*b)))
 	*b = (*b)[4:]
 	return
 }
 func (b *readBuf) oid() (n oid.Oid) {
 	n = oid.Oid(binary.BigEndian.Uint32(*b))
 	*b = (*b)[4:]
 	return
 }
 // N.B: this is actually an unsigned 16-bit integer, unlike int32
 func (b *readBuf) int16() (n int) {
 	n = int(binary.BigEndian.Uint16(*b))
 	*b = (*b)[2:]
 	return
 }
 func (b *readBuf) string() string {
 	i := bytes.IndexByte(*b, 0)
 	if i < 0 {
 		errorf("invalid message format; expected string terminator")
 	}
 	s := (*b)[:i]
 	*b = (*b)[i+1:]
 	return string(s)
 }
 func (b *readBuf) next(n int) (v []byte) {
 	v = (*b)[:n]
 	*b = (*b)[n:]
 	return
 }
 func (b *readBuf) byte() byte {
 	return b.next(1)[0]
 }
 type writeBuf struct {
 	buf []byte
 	pos int
 }
 func (b *writeBuf) int32(n int) {
 	x := make([]byte, 4)
 	binary.BigEndian.PutUint32(x, uint32(n))
 	b.buf = append(b.buf, x...)
 }
 func (b *writeBuf) int16(n int) {
 	x := make([]byte, 2)
 	binary.BigEndian.PutUint16(x, uint16(n))
 	b.buf = append(b.buf, x...)
 }
 func (b *writeBuf) string(s string) {
 	b.buf = append(b.buf, (s + "\000")...)
 }
 func (b *writeBuf) byte(c byte) {
 	b.buf = append(b.buf, c)
 }
 func (b *writeBuf) bytes(v []byte) {
 	b.buf = append(b.buf, v...)
 }
 func (b *writeBuf) wrap() []byte {
 	p := b.buf[b.pos:]
 	binary.BigEndian.PutUint32(p, uint32(len(p)))
 	return b.buf
 }
 func (b *writeBuf) next(c byte) {
 	p := b.buf[b.pos:]
 	binary.BigEndian.PutUint32(p, uint32(len(p)))
 	b.pos = len(b.buf) + 1
 	b.buf = append(b.buf, c, 0, 0, 0, 0)
 }
--- a/vendor/github.com/lib/pq/conn.go
+++ b/vendor/github.com/lib/pq/conn.go
--- a/vendor/github.com/lib/pq/conn_go18.go
+++ b/vendor/github.com/lib/pq/conn_go18.go
@ -0,0 +1,149 @@
 package pq
 import (
 	"context"
 	"database/sql"
 	"database/sql/driver"
 	"fmt"
 	"io"
 	"io/ioutil"
 	"time"
 )
 // Implement the "QueryerContext" interface
 func (cn *conn) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) {
 	list := make([]driver.Value, len(args))
 	for i, nv := range args {
 		list[i] = nv.Value
 	}
 	finish := cn.watchCancel(ctx)
 	r, err := cn.query(query, list)
 	if err != nil {
 		if finish != nil {
 			finish()
 		}
 		return nil, err
 	}
 	r.finish = finish
 	return r, nil
 }
 // Implement the "ExecerContext" interface
 func (cn *conn) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) {
 	list := make([]driver.Value, len(args))
 	for i, nv := range args {
 		list[i] = nv.Value
 	}
 	if finish := cn.watchCancel(ctx); finish != nil {
 		defer finish()
 	}
 	return cn.Exec(query, list)
 }
 // Implement the "ConnBeginTx" interface
 func (cn *conn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) {
 	var mode string
 	switch sql.IsolationLevel(opts.Isolation) {
 	case sql.LevelDefault:
 		// Don't touch mode: use the server's default
 	case sql.LevelReadUncommitted:
 		mode = " ISOLATION LEVEL READ UNCOMMITTED"
 	case sql.LevelReadCommitted:
 		mode = " ISOLATION LEVEL READ COMMITTED"
 	case sql.LevelRepeatableRead:
 		mode = " ISOLATION LEVEL REPEATABLE READ"
 	case sql.LevelSerializable:
 		mode = " ISOLATION LEVEL SERIALIZABLE"
 	default:
 		return nil, fmt.Errorf("pq: isolation level not supported: %d", opts.Isolation)
 	}
 	if opts.ReadOnly {
 		mode += " READ ONLY"
 	} else {
 		mode += " READ WRITE"
 	}
 	tx, err := cn.begin(mode)
 	if err != nil {
 		return nil, err
 	}
 	cn.txnFinish = cn.watchCancel(ctx)
 	return tx, nil
 }
 func (cn *conn) Ping(ctx context.Context) error {
 	if finish := cn.watchCancel(ctx); finish != nil {
 		defer finish()
 	}
 	rows, err := cn.simpleQuery("SELECT 'lib/pq ping test';")
 	if err != nil {
 		return driver.ErrBadConn // https://golang.org/pkg/database/sql/driver/#Pinger
 	}
 	rows.Close()
 	return nil
 }
 func (cn *conn) watchCancel(ctx context.Context) func() {
 	if done := ctx.Done(); done != nil {
 		finished := make(chan struct{})
 		go func() {
 			select {
 			case <-done:
 				// At this point the function level context is canceled,
 				// so it must not be used for the additional network
 				// request to cancel the query.
 				// Create a new context to pass into the dial.
 				ctxCancel, cancel := context.WithTimeout(context.Background(), time.Second*10)
 				defer cancel()
 				_ = cn.cancel(ctxCancel)
 				finished <- struct{}{}
 			case <-finished:
 			}
 		}()
 		return func() {
 			select {
 			case <-finished:
 			case finished <- struct{}{}:
 			}
 		}
 	}
 	return nil
 }
 func (cn *conn) cancel(ctx context.Context) error {
 	c, err := dial(ctx, cn.dialer, cn.opts)
 	if err != nil {
 		return err
 	}
 	defer c.Close()
 	{
 		can := conn{
 			c: c,
 		}
 		err = can.ssl(cn.opts)
 		if err != nil {
 			return err
 		}
 		w := can.writeBuf(0)
 		w.int32(80877102) // cancel request code
 		w.int32(cn.processID)
 		w.int32(cn.secretKey)
 		if err := can.sendStartupPacket(w); err != nil {
 			return err
 		}
 	}
 	// Read until EOF to ensure that the server received the cancel.
 	{
 		_, err := io.Copy(ioutil.Discard, c)
 		return err
 	}
 }
--- a/vendor/github.com/lib/pq/connector.go
+++ b/vendor/github.com/lib/pq/connector.go
@ -0,0 +1,110 @@
 package pq
 import (
 	"context"
 	"database/sql/driver"
 	"errors"
 	"fmt"
 	"os"
 	"strings"
 )
 // Connector represents a fixed configuration for the pq driver with a given
 // name. Connector satisfies the database/sql/driver Connector interface and
 // can be used to create any number of DB Conn's via the database/sql OpenDB
 // function.
 //
 // See https://golang.org/pkg/database/sql/driver/#Connector.
 // See https://golang.org/pkg/database/sql/#OpenDB.
 type Connector struct {
 	opts   values
 	dialer Dialer
 }
 // Connect returns a connection to the database using the fixed configuration
 // of this Connector. Context is not used.
 func (c *Connector) Connect(ctx context.Context) (driver.Conn, error) {
 	return c.open(ctx)
 }
 // Driver returnst the underlying driver of this Connector.
 func (c *Connector) Driver() driver.Driver {
 	return &Driver{}
 }
 // NewConnector returns a connector for the pq driver in a fixed configuration
 // with the given dsn. The returned connector can be used to create any number
 // of equivalent Conn's. The returned connector is intended to be used with
 // database/sql.OpenDB.
 //
 // See https://golang.org/pkg/database/sql/driver/#Connector.
 // See https://golang.org/pkg/database/sql/#OpenDB.
 func NewConnector(dsn string) (*Connector, error) {
 	var err error
 	o := make(values)
 	// A number of defaults are applied here, in this order:
 	//
 	// * Very low precedence defaults applied in every situation
 	// * Environment variables
 	// * Explicitly passed connection information
 	o["host"] = "localhost"
 	o["port"] = "5432"
 	// N.B.: Extra float digits should be set to 3, but that breaks
 	// Postgres 8.4 and older, where the max is 2.
 	o["extra_float_digits"] = "2"
 	for k, v := range parseEnviron(os.Environ()) {
 		o[k] = v
 	}
 	if strings.HasPrefix(dsn, "postgres://") || strings.HasPrefix(dsn, "postgresql://") {
 		dsn, err = ParseURL(dsn)
 		if err != nil {
 			return nil, err
 		}
 	}
 	if err := parseOpts(dsn, o); err != nil {
 		return nil, err
 	}
 	// Use the "fallback" application name if necessary
 	if fallback, ok := o["fallback_application_name"]; ok {
 		if _, ok := o["application_name"]; !ok {
 			o["application_name"] = fallback
 		}
 	}
 	// We can't work with any client_encoding other than UTF-8 currently.
 	// However, we have historically allowed the user to set it to UTF-8
 	// explicitly, and there's no reason to break such programs, so allow that.
 	// Note that the "options" setting could also set client_encoding, but
 	// parsing its value is not worth it.  Instead, we always explicitly send
 	// client_encoding as a separate run-time parameter, which should override
 	// anything set in options.
 	if enc, ok := o["client_encoding"]; ok && !isUTF8(enc) {
 		return nil, errors.New("client_encoding must be absent or 'UTF8'")
 	}
 	o["client_encoding"] = "UTF8"
 	// DateStyle needs a similar treatment.
 	if datestyle, ok := o["datestyle"]; ok {
 		if datestyle != "ISO, MDY" {
 			return nil, fmt.Errorf("setting datestyle must be absent or %v; got %v", "ISO, MDY", datestyle)
 		}
 	} else {
 		o["datestyle"] = "ISO, MDY"
 	}
 	// If a user is not provided by any other means, the last
 	// resort is to use the current operating system provided user
 	// name.
 	if _, ok := o["user"]; !ok {
 		u, err := userCurrent()
 		if err != nil {
 			return nil, err
 		}
 		o["user"] = u
 	}
 	return &Connector{opts: o, dialer: defaultDialer{}}, nil
 }
--- a/vendor/github.com/lib/pq/copy.go
+++ b/vendor/github.com/lib/pq/copy.go
@ -0,0 +1,282 @@
 package pq
 import (
 	"database/sql/driver"
 	"encoding/binary"
 	"errors"
 	"fmt"
 	"sync"
 )
 var (
 	errCopyInClosed               = errors.New("pq: copyin statement has already been closed")
 	errBinaryCopyNotSupported     = errors.New("pq: only text format supported for COPY")
 	errCopyToNotSupported         = errors.New("pq: COPY TO is not supported")
 	errCopyNotSupportedOutsideTxn = errors.New("pq: COPY is only allowed inside a transaction")
 	errCopyInProgress             = errors.New("pq: COPY in progress")
 )
 // CopyIn creates a COPY FROM statement which can be prepared with
 // Tx.Prepare().  The target table should be visible in search_path.
 func CopyIn(table string, columns ...string) string {
 	stmt := "COPY " + QuoteIdentifier(table) + " ("
 	for i, col := range columns {
 		if i != 0 {
 			stmt += ", "
 		}
 		stmt += QuoteIdentifier(col)
 	}
 	stmt += ") FROM STDIN"
 	return stmt
 }
 // CopyInSchema creates a COPY FROM statement which can be prepared with
 // Tx.Prepare().
 func CopyInSchema(schema, table string, columns ...string) string {
 	stmt := "COPY " + QuoteIdentifier(schema) + "." + QuoteIdentifier(table) + " ("
 	for i, col := range columns {
 		if i != 0 {
 			stmt += ", "
 		}
 		stmt += QuoteIdentifier(col)
 	}
 	stmt += ") FROM STDIN"
 	return stmt
 }
 type copyin struct {
 	cn      *conn
 	buffer  []byte
 	rowData chan []byte
 	done    chan bool
 	closed bool
 	sync.Mutex // guards err
 	err        error
 }
 const ciBufferSize = 64 * 1024
 // flush buffer before the buffer is filled up and needs reallocation
 const ciBufferFlushSize = 63 * 1024
 func (cn *conn) prepareCopyIn(q string) (_ driver.Stmt, err error) {
 	if !cn.isInTransaction() {
 		return nil, errCopyNotSupportedOutsideTxn
 	}
 	ci := &copyin{
 		cn:      cn,
 		buffer:  make([]byte, 0, ciBufferSize),
 		rowData: make(chan []byte),
 		done:    make(chan bool, 1),
 	}
 	// add CopyData identifier + 4 bytes for message length
 	ci.buffer = append(ci.buffer, 'd', 0, 0, 0, 0)
 	b := cn.writeBuf('Q')
 	b.string(q)
 	cn.send(b)
 awaitCopyInResponse:
 	for {
 		t, r := cn.recv1()
 		switch t {
 		case 'G':
 			if r.byte() != 0 {
 				err = errBinaryCopyNotSupported
 				break awaitCopyInResponse
 			}
 			go ci.resploop()
 			return ci, nil
 		case 'H':
 			err = errCopyToNotSupported
 			break awaitCopyInResponse
 		case 'E':
 			err = parseError(r)
 		case 'Z':
 			if err == nil {
 				ci.setBad()
 				errorf("unexpected ReadyForQuery in response to COPY")
 			}
 			cn.processReadyForQuery(r)
 			return nil, err
 		default:
 			ci.setBad()
 			errorf("unknown response for copy query: %q", t)
 		}
 	}
 	// something went wrong, abort COPY before we return
 	b = cn.writeBuf('f')
 	b.string(err.Error())
 	cn.send(b)
 	for {
 		t, r := cn.recv1()
 		switch t {
 		case 'c', 'C', 'E':
 		case 'Z':
 			// correctly aborted, we're done
 			cn.processReadyForQuery(r)
 			return nil, err
 		default:
 			ci.setBad()
 			errorf("unknown response for CopyFail: %q", t)
 		}
 	}
 }
 func (ci *copyin) flush(buf []byte) {
 	// set message length (without message identifier)
 	binary.BigEndian.PutUint32(buf[1:], uint32(len(buf)-1))
 	_, err := ci.cn.c.Write(buf)
 	if err != nil {
 		panic(err)
 	}
 }
 func (ci *copyin) resploop() {
 	for {
 		var r readBuf
 		t, err := ci.cn.recvMessage(&r)
 		if err != nil {
 			ci.setBad()
 			ci.setError(err)
 			ci.done <- true
 			return
 		}
 		switch t {
 		case 'C':
 			// complete
 		case 'N':
 			// NoticeResponse
 		case 'Z':
 			ci.cn.processReadyForQuery(&r)
 			ci.done <- true
 			return
 		case 'E':
 			err := parseError(&r)
 			ci.setError(err)
 		default:
 			ci.setBad()
 			ci.setError(fmt.Errorf("unknown response during CopyIn: %q", t))
 			ci.done <- true
 			return
 		}
 	}
 }
 func (ci *copyin) setBad() {
 	ci.Lock()
 	ci.cn.bad = true
 	ci.Unlock()
 }
 func (ci *copyin) isBad() bool {
 	ci.Lock()
 	b := ci.cn.bad
 	ci.Unlock()
 	return b
 }
 func (ci *copyin) isErrorSet() bool {
 	ci.Lock()
 	isSet := (ci.err != nil)
 	ci.Unlock()
 	return isSet
 }
 // setError() sets ci.err if one has not been set already.  Caller must not be
 // holding ci.Mutex.
 func (ci *copyin) setError(err error) {
 	ci.Lock()
 	if ci.err == nil {
 		ci.err = err
 	}
 	ci.Unlock()
 }
 func (ci *copyin) NumInput() int {
 	return -1
 }
 func (ci *copyin) Query(v []driver.Value) (r driver.Rows, err error) {
 	return nil, ErrNotSupported
 }
 // Exec inserts values into the COPY stream. The insert is asynchronous
 // and Exec can return errors from previous Exec calls to the same
 // COPY stmt.
 //
 // You need to call Exec(nil) to sync the COPY stream and to get any
 // errors from pending data, since Stmt.Close() doesn't return errors
 // to the user.
 func (ci *copyin) Exec(v []driver.Value) (r driver.Result, err error) {
 	if ci.closed {
 		return nil, errCopyInClosed
 	}
 	if ci.isBad() {
 		return nil, driver.ErrBadConn
 	}
 	defer ci.cn.errRecover(&err)
 	if ci.isErrorSet() {
 		return nil, ci.err
 	}
 	if len(v) == 0 {
 		return nil, ci.Close()
 	}
 	numValues := len(v)
 	for i, value := range v {
 		ci.buffer = appendEncodedText(&ci.cn.parameterStatus, ci.buffer, value)
 		if i < numValues-1 {
 			ci.buffer = append(ci.buffer, '\t')
 		}
 	}
 	ci.buffer = append(ci.buffer, '\n')
 	if len(ci.buffer) > ciBufferFlushSize {
 		ci.flush(ci.buffer)
 		// reset buffer, keep bytes for message identifier and length
 		ci.buffer = ci.buffer[:5]
 	}
 	return driver.RowsAffected(0), nil
 }
 func (ci *copyin) Close() (err error) {
 	if ci.closed { // Don't do anything, we're already closed
 		return nil
 	}
 	ci.closed = true
 	if ci.isBad() {
 		return driver.ErrBadConn
 	}
 	defer ci.cn.errRecover(&err)
 	if len(ci.buffer) > 0 {
 		ci.flush(ci.buffer)
 	}
 	// Avoid touching the scratch buffer as resploop could be using it.
 	err = ci.cn.sendSimpleMessage('c')
 	if err != nil {
 		return err
 	}
 	<-ci.done
 	ci.cn.inCopy = false
 	if ci.isErrorSet() {
 		err = ci.err
 		return err
 	}
 	return nil
 }
--- a/vendor/github.com/lib/pq/doc.go
+++ b/vendor/github.com/lib/pq/doc.go
@ -0,0 +1,245 @@
 /*
 Package pq is a pure Go Postgres driver for the database/sql package.
 In most cases clients will use the database/sql package instead of
 using this package directly. For example:
 	import (
 		"database/sql"
 		_ "github.com/lib/pq"
 	)
 	func main() {
 		connStr := "user=pqgotest dbname=pqgotest sslmode=verify-full"
 		db, err := sql.Open("postgres", connStr)
 		if err != nil {
 			log.Fatal(err)
 		}
 		age := 21
 		rows, err := db.Query("SELECT name FROM users WHERE age = $1", age)
 		…
 	}
 You can also connect to a database using a URL. For example:
 	connStr := "postgres://pqgotest:password@localhost/pqgotest?sslmode=verify-full"
 	db, err := sql.Open("postgres", connStr)
 Connection String Parameters
 Similarly to libpq, when establishing a connection using pq you are expected to
 supply a connection string containing zero or more parameters.
 A subset of the connection parameters supported by libpq are also supported by pq.
 Additionally, pq also lets you specify run-time parameters (such as search_path or work_mem)
 directly in the connection string.  This is different from libpq, which does not allow
 run-time parameters in the connection string, instead requiring you to supply
 them in the options parameter.
 For compatibility with libpq, the following special connection parameters are
 supported:
 	* dbname - The name of the database to connect to
 	* user - The user to sign in as
 	* password - The user's password
 	* host - The host to connect to. Values that start with / are for unix
 	  domain sockets. (default is localhost)
 	* port - The port to bind to. (default is 5432)
 	* sslmode - Whether or not to use SSL (default is require, this is not
 	  the default for libpq)
 	* fallback_application_name - An application_name to fall back to if one isn't provided.
 	* connect_timeout - Maximum wait for connection, in seconds. Zero or
 	  not specified means wait indefinitely.
 	* sslcert - Cert file location. The file must contain PEM encoded data.
 	* sslkey - Key file location. The file must contain PEM encoded data.
 	* sslrootcert - The location of the root certificate file. The file
 	  must contain PEM encoded data.
 Valid values for sslmode are:
 	* disable - No SSL
 	* require - Always SSL (skip verification)
 	* verify-ca - Always SSL (verify that the certificate presented by the
 	  server was signed by a trusted CA)
 	* verify-full - Always SSL (verify that the certification presented by
 	  the server was signed by a trusted CA and the server host name
 	  matches the one in the certificate)
 See http://www.postgresql.org/docs/current/static/libpq-connect.html#LIBPQ-CONNSTRING
 for more information about connection string parameters.
 Use single quotes for values that contain whitespace:
    "user=pqgotest password='with spaces'"
 A backslash will escape the next character in values:
    "user=space\ man password='it\'s valid'"
 Note that the connection parameter client_encoding (which sets the
 text encoding for the connection) may be set but must be "UTF8",
 matching with the same rules as Postgres. It is an error to provide
 any other value.
 In addition to the parameters listed above, any run-time parameter that can be
 set at backend start time can be set in the connection string.  For more
 information, see
 http://www.postgresql.org/docs/current/static/runtime-config.html.
 Most environment variables as specified at http://www.postgresql.org/docs/current/static/libpq-envars.html
 supported by libpq are also supported by pq.  If any of the environment
 variables not supported by pq are set, pq will panic during connection
 establishment.  Environment variables have a lower precedence than explicitly
 provided connection parameters.
 The pgpass mechanism as described in http://www.postgresql.org/docs/current/static/libpq-pgpass.html
 is supported, but on Windows PGPASSFILE must be specified explicitly.
 Queries
 database/sql does not dictate any specific format for parameter
 markers in query strings, and pq uses the Postgres-native ordinal markers,
 as shown above. The same marker can be reused for the same parameter:
 	rows, err := db.Query(`SELECT name FROM users WHERE favorite_fruit = $1
 		OR age BETWEEN $2 AND $2 + 3`, "orange", 64)
 pq does not support the LastInsertId() method of the Result type in database/sql.
 To return the identifier of an INSERT (or UPDATE or DELETE), use the Postgres
 RETURNING clause with a standard Query or QueryRow call:
 	var userid int
 	err := db.QueryRow(`INSERT INTO users(name, favorite_fruit, age)
 		VALUES('beatrice', 'starfruit', 93) RETURNING id`).Scan(&userid)
 For more details on RETURNING, see the Postgres documentation:
 	http://www.postgresql.org/docs/current/static/sql-insert.html
 	http://www.postgresql.org/docs/current/static/sql-update.html
 	http://www.postgresql.org/docs/current/static/sql-delete.html
 For additional instructions on querying see the documentation for the database/sql package.
 Data Types
 Parameters pass through driver.DefaultParameterConverter before they are handled
 by this package. When the binary_parameters connection option is enabled,
 []byte values are sent directly to the backend as data in binary format.
 This package returns the following types for values from the PostgreSQL backend:
 	- integer types smallint, integer, and bigint are returned as int64
 	- floating-point types real and double precision are returned as float64
 	- character types char, varchar, and text are returned as string
 	- temporal types date, time, timetz, timestamp, and timestamptz are
 	  returned as time.Time
 	- the boolean type is returned as bool
 	- the bytea type is returned as []byte
 All other types are returned directly from the backend as []byte values in text format.
 Errors
 pq may return errors of type *pq.Error which can be interrogated for error details:
        if err, ok := err.(*pq.Error); ok {
            fmt.Println("pq error:", err.Code.Name())
        }
 See the pq.Error type for details.
 Bulk imports
 You can perform bulk imports by preparing a statement returned by pq.CopyIn (or
 pq.CopyInSchema) in an explicit transaction (sql.Tx). The returned statement
 handle can then be repeatedly "executed" to copy data into the target table.
 After all data has been processed you should call Exec() once with no arguments
 to flush all buffered data. Any call to Exec() might return an error which
 should be handled appropriately, but because of the internal buffering an error
 returned by Exec() might not be related to the data passed in the call that
 failed.
 CopyIn uses COPY FROM internally. It is not possible to COPY outside of an
 explicit transaction in pq.
 Usage example:
 	txn, err := db.Begin()
 	if err != nil {
 		log.Fatal(err)
 	}
 	stmt, err := txn.Prepare(pq.CopyIn("users", "name", "age"))
 	if err != nil {
 		log.Fatal(err)
 	}
 	for _, user := range users {
 		_, err = stmt.Exec(user.Name, int64(user.Age))
 		if err != nil {
 			log.Fatal(err)
 		}
 	}
 	_, err = stmt.Exec()
 	if err != nil {
 		log.Fatal(err)
 	}
 	err = stmt.Close()
 	if err != nil {
 		log.Fatal(err)
 	}
 	err = txn.Commit()
 	if err != nil {
 		log.Fatal(err)
 	}
 Notifications
 PostgreSQL supports a simple publish/subscribe model over database
 connections.  See http://www.postgresql.org/docs/current/static/sql-notify.html
 for more information about the general mechanism.
 To start listening for notifications, you first have to open a new connection
 to the database by calling NewListener.  This connection can not be used for
 anything other than LISTEN / NOTIFY.  Calling Listen will open a "notification
 channel"; once a notification channel is open, a notification generated on that
 channel will effect a send on the Listener.Notify channel.  A notification
 channel will remain open until Unlisten is called, though connection loss might
 result in some notifications being lost.  To solve this problem, Listener sends
 a nil pointer over the Notify channel any time the connection is re-established
 following a connection loss.  The application can get information about the
 state of the underlying connection by setting an event callback in the call to
 NewListener.
 A single Listener can safely be used from concurrent goroutines, which means
 that there is often no need to create more than one Listener in your
 application.  However, a Listener is always connected to a single database, so
 you will need to create a new Listener instance for every database you want to
 receive notifications in.
 The channel name in both Listen and Unlisten is case sensitive, and can contain
 any characters legal in an identifier (see
 http://www.postgresql.org/docs/current/static/sql-syntax-lexical.html#SQL-SYNTAX-IDENTIFIERS
 for more information).  Note that the channel name will be truncated to 63
 bytes by the PostgreSQL server.
 You can find a complete, working example of Listener usage at
 https://godoc.org/github.com/lib/pq/example/listen.
 */
 package pq
--- a/vendor/github.com/lib/pq/encode.go
+++ b/vendor/github.com/lib/pq/encode.go
@ -0,0 +1,602 @@
 package pq
 import (
 	"bytes"
 	"database/sql/driver"
 	"encoding/binary"
 	"encoding/hex"
 	"errors"
 	"fmt"
 	"math"
 	"strconv"
 	"strings"
 	"sync"
 	"time"
 	"github.com/lib/pq/oid"
 )
 func binaryEncode(parameterStatus *parameterStatus, x interface{}) []byte {
 	switch v := x.(type) {
 	case []byte:
 		return v
 	default:
 		return encode(parameterStatus, x, oid.T_unknown)
 	}
 }
 func encode(parameterStatus *parameterStatus, x interface{}, pgtypOid oid.Oid) []byte {
 	switch v := x.(type) {
 	case int64:
 		return strconv.AppendInt(nil, v, 10)
 	case float64:
 		return strconv.AppendFloat(nil, v, 'f', -1, 64)
 	case []byte:
 		if pgtypOid == oid.T_bytea {
 			return encodeBytea(parameterStatus.serverVersion, v)
 		}
 		return v
 	case string:
 		if pgtypOid == oid.T_bytea {
 			return encodeBytea(parameterStatus.serverVersion, []byte(v))
 		}
 		return []byte(v)
 	case bool:
 		return strconv.AppendBool(nil, v)
 	case time.Time:
 		return formatTs(v)
 	default:
 		errorf("encode: unknown type for %T", v)
 	}
 	panic("not reached")
 }
 func decode(parameterStatus *parameterStatus, s []byte, typ oid.Oid, f format) interface{} {
 	switch f {
 	case formatBinary:
 		return binaryDecode(parameterStatus, s, typ)
 	case formatText:
 		return textDecode(parameterStatus, s, typ)
 	default:
 		panic("not reached")
 	}
 }
 func binaryDecode(parameterStatus *parameterStatus, s []byte, typ oid.Oid) interface{} {
 	switch typ {
 	case oid.T_bytea:
 		return s
 	case oid.T_int8:
 		return int64(binary.BigEndian.Uint64(s))
 	case oid.T_int4:
 		return int64(int32(binary.BigEndian.Uint32(s)))
 	case oid.T_int2:
 		return int64(int16(binary.BigEndian.Uint16(s)))
 	case oid.T_uuid:
 		b, err := decodeUUIDBinary(s)
 		if err != nil {
 			panic(err)
 		}
 		return b
 	default:
 		errorf("don't know how to decode binary parameter of type %d", uint32(typ))
 	}
 	panic("not reached")
 }
 func textDecode(parameterStatus *parameterStatus, s []byte, typ oid.Oid) interface{} {
 	switch typ {
 	case oid.T_char, oid.T_varchar, oid.T_text:
 		return string(s)
 	case oid.T_bytea:
 		b, err := parseBytea(s)
 		if err != nil {
 			errorf("%s", err)
 		}
 		return b
 	case oid.T_timestamptz:
 		return parseTs(parameterStatus.currentLocation, string(s))
 	case oid.T_timestamp, oid.T_date:
 		return parseTs(nil, string(s))
 	case oid.T_time:
 		return mustParse("15:04:05", typ, s)
 	case oid.T_timetz:
 		return mustParse("15:04:05-07", typ, s)
 	case oid.T_bool:
 		return s[0] == 't'
 	case oid.T_int8, oid.T_int4, oid.T_int2:
 		i, err := strconv.ParseInt(string(s), 10, 64)
 		if err != nil {
 			errorf("%s", err)
 		}
 		return i
 	case oid.T_float4, oid.T_float8:
 		// We always use 64 bit parsing, regardless of whether the input text is for
 		// a float4 or float8, because clients expect float64s for all float datatypes
 		// and returning a 32-bit parsed float64 produces lossy results.
 		f, err := strconv.ParseFloat(string(s), 64)
 		if err != nil {
 			errorf("%s", err)
 		}
 		return f
 	}
 	return s
 }
 // appendEncodedText encodes item in text format as required by COPY
 // and appends to buf
 func appendEncodedText(parameterStatus *parameterStatus, buf []byte, x interface{}) []byte {
 	switch v := x.(type) {
 	case int64:
 		return strconv.AppendInt(buf, v, 10)
 	case float64:
 		return strconv.AppendFloat(buf, v, 'f', -1, 64)
 	case []byte:
 		encodedBytea := encodeBytea(parameterStatus.serverVersion, v)
 		return appendEscapedText(buf, string(encodedBytea))
 	case string:
 		return appendEscapedText(buf, v)
 	case bool:
 		return strconv.AppendBool(buf, v)
 	case time.Time:
 		return append(buf, formatTs(v)...)
 	case nil:
 		return append(buf, "\\N"...)
 	default:
 		errorf("encode: unknown type for %T", v)
 	}
 	panic("not reached")
 }
 func appendEscapedText(buf []byte, text string) []byte {
 	escapeNeeded := false
 	startPos := 0
 	var c byte
 	// check if we need to escape
 	for i := 0; i < len(text); i++ {
 		c = text[i]
 		if c == '\\' || c == '\n' || c == '\r' || c == '\t' {
 			escapeNeeded = true
 			startPos = i
 			break
 		}
 	}
 	if !escapeNeeded {
 		return append(buf, text...)
 	}
 	// copy till first char to escape, iterate the rest
 	result := append(buf, text[:startPos]...)
 	for i := startPos; i < len(text); i++ {
 		c = text[i]
 		switch c {
 		case '\\':
 			result = append(result, '\\', '\\')
 		case '\n':
 			result = append(result, '\\', 'n')
 		case '\r':
 			result = append(result, '\\', 'r')
 		case '\t':
 			result = append(result, '\\', 't')
 		default:
 			result = append(result, c)
 		}
 	}
 	return result
 }
 func mustParse(f string, typ oid.Oid, s []byte) time.Time {
 	str := string(s)
 	// check for a 30-minute-offset timezone
 	if (typ == oid.T_timestamptz || typ == oid.T_timetz) &&
 		str[len(str)-3] == ':' {
 		f += ":00"
 	}
 	t, err := time.Parse(f, str)
 	if err != nil {
 		errorf("decode: %s", err)
 	}
 	return t
 }
 var errInvalidTimestamp = errors.New("invalid timestamp")
 type timestampParser struct {
 	err error
 }
 func (p *timestampParser) expect(str string, char byte, pos int) {
 	if p.err != nil {
 		return
 	}
 	if pos+1 > len(str) {
 		p.err = errInvalidTimestamp
 		return
 	}
 	if c := str[pos]; c != char && p.err == nil {
 		p.err = fmt.Errorf("expected '%v' at position %v; got '%v'", char, pos, c)
 	}
 }
 func (p *timestampParser) mustAtoi(str string, begin int, end int) int {
 	if p.err != nil {
 		return 0
 	}
 	if begin < 0 || end < 0 || begin > end || end > len(str) {
 		p.err = errInvalidTimestamp
 		return 0
 	}
 	result, err := strconv.Atoi(str[begin:end])
 	if err != nil {
 		if p.err == nil {
 			p.err = fmt.Errorf("expected number; got '%v'", str)
 		}
 		return 0
 	}
 	return result
 }
 // The location cache caches the time zones typically used by the client.
 type locationCache struct {
 	cache map[int]*time.Location
 	lock  sync.Mutex
 }
 // All connections share the same list of timezones. Benchmarking shows that
 // about 5% speed could be gained by putting the cache in the connection and
 // losing the mutex, at the cost of a small amount of memory and a somewhat
 // significant increase in code complexity.
 var globalLocationCache = newLocationCache()
 func newLocationCache() *locationCache {
 	return &locationCache{cache: make(map[int]*time.Location)}
 }
 // Returns the cached timezone for the specified offset, creating and caching
 // it if necessary.
 func (c *locationCache) getLocation(offset int) *time.Location {
 	c.lock.Lock()
 	defer c.lock.Unlock()
 	location, ok := c.cache[offset]
 	if !ok {
 		location = time.FixedZone("", offset)
 		c.cache[offset] = location
 	}
 	return location
 }
 var infinityTsEnabled = false
 var infinityTsNegative time.Time
 var infinityTsPositive time.Time
 const (
 	infinityTsEnabledAlready        = "pq: infinity timestamp enabled already"
 	infinityTsNegativeMustBeSmaller = "pq: infinity timestamp: negative value must be smaller (before) than positive"
 )
 // EnableInfinityTs controls the handling of Postgres' "-infinity" and
 // "infinity" "timestamp"s.
 //
 // If EnableInfinityTs is not called, "-infinity" and "infinity" will return
 // []byte("-infinity") and []byte("infinity") respectively, and potentially
 // cause error "sql: Scan error on column index 0: unsupported driver -> Scan
 // pair: []uint8 -> *time.Time", when scanning into a time.Time value.
 //
 // Once EnableInfinityTs has been called, all connections created using this
 // driver will decode Postgres' "-infinity" and "infinity" for "timestamp",
 // "timestamp with time zone" and "date" types to the predefined minimum and
 // maximum times, respectively.  When encoding time.Time values, any time which
 // equals or precedes the predefined minimum time will be encoded to
 // "-infinity".  Any values at or past the maximum time will similarly be
 // encoded to "infinity".
 //
 // If EnableInfinityTs is called with negative >= positive, it will panic.
 // Calling EnableInfinityTs after a connection has been established results in
 // undefined behavior.  If EnableInfinityTs is called more than once, it will
 // panic.
 func EnableInfinityTs(negative time.Time, positive time.Time) {
 	if infinityTsEnabled {
 		panic(infinityTsEnabledAlready)
 	}
 	if !negative.Before(positive) {
 		panic(infinityTsNegativeMustBeSmaller)
 	}
 	infinityTsEnabled = true
 	infinityTsNegative = negative
 	infinityTsPositive = positive
 }
 /*
 * Testing might want to toggle infinityTsEnabled
 */
 func disableInfinityTs() {
 	infinityTsEnabled = false
 }
 // This is a time function specific to the Postgres default DateStyle
 // setting ("ISO, MDY"), the only one we currently support. This
 // accounts for the discrepancies between the parsing available with
 // time.Parse and the Postgres date formatting quirks.
 func parseTs(currentLocation *time.Location, str string) interface{} {
 	switch str {
 	case "-infinity":
 		if infinityTsEnabled {
 			return infinityTsNegative
 		}
 		return []byte(str)
 	case "infinity":
 		if infinityTsEnabled {
 			return infinityTsPositive
 		}
 		return []byte(str)
 	}
 	t, err := ParseTimestamp(currentLocation, str)
 	if err != nil {
 		panic(err)
 	}
 	return t
 }
 // ParseTimestamp parses Postgres' text format. It returns a time.Time in
 // currentLocation iff that time's offset agrees with the offset sent from the
 // Postgres server. Otherwise, ParseTimestamp returns a time.Time with the
 // fixed offset offset provided by the Postgres server.
 func ParseTimestamp(currentLocation *time.Location, str string) (time.Time, error) {
 	p := timestampParser{}
 	monSep := strings.IndexRune(str, '-')
 	// this is Gregorian year, not ISO Year
 	// In Gregorian system, the year 1 BC is followed by AD 1
 	year := p.mustAtoi(str, 0, monSep)
 	daySep := monSep + 3
 	month := p.mustAtoi(str, monSep+1, daySep)
 	p.expect(str, '-', daySep)
 	timeSep := daySep + 3
 	day := p.mustAtoi(str, daySep+1, timeSep)
 	minLen := monSep + len("01-01") + 1
 	isBC := strings.HasSuffix(str, " BC")
 	if isBC {
 		minLen += 3
 	}
 	var hour, minute, second int
 	if len(str) > minLen {
 		p.expect(str, ' ', timeSep)
 		minSep := timeSep + 3
 		p.expect(str, ':', minSep)
 		hour = p.mustAtoi(str, timeSep+1, minSep)
 		secSep := minSep + 3
 		p.expect(str, ':', secSep)
 		minute = p.mustAtoi(str, minSep+1, secSep)
 		secEnd := secSep + 3
 		second = p.mustAtoi(str, secSep+1, secEnd)
 	}
 	remainderIdx := monSep + len("01-01 00:00:00") + 1
 	// Three optional (but ordered) sections follow: the
 	// fractional seconds, the time zone offset, and the BC
 	// designation. We set them up here and adjust the other
 	// offsets if the preceding sections exist.
 	nanoSec := 0
 	tzOff := 0
 	if remainderIdx < len(str) && str[remainderIdx] == '.' {
 		fracStart := remainderIdx + 1
 		fracOff := strings.IndexAny(str[fracStart:], "-+ ")
 		if fracOff < 0 {
 			fracOff = len(str) - fracStart
 		}
 		fracSec := p.mustAtoi(str, fracStart, fracStart+fracOff)
 		nanoSec = fracSec * (1000000000 / int(math.Pow(10, float64(fracOff))))
 		remainderIdx += fracOff + 1
 	}
 	if tzStart := remainderIdx; tzStart < len(str) && (str[tzStart] == '-' || str[tzStart] == '+') {
 		// time zone separator is always '-' or '+' (UTC is +00)
 		var tzSign int
 		switch c := str[tzStart]; c {
 		case '-':
 			tzSign = -1
 		case '+':
 			tzSign = +1
 		default:
 			return time.Time{}, fmt.Errorf("expected '-' or '+' at position %v; got %v", tzStart, c)
 		}
 		tzHours := p.mustAtoi(str, tzStart+1, tzStart+3)
 		remainderIdx += 3
 		var tzMin, tzSec int
 		if remainderIdx < len(str) && str[remainderIdx] == ':' {
 			tzMin = p.mustAtoi(str, remainderIdx+1, remainderIdx+3)
 			remainderIdx += 3
 		}
 		if remainderIdx < len(str) && str[remainderIdx] == ':' {
 			tzSec = p.mustAtoi(str, remainderIdx+1, remainderIdx+3)
 			remainderIdx += 3
 		}
 		tzOff = tzSign * ((tzHours * 60 * 60) + (tzMin * 60) + tzSec)
 	}
 	var isoYear int
 	if isBC {
 		isoYear = 1 - year
 		remainderIdx += 3
 	} else {
 		isoYear = year
 	}
 	if remainderIdx < len(str) {
 		return time.Time{}, fmt.Errorf("expected end of input, got %v", str[remainderIdx:])
 	}
 	t := time.Date(isoYear, time.Month(month), day,
 		hour, minute, second, nanoSec,
 		globalLocationCache.getLocation(tzOff))
 	if currentLocation != nil {
 		// Set the location of the returned Time based on the session's
 		// TimeZone value, but only if the local time zone database agrees with
 		// the remote database on the offset.
 		lt := t.In(currentLocation)
 		_, newOff := lt.Zone()
 		if newOff == tzOff {
 			t = lt
 		}
 	}
 	return t, p.err
 }
 // formatTs formats t into a format postgres understands.
 func formatTs(t time.Time) []byte {
 	if infinityTsEnabled {
 		// t <= -infinity : ! (t > -infinity)
 		if !t.After(infinityTsNegative) {
 			return []byte("-infinity")
 		}
 		// t >= infinity : ! (!t < infinity)
 		if !t.Before(infinityTsPositive) {
 			return []byte("infinity")
 		}
 	}
 	return FormatTimestamp(t)
 }
 // FormatTimestamp formats t into Postgres' text format for timestamps.
 func FormatTimestamp(t time.Time) []byte {
 	// Need to send dates before 0001 A.D. with " BC" suffix, instead of the
 	// minus sign preferred by Go.
 	// Beware, "0000" in ISO is "1 BC", "-0001" is "2 BC" and so on
 	bc := false
 	if t.Year() <= 0 {
 		// flip year sign, and add 1, e.g: "0" will be "1", and "-10" will be "11"
 		t = t.AddDate((-t.Year())*2+1, 0, 0)
 		bc = true
 	}
 	b := []byte(t.Format("2006-01-02 15:04:05.999999999Z07:00"))
 	_, offset := t.Zone()
 	offset = offset % 60
 	if offset != 0 {
 		// RFC3339Nano already printed the minus sign
 		if offset < 0 {
 			offset = -offset
 		}
 		b = append(b, ':')
 		if offset < 10 {
 			b = append(b, '0')
 		}
 		b = strconv.AppendInt(b, int64(offset), 10)
 	}
 	if bc {
 		b = append(b, " BC"...)
 	}
 	return b
 }
 // Parse a bytea value received from the server.  Both "hex" and the legacy
 // "escape" format are supported.
 func parseBytea(s []byte) (result []byte, err error) {
 	if len(s) >= 2 && bytes.Equal(s[:2], []byte("\\x")) {
 		// bytea_output = hex
 		s = s[2:] // trim off leading "\\x"
 		result = make([]byte, hex.DecodedLen(len(s)))
 		_, err := hex.Decode(result, s)
 		if err != nil {
 			return nil, err
 		}
 	} else {
 		// bytea_output = escape
 		for len(s) > 0 {
 			if s[0] == '\\' {
 				// escaped '\\'
 				if len(s) >= 2 && s[1] == '\\' {
 					result = append(result, '\\')
 					s = s[2:]
 					continue
 				}
 				// '\\' followed by an octal number
 				if len(s) < 4 {
 					return nil, fmt.Errorf("invalid bytea sequence %v", s)
 				}
 				r, err := strconv.ParseInt(string(s[1:4]), 8, 9)
 				if err != nil {
 					return nil, fmt.Errorf("could not parse bytea value: %s", err.Error())
 				}
 				result = append(result, byte(r))
 				s = s[4:]
 			} else {
 				// We hit an unescaped, raw byte.  Try to read in as many as
 				// possible in one go.
 				i := bytes.IndexByte(s, '\\')
 				if i == -1 {
 					result = append(result, s...)
 					break
 				}
 				result = append(result, s[:i]...)
 				s = s[i:]
 			}
 		}
 	}
 	return result, nil
 }
 func encodeBytea(serverVersion int, v []byte) (result []byte) {
 	if serverVersion >= 90000 {
 		// Use the hex format if we know that the server supports it
 		result = make([]byte, 2+hex.EncodedLen(len(v)))
 		result[0] = '\\'
 		result[1] = 'x'
 		hex.Encode(result[2:], v)
 	} else {
 		// .. or resort to "escape"
 		for _, b := range v {
 			if b == '\\' {
 				result = append(result, '\\', '\\')
 			} else if b < 0x20 || b > 0x7e {
 				result = append(result, []byte(fmt.Sprintf("\\%03o", b))...)
 			} else {
 				result = append(result, b)
 			}
 		}
 	}
 	return result
 }
 // NullTime represents a time.Time that may be null. NullTime implements the
 // sql.Scanner interface so it can be used as a scan destination, similar to
 // sql.NullString.
 type NullTime struct {
 	Time  time.Time
 	Valid bool // Valid is true if Time is not NULL
 }
 // Scan implements the Scanner interface.
 func (nt *NullTime) Scan(value interface{}) error {
 	nt.Time, nt.Valid = value.(time.Time)
 	return nil
 }
 // Value implements the driver Valuer interface.
 func (nt NullTime) Value() (driver.Value, error) {
 	if !nt.Valid {
 		return nil, nil
 	}
 	return nt.Time, nil
 }
--- a/vendor/github.com/lib/pq/error.go
+++ b/vendor/github.com/lib/pq/error.go
@ -0,0 +1,515 @@
 package pq
 import (
 	"database/sql/driver"
 	"fmt"
 	"io"
 	"net"
 	"runtime"
 )
 // Error severities
 const (
 	Efatal   = "FATAL"
 	Epanic   = "PANIC"
 	Ewarning = "WARNING"
 	Enotice  = "NOTICE"
 	Edebug   = "DEBUG"
 	Einfo    = "INFO"
 	Elog     = "LOG"
 )
 // Error represents an error communicating with the server.
 //
 // See http://www.postgresql.org/docs/current/static/protocol-error-fields.html for details of the fields
 type Error struct {
 	Severity         string
 	Code             ErrorCode
 	Message          string
 	Detail           string
 	Hint             string
 	Position         string
 	InternalPosition string
 	InternalQuery    string
 	Where            string
 	Schema           string
 	Table            string
 	Column           string
 	DataTypeName     string
 	Constraint       string
 	File             string
 	Line             string
 	Routine          string
 }
 // ErrorCode is a five-character error code.
 type ErrorCode string
 // Name returns a more human friendly rendering of the error code, namely the
 // "condition name".
 //
 // See http://www.postgresql.org/docs/9.3/static/errcodes-appendix.html for
 // details.
 func (ec ErrorCode) Name() string {
 	return errorCodeNames[ec]
 }
 // ErrorClass is only the class part of an error code.
 type ErrorClass string
 // Name returns the condition name of an error class.  It is equivalent to the
 // condition name of the "standard" error code (i.e. the one having the last
 // three characters "000").
 func (ec ErrorClass) Name() string {
 	return errorCodeNames[ErrorCode(ec+"000")]
 }
 // Class returns the error class, e.g. "28".
 //
 // See http://www.postgresql.org/docs/9.3/static/errcodes-appendix.html for
 // details.
 func (ec ErrorCode) Class() ErrorClass {
 	return ErrorClass(ec[0:2])
 }
 // errorCodeNames is a mapping between the five-character error codes and the
 // human readable "condition names". It is derived from the list at
 // http://www.postgresql.org/docs/9.3/static/errcodes-appendix.html
 var errorCodeNames = map[ErrorCode]string{
 	// Class 00 - Successful Completion
 	"00000": "successful_completion",
 	// Class 01 - Warning
 	"01000": "warning",
 	"0100C": "dynamic_result_sets_returned",
 	"01008": "implicit_zero_bit_padding",
 	"01003": "null_value_eliminated_in_set_function",
 	"01007": "privilege_not_granted",
 	"01006": "privilege_not_revoked",
 	"01004": "string_data_right_truncation",
 	"01P01": "deprecated_feature",
 	// Class 02 - No Data (this is also a warning class per the SQL standard)
 	"02000": "no_data",
 	"02001": "no_additional_dynamic_result_sets_returned",
 	// Class 03 - SQL Statement Not Yet Complete
 	"03000": "sql_statement_not_yet_complete",
 	// Class 08 - Connection Exception
 	"08000": "connection_exception",
 	"08003": "connection_does_not_exist",
 	"08006": "connection_failure",
 	"08001": "sqlclient_unable_to_establish_sqlconnection",
 	"08004": "sqlserver_rejected_establishment_of_sqlconnection",
 	"08007": "transaction_resolution_unknown",
 	"08P01": "protocol_violation",
 	// Class 09 - Triggered Action Exception
 	"09000": "triggered_action_exception",
 	// Class 0A - Feature Not Supported
 	"0A000": "feature_not_supported",
 	// Class 0B - Invalid Transaction Initiation
 	"0B000": "invalid_transaction_initiation",
 	// Class 0F - Locator Exception
 	"0F000": "locator_exception",
 	"0F001": "invalid_locator_specification",
 	// Class 0L - Invalid Grantor
 	"0L000": "invalid_grantor",
 	"0LP01": "invalid_grant_operation",
 	// Class 0P - Invalid Role Specification
 	"0P000": "invalid_role_specification",
 	// Class 0Z - Diagnostics Exception
 	"0Z000": "diagnostics_exception",
 	"0Z002": "stacked_diagnostics_accessed_without_active_handler",
 	// Class 20 - Case Not Found
 	"20000": "case_not_found",
 	// Class 21 - Cardinality Violation
 	"21000": "cardinality_violation",
 	// Class 22 - Data Exception
 	"22000": "data_exception",
 	"2202E": "array_subscript_error",
 	"22021": "character_not_in_repertoire",
 	"22008": "datetime_field_overflow",
 	"22012": "division_by_zero",
 	"22005": "error_in_assignment",
 	"2200B": "escape_character_conflict",
 	"22022": "indicator_overflow",
 	"22015": "interval_field_overflow",
 	"2201E": "invalid_argument_for_logarithm",
 	"22014": "invalid_argument_for_ntile_function",
 	"22016": "invalid_argument_for_nth_value_function",
 	"2201F": "invalid_argument_for_power_function",
 	"2201G": "invalid_argument_for_width_bucket_function",
 	"22018": "invalid_character_value_for_cast",
 	"22007": "invalid_datetime_format",
 	"22019": "invalid_escape_character",
 	"2200D": "invalid_escape_octet",
 	"22025": "invalid_escape_sequence",
 	"22P06": "nonstandard_use_of_escape_character",
 	"22010": "invalid_indicator_parameter_value",
 	"22023": "invalid_parameter_value",
 	"2201B": "invalid_regular_expression",
 	"2201W": "invalid_row_count_in_limit_clause",
 	"2201X": "invalid_row_count_in_result_offset_clause",
 	"22009": "invalid_time_zone_displacement_value",
 	"2200C": "invalid_use_of_escape_character",
 	"2200G": "most_specific_type_mismatch",
 	"22004": "null_value_not_allowed",
 	"22002": "null_value_no_indicator_parameter",
 	"22003": "numeric_value_out_of_range",
 	"2200H": "sequence_generator_limit_exceeded",
 	"22026": "string_data_length_mismatch",
 	"22001": "string_data_right_truncation",
 	"22011": "substring_error",
 	"22027": "trim_error",
 	"22024": "unterminated_c_string",
 	"2200F": "zero_length_character_string",
 	"22P01": "floating_point_exception",
 	"22P02": "invalid_text_representation",
 	"22P03": "invalid_binary_representation",
 	"22P04": "bad_copy_file_format",
 	"22P05": "untranslatable_character",
 	"2200L": "not_an_xml_document",
 	"2200M": "invalid_xml_document",
 	"2200N": "invalid_xml_content",
 	"2200S": "invalid_xml_comment",
 	"2200T": "invalid_xml_processing_instruction",
 	// Class 23 - Integrity Constraint Violation
 	"23000": "integrity_constraint_violation",
 	"23001": "restrict_violation",
 	"23502": "not_null_violation",
 	"23503": "foreign_key_violation",
 	"23505": "unique_violation",
 	"23514": "check_violation",
 	"23P01": "exclusion_violation",
 	// Class 24 - Invalid Cursor State
 	"24000": "invalid_cursor_state",
 	// Class 25 - Invalid Transaction State
 	"25000": "invalid_transaction_state",
 	"25001": "active_sql_transaction",
 	"25002": "branch_transaction_already_active",
 	"25008": "held_cursor_requires_same_isolation_level",
 	"25003": "inappropriate_access_mode_for_branch_transaction",
 	"25004": "inappropriate_isolation_level_for_branch_transaction",
 	"25005": "no_active_sql_transaction_for_branch_transaction",
 	"25006": "read_only_sql_transaction",
 	"25007": "schema_and_data_statement_mixing_not_supported",
 	"25P01": "no_active_sql_transaction",
 	"25P02": "in_failed_sql_transaction",
 	// Class 26 - Invalid SQL Statement Name
 	"26000": "invalid_sql_statement_name",
 	// Class 27 - Triggered Data Change Violation
 	"27000": "triggered_data_change_violation",
 	// Class 28 - Invalid Authorization Specification
 	"28000": "invalid_authorization_specification",
 	"28P01": "invalid_password",
 	// Class 2B - Dependent Privilege Descriptors Still Exist
 	"2B000": "dependent_privilege_descriptors_still_exist",
 	"2BP01": "dependent_objects_still_exist",
 	// Class 2D - Invalid Transaction Termination
 	"2D000": "invalid_transaction_termination",
 	// Class 2F - SQL Routine Exception
 	"2F000": "sql_routine_exception",
 	"2F005": "function_executed_no_return_statement",
 	"2F002": "modifying_sql_data_not_permitted",
 	"2F003": "prohibited_sql_statement_attempted",
 	"2F004": "reading_sql_data_not_permitted",
 	// Class 34 - Invalid Cursor Name
 	"34000": "invalid_cursor_name",
 	// Class 38 - External Routine Exception
 	"38000": "external_routine_exception",
 	"38001": "containing_sql_not_permitted",
 	"38002": "modifying_sql_data_not_permitted",
 	"38003": "prohibited_sql_statement_attempted",
 	"38004": "reading_sql_data_not_permitted",
 	// Class 39 - External Routine Invocation Exception
 	"39000": "external_routine_invocation_exception",
 	"39001": "invalid_sqlstate_returned",
 	"39004": "null_value_not_allowed",
 	"39P01": "trigger_protocol_violated",
 	"39P02": "srf_protocol_violated",
 	// Class 3B - Savepoint Exception
 	"3B000": "savepoint_exception",
 	"3B001": "invalid_savepoint_specification",
 	// Class 3D - Invalid Catalog Name
 	"3D000": "invalid_catalog_name",
 	// Class 3F - Invalid Schema Name
 	"3F000": "invalid_schema_name",
 	// Class 40 - Transaction Rollback
 	"40000": "transaction_rollback",
 	"40002": "transaction_integrity_constraint_violation",
 	"40001": "serialization_failure",
 	"40003": "statement_completion_unknown",
 	"40P01": "deadlock_detected",
 	// Class 42 - Syntax Error or Access Rule Violation
 	"42000": "syntax_error_or_access_rule_violation",
 	"42601": "syntax_error",
 	"42501": "insufficient_privilege",
 	"42846": "cannot_coerce",
 	"42803": "grouping_error",
 	"42P20": "windowing_error",
 	"42P19": "invalid_recursion",
 	"42830": "invalid_foreign_key",
 	"42602": "invalid_name",
 	"42622": "name_too_long",
 	"42939": "reserved_name",
 	"42804": "datatype_mismatch",
 	"42P18": "indeterminate_datatype",
 	"42P21": "collation_mismatch",
 	"42P22": "indeterminate_collation",
 	"42809": "wrong_object_type",
 	"42703": "undefined_column",
 	"42883": "undefined_function",
 	"42P01": "undefined_table",
 	"42P02": "undefined_parameter",
 	"42704": "undefined_object",
 	"42701": "duplicate_column",
 	"42P03": "duplicate_cursor",
 	"42P04": "duplicate_database",
 	"42723": "duplicate_function",
 	"42P05": "duplicate_prepared_statement",
 	"42P06": "duplicate_schema",
 	"42P07": "duplicate_table",
 	"42712": "duplicate_alias",
 	"42710": "duplicate_object",
 	"42702": "ambiguous_column",
 	"42725": "ambiguous_function",
 	"42P08": "ambiguous_parameter",
 	"42P09": "ambiguous_alias",
 	"42P10": "invalid_column_reference",
 	"42611": "invalid_column_definition",
 	"42P11": "invalid_cursor_definition",
 	"42P12": "invalid_database_definition",
 	"42P13": "invalid_function_definition",
 	"42P14": "invalid_prepared_statement_definition",
 	"42P15": "invalid_schema_definition",
 	"42P16": "invalid_table_definition",
 	"42P17": "invalid_object_definition",
 	// Class 44 - WITH CHECK OPTION Violation
 	"44000": "with_check_option_violation",
 	// Class 53 - Insufficient Resources
 	"53000": "insufficient_resources",
 	"53100": "disk_full",
 	"53200": "out_of_memory",
 	"53300": "too_many_connections",
 	"53400": "configuration_limit_exceeded",
 	// Class 54 - Program Limit Exceeded
 	"54000": "program_limit_exceeded",
 	"54001": "statement_too_complex",
 	"54011": "too_many_columns",
 	"54023": "too_many_arguments",
 	// Class 55 - Object Not In Prerequisite State
 	"55000": "object_not_in_prerequisite_state",
 	"55006": "object_in_use",
 	"55P02": "cant_change_runtime_param",
 	"55P03": "lock_not_available",
 	// Class 57 - Operator Intervention
 	"57000": "operator_intervention",
 	"57014": "query_canceled",
 	"57P01": "admin_shutdown",
 	"57P02": "crash_shutdown",
 	"57P03": "cannot_connect_now",
 	"57P04": "database_dropped",
 	// Class 58 - System Error (errors external to PostgreSQL itself)
 	"58000": "system_error",
 	"58030": "io_error",
 	"58P01": "undefined_file",
 	"58P02": "duplicate_file",
 	// Class F0 - Configuration File Error
 	"F0000": "config_file_error",
 	"F0001": "lock_file_exists",
 	// Class HV - Foreign Data Wrapper Error (SQL/MED)
 	"HV000": "fdw_error",
 	"HV005": "fdw_column_name_not_found",
 	"HV002": "fdw_dynamic_parameter_value_needed",
 	"HV010": "fdw_function_sequence_error",
 	"HV021": "fdw_inconsistent_descriptor_information",
 	"HV024": "fdw_invalid_attribute_value",
 	"HV007": "fdw_invalid_column_name",
 	"HV008": "fdw_invalid_column_number",
 	"HV004": "fdw_invalid_data_type",
 	"HV006": "fdw_invalid_data_type_descriptors",
 	"HV091": "fdw_invalid_descriptor_field_identifier",
 	"HV00B": "fdw_invalid_handle",
 	"HV00C": "fdw_invalid_option_index",
 	"HV00D": "fdw_invalid_option_name",
 	"HV090": "fdw_invalid_string_length_or_buffer_length",
 	"HV00A": "fdw_invalid_string_format",
 	"HV009": "fdw_invalid_use_of_null_pointer",
 	"HV014": "fdw_too_many_handles",
 	"HV001": "fdw_out_of_memory",
 	"HV00P": "fdw_no_schemas",
 	"HV00J": "fdw_option_name_not_found",
 	"HV00K": "fdw_reply_handle",
 	"HV00Q": "fdw_schema_not_found",
 	"HV00R": "fdw_table_not_found",
 	"HV00L": "fdw_unable_to_create_execution",
 	"HV00M": "fdw_unable_to_create_reply",
 	"HV00N": "fdw_unable_to_establish_connection",
 	// Class P0 - PL/pgSQL Error
 	"P0000": "plpgsql_error",
 	"P0001": "raise_exception",
 	"P0002": "no_data_found",
 	"P0003": "too_many_rows",
 	// Class XX - Internal Error
 	"XX000": "internal_error",
 	"XX001": "data_corrupted",
 	"XX002": "index_corrupted",
 }
 func parseError(r *readBuf) *Error {
 	err := new(Error)
 	for t := r.byte(); t != 0; t = r.byte() {
 		msg := r.string()
 		switch t {
 		case 'S':
 			err.Severity = msg
 		case 'C':
 			err.Code = ErrorCode(msg)
 		case 'M':
 			err.Message = msg
 		case 'D':
 			err.Detail = msg
 		case 'H':
 			err.Hint = msg
 		case 'P':
 			err.Position = msg
 		case 'p':
 			err.InternalPosition = msg
 		case 'q':
 			err.InternalQuery = msg
 		case 'W':
 			err.Where = msg
 		case 's':
 			err.Schema = msg
 		case 't':
 			err.Table = msg
 		case 'c':
 			err.Column = msg
 		case 'd':
 			err.DataTypeName = msg
 		case 'n':
 			err.Constraint = msg
 		case 'F':
 			err.File = msg
 		case 'L':
 			err.Line = msg
 		case 'R':
 			err.Routine = msg
 		}
 	}
 	return err
 }
 // Fatal returns true if the Error Severity is fatal.
 func (err *Error) Fatal() bool {
 	return err.Severity == Efatal
 }
 // Get implements the legacy PGError interface. New code should use the fields
 // of the Error struct directly.
 func (err *Error) Get(k byte) (v string) {
 	switch k {
 	case 'S':
 		return err.Severity
 	case 'C':
 		return string(err.Code)
 	case 'M':
 		return err.Message
 	case 'D':
 		return err.Detail
 	case 'H':
 		return err.Hint
 	case 'P':
 		return err.Position
 	case 'p':
 		return err.InternalPosition
 	case 'q':
 		return err.InternalQuery
 	case 'W':
 		return err.Where
 	case 's':
 		return err.Schema
 	case 't':
 		return err.Table
 	case 'c':
 		return err.Column
 	case 'd':
 		return err.DataTypeName
 	case 'n':
 		return err.Constraint
 	case 'F':
 		return err.File
 	case 'L':
 		return err.Line
 	case 'R':
 		return err.Routine
 	}
 	return ""
 }
 func (err Error) Error() string {
 	return "pq: " + err.Message
 }
 // PGError is an interface used by previous versions of pq. It is provided
 // only to support legacy code. New code should use the Error type.
 type PGError interface {
 	Error() string
 	Fatal() bool
 	Get(k byte) (v string)
 }
 func errorf(s string, args ...interface{}) {
 	panic(fmt.Errorf("pq: %s", fmt.Sprintf(s, args...)))
 }
 // TODO(ainar-g) Rename to errorf after removing panics.
 func fmterrorf(s string, args ...interface{}) error {
 	return fmt.Errorf("pq: %s", fmt.Sprintf(s, args...))
 }
 func errRecoverNoErrBadConn(err *error) {
 	e := recover()
 	if e == nil {
 		// Do nothing
 		return
 	}
 	var ok bool
 	*err, ok = e.(error)
 	if !ok {
 		*err = fmt.Errorf("pq: unexpected error: %#v", e)
 	}
 }
 func (c *conn) errRecover(err *error) {
 	e := recover()
 	switch v := e.(type) {
 	case nil:
 		// Do nothing
 	case runtime.Error:
 		c.bad = true
 		panic(v)
 	case *Error:
 		if v.Fatal() {
 			*err = driver.ErrBadConn
 		} else {
 			*err = v
 		}
 	case *net.OpError:
 		c.bad = true
 		*err = v
 	case error:
 		if v == io.EOF || v.(error).Error() == "remote error: handshake failure" {
 			*err = driver.ErrBadConn
 		} else {
 			*err = v
 		}
 	default:
 		c.bad = true
 		panic(fmt.Sprintf("unknown error: %#v", e))
 	}
 	// Any time we return ErrBadConn, we need to remember it since *Tx doesn't
 	// mark the connection bad in database/sql.
 	if *err == driver.ErrBadConn {
 		c.bad = true
 	}
 }
--- a/vendor/github.com/lib/pq/go.mod
+++ b/vendor/github.com/lib/pq/go.mod
@ -0,0 +1 @@
 module github.com/lib/pq
--- a/vendor/github.com/lib/pq/notify.go
+++ b/vendor/github.com/lib/pq/notify.go
@ -0,0 +1,797 @@
 package pq
 // Package pq is a pure Go Postgres driver for the database/sql package.
 // This module contains support for Postgres LISTEN/NOTIFY.
 import (
 	"errors"
 	"fmt"
 	"sync"
 	"sync/atomic"
 	"time"
 )
 // Notification represents a single notification from the database.
 type Notification struct {
 	// Process ID (PID) of the notifying postgres backend.
 	BePid int
 	// Name of the channel the notification was sent on.
 	Channel string
 	// Payload, or the empty string if unspecified.
 	Extra string
 }
 func recvNotification(r *readBuf) *Notification {
 	bePid := r.int32()
 	channel := r.string()
 	extra := r.string()
 	return &Notification{bePid, channel, extra}
 }
 const (
 	connStateIdle int32 = iota
 	connStateExpectResponse
 	connStateExpectReadyForQuery
 )
 type message struct {
 	typ byte
 	err error
 }
 var errListenerConnClosed = errors.New("pq: ListenerConn has been closed")
 // ListenerConn is a low-level interface for waiting for notifications.  You
 // should use Listener instead.
 type ListenerConn struct {
 	// guards cn and err
 	connectionLock sync.Mutex
 	cn             *conn
 	err            error
 	connState int32
 	// the sending goroutine will be holding this lock
 	senderLock sync.Mutex
 	notificationChan chan<- *Notification
 	replyChan chan message
 }
 // NewListenerConn creates a new ListenerConn. Use NewListener instead.
 func NewListenerConn(name string, notificationChan chan<- *Notification) (*ListenerConn, error) {
 	return newDialListenerConn(defaultDialer{}, name, notificationChan)
 }
 func newDialListenerConn(d Dialer, name string, c chan<- *Notification) (*ListenerConn, error) {
 	cn, err := DialOpen(d, name)
 	if err != nil {
 		return nil, err
 	}
 	l := &ListenerConn{
 		cn:               cn.(*conn),
 		notificationChan: c,
 		connState:        connStateIdle,
 		replyChan:        make(chan message, 2),
 	}
 	go l.listenerConnMain()
 	return l, nil
 }
 // We can only allow one goroutine at a time to be running a query on the
 // connection for various reasons, so the goroutine sending on the connection
 // must be holding senderLock.
 //
 // Returns an error if an unrecoverable error has occurred and the ListenerConn
 // should be abandoned.
 func (l *ListenerConn) acquireSenderLock() error {
 	// we must acquire senderLock first to avoid deadlocks; see ExecSimpleQuery
 	l.senderLock.Lock()
 	l.connectionLock.Lock()
 	err := l.err
 	l.connectionLock.Unlock()
 	if err != nil {
 		l.senderLock.Unlock()
 		return err
 	}
 	return nil
 }
 func (l *ListenerConn) releaseSenderLock() {
 	l.senderLock.Unlock()
 }
 // setState advances the protocol state to newState.  Returns false if moving
 // to that state from the current state is not allowed.
 func (l *ListenerConn) setState(newState int32) bool {
 	var expectedState int32
 	switch newState {
 	case connStateIdle:
 		expectedState = connStateExpectReadyForQuery
 	case connStateExpectResponse:
 		expectedState = connStateIdle
 	case connStateExpectReadyForQuery:
 		expectedState = connStateExpectResponse
 	default:
 		panic(fmt.Sprintf("unexpected listenerConnState %d", newState))
 	}
 	return atomic.CompareAndSwapInt32(&l.connState, expectedState, newState)
 }
 // Main logic is here: receive messages from the postgres backend, forward
 // notifications and query replies and keep the internal state in sync with the
 // protocol state.  Returns when the connection has been lost, is about to go
 // away or should be discarded because we couldn't agree on the state with the
 // server backend.
 func (l *ListenerConn) listenerConnLoop() (err error) {
 	defer errRecoverNoErrBadConn(&err)
 	r := &readBuf{}
 	for {
 		t, err := l.cn.recvMessage(r)
 		if err != nil {
 			return err
 		}
 		switch t {
 		case 'A':
 			// recvNotification copies all the data so we don't need to worry
 			// about the scratch buffer being overwritten.
 			l.notificationChan <- recvNotification(r)
 		case 'T', 'D':
 			// only used by tests; ignore
 		case 'E':
 			// We might receive an ErrorResponse even when not in a query; it
 			// is expected that the server will close the connection after
 			// that, but we should make sure that the error we display is the
 			// one from the stray ErrorResponse, not io.ErrUnexpectedEOF.
 			if !l.setState(connStateExpectReadyForQuery) {
 				return parseError(r)
 			}
 			l.replyChan <- message{t, parseError(r)}
 		case 'C', 'I':
 			if !l.setState(connStateExpectReadyForQuery) {
 				// protocol out of sync
 				return fmt.Errorf("unexpected CommandComplete")
 			}
 			// ExecSimpleQuery doesn't need to know about this message
 		case 'Z':
 			if !l.setState(connStateIdle) {
 				// protocol out of sync
 				return fmt.Errorf("unexpected ReadyForQuery")
 			}
 			l.replyChan <- message{t, nil}
 		case 'N', 'S':
 			// ignore
 		default:
 			return fmt.Errorf("unexpected message %q from server in listenerConnLoop", t)
 		}
 	}
 }
 // This is the main routine for the goroutine receiving on the database
 // connection.  Most of the main logic is in listenerConnLoop.
 func (l *ListenerConn) listenerConnMain() {
 	err := l.listenerConnLoop()
 	// listenerConnLoop terminated; we're done, but we still have to clean up.
 	// Make sure nobody tries to start any new queries by making sure the err
 	// pointer is set.  It is important that we do not overwrite its value; a
 	// connection could be closed by either this goroutine or one sending on
 	// the connection -- whoever closes the connection is assumed to have the
 	// more meaningful error message (as the other one will probably get
 	// net.errClosed), so that goroutine sets the error we expose while the
 	// other error is discarded.  If the connection is lost while two
 	// goroutines are operating on the socket, it probably doesn't matter which
 	// error we expose so we don't try to do anything more complex.
 	l.connectionLock.Lock()
 	if l.err == nil {
 		l.err = err
 	}
 	l.cn.Close()
 	l.connectionLock.Unlock()
 	// There might be a query in-flight; make sure nobody's waiting for a
 	// response to it, since there's not going to be one.
 	close(l.replyChan)
 	// let the listener know we're done
 	close(l.notificationChan)
 	// this ListenerConn is done
 }
 // Listen sends a LISTEN query to the server. See ExecSimpleQuery.
 func (l *ListenerConn) Listen(channel string) (bool, error) {
 	return l.ExecSimpleQuery("LISTEN " + QuoteIdentifier(channel))
 }
 // Unlisten sends an UNLISTEN query to the server. See ExecSimpleQuery.
 func (l *ListenerConn) Unlisten(channel string) (bool, error) {
 	return l.ExecSimpleQuery("UNLISTEN " + QuoteIdentifier(channel))
 }
 // UnlistenAll sends an `UNLISTEN *` query to the server. See ExecSimpleQuery.
 func (l *ListenerConn) UnlistenAll() (bool, error) {
 	return l.ExecSimpleQuery("UNLISTEN *")
 }
 // Ping the remote server to make sure it's alive.  Non-nil error means the
 // connection has failed and should be abandoned.
 func (l *ListenerConn) Ping() error {
 	sent, err := l.ExecSimpleQuery("")
 	if !sent {
 		return err
 	}
 	if err != nil {
 		// shouldn't happen
 		panic(err)
 	}
 	return nil
 }
 // Attempt to send a query on the connection.  Returns an error if sending the
 // query failed, and the caller should initiate closure of this connection.
 // The caller must be holding senderLock (see acquireSenderLock and
 // releaseSenderLock).
 func (l *ListenerConn) sendSimpleQuery(q string) (err error) {
 	defer errRecoverNoErrBadConn(&err)
 	// must set connection state before sending the query
 	if !l.setState(connStateExpectResponse) {
 		panic("two queries running at the same time")
 	}
 	// Can't use l.cn.writeBuf here because it uses the scratch buffer which
 	// might get overwritten by listenerConnLoop.
 	b := &writeBuf{
 		buf: []byte("Q\x00\x00\x00\x00"),
 		pos: 1,
 	}
 	b.string(q)
 	l.cn.send(b)
 	return nil
 }
 // ExecSimpleQuery executes a "simple query" (i.e. one with no bindable
 // parameters) on the connection. The possible return values are:
 //   1) "executed" is true; the query was executed to completion on the
 //      database server.  If the query failed, err will be set to the error
 //      returned by the database, otherwise err will be nil.
 //   2) If "executed" is false, the query could not be executed on the remote
 //      server.  err will be non-nil.
 //
 // After a call to ExecSimpleQuery has returned an executed=false value, the
 // connection has either been closed or will be closed shortly thereafter, and
 // all subsequently executed queries will return an error.
 func (l *ListenerConn) ExecSimpleQuery(q string) (executed bool, err error) {
 	if err = l.acquireSenderLock(); err != nil {
 		return false, err
 	}
 	defer l.releaseSenderLock()
 	err = l.sendSimpleQuery(q)
 	if err != nil {
 		// We can't know what state the protocol is in, so we need to abandon
 		// this connection.
 		l.connectionLock.Lock()
 		// Set the error pointer if it hasn't been set already; see
 		// listenerConnMain.
 		if l.err == nil {
 			l.err = err
 		}
 		l.connectionLock.Unlock()
 		l.cn.c.Close()
 		return false, err
 	}
 	// now we just wait for a reply..
 	for {
 		m, ok := <-l.replyChan
 		if !ok {
 			// We lost the connection to server, don't bother waiting for a
 			// a response.  err should have been set already.
 			l.connectionLock.Lock()
 			err := l.err
 			l.connectionLock.Unlock()
 			return false, err
 		}
 		switch m.typ {
 		case 'Z':
 			// sanity check
 			if m.err != nil {
 				panic("m.err != nil")
 			}
 			// done; err might or might not be set
 			return true, err
 		case 'E':
 			// sanity check
 			if m.err == nil {
 				panic("m.err == nil")
 			}
 			// server responded with an error; ReadyForQuery to follow
 			err = m.err
 		default:
 			return false, fmt.Errorf("unknown response for simple query: %q", m.typ)
 		}
 	}
 }
 // Close closes the connection.
 func (l *ListenerConn) Close() error {
 	l.connectionLock.Lock()
 	if l.err != nil {
 		l.connectionLock.Unlock()
 		return errListenerConnClosed
 	}
 	l.err = errListenerConnClosed
 	l.connectionLock.Unlock()
 	// We can't send anything on the connection without holding senderLock.
 	// Simply close the net.Conn to wake up everyone operating on it.
 	return l.cn.c.Close()
 }
 // Err returns the reason the connection was closed. It is not safe to call
 // this function until l.Notify has been closed.
 func (l *ListenerConn) Err() error {
 	return l.err
 }
 var errListenerClosed = errors.New("pq: Listener has been closed")
 // ErrChannelAlreadyOpen is returned from Listen when a channel is already
 // open.
 var ErrChannelAlreadyOpen = errors.New("pq: channel is already open")
 // ErrChannelNotOpen is returned from Unlisten when a channel is not open.
 var ErrChannelNotOpen = errors.New("pq: channel is not open")
 // ListenerEventType is an enumeration of listener event types.
 type ListenerEventType int
 const (
 	// ListenerEventConnected is emitted only when the database connection
 	// has been initially initialized. The err argument of the callback
 	// will always be nil.
 	ListenerEventConnected ListenerEventType = iota
 	// ListenerEventDisconnected is emitted after a database connection has
 	// been lost, either because of an error or because Close has been
 	// called. The err argument will be set to the reason the database
 	// connection was lost.
 	ListenerEventDisconnected
 	// ListenerEventReconnected is emitted after a database connection has
 	// been re-established after connection loss. The err argument of the
 	// callback will always be nil. After this event has been emitted, a
 	// nil pq.Notification is sent on the Listener.Notify channel.
 	ListenerEventReconnected
 	// ListenerEventConnectionAttemptFailed is emitted after a connection
 	// to the database was attempted, but failed. The err argument will be
 	// set to an error describing why the connection attempt did not
 	// succeed.
 	ListenerEventConnectionAttemptFailed
 )
 // EventCallbackType is the event callback type. See also ListenerEventType
 // constants' documentation.
 type EventCallbackType func(event ListenerEventType, err error)
 // Listener provides an interface for listening to notifications from a
 // PostgreSQL database.  For general usage information, see section
 // "Notifications".
 //
 // Listener can safely be used from concurrently running goroutines.
 type Listener struct {
 	// Channel for receiving notifications from the database.  In some cases a
 	// nil value will be sent.  See section "Notifications" above.
 	Notify chan *Notification
 	name                 string
 	minReconnectInterval time.Duration
 	maxReconnectInterval time.Duration
 	dialer               Dialer
 	eventCallback        EventCallbackType
 	lock                 sync.Mutex
 	isClosed             bool
 	reconnectCond        *sync.Cond
 	cn                   *ListenerConn
 	connNotificationChan <-chan *Notification
 	channels             map[string]struct{}
 }
 // NewListener creates a new database connection dedicated to LISTEN / NOTIFY.
 //
 // name should be set to a connection string to be used to establish the
 // database connection (see section "Connection String Parameters" above).
 //
 // minReconnectInterval controls the duration to wait before trying to
 // re-establish the database connection after connection loss.  After each
 // consecutive failure this interval is doubled, until maxReconnectInterval is
 // reached.  Successfully completing the connection establishment procedure
 // resets the interval back to minReconnectInterval.
 //
 // The last parameter eventCallback can be set to a function which will be
 // called by the Listener when the state of the underlying database connection
 // changes.  This callback will be called by the goroutine which dispatches the
 // notifications over the Notify channel, so you should try to avoid doing
 // potentially time-consuming operations from the callback.
 func NewListener(name string,
 	minReconnectInterval time.Duration,
 	maxReconnectInterval time.Duration,
 	eventCallback EventCallbackType) *Listener {
 	return NewDialListener(defaultDialer{}, name, minReconnectInterval, maxReconnectInterval, eventCallback)
 }
 // NewDialListener is like NewListener but it takes a Dialer.
 func NewDialListener(d Dialer,
 	name string,
 	minReconnectInterval time.Duration,
 	maxReconnectInterval time.Duration,
 	eventCallback EventCallbackType) *Listener {
 	l := &Listener{
 		name:                 name,
 		minReconnectInterval: minReconnectInterval,
 		maxReconnectInterval: maxReconnectInterval,
 		dialer:               d,
 		eventCallback:        eventCallback,
 		channels: make(map[string]struct{}),
 		Notify: make(chan *Notification, 32),
 	}
 	l.reconnectCond = sync.NewCond(&l.lock)
 	go l.listenerMain()
 	return l
 }
 // NotificationChannel returns the notification channel for this listener.
 // This is the same channel as Notify, and will not be recreated during the
 // life time of the Listener.
 func (l *Listener) NotificationChannel() <-chan *Notification {
 	return l.Notify
 }
 // Listen starts listening for notifications on a channel.  Calls to this
 // function will block until an acknowledgement has been received from the
 // server.  Note that Listener automatically re-establishes the connection
 // after connection loss, so this function may block indefinitely if the
 // connection can not be re-established.
 //
 // Listen will only fail in three conditions:
 //   1) The channel is already open.  The returned error will be
 //      ErrChannelAlreadyOpen.
 //   2) The query was executed on the remote server, but PostgreSQL returned an
 //      error message in response to the query.  The returned error will be a
 //      pq.Error containing the information the server supplied.
 //   3) Close is called on the Listener before the request could be completed.
 //
 // The channel name is case-sensitive.
 func (l *Listener) Listen(channel string) error {
 	l.lock.Lock()
 	defer l.lock.Unlock()
 	if l.isClosed {
 		return errListenerClosed
 	}
 	// The server allows you to issue a LISTEN on a channel which is already
 	// open, but it seems useful to be able to detect this case to spot for
 	// mistakes in application logic.  If the application genuinely does't
 	// care, it can check the exported error and ignore it.
 	_, exists := l.channels[channel]
 	if exists {
 		return ErrChannelAlreadyOpen
 	}
 	if l.cn != nil {
 		// If gotResponse is true but error is set, the query was executed on
 		// the remote server, but resulted in an error.  This should be
 		// relatively rare, so it's fine if we just pass the error to our
 		// caller.  However, if gotResponse is false, we could not complete the
 		// query on the remote server and our underlying connection is about
 		// to go away, so we only add relname to l.channels, and wait for
 		// resync() to take care of the rest.
 		gotResponse, err := l.cn.Listen(channel)
 		if gotResponse && err != nil {
 			return err
 		}
 	}
 	l.channels[channel] = struct{}{}
 	for l.cn == nil {
 		l.reconnectCond.Wait()
 		// we let go of the mutex for a while
 		if l.isClosed {
 			return errListenerClosed
 		}
 	}
 	return nil
 }
 // Unlisten removes a channel from the Listener's channel list.  Returns
 // ErrChannelNotOpen if the Listener is not listening on the specified channel.
 // Returns immediately with no error if there is no connection.  Note that you
 // might still get notifications for this channel even after Unlisten has
 // returned.
 //
 // The channel name is case-sensitive.
 func (l *Listener) Unlisten(channel string) error {
 	l.lock.Lock()
 	defer l.lock.Unlock()
 	if l.isClosed {
 		return errListenerClosed
 	}
 	// Similarly to LISTEN, this is not an error in Postgres, but it seems
 	// useful to distinguish from the normal conditions.
 	_, exists := l.channels[channel]
 	if !exists {
 		return ErrChannelNotOpen
 	}
 	if l.cn != nil {
 		// Similarly to Listen (see comment in that function), the caller
 		// should only be bothered with an error if it came from the backend as
 		// a response to our query.
 		gotResponse, err := l.cn.Unlisten(channel)
 		if gotResponse && err != nil {
 			return err
 		}
 	}
 	// Don't bother waiting for resync if there's no connection.
 	delete(l.channels, channel)
 	return nil
 }
 // UnlistenAll removes all channels from the Listener's channel list.  Returns
 // immediately with no error if there is no connection.  Note that you might
 // still get notifications for any of the deleted channels even after
 // UnlistenAll has returned.
 func (l *Listener) UnlistenAll() error {
 	l.lock.Lock()
 	defer l.lock.Unlock()
 	if l.isClosed {
 		return errListenerClosed
 	}
 	if l.cn != nil {
 		// Similarly to Listen (see comment in that function), the caller
 		// should only be bothered with an error if it came from the backend as
 		// a response to our query.
 		gotResponse, err := l.cn.UnlistenAll()
 		if gotResponse && err != nil {
 			return err
 		}
 	}
 	// Don't bother waiting for resync if there's no connection.
 	l.channels = make(map[string]struct{})
 	return nil
 }
 // Ping the remote server to make sure it's alive.  Non-nil return value means
 // that there is no active connection.
 func (l *Listener) Ping() error {
 	l.lock.Lock()
 	defer l.lock.Unlock()
 	if l.isClosed {
 		return errListenerClosed
 	}
 	if l.cn == nil {
 		return errors.New("no connection")
 	}
 	return l.cn.Ping()
 }
 // Clean up after losing the server connection.  Returns l.cn.Err(), which
 // should have the reason the connection was lost.
 func (l *Listener) disconnectCleanup() error {
 	l.lock.Lock()
 	defer l.lock.Unlock()
 	// sanity check; can't look at Err() until the channel has been closed
 	select {
 	case _, ok := <-l.connNotificationChan:
 		if ok {
 			panic("connNotificationChan not closed")
 		}
 	default:
 		panic("connNotificationChan not closed")
 	}
 	err := l.cn.Err()
 	l.cn.Close()
 	l.cn = nil
 	return err
 }
 // Synchronize the list of channels we want to be listening on with the server
 // after the connection has been established.
 func (l *Listener) resync(cn *ListenerConn, notificationChan <-chan *Notification) error {
 	doneChan := make(chan error)
 	go func(notificationChan <-chan *Notification) {
 		for channel := range l.channels {
 			// If we got a response, return that error to our caller as it's
 			// going to be more descriptive than cn.Err().
 			gotResponse, err := cn.Listen(channel)
 			if gotResponse && err != nil {
 				doneChan <- err
 				return
 			}
 			// If we couldn't reach the server, wait for notificationChan to
 			// close and then return the error message from the connection, as
 			// per ListenerConn's interface.
 			if err != nil {
 				for range notificationChan {
 				}
 				doneChan <- cn.Err()
 				return
 			}
 		}
 		doneChan <- nil
 	}(notificationChan)
 	// Ignore notifications while synchronization is going on to avoid
 	// deadlocks.  We have to send a nil notification over Notify anyway as
 	// we can't possibly know which notifications (if any) were lost while
 	// the connection was down, so there's no reason to try and process
 	// these messages at all.
 	for {
 		select {
 		case _, ok := <-notificationChan:
 			if !ok {
 				notificationChan = nil
 			}
 		case err := <-doneChan:
 			return err
 		}
 	}
 }
 // caller should NOT be holding l.lock
 func (l *Listener) closed() bool {
 	l.lock.Lock()
 	defer l.lock.Unlock()
 	return l.isClosed
 }
 func (l *Listener) connect() error {
 	notificationChan := make(chan *Notification, 32)
 	cn, err := newDialListenerConn(l.dialer, l.name, notificationChan)
 	if err != nil {
 		return err
 	}
 	l.lock.Lock()
 	defer l.lock.Unlock()
 	err = l.resync(cn, notificationChan)
 	if err != nil {
 		cn.Close()
 		return err
 	}
 	l.cn = cn
 	l.connNotificationChan = notificationChan
 	l.reconnectCond.Broadcast()
 	return nil
 }
 // Close disconnects the Listener from the database and shuts it down.
 // Subsequent calls to its methods will return an error.  Close returns an
 // error if the connection has already been closed.
 func (l *Listener) Close() error {
 	l.lock.Lock()
 	defer l.lock.Unlock()
 	if l.isClosed {
 		return errListenerClosed
 	}
 	if l.cn != nil {
 		l.cn.Close()
 	}
 	l.isClosed = true
 	// Unblock calls to Listen()
 	l.reconnectCond.Broadcast()
 	return nil
 }
 func (l *Listener) emitEvent(event ListenerEventType, err error) {
 	if l.eventCallback != nil {
 		l.eventCallback(event, err)
 	}
 }
 // Main logic here: maintain a connection to the server when possible, wait
 // for notifications and emit events.
 func (l *Listener) listenerConnLoop() {
 	var nextReconnect time.Time
 	reconnectInterval := l.minReconnectInterval
 	for {
 		for {
 			err := l.connect()
 			if err == nil {
 				break
 			}
 			if l.closed() {
 				return
 			}
 			l.emitEvent(ListenerEventConnectionAttemptFailed, err)
 			time.Sleep(reconnectInterval)
 			reconnectInterval *= 2
 			if reconnectInterval > l.maxReconnectInterval {
 				reconnectInterval = l.maxReconnectInterval
 			}
 		}
 		if nextReconnect.IsZero() {
 			l.emitEvent(ListenerEventConnected, nil)
 		} else {
 			l.emitEvent(ListenerEventReconnected, nil)
 			l.Notify <- nil
 		}
 		reconnectInterval = l.minReconnectInterval
 		nextReconnect = time.Now().Add(reconnectInterval)
 		for {
 			notification, ok := <-l.connNotificationChan
 			if !ok {
 				// lost connection, loop again
 				break
 			}
 			l.Notify <- notification
 		}
 		err := l.disconnectCleanup()
 		if l.closed() {
 			return
 		}
 		l.emitEvent(ListenerEventDisconnected, err)
 		time.Sleep(time.Until(nextReconnect))
 	}
 }
 func (l *Listener) listenerMain() {
 	l.listenerConnLoop()
 	close(l.Notify)
 }
--- a/vendor/github.com/lib/pq/oid/doc.go
+++ b/vendor/github.com/lib/pq/oid/doc.go
@ -0,0 +1,6 @@
 // Package oid contains OID constants
 // as defined by the Postgres server.
 package oid
 // Oid is a Postgres Object ID.
 type Oid uint32
--- a/vendor/github.com/lib/pq/oid/types.go
+++ b/vendor/github.com/lib/pq/oid/types.go
@ -0,0 +1,343 @@
 // Code generated by gen.go. DO NOT EDIT.
 package oid
 const (
 	T_bool             Oid = 16
 	T_bytea            Oid = 17
 	T_char             Oid = 18
 	T_name             Oid = 19
 	T_int8             Oid = 20
 	T_int2             Oid = 21
 	T_int2vector       Oid = 22
 	T_int4             Oid = 23
 	T_regproc          Oid = 24
 	T_text             Oid = 25
 	T_oid              Oid = 26
 	T_tid              Oid = 27
 	T_xid              Oid = 28
 	T_cid              Oid = 29
 	T_oidvector        Oid = 30
 	T_pg_ddl_command   Oid = 32
 	T_pg_type          Oid = 71
 	T_pg_attribute     Oid = 75
 	T_pg_proc          Oid = 81
 	T_pg_class         Oid = 83
 	T_json             Oid = 114
 	T_xml              Oid = 142
 	T__xml             Oid = 143
 	T_pg_node_tree     Oid = 194
 	T__json            Oid = 199
 	T_smgr             Oid = 210
 	T_index_am_handler Oid = 325
 	T_point            Oid = 600
 	T_lseg             Oid = 601
 	T_path             Oid = 602
 	T_box              Oid = 603
 	T_polygon          Oid = 604
 	T_line             Oid = 628
 	T__line            Oid = 629
 	T_cidr             Oid = 650
 	T__cidr            Oid = 651
 	T_float4           Oid = 700
 	T_float8           Oid = 701
 	T_abstime          Oid = 702
 	T_reltime          Oid = 703
 	T_tinterval        Oid = 704
 	T_unknown          Oid = 705
 	T_circle           Oid = 718
 	T__circle          Oid = 719
 	T_money            Oid = 790
 	T__money           Oid = 791
 	T_macaddr          Oid = 829
 	T_inet             Oid = 869
 	T__bool            Oid = 1000
 	T__bytea           Oid = 1001
 	T__char            Oid = 1002
 	T__name            Oid = 1003
 	T__int2            Oid = 1005
 	T__int2vector      Oid = 1006
 	T__int4            Oid = 1007
 	T__regproc         Oid = 1008
 	T__text            Oid = 1009
 	T__tid             Oid = 1010
 	T__xid             Oid = 1011
 	T__cid             Oid = 1012
 	T__oidvector       Oid = 1013
 	T__bpchar          Oid = 1014
 	T__varchar         Oid = 1015
 	T__int8            Oid = 1016
 	T__point           Oid = 1017
 	T__lseg            Oid = 1018
 	T__path            Oid = 1019
 	T__box             Oid = 1020
 	T__float4          Oid = 1021
 	T__float8          Oid = 1022
 	T__abstime         Oid = 1023
 	T__reltime         Oid = 1024
 	T__tinterval       Oid = 1025
 	T__polygon         Oid = 1027
 	T__oid             Oid = 1028
 	T_aclitem          Oid = 1033
 	T__aclitem         Oid = 1034
 	T__macaddr         Oid = 1040
 	T__inet            Oid = 1041
 	T_bpchar           Oid = 1042
 	T_varchar          Oid = 1043
 	T_date             Oid = 1082
 	T_time             Oid = 1083
 	T_timestamp        Oid = 1114
 	T__timestamp       Oid = 1115
 	T__date            Oid = 1182
 	T__time            Oid = 1183
 	T_timestamptz      Oid = 1184
 	T__timestamptz     Oid = 1185
 	T_interval         Oid = 1186
 	T__interval        Oid = 1187
 	T__numeric         Oid = 1231
 	T_pg_database      Oid = 1248
 	T__cstring         Oid = 1263
 	T_timetz           Oid = 1266
 	T__timetz          Oid = 1270
 	T_bit              Oid = 1560
 	T__bit             Oid = 1561
 	T_varbit           Oid = 1562
 	T__varbit          Oid = 1563
 	T_numeric          Oid = 1700
 	T_refcursor        Oid = 1790
 	T__refcursor       Oid = 2201
 	T_regprocedure     Oid = 2202
 	T_regoper          Oid = 2203
 	T_regoperator      Oid = 2204
 	T_regclass         Oid = 2205
 	T_regtype          Oid = 2206
 	T__regprocedure    Oid = 2207
 	T__regoper         Oid = 2208
 	T__regoperator     Oid = 2209
 	T__regclass        Oid = 2210
 	T__regtype         Oid = 2211
 	T_record           Oid = 2249
 	T_cstring          Oid = 2275
 	T_any              Oid = 2276
 	T_anyarray         Oid = 2277
 	T_void             Oid = 2278
 	T_trigger          Oid = 2279
 	T_language_handler Oid = 2280
 	T_internal         Oid = 2281
 	T_opaque           Oid = 2282
 	T_anyelement       Oid = 2283
 	T__record          Oid = 2287
 	T_anynonarray      Oid = 2776
 	T_pg_authid        Oid = 2842
 	T_pg_auth_members  Oid = 2843
 	T__txid_snapshot   Oid = 2949
 	T_uuid             Oid = 2950
 	T__uuid            Oid = 2951
 	T_txid_snapshot    Oid = 2970
 	T_fdw_handler      Oid = 3115
 	T_pg_lsn           Oid = 3220
 	T__pg_lsn          Oid = 3221
 	T_tsm_handler      Oid = 3310
 	T_anyenum          Oid = 3500
 	T_tsvector         Oid = 3614
 	T_tsquery          Oid = 3615
 	T_gtsvector        Oid = 3642
 	T__tsvector        Oid = 3643
 	T__gtsvector       Oid = 3644
 	T__tsquery         Oid = 3645
 	T_regconfig        Oid = 3734
 	T__regconfig       Oid = 3735
 	T_regdictionary    Oid = 3769
 	T__regdictionary   Oid = 3770
 	T_jsonb            Oid = 3802
 	T__jsonb           Oid = 3807
 	T_anyrange         Oid = 3831
 	T_event_trigger    Oid = 3838
 	T_int4range        Oid = 3904
 	T__int4range       Oid = 3905
 	T_numrange         Oid = 3906
 	T__numrange        Oid = 3907
 	T_tsrange          Oid = 3908
 	T__tsrange         Oid = 3909
 	T_tstzrange        Oid = 3910
 	T__tstzrange       Oid = 3911
 	T_daterange        Oid = 3912
 	T__daterange       Oid = 3913
 	T_int8range        Oid = 3926
 	T__int8range       Oid = 3927
 	T_pg_shseclabel    Oid = 4066
 	T_regnamespace     Oid = 4089
 	T__regnamespace    Oid = 4090
 	T_regrole          Oid = 4096
 	T__regrole         Oid = 4097
 )
 var TypeName = map[Oid]string{
 	T_bool:             "BOOL",
 	T_bytea:            "BYTEA",
 	T_char:             "CHAR",
 	T_name:             "NAME",
 	T_int8:             "INT8",
 	T_int2:             "INT2",
 	T_int2vector:       "INT2VECTOR",
 	T_int4:             "INT4",
 	T_regproc:          "REGPROC",
 	T_text:             "TEXT",
 	T_oid:              "OID",
 	T_tid:              "TID",
 	T_xid:              "XID",
 	T_cid:              "CID",
 	T_oidvector:        "OIDVECTOR",
 	T_pg_ddl_command:   "PG_DDL_COMMAND",
 	T_pg_type:          "PG_TYPE",
 	T_pg_attribute:     "PG_ATTRIBUTE",
 	T_pg_proc:          "PG_PROC",
 	T_pg_class:         "PG_CLASS",
 	T_json:             "JSON",
 	T_xml:              "XML",
 	T__xml:             "_XML",
 	T_pg_node_tree:     "PG_NODE_TREE",
 	T__json:            "_JSON",
 	T_smgr:             "SMGR",
 	T_index_am_handler: "INDEX_AM_HANDLER",
 	T_point:            "POINT",
 	T_lseg:             "LSEG",
 	T_path:             "PATH",
 	T_box:              "BOX",
 	T_polygon:          "POLYGON",
 	T_line:             "LINE",
 	T__line:            "_LINE",
 	T_cidr:             "CIDR",
 	T__cidr:            "_CIDR",
 	T_float4:           "FLOAT4",
 	T_float8:           "FLOAT8",
 	T_abstime:          "ABSTIME",
 	T_reltime:          "RELTIME",
 	T_tinterval:        "TINTERVAL",
 	T_unknown:          "UNKNOWN",
 	T_circle:           "CIRCLE",
 	T__circle:          "_CIRCLE",
 	T_money:            "MONEY",
 	T__money:           "_MONEY",
 	T_macaddr:          "MACADDR",
 	T_inet:             "INET",
 	T__bool:            "_BOOL",
 	T__bytea:           "_BYTEA",
 	T__char:            "_CHAR",
 	T__name:            "_NAME",
 	T__int2:            "_INT2",
 	T__int2vector:      "_INT2VECTOR",
 	T__int4:            "_INT4",
 	T__regproc:         "_REGPROC",
 	T__text:            "_TEXT",
 	T__tid:             "_TID",
 	T__xid:             "_XID",
 	T__cid:             "_CID",
 	T__oidvector:       "_OIDVECTOR",
 	T__bpchar:          "_BPCHAR",
 	T__varchar:         "_VARCHAR",
 	T__int8:            "_INT8",
 	T__point:           "_POINT",
 	T__lseg:            "_LSEG",
 	T__path:            "_PATH",
 	T__box:             "_BOX",
 	T__float4:          "_FLOAT4",
 	T__float8:          "_FLOAT8",
 	T__abstime:         "_ABSTIME",
 	T__reltime:         "_RELTIME",
 	T__tinterval:       "_TINTERVAL",
 	T__polygon:         "_POLYGON",
 	T__oid:             "_OID",
 	T_aclitem:          "ACLITEM",
 	T__aclitem:         "_ACLITEM",
 	T__macaddr:         "_MACADDR",
 	T__inet:            "_INET",
 	T_bpchar:           "BPCHAR",
 	T_varchar:          "VARCHAR",
 	T_date:             "DATE",
 	T_time:             "TIME",
 	T_timestamp:        "TIMESTAMP",
 	T__timestamp:       "_TIMESTAMP",
 	T__date:            "_DATE",
 	T__time:            "_TIME",
 	T_timestamptz:      "TIMESTAMPTZ",
 	T__timestamptz:     "_TIMESTAMPTZ",
 	T_interval:         "INTERVAL",
 	T__interval:        "_INTERVAL",
 	T__numeric:         "_NUMERIC",
 	T_pg_database:      "PG_DATABASE",
 	T__cstring:         "_CSTRING",
 	T_timetz:           "TIMETZ",
 	T__timetz:          "_TIMETZ",
 	T_bit:              "BIT",
 	T__bit:             "_BIT",
 	T_varbit:           "VARBIT",
 	T__varbit:          "_VARBIT",
 	T_numeric:          "NUMERIC",
 	T_refcursor:        "REFCURSOR",
 	T__refcursor:       "_REFCURSOR",
 	T_regprocedure:     "REGPROCEDURE",
 	T_regoper:          "REGOPER",
 	T_regoperator:      "REGOPERATOR",
 	T_regclass:         "REGCLASS",
 	T_regtype:          "REGTYPE",
 	T__regprocedure:    "_REGPROCEDURE",
 	T__regoper:         "_REGOPER",
 	T__regoperator:     "_REGOPERATOR",
 	T__regclass:        "_REGCLASS",
 	T__regtype:         "_REGTYPE",
 	T_record:           "RECORD",
 	T_cstring:          "CSTRING",
 	T_any:              "ANY",
 	T_anyarray:         "ANYARRAY",
 	T_void:             "VOID",
 	T_trigger:          "TRIGGER",
 	T_language_handler: "LANGUAGE_HANDLER",
 	T_internal:         "INTERNAL",
 	T_opaque:           "OPAQUE",
 	T_anyelement:       "ANYELEMENT",
 	T__record:          "_RECORD",
 	T_anynonarray:      "ANYNONARRAY",
 	T_pg_authid:        "PG_AUTHID",
 	T_pg_auth_members:  "PG_AUTH_MEMBERS",
 	T__txid_snapshot:   "_TXID_SNAPSHOT",
 	T_uuid:             "UUID",
 	T__uuid:            "_UUID",
 	T_txid_snapshot:    "TXID_SNAPSHOT",
 	T_fdw_handler:      "FDW_HANDLER",
 	T_pg_lsn:           "PG_LSN",
 	T__pg_lsn:          "_PG_LSN",
 	T_tsm_handler:      "TSM_HANDLER",
 	T_anyenum:          "ANYENUM",
 	T_tsvector:         "TSVECTOR",
 	T_tsquery:          "TSQUERY",
 	T_gtsvector:        "GTSVECTOR",
 	T__tsvector:        "_TSVECTOR",
 	T__gtsvector:       "_GTSVECTOR",
 	T__tsquery:         "_TSQUERY",
 	T_regconfig:        "REGCONFIG",
 	T__regconfig:       "_REGCONFIG",
 	T_regdictionary:    "REGDICTIONARY",
 	T__regdictionary:   "_REGDICTIONARY",
 	T_jsonb:            "JSONB",
 	T__jsonb:           "_JSONB",
 	T_anyrange:         "ANYRANGE",
 	T_event_trigger:    "EVENT_TRIGGER",
 	T_int4range:        "INT4RANGE",
 	T__int4range:       "_INT4RANGE",
 	T_numrange:         "NUMRANGE",
 	T__numrange:        "_NUMRANGE",
 	T_tsrange:          "TSRANGE",
 	T__tsrange:         "_TSRANGE",
 	T_tstzrange:        "TSTZRANGE",
 	T__tstzrange:       "_TSTZRANGE",
 	T_daterange:        "DATERANGE",
 	T__daterange:       "_DATERANGE",
 	T_int8range:        "INT8RANGE",
 	T__int8range:       "_INT8RANGE",
 	T_pg_shseclabel:    "PG_SHSECLABEL",
 	T_regnamespace:     "REGNAMESPACE",
 	T__regnamespace:    "_REGNAMESPACE",
 	T_regrole:          "REGROLE",
 	T__regrole:         "_REGROLE",
 }
--- a/vendor/github.com/lib/pq/rows.go
+++ b/vendor/github.com/lib/pq/rows.go
@ -0,0 +1,93 @@
 package pq
 import (
 	"math"
 	"reflect"
 	"time"
 	"github.com/lib/pq/oid"
 )
 const headerSize = 4
 type fieldDesc struct {
 	// The object ID of the data type.
 	OID oid.Oid
 	// The data type size (see pg_type.typlen).
 	// Note that negative values denote variable-width types.
 	Len int
 	// The type modifier (see pg_attribute.atttypmod).
 	// The meaning of the modifier is type-specific.
 	Mod int
 }
 func (fd fieldDesc) Type() reflect.Type {
 	switch fd.OID {
 	case oid.T_int8:
 		return reflect.TypeOf(int64(0))
 	case oid.T_int4:
 		return reflect.TypeOf(int32(0))
 	case oid.T_int2:
 		return reflect.TypeOf(int16(0))
 	case oid.T_varchar, oid.T_text:
 		return reflect.TypeOf("")
 	case oid.T_bool:
 		return reflect.TypeOf(false)
 	case oid.T_date, oid.T_time, oid.T_timetz, oid.T_timestamp, oid.T_timestamptz:
 		return reflect.TypeOf(time.Time{})
 	case oid.T_bytea:
 		return reflect.TypeOf([]byte(nil))
 	default:
 		return reflect.TypeOf(new(interface{})).Elem()
 	}
 }
 func (fd fieldDesc) Name() string {
 	return oid.TypeName[fd.OID]
 }
 func (fd fieldDesc) Length() (length int64, ok bool) {
 	switch fd.OID {
 	case oid.T_text, oid.T_bytea:
 		return math.MaxInt64, true
 	case oid.T_varchar, oid.T_bpchar:
 		return int64(fd.Mod - headerSize), true
 	default:
 		return 0, false
 	}
 }
 func (fd fieldDesc) PrecisionScale() (precision, scale int64, ok bool) {
 	switch fd.OID {
 	case oid.T_numeric, oid.T__numeric:
 		mod := fd.Mod - headerSize
 		precision = int64((mod >> 16) & 0xffff)
 		scale = int64(mod & 0xffff)
 		return precision, scale, true
 	default:
 		return 0, 0, false
 	}
 }
 // ColumnTypeScanType returns the value type that can be used to scan types into.
 func (rs *rows) ColumnTypeScanType(index int) reflect.Type {
 	return rs.colTyps[index].Type()
 }
 // ColumnTypeDatabaseTypeName return the database system type name.
 func (rs *rows) ColumnTypeDatabaseTypeName(index int) string {
 	return rs.colTyps[index].Name()
 }
 // ColumnTypeLength returns the length of the column type if the column is a
 // variable length type. If the column is not a variable length type ok
 // should return false.
 func (rs *rows) ColumnTypeLength(index int) (length int64, ok bool) {
 	return rs.colTyps[index].Length()
 }
 // ColumnTypePrecisionScale should return the precision and scale for decimal
 // types. If not applicable, ok should be false.
 func (rs *rows) ColumnTypePrecisionScale(index int) (precision, scale int64, ok bool) {
 	return rs.colTyps[index].PrecisionScale()
 }
--- a/vendor/github.com/lib/pq/scram/scram.go
+++ b/vendor/github.com/lib/pq/scram/scram.go
@ -0,0 +1,264 @@
 // Copyright (c) 2014 - Gustavo Niemeyer <gustavo@niemeyer.net>
 //
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
 //
 // 1. Redistributions of source code must retain the above copyright notice, this
 //    list of conditions and the following disclaimer.
 // 2. Redistributions in binary form must reproduce the above copyright notice,
 //    this list of conditions and the following disclaimer in the documentation
 //    and/or other materials provided with the distribution.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 // ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // Pacakage scram implements a SCRAM-{SHA-1,etc} client per RFC5802.
 //
 // http://tools.ietf.org/html/rfc5802
 //
 package scram
 import (
 	"bytes"
 	"crypto/hmac"
 	"crypto/rand"
 	"encoding/base64"
 	"fmt"
 	"hash"
 	"strconv"
 	"strings"
 )
 // Client implements a SCRAM-* client (SCRAM-SHA-1, SCRAM-SHA-256, etc).
 //
 // A Client may be used within a SASL conversation with logic resembling:
 //
 //    var in []byte
 //    var client = scram.NewClient(sha1.New, user, pass)
 //    for client.Step(in) {
 //            out := client.Out()
 //            // send out to server
 //            in := serverOut
 //    }
 //    if client.Err() != nil {
 //            // auth failed
 //    }
 //
 type Client struct {
 	newHash func() hash.Hash
 	user string
 	pass string
 	step int
 	out  bytes.Buffer
 	err  error
 	clientNonce []byte
 	serverNonce []byte
 	saltedPass  []byte
 	authMsg     bytes.Buffer
 }
 // NewClient returns a new SCRAM-* client with the provided hash algorithm.
 //
 // For SCRAM-SHA-256, for example, use:
 //
 //    client := scram.NewClient(sha256.New, user, pass)
 //
 func NewClient(newHash func() hash.Hash, user, pass string) *Client {
 	c := &Client{
 		newHash: newHash,
 		user:    user,
 		pass:    pass,
 	}
 	c.out.Grow(256)
 	c.authMsg.Grow(256)
 	return c
 }
 // Out returns the data to be sent to the server in the current step.
 func (c *Client) Out() []byte {
 	if c.out.Len() == 0 {
 		return nil
 	}
 	return c.out.Bytes()
 }
 // Err returns the error that ocurred, or nil if there were no errors.
 func (c *Client) Err() error {
 	return c.err
 }
 // SetNonce sets the client nonce to the provided value.
 // If not set, the nonce is generated automatically out of crypto/rand on the first step.
 func (c *Client) SetNonce(nonce []byte) {
 	c.clientNonce = nonce
 }
 var escaper = strings.NewReplacer("=", "=3D", ",", "=2C")
 // Step processes the incoming data from the server and makes the
 // next round of data for the server available via Client.Out.
 // Step returns false if there are no errors and more data is
 // still expected.
 func (c *Client) Step(in []byte) bool {
 	c.out.Reset()
 	if c.step > 2 || c.err != nil {
 		return false
 	}
 	c.step++
 	switch c.step {
 	case 1:
 		c.err = c.step1(in)
 	case 2:
 		c.err = c.step2(in)
 	case 3:
 		c.err = c.step3(in)
 	}
 	return c.step > 2 || c.err != nil
 }
 func (c *Client) step1(in []byte) error {
 	if len(c.clientNonce) == 0 {
 		const nonceLen = 16
 		buf := make([]byte, nonceLen+b64.EncodedLen(nonceLen))
 		if _, err := rand.Read(buf[:nonceLen]); err != nil {
 			return fmt.Errorf("cannot read random SCRAM-SHA-256 nonce from operating system: %v", err)
 		}
 		c.clientNonce = buf[nonceLen:]
 		b64.Encode(c.clientNonce, buf[:nonceLen])
 	}
 	c.authMsg.WriteString("n=")
 	escaper.WriteString(&c.authMsg, c.user)
 	c.authMsg.WriteString(",r=")
 	c.authMsg.Write(c.clientNonce)
 	c.out.WriteString("n,,")
 	c.out.Write(c.authMsg.Bytes())
 	return nil
 }
 var b64 = base64.StdEncoding
 func (c *Client) step2(in []byte) error {
 	c.authMsg.WriteByte(',')
 	c.authMsg.Write(in)
 	fields := bytes.Split(in, []byte(","))
 	if len(fields) != 3 {
 		return fmt.Errorf("expected 3 fields in first SCRAM-SHA-256 server message, got %d: %q", len(fields), in)
 	}
 	if !bytes.HasPrefix(fields[0], []byte("r=")) || len(fields[0]) < 2 {
 		return fmt.Errorf("server sent an invalid SCRAM-SHA-256 nonce: %q", fields[0])
 	}
 	if !bytes.HasPrefix(fields[1], []byte("s=")) || len(fields[1]) < 6 {
 		return fmt.Errorf("server sent an invalid SCRAM-SHA-256 salt: %q", fields[1])
 	}
 	if !bytes.HasPrefix(fields[2], []byte("i=")) || len(fields[2]) < 6 {
 		return fmt.Errorf("server sent an invalid SCRAM-SHA-256 iteration count: %q", fields[2])
 	}
 	c.serverNonce = fields[0][2:]
 	if !bytes.HasPrefix(c.serverNonce, c.clientNonce) {
 		return fmt.Errorf("server SCRAM-SHA-256 nonce is not prefixed by client nonce: got %q, want %q+\"...\"", c.serverNonce, c.clientNonce)
 	}
 	salt := make([]byte, b64.DecodedLen(len(fields[1][2:])))
 	n, err := b64.Decode(salt, fields[1][2:])
 	if err != nil {
 		return fmt.Errorf("cannot decode SCRAM-SHA-256 salt sent by server: %q", fields[1])
 	}
 	salt = salt[:n]
 	iterCount, err := strconv.Atoi(string(fields[2][2:]))
 	if err != nil {
 		return fmt.Errorf("server sent an invalid SCRAM-SHA-256 iteration count: %q", fields[2])
 	}
 	c.saltPassword(salt, iterCount)
 	c.authMsg.WriteString(",c=biws,r=")
 	c.authMsg.Write(c.serverNonce)
 	c.out.WriteString("c=biws,r=")
 	c.out.Write(c.serverNonce)
 	c.out.WriteString(",p=")
 	c.out.Write(c.clientProof())
 	return nil
 }
 func (c *Client) step3(in []byte) error {
 	var isv, ise bool
 	var fields = bytes.Split(in, []byte(","))
 	if len(fields) == 1 {
 		isv = bytes.HasPrefix(fields[0], []byte("v="))
 		ise = bytes.HasPrefix(fields[0], []byte("e="))
 	}
 	if ise {
 		return fmt.Errorf("SCRAM-SHA-256 authentication error: %s", fields[0][2:])
 	} else if !isv {
 		return fmt.Errorf("unsupported SCRAM-SHA-256 final message from server: %q", in)
 	}
 	if !bytes.Equal(c.serverSignature(), fields[0][2:]) {
 		return fmt.Errorf("cannot authenticate SCRAM-SHA-256 server signature: %q", fields[0][2:])
 	}
 	return nil
 }
 func (c *Client) saltPassword(salt []byte, iterCount int) {
 	mac := hmac.New(c.newHash, []byte(c.pass))
 	mac.Write(salt)
 	mac.Write([]byte{0, 0, 0, 1})
 	ui := mac.Sum(nil)
 	hi := make([]byte, len(ui))
 	copy(hi, ui)
 	for i := 1; i < iterCount; i++ {
 		mac.Reset()
 		mac.Write(ui)
 		mac.Sum(ui[:0])
 		for j, b := range ui {
 			hi[j] ^= b
 		}
 	}
 	c.saltedPass = hi
 }
 func (c *Client) clientProof() []byte {
 	mac := hmac.New(c.newHash, c.saltedPass)
 	mac.Write([]byte("Client Key"))
 	clientKey := mac.Sum(nil)
 	hash := c.newHash()
 	hash.Write(clientKey)
 	storedKey := hash.Sum(nil)
 	mac = hmac.New(c.newHash, storedKey)
 	mac.Write(c.authMsg.Bytes())
 	clientProof := mac.Sum(nil)
 	for i, b := range clientKey {
 		clientProof[i] ^= b
 	}
 	clientProof64 := make([]byte, b64.EncodedLen(len(clientProof)))
 	b64.Encode(clientProof64, clientProof)
 	return clientProof64
 }
 func (c *Client) serverSignature() []byte {
 	mac := hmac.New(c.newHash, c.saltedPass)
 	mac.Write([]byte("Server Key"))
 	serverKey := mac.Sum(nil)
 	mac = hmac.New(c.newHash, serverKey)
 	mac.Write(c.authMsg.Bytes())
 	serverSignature := mac.Sum(nil)
 	encoded := make([]byte, b64.EncodedLen(len(serverSignature)))
 	b64.Encode(encoded, serverSignature)
 	return encoded
 }
--- a/vendor/github.com/lib/pq/ssl.go
+++ b/vendor/github.com/lib/pq/ssl.go
@ -0,0 +1,175 @@
 package pq
 import (
 	"crypto/tls"
 	"crypto/x509"
 	"io/ioutil"
 	"net"
 	"os"
 	"os/user"
 	"path/filepath"
 )
 // ssl generates a function to upgrade a net.Conn based on the "sslmode" and
 // related settings. The function is nil when no upgrade should take place.
 func ssl(o values) (func(net.Conn) (net.Conn, error), error) {
 	verifyCaOnly := false
 	tlsConf := tls.Config{}
 	switch mode := o["sslmode"]; mode {
 	// "require" is the default.
 	case "", "require":
 		// We must skip TLS's own verification since it requires full
 		// verification since Go 1.3.
 		tlsConf.InsecureSkipVerify = true
 		// From http://www.postgresql.org/docs/current/static/libpq-ssl.html:
 		//
 		// Note: For backwards compatibility with earlier versions of
 		// PostgreSQL, if a root CA file exists, the behavior of
 		// sslmode=require will be the same as that of verify-ca, meaning the
 		// server certificate is validated against the CA. Relying on this
 		// behavior is discouraged, and applications that need certificate
 		// validation should always use verify-ca or verify-full.
 		if sslrootcert, ok := o["sslrootcert"]; ok {
 			if _, err := os.Stat(sslrootcert); err == nil {
 				verifyCaOnly = true
 			} else {
 				delete(o, "sslrootcert")
 			}
 		}
 	case "verify-ca":
 		// We must skip TLS's own verification since it requires full
 		// verification since Go 1.3.
 		tlsConf.InsecureSkipVerify = true
 		verifyCaOnly = true
 	case "verify-full":
 		tlsConf.ServerName = o["host"]
 	case "disable":
 		return nil, nil
 	default:
 		return nil, fmterrorf(`unsupported sslmode %q; only "require" (default), "verify-full", "verify-ca", and "disable" supported`, mode)
 	}
 	err := sslClientCertificates(&tlsConf, o)
 	if err != nil {
 		return nil, err
 	}
 	err = sslCertificateAuthority(&tlsConf, o)
 	if err != nil {
 		return nil, err
 	}
 	// Accept renegotiation requests initiated by the backend.
 	//
 	// Renegotiation was deprecated then removed from PostgreSQL 9.5, but
 	// the default configuration of older versions has it enabled. Redshift
 	// also initiates renegotiations and cannot be reconfigured.
 	tlsConf.Renegotiation = tls.RenegotiateFreelyAsClient
 	return func(conn net.Conn) (net.Conn, error) {
 		client := tls.Client(conn, &tlsConf)
 		if verifyCaOnly {
 			err := sslVerifyCertificateAuthority(client, &tlsConf)
 			if err != nil {
 				return nil, err
 			}
 		}
 		return client, nil
 	}, nil
 }
 // sslClientCertificates adds the certificate specified in the "sslcert" and
 // "sslkey" settings, or if they aren't set, from the .postgresql directory
 // in the user's home directory. The configured files must exist and have
 // the correct permissions.
 func sslClientCertificates(tlsConf *tls.Config, o values) error {
 	// user.Current() might fail when cross-compiling. We have to ignore the
 	// error and continue without home directory defaults, since we wouldn't
 	// know from where to load them.
 	user, _ := user.Current()
 	// In libpq, the client certificate is only loaded if the setting is not blank.
 	//
 	// https://github.com/postgres/postgres/blob/REL9_6_2/src/interfaces/libpq/fe-secure-openssl.c#L1036-L1037
 	sslcert := o["sslcert"]
 	if len(sslcert) == 0 && user != nil {
 		sslcert = filepath.Join(user.HomeDir, ".postgresql", "postgresql.crt")
 	}
 	// https://github.com/postgres/postgres/blob/REL9_6_2/src/interfaces/libpq/fe-secure-openssl.c#L1045
 	if len(sslcert) == 0 {
 		return nil
 	}
 	// https://github.com/postgres/postgres/blob/REL9_6_2/src/interfaces/libpq/fe-secure-openssl.c#L1050:L1054
 	if _, err := os.Stat(sslcert); os.IsNotExist(err) {
 		return nil
 	} else if err != nil {
 		return err
 	}
 	// In libpq, the ssl key is only loaded if the setting is not blank.
 	//
 	// https://github.com/postgres/postgres/blob/REL9_6_2/src/interfaces/libpq/fe-secure-openssl.c#L1123-L1222
 	sslkey := o["sslkey"]
 	if len(sslkey) == 0 && user != nil {
 		sslkey = filepath.Join(user.HomeDir, ".postgresql", "postgresql.key")
 	}
 	if len(sslkey) > 0 {
 		if err := sslKeyPermissions(sslkey); err != nil {
 			return err
 		}
 	}
 	cert, err := tls.LoadX509KeyPair(sslcert, sslkey)
 	if err != nil {
 		return err
 	}
 	tlsConf.Certificates = []tls.Certificate{cert}
 	return nil
 }
 // sslCertificateAuthority adds the RootCA specified in the "sslrootcert" setting.
 func sslCertificateAuthority(tlsConf *tls.Config, o values) error {
 	// In libpq, the root certificate is only loaded if the setting is not blank.
 	//
 	// https://github.com/postgres/postgres/blob/REL9_6_2/src/interfaces/libpq/fe-secure-openssl.c#L950-L951
 	if sslrootcert := o["sslrootcert"]; len(sslrootcert) > 0 {
 		tlsConf.RootCAs = x509.NewCertPool()
 		cert, err := ioutil.ReadFile(sslrootcert)
 		if err != nil {
 			return err
 		}
 		if !tlsConf.RootCAs.AppendCertsFromPEM(cert) {
 			return fmterrorf("couldn't parse pem in sslrootcert")
 		}
 	}
 	return nil
 }
 // sslVerifyCertificateAuthority carries out a TLS handshake to the server and
 // verifies the presented certificate against the CA, i.e. the one specified in
 // sslrootcert or the system CA if sslrootcert was not specified.
 func sslVerifyCertificateAuthority(client *tls.Conn, tlsConf *tls.Config) error {
 	err := client.Handshake()
 	if err != nil {
 		return err
 	}
 	certs := client.ConnectionState().PeerCertificates
 	opts := x509.VerifyOptions{
 		DNSName:       client.ConnectionState().ServerName,
 		Intermediates: x509.NewCertPool(),
 		Roots:         tlsConf.RootCAs,
 	}
 	for i, cert := range certs {
 		if i == 0 {
 			continue
 		}
 		opts.Intermediates.AddCert(cert)
 	}
 	_, err = certs[0].Verify(opts)
 	return err
 }
--- a/vendor/github.com/lib/pq/ssl_permissions.go
+++ b/vendor/github.com/lib/pq/ssl_permissions.go
@ -0,0 +1,20 @@
 // +build !windows
 package pq
 import "os"
 // sslKeyPermissions checks the permissions on user-supplied ssl key files.
 // The key file should have very little access.
 //
 // libpq does not check key file permissions on Windows.
 func sslKeyPermissions(sslkey string) error {
 	info, err := os.Stat(sslkey)
 	if err != nil {
 		return err
 	}
 	if info.Mode().Perm()&0077 != 0 {
 		return ErrSSLKeyHasWorldPermissions
 	}
 	return nil
 }
--- a/vendor/github.com/lib/pq/ssl_windows.go
+++ b/vendor/github.com/lib/pq/ssl_windows.go
@ -0,0 +1,9 @@
 // +build windows
 package pq
 // sslKeyPermissions checks the permissions on user-supplied ssl key files.
 // The key file should have very little access.
 //
 // libpq does not check key file permissions on Windows.
 func sslKeyPermissions(string) error { return nil }
--- a/vendor/github.com/lib/pq/url.go
+++ b/vendor/github.com/lib/pq/url.go
@ -0,0 +1,76 @@
 package pq
 import (
 	"fmt"
 	"net"
 	nurl "net/url"
 	"sort"
 	"strings"
 )
 // ParseURL no longer needs to be used by clients of this library since supplying a URL as a
 // connection string to sql.Open() is now supported:
 //
 //	sql.Open("postgres", "postgres://bob:secret@1.2.3.4:5432/mydb?sslmode=verify-full")
 //
 // It remains exported here for backwards-compatibility.
 //
 // ParseURL converts a url to a connection string for driver.Open.
 // Example:
 //
 //	"postgres://bob:secret@1.2.3.4:5432/mydb?sslmode=verify-full"
 //
 // converts to:
 //
 //	"user=bob password=secret host=1.2.3.4 port=5432 dbname=mydb sslmode=verify-full"
 //
 // A minimal example:
 //
 //	"postgres://"
 //
 // This will be blank, causing driver.Open to use all of the defaults
 func ParseURL(url string) (string, error) {
 	u, err := nurl.Parse(url)
 	if err != nil {
 		return "", err
 	}
 	if u.Scheme != "postgres" && u.Scheme != "postgresql" {
 		return "", fmt.Errorf("invalid connection protocol: %s", u.Scheme)
 	}
 	var kvs []string
 	escaper := strings.NewReplacer(` `, `\ `, `'`, `\'`, `\`, `\\`)
 	accrue := func(k, v string) {
 		if v != "" {
 			kvs = append(kvs, k+"="+escaper.Replace(v))
 		}
 	}
 	if u.User != nil {
 		v := u.User.Username()
 		accrue("user", v)
 		v, _ = u.User.Password()
 		accrue("password", v)
 	}
 	if host, port, err := net.SplitHostPort(u.Host); err != nil {
 		accrue("host", u.Host)
 	} else {
 		accrue("host", host)
 		accrue("port", port)
 	}
 	if u.Path != "" {
 		accrue("dbname", u.Path[1:])
 	}
 	q := u.Query()
 	for k := range q {
 		accrue(k, q.Get(k))
 	}
 	sort.Strings(kvs) // Makes testing easier (not a performance concern)
 	return strings.Join(kvs, " "), nil
 }
--- a/Show More
+++ b/Show More