Migrate to dep (#3972)

* Update makefile to use dep * Migrate to dep * Fix some deps * Try to find a better version for golang.org/x/net * Try to find a better version for golang.org/x/oauth2
7 years ago · 3f3383dc0a
parent d7fd9bf7bb
commit 3f3383dc0a
281 changed files with 12024 additions and 32676 deletions
--- a/Gopkg.lock
+++ b/Gopkg.lock
@ -0,0 +1,875 @@
 # This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
 [[projects]]
  branch = "master"
  name = "code.gitea.io/git"
  packages = ["."]
  revision = "0077debc17a58c821f4e62e815a54c1ab52da157"
 [[projects]]
  branch = "master"
  name = "code.gitea.io/sdk"
  packages = ["gitea"]
  revision = "b2308e3f700875a3642a78bd3f6e5db8ef6f974d"
 [[projects]]
  name = "github.com/PuerkitoBio/goquery"
  packages = ["."]
  revision = "ed7d758e9a34ba1f55e8084e0d731448b46921a8"
 [[projects]]
  name = "github.com/RoaringBitmap/roaring"
  packages = ["."]
  revision = "1a28a7fa985680f9f4e1644c0a857ec359a444b0"
  version = "v0.4.7"
 [[projects]]
  branch = "master"
  name = "github.com/Smerity/govarint"
  packages = ["."]
  revision = "7265e41f48f15fd61751e16da866af3c704bb3ab"
 [[projects]]
  branch = "master"
  name = "github.com/Unknwon/cae"
  packages = [
    ".",
    "zip"
  ]
  revision = "c6aac99ea2cae2ebaf23f26f76b04fe3fcfc9f8c"
 [[projects]]
  branch = "master"
  name = "github.com/Unknwon/com"
  packages = ["."]
  revision = "7677a1d7c1137cd3dd5ba7a076d0c898a1ef4520"
 [[projects]]
  branch = "master"
  name = "github.com/Unknwon/i18n"
  packages = ["."]
  revision = "b64d336589669d317928070e70ba0ae558f16633"
 [[projects]]
  name = "github.com/Unknwon/paginater"
  packages = ["."]
  revision = "7748a72e01415173a27d79866b984328e7b0c12b"
 [[projects]]
  name = "github.com/andybalholm/cascadia"
  packages = ["."]
  revision = "349dd0209470eabd9514242c688c403c0926d266"
 [[projects]]
  name = "github.com/blevesearch/bleve"
  packages = [
    ".",
    "analysis",
    "analysis/analyzer/custom",
    "analysis/analyzer/standard",
    "analysis/datetime/flexible",
    "analysis/datetime/optional",
    "analysis/lang/en",
    "analysis/token/camelcase",
    "analysis/token/lowercase",
    "analysis/token/porter",
    "analysis/token/stop",
    "analysis/token/unicodenorm",
    "analysis/token/unique",
    "analysis/tokenizer/unicode",
    "document",
    "geo",
    "index",
    "index/scorch",
    "index/scorch/mergeplan",
    "index/scorch/segment",
    "index/scorch/segment/mem",
    "index/scorch/segment/zap",
    "index/store",
    "index/store/boltdb",
    "index/store/gtreap",
    "index/upsidedown",
    "mapping",
    "numeric",
    "registry",
    "search",
    "search/collector",
    "search/facet",
    "search/highlight",
    "search/highlight/format/html",
    "search/highlight/fragmenter/simple",
    "search/highlight/highlighter/html",
    "search/highlight/highlighter/simple",
    "search/query",
    "search/scorer",
    "search/searcher"
  ]
  revision = "ff210fbc6d348ad67aa5754eaea11a463fcddafd"
 [[projects]]
  branch = "master"
  name = "github.com/blevesearch/go-porterstemmer"
  packages = ["."]
  revision = "23a2c8e5cf1f380f27722c6d2ae8896431dc7d0e"
 [[projects]]
  name = "github.com/blevesearch/segment"
  packages = ["."]
  revision = "db70c57796cc8c310613541dfade3dce627d09c7"
 [[projects]]
  name = "github.com/boltdb/bolt"
  packages = ["."]
  revision = "ccd680d8c1a0179ac3d68f692b01e1a1589cbfc7"
  source = "github.com/go-gitea/bolt"
 [[projects]]
  name = "github.com/boombuler/barcode"
  packages = [
    ".",
    "qr",
    "utils"
  ]
  revision = "fe0f26ff6d26693948ee8189aa064ee8c54141fa"
 [[projects]]
  name = "github.com/bradfitz/gomemcache"
  packages = ["memcache"]
  revision = "fb1f79c6b65acda83063cbc69f6bba1522558bfc"
 [[projects]]
  name = "github.com/chaseadamsio/goorgeous"
  packages = ["."]
  revision = "098da33fde5f9220736531b3cb26a2dec86a8367"
 [[projects]]
  name = "github.com/coreos/etcd"
  packages = ["error"]
  revision = "01c303113d0a3d5a8075864321c3aedb72035bdd"
 [[projects]]
  branch = "master"
  name = "github.com/coreos/go-etcd"
  packages = ["etcd"]
  revision = "003851be7bb0694fe3cc457a49529a19388ee7cf"
 [[projects]]
  branch = "master"
  name = "github.com/couchbase/vellum"
  packages = [
    ".",
    "regexp",
    "utf8"
  ]
  revision = "eb6ae3743b3f300f2136f83ca78c08cc071edbd4"
 [[projects]]
  name = "github.com/davecgh/go-spew"
  packages = ["spew"]
  revision = "ecdeabc65495df2dec95d7c4a4c3e021903035e5"
 [[projects]]
  name = "github.com/denisenkom/go-mssqldb"
  packages = ["."]
  revision = "e32ca5036449b7ea12c62ed761ea1ad7fc88a4e2"
 [[projects]]
  name = "github.com/dgrijalva/jwt-go"
  packages = ["."]
  revision = "9ed569b5d1ac936e6494082958d63a6aa4fff99a"
 [[projects]]
  branch = "master"
  name = "github.com/edsrzf/mmap-go"
  packages = ["."]
  revision = "0bce6a6887123b67a60366d2c9fe2dfb74289d2e"
 [[projects]]
  name = "github.com/elazarl/go-bindata-assetfs"
  packages = ["."]
  revision = "57eb5e1fc594ad4b0b1dbea7b286d299e0cb43c2"
 [[projects]]
  name = "github.com/ethantkoenig/rupture"
  packages = ["."]
  revision = "0a76f03a811abcca2e6357329b673e9bb8ef9643"
 [[projects]]
  branch = "master"
  name = "github.com/facebookgo/clock"
  packages = ["."]
  revision = "600d898af40aa09a7a93ecb9265d87b0504b6f03"
 [[projects]]
  name = "github.com/facebookgo/grace"
  packages = [
    "gracehttp",
    "gracenet"
  ]
  revision = "5729e484473f52048578af1b80d0008c7024089b"
 [[projects]]
  branch = "master"
  name = "github.com/facebookgo/httpdown"
  packages = ["."]
  revision = "a3b1354551a26449fbe05f5d855937f6e7acbd71"
 [[projects]]
  branch = "master"
  name = "github.com/facebookgo/stats"
  packages = ["."]
  revision = "1b76add642e42c6ffba7211ad7b3939ce654526e"
 [[projects]]
  branch = "master"
  name = "github.com/glycerine/go-unsnap-stream"
  packages = ["."]
  revision = "9f0cb55181dd3a0a4c168d3dbc72d4aca4853126"
 [[projects]]
  branch = "master"
  name = "github.com/go-macaron/bindata"
  packages = ["."]
  revision = "85786f57eee3e5544a9cc24fa2afe425b97a8652"
 [[projects]]
  name = "github.com/go-macaron/binding"
  packages = ["."]
  revision = "9440f336b443056c90d7d448a0a55ad8c7599880"
 [[projects]]
  branch = "master"
  name = "github.com/go-macaron/cache"
  packages = [
    ".",
    "memcache",
    "redis"
  ]
  revision = "56173531277692bc2925924d51fda1cd0a6b8178"
 [[projects]]
  name = "github.com/go-macaron/captcha"
  packages = ["."]
  revision = "8aa5919789ab301e865595eb4b1114d6b9847deb"
 [[projects]]
  name = "github.com/go-macaron/csrf"
  packages = ["."]
  revision = "6a9a7df172cc1fcd81e4585f44b09200b6087cc0"
 [[projects]]
  branch = "master"
  name = "github.com/go-macaron/gzip"
  packages = ["."]
  revision = "cad1c6580a07c56f5f6bc52d66002a05985c5854"
 [[projects]]
  branch = "master"
  name = "github.com/go-macaron/i18n"
  packages = ["."]
  revision = "ef57533c3b0fc2d8581deda14937e52f11a203ab"
 [[projects]]
  branch = "master"
  name = "github.com/go-macaron/inject"
  packages = ["."]
  revision = "d8a0b8677191f4380287cfebd08e462217bac7ad"
 [[projects]]
  name = "github.com/go-macaron/session"
  packages = [
    ".",
    "redis"
  ]
  revision = "66031fcb37a0fff002a1f028eb0b3a815c78306b"
 [[projects]]
  name = "github.com/go-macaron/toolbox"
  packages = ["."]
  revision = "99a42f20e9e88daec5c0d7beb4e7eac134680ab0"
 [[projects]]
  name = "github.com/go-sql-driver/mysql"
  packages = ["."]
  revision = "ce924a41eea897745442daaa1739089b0f3f561d"
 [[projects]]
  name = "github.com/go-xorm/builder"
  packages = ["."]
  revision = "488224409dd8aa2ce7a5baf8d10d55764a913738"
 [[projects]]
  name = "github.com/go-xorm/core"
  packages = ["."]
  revision = "cb1d0ca71f42d3ee1bf4aba7daa16099bc31a7e9"
 [[projects]]
  name = "github.com/go-xorm/tidb"
  packages = ["."]
  revision = "21e49190ce47a766fa741cf7edc831a30c12c6ac"
 [[projects]]
  name = "github.com/go-xorm/xorm"
  packages = ["."]
  revision = "d4149d1eee0c2c488a74a5863fd9caf13d60fd03"
 [[projects]]
  branch = "master"
  name = "github.com/gogits/chardet"
  packages = ["."]
  revision = "2404f777256163ea3eadb273dada5dcb037993c0"
 [[projects]]
  name = "github.com/gogits/cron"
  packages = ["."]
  revision = "7f3990acf1833faa5ebd0e86f0a4c72a4b5eba3c"
 [[projects]]
  name = "github.com/golang/protobuf"
  packages = ["proto"]
  revision = "99511271042a09d1e01baea8781caa5210fec66e"
 [[projects]]
  name = "github.com/golang/snappy"
  packages = ["."]
  revision = "5f1c01d9f64b941dd9582c638279d046eda6ca31"
 [[projects]]
  name = "github.com/gorilla/context"
  packages = ["."]
  revision = "08b5f424b9271eedf6f9f0ce86cb9396ed337a42"
  version = "v1.1.1"
 [[projects]]
  name = "github.com/gorilla/mux"
  packages = ["."]
  revision = "757bef944d0f21880861c2dd9c871ca543023cba"
 [[projects]]
  name = "github.com/gorilla/securecookie"
  packages = ["."]
  revision = "e59506cc896acb7f7bf732d4fdf5e25f7ccd8983"
  version = "v1.1.1"
 [[projects]]
  name = "github.com/gorilla/sessions"
  packages = ["."]
  revision = "ca9ada44574153444b00d3fd9c8559e4cc95f896"
  version = "v1.1"
 [[projects]]
  name = "github.com/issue9/identicon"
  packages = ["."]
  revision = "d36b54562f4cf70c83653e13dc95c220c79ef521"
 [[projects]]
  name = "github.com/jaytaylor/html2text"
  packages = ["."]
  revision = "8fb95d837f7d6db1913fecfd7bcc5333e6499596"
 [[projects]]
  name = "github.com/juju/errors"
  packages = ["."]
  revision = "b2c7a7da5b2995941048f60146e67702a292e468"
 [[projects]]
  name = "github.com/kballard/go-shellquote"
  packages = ["."]
  revision = "cd60e84ee657ff3dc51de0b4f55dd299a3e136f2"
 [[projects]]
  name = "github.com/keybase/go-crypto"
  packages = [
    "brainpool",
    "cast5",
    "curve25519",
    "ed25519",
    "ed25519/internal/edwards25519",
    "openpgp",
    "openpgp/armor",
    "openpgp/ecdh",
    "openpgp/elgamal",
    "openpgp/errors",
    "openpgp/packet",
    "openpgp/s2k",
    "rsa"
  ]
  revision = "00ac4db533f63ef97576cbc7b07939ff7daf7329"
 [[projects]]
  name = "github.com/klauspost/compress"
  packages = [
    "flate",
    "gzip"
  ]
  revision = "8df558b6cb6f9b445f9586446cfe7223e7d8bd6b"
  version = "v1.1"
 [[projects]]
  name = "github.com/klauspost/cpuid"
  packages = ["."]
  revision = "09cded8978dc9e80714c4d85b0322337b0a1e5e0"
  version = "v1.0"
 [[projects]]
  name = "github.com/klauspost/crc32"
  packages = ["."]
  revision = "cb6bfca970f6908083f26f39a79009d608efd5cd"
  version = "v1.1"
 [[projects]]
  name = "github.com/lafriks/xormstore"
  packages = [
    ".",
    "util"
  ]
  revision = "9cab149ea91875cf056211bd6ef82379fce9cb67"
  version = "v1.0.0"
 [[projects]]
  name = "github.com/lib/pq"
  packages = [
    ".",
    "oid"
  ]
  revision = "456514e2defec52e0cd37f90ccf17ec8b28295e2"
 [[projects]]
  branch = "master"
  name = "github.com/lunny/dingtalk_webhook"
  packages = ["."]
  revision = "e3534c89ef969912856dfa39e56b09e58c5f5daf"
 [[projects]]
  name = "github.com/markbates/goth"
  packages = [
    ".",
    "gothic",
    "providers/bitbucket",
    "providers/dropbox",
    "providers/facebook",
    "providers/github",
    "providers/gitlab",
    "providers/gplus",
    "providers/openidConnect",
    "providers/twitter"
  ]
  revision = "4933f155d89c3c52ab4ca545c6602cf4a1e87913"
  version = "1.45.5"
 [[projects]]
  name = "github.com/mattn/go-sqlite3"
  packages = ["."]
  revision = "acfa60124032040b9f5a9406f5a772ee16fe845e"
 [[projects]]
  branch = "master"
  name = "github.com/mcuadros/go-version"
  packages = ["."]
  revision = "88e56e02bea1c203c99222c365fa52a69996ccac"
 [[projects]]
  name = "github.com/microcosm-cc/bluemonday"
  packages = ["."]
  revision = "f77f16ffc87a6a58814e64ae72d55f9c41374e6d"
 [[projects]]
  name = "github.com/mrjones/oauth"
  packages = ["."]
  revision = "3f67d9c274355678b2f9844b08d643e2f9213340"
 [[projects]]
  branch = "master"
  name = "github.com/mschoch/smat"
  packages = ["."]
  revision = "90eadee771aeab36e8bf796039b8c261bebebe4f"
 [[projects]]
  name = "github.com/msteinert/pam"
  packages = ["."]
  revision = "02ccfbfaf0cc627aa3aec8ef7ed5cfeec5b43f63"
 [[projects]]
  name = "github.com/nfnt/resize"
  packages = ["."]
  revision = "891127d8d1b52734debe1b3c3d7e747502b6c366"
 [[projects]]
  name = "github.com/ngaut/deadline"
  packages = ["."]
  revision = "fae8f9dfd7048de16575b9d4c255278e38c28a4f"
 [[projects]]
  branch = "master"
  name = "github.com/ngaut/go-zookeeper"
  packages = ["zk"]
  revision = "9c3719e318c7cfd072e41eb48cb71fcaa49d5e05"
 [[projects]]
  name = "github.com/ngaut/log"
  packages = ["."]
  revision = "d2af3a61f64d093457fb23b25d20f4ce3cd551ce"
 [[projects]]
  branch = "master"
  name = "github.com/ngaut/pools"
  packages = ["."]
  revision = "b7bc8c42aac787667ba45adea78233f53f548443"
 [[projects]]
  branch = "master"
  name = "github.com/ngaut/sync2"
  packages = ["."]
  revision = "7a24ed77b2efb460c1468b7dc917821c66e80e55"
 [[projects]]
  branch = "master"
  name = "github.com/ngaut/tso"
  packages = [
    "client",
    "proto",
    "util"
  ]
  revision = "118f6c141d58f1e72577ff61f43f649bf39355ee"
 [[projects]]
  branch = "master"
  name = "github.com/ngaut/zkhelper"
  packages = ["."]
  revision = "6738bdc138d469112c6687fbfcfe049ccabd6a0a"
 [[projects]]
  branch = "master"
  name = "github.com/petar/GoLLRB"
  packages = ["llrb"]
  revision = "53be0d36a84c2a886ca057d34b6aa4468df9ccb4"
 [[projects]]
  name = "github.com/philhofer/fwd"
  packages = ["."]
  revision = "bb6d471dc95d4fe11e432687f8b70ff496cf3136"
  version = "v1.0.0"
 [[projects]]
  name = "github.com/pingcap/go-hbase"
  packages = [
    ".",
    "iohelper",
    "proto"
  ]
  revision = "7a98d1fe4e9e115de8c77ae0e158c0d08732c550"
 [[projects]]
  branch = "master"
  name = "github.com/pingcap/go-themis"
  packages = [
    ".",
    "oracle",
    "oracle/oracles"
  ]
  revision = "dbb996606c1d1fe8571fd9ac6da2254c76d2c5c9"
 [[projects]]
  name = "github.com/pingcap/tidb"
  packages = [
    ".",
    "ast",
    "column",
    "context",
    "ddl",
    "domain",
    "evaluator",
    "executor",
    "infoschema",
    "inspectkv",
    "kv",
    "kv/memkv",
    "meta",
    "meta/autoid",
    "model",
    "mysql",
    "optimizer",
    "optimizer/plan",
    "parser",
    "parser/opcode",
    "perfschema",
    "privilege",
    "privilege/privileges",
    "sessionctx",
    "sessionctx/autocommit",
    "sessionctx/db",
    "sessionctx/forupdate",
    "sessionctx/variable",
    "store/hbase",
    "store/localstore",
    "store/localstore/boltdb",
    "store/localstore/engine",
    "store/localstore/goleveldb",
    "structure",
    "table",
    "table/tables",
    "terror",
    "util",
    "util/bytes",
    "util/charset",
    "util/codec",
    "util/distinct",
    "util/hack",
    "util/segmentmap",
    "util/sqlexec",
    "util/stringutil",
    "util/types"
  ]
  revision = "33197485abe227dcb254644cf5081c9a3c281669"
 [[projects]]
  name = "github.com/pmezard/go-difflib"
  packages = ["difflib"]
  revision = "792786c7400a136282c1664665ae0a8db921c6c2"
  version = "v1.0.0"
 [[projects]]
  name = "github.com/pquerna/otp"
  packages = [
    ".",
    "hotp",
    "totp"
  ]
  revision = "54653902c20e47f3417541d35435cb6d6162e28a"
 [[projects]]
  branch = "master"
  name = "github.com/russross/blackfriday"
  packages = ["."]
  revision = "11635eb403ff09dbc3a6b5a007ab5ab09151c229"
 [[projects]]
  name = "github.com/satori/go.uuid"
  packages = ["."]
  revision = "b061729afc07e77a8aa4fad0a2fd840958f1942a"
 [[projects]]
  name = "github.com/sergi/go-diff"
  packages = ["diffmatchpatch"]
  revision = "552b4e9bbdca9e5adafd95ee98c822fdd11b330b"
 [[projects]]
  name = "github.com/shurcooL/sanitized_anchor_name"
  packages = ["."]
  revision = "1dba4b3954bc059efc3991ec364f9f9a35f597d2"
 [[projects]]
  branch = "master"
  name = "github.com/steveyen/gtreap"
  packages = ["."]
  revision = "0abe01ef9be25c4aedc174758ec2d917314d6d70"
 [[projects]]
  name = "github.com/stretchr/testify"
  packages = ["assert"]
  revision = "2aa2c176b9dab406a6970f6a55f513e8a8c8b18f"
 [[projects]]
  name = "github.com/syndtr/goleveldb"
  packages = [
    "leveldb",
    "leveldb/cache",
    "leveldb/comparer",
    "leveldb/errors",
    "leveldb/filter",
    "leveldb/iterator",
    "leveldb/journal",
    "leveldb/memdb",
    "leveldb/opt",
    "leveldb/storage",
    "leveldb/table",
    "leveldb/util"
  ]
  revision = "917f41c560270110ceb73c5b38be2a9127387071"
 [[projects]]
  branch = "master"
  name = "github.com/tinylib/msgp"
  packages = ["msgp"]
  revision = "c8cf64dff2009d53fa8f8a16df54d1cdfc64c4a7"
 [[projects]]
  branch = "master"
  name = "github.com/tstranex/u2f"
  packages = ["."]
  revision = "d21a03e0b1d9fc1df59ff54e7a513655c1748b0c"
 [[projects]]
  name = "github.com/twinj/uuid"
  packages = ["."]
  revision = "89173bcdda19db0eb88aef1e1cb1cb2505561d31"
  version = "0.10.0"
 [[projects]]
  name = "github.com/ugorji/go"
  packages = ["codec"]
  revision = "c062049c1793b01a3cc3fe786108edabbaf7756b"
 [[projects]]
  name = "github.com/urfave/cli"
  packages = ["."]
  revision = "d86a009f5e13f83df65d0d6cee9a2e3f1445f0da"
 [[projects]]
  branch = "master"
  name = "github.com/willf/bitset"
  packages = ["."]
  revision = "8ce1146b8621c95164efd9c8b1124cfa9b8afb4e"
 [[projects]]
  name = "github.com/yohcop/openid-go"
  packages = ["."]
  revision = "2c050d2dae5345c417db301f11fda6fbf5ad0f0a"
 [[projects]]
  name = "golang.org/x/crypto"
  packages = [
    "curve25519",
    "ed25519",
    "ed25519/internal/edwards25519",
    "md4",
    "pbkdf2",
    "ssh"
  ]
  revision = "9f005a07e0d31d45e6656d241bb5c0f2efd4bc94"
 [[projects]]
  name = "golang.org/x/net"
  packages = [
    "context",
    "html",
    "html/atom",
    "html/charset"
  ]
  revision = "f2499483f923065a842d38eb4c7f1927e6fc6e6d"
 [[projects]]
  name = "golang.org/x/oauth2"
  packages = [
    ".",
    "internal"
  ]
  revision = "c10ba270aa0bf8b8c1c986e103859c67a9103061"
 [[projects]]
  name = "golang.org/x/sync"
  packages = ["syncmap"]
  revision = "5a06fca2c336a4b2b2fcb45702e8c47621b2aa2c"
 [[projects]]
  name = "golang.org/x/sys"
  packages = [
    "unix",
    "windows",
    "windows/svc"
  ]
  revision = "a646d33e2ee3172a661fc09bca23bb4889a41bc8"
 [[projects]]
  name = "golang.org/x/text"
  packages = [
    "encoding",
    "encoding/charmap",
    "encoding/htmlindex",
    "encoding/internal",
    "encoding/internal/identifier",
    "encoding/japanese",
    "encoding/korean",
    "encoding/simplifiedchinese",
    "encoding/traditionalchinese",
    "encoding/unicode",
    "internal/gen",
    "internal/tag",
    "internal/triegen",
    "internal/ucd",
    "internal/utf8internal",
    "language",
    "runes",
    "transform",
    "unicode/cldr",
    "unicode/norm"
  ]
  revision = "2bf8f2a19ec09c670e931282edfe6567f6be21c9"
 [[projects]]
  branch = "v3"
  name = "gopkg.in/alexcesaro/quotedprintable.v3"
  packages = ["."]
  revision = "2caba252f4dc53eaf6b553000885530023f54623"
 [[projects]]
  name = "gopkg.in/asn1-ber.v1"
  packages = ["."]
  revision = "4e86f4367175e39f69d9358a5f17b4dda270378d"
  version = "v1.1"
 [[projects]]
  name = "gopkg.in/bufio.v1"
  packages = ["."]
  revision = "567b2bfa514e796916c4747494d6ff5132a1dfce"
  version = "v1"
 [[projects]]
  name = "gopkg.in/editorconfig/editorconfig-core-go.v1"
  packages = ["."]
  revision = "a872f05c2e34b37b567401384d202aff11ba06d4"
  version = "v1.2.0"
 [[projects]]
  branch = "v2"
  name = "gopkg.in/gomail.v2"
  packages = ["."]
  revision = "81ebce5c23dfd25c6c67194b37d3dd3f338c98b1"
 [[projects]]
  name = "gopkg.in/ini.v1"
  packages = ["."]
  revision = "7e7da451323b6766da368f8a1e8ec9a88a16b4a0"
  version = "v1.31.1"
 [[projects]]
  name = "gopkg.in/ldap.v2"
  packages = ["."]
  revision = "d0a5ced67b4dc310b9158d63a2c6f9c5ec13f105"
  version = "v2.4.1"
 [[projects]]
  name = "gopkg.in/macaron.v1"
  packages = ["."]
  revision = "75f2e9b42e99652f0d82b28ccb73648f44615faa"
  version = "v1.2.4"
 [[projects]]
  name = "gopkg.in/redis.v2"
  packages = ["."]
  revision = "e6179049628164864e6e84e973cfb56335748dea"
  version = "v2.3.2"
 [[projects]]
  name = "gopkg.in/testfixtures.v2"
  packages = ["."]
  revision = "b9ef14dc461bf934d8df2dfc6f1f456be5664cca"
  version = "v2.0.0"
 [[projects]]
  name = "gopkg.in/yaml.v2"
  packages = ["."]
  revision = "a5b47d31c556af34a302ce5d659e6fea44d90de0"
 [[projects]]
  name = "strk.kbt.io/projects/go/libravatar"
  packages = ["."]
  revision = "5eed7bff870ae19ef51c5773dbc8f3e9fcbd0982"
 [solve-meta]
  analyzer-name = "dep"
  analyzer-version = 1
  inputs-digest = "036b8c882671cf8d2c5e2fdbe53b1bdfbd39f7ebd7765bd50276c7c4ecf16687"
  solver-name = "gps-cdcl"
  solver-version = 1
--- a/Gopkg.toml
+++ b/Gopkg.toml
@ -0,0 +1,106 @@
 ignored = ["google.golang.org/appengine*"]
 [prune]
  go-tests = true
  unused-packages = true
  non-go = true
 [[constraint]]
  branch = "master"
  name = "code.gitea.io/git"
 [[constraint]]
  branch = "master"
  name = "code.gitea.io/sdk"
 [[constraint]]
  revision = "9f005a07e0d31d45e6656d241bb5c0f2efd4bc94"
  name = "golang.org/x/crypto"
 [[constraint]]
  revision = "a646d33e2ee3172a661fc09bca23bb4889a41bc8"
  name = "golang.org/x/sys"
 [[constraint]]
  revision = "2bf8f2a19ec09c670e931282edfe6567f6be21c9"
  name = "golang.org/x/text"
 [[constraint]]
  revision = "f2499483f923065a842d38eb4c7f1927e6fc6e6d"
  name = "golang.org/x/net"
 [[constraint]]
  #version = "v1.0.0"
  revision = "33197485abe227dcb254644cf5081c9a3c281669"
  name = "github.com/pingcap/tidb"
 [[override]]
  name = "github.com/go-xorm/xorm"
  #version = "0.6.5"
  revision = "d4149d1eee0c2c488a74a5863fd9caf13d60fd03"
 [[override]]
  name = "github.com/gorilla/mux"
  revision = "757bef944d0f21880861c2dd9c871ca543023cba"
 [[constraint]]
  name = "github.com/gorilla/context"
  version = "1.1.1"
 [[constraint]]
  name = "github.com/lafriks/xormstore"
  version = "1.0.0"
 [[constraint]]
  branch = "master"
  name = "github.com/lunny/dingtalk_webhook"
 [[constraint]]
  name = "github.com/markbates/goth"
  version = "1.45.5"
 [[constraint]]
  branch = "master"
  name = "github.com/mcuadros/go-version"
 [[constraint]]
  branch = "master"
  name = "github.com/russross/blackfriday"
 [[constraint]]
  branch = "master"
  name = "github.com/tstranex/u2f"
 [[constraint]]
  name = "gopkg.in/editorconfig/editorconfig-core-go.v1"
  version = "1.2.0"
 [[constraint]]
  branch = "v2"
  name = "gopkg.in/gomail.v2"
 [[constraint]]
  name = "gopkg.in/ini.v1"
  version = "1.31.1"
 [[constraint]]
  name = "gopkg.in/ldap.v2"
  version = "2.4.1"
 [[constraint]]
  name = "gopkg.in/macaron.v1"
  version = "1.2.4"
 [[constraint]]
  name = "gopkg.in/testfixtures.v2"
  version = "2.0.0"
 [[override]]
  name = "github.com/boltdb/bolt"
  revision = "ccd680d8c1a0179ac3d68f692b01e1a1589cbfc7"
  source = "github.com/go-gitea/bolt"
 [[override]]
  revision = "c10ba270aa0bf8b8c1c986e103859c67a9103061"
  name = "golang.org/x/oauth2"
--- a/24
+++ b/24
@ -153,18 +153,22 @@ coverage:
 unit-test-coverage:
 	for PKG in $(PACKAGES); do $(GO) test -tags=sqlite -cover -coverprofile $$GOPATH/src/$$PKG/coverage.out $$PKG || exit 1; done;
-.PHONY: test-vendor
+.PHONY: vendor
-test-vendor:
+vendor:
-	@hash govendor > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
+	@hash dep > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		$(GO) get -u github.com/kardianos/govendor; \
+		$(GO) get -u github.com/golang/dep/cmd/dep; \
 	fi
-	govendor list +unused | tee "$(TMPDIR)/wc-gitea-unused"
+	dep ensure -vendor-only
 	[ $$(cat "$(TMPDIR)/wc-gitea-unused" | wc -l) -eq 0 ] || echo "Warning: /!\\ Some vendor are not used /!\\"
 	govendor list +outside | tee "$(TMPDIR)/wc-gitea-outside"
 	[ $$(cat "$(TMPDIR)/wc-gitea-outside" | wc -l) -eq 0 ] || exit 1
-	govendor status || exit 1
+.PHONY: test-vendor
 test-vendor: vendor
 	@diff=$$(git diff vendor/); \
 	if [ -n "$$diff" ]; then \
 		echo "Please run 'make vendor' and commit the result:"; \
 		echo "$${diff}"; \
 		exit 1; \
 	fi;
 #TODO add dep status -missing when implemented
 .PHONY: test-sqlite
 test-sqlite: integrations.sqlite.test
--- a/vendor/code.gitea.io/git/CONTRIBUTING.md
+++ b/vendor/code.gitea.io/git/CONTRIBUTING.md
@ -1,86 +0,0 @@
 # Contribution Guidelines
 ## Introduction
 This document explains how to contribute changes to the Gitea project. It assumes you have followed the [installation instructions](https://github.com/go-gitea/docs/tree/master/en-US/installation). Sensitive security-related issues should be reported to [security@gitea.io](mailto:security@gitea.io).
 ## Bug reports
 Please search the issues on the issue tracker with a variety of keywords to ensure your bug is not already reported.
 If unique, [open an issue](https://github.com/go-gitea/gitea/issues/new) and answer the questions so we can understand and reproduce the problematic behavior.
 To show us that the issue you are having is in Gitea itself, please write clear, concise instructions so we can reproduce the behavior (even if it seems obvious). The more detailed and specific you are, the faster we can fix the issue. Check out [How to Report Bugs Effectively](http://www.chiark.greenend.org.uk/~sgtatham/bugs.html).
 Please be kind, remember that Gitea comes at no cost to you, and you're getting free help.
 ## Discuss your design
 The project welcomes submissions but please let everyone know what you're working on if you want to change or add something to the Gitea repositories.
 Before starting to write something new for the Gitea project, please [file an issue](https://github.com/go-gitea/gitea/issues/new). Significant changes must go through the [change proposal process](https://github.com/go-gitea/proposals) before they can be accepted.
 This process gives everyone a chance to validate the design, helps prevent duplication of effort, and ensures that the idea fits inside the goals for the project and tools. It also checks that the design is sound before code is written; the code review tool is not the place for high-level discussions.
 ## Testing redux
 Before sending code out for review, run all the tests for the whole tree to make sure the changes don't break other usage and keep the compatibility on upgrade. To make sure you are running the test suite exactly like we do, you should install the CLI for [Drone CI](https://github.com/drone/drone), as we are using the server for continous testing, following [these instructions](http://readme.drone.io/0.5/install/cli/). After that you can simply call `drone exec` within your working directory and it will try to run the test suite locally.
 ## Code review
 Changes to Gitea must be reviewed before they are accepted, no matter who makes the change even if it is an owner or a maintainer. We use GitHub's pull request workflow to do that and we also use [LGTM](http://lgtm.co) to ensure every PR is reviewed by at least 2 maintainers.
 Please try to make your pull request easy to review for us. Please read the "[How to get faster PR reviews](https://github.com/kubernetes/community/blob/master/contributors/devel/faster_reviews.md)" guide, it has lots of useful tips for any project you may want to contribute. Some of the key points:
 * Make small pull requests. The smaller, the faster to review and the more likely it will be merged soon.
 * Don't make changes unrelated to your PR. Maybe there are typos on some comments, maybe refactoring would be welcome on a function... but if that is not related to your PR, please make *another* PR for that.
 * Split big pull requests into multiple small ones. An incremental change will be faster to review than a huge PR.
 ## Sign your work
 The sign-off is a simple line at the end of the explanation for the patch. Your signature certifies that you wrote the patch or otherwise have the right to pass it on as an open-source patch. The rules are pretty simple: If you can certify [DCO](DCO), then you just add a line to every git commit message:
 ```
 Signed-off-by: Joe Smith <joe.smith@email.com>
 ```
 Please use your real name, we really dislike pseudonyms or anonymous contributions. We are in the open-source world without secrets. If you set your `user.name` and `user.email` git configs, you can sign your commit automatically with `git commit -s`.
 ## Maintainers
 To make sure every PR is checked, we have [team maintainers](https://github.com/orgs/go-gitea/teams/maintainers). Every PR **MUST** be reviewed by at least two maintainers (or owners) before it can get merged. A maintainer should be a contributor of Gitea (or Gogs) and contributed at least 4 accepted PRs. A contributor should apply as a maintainer in the [Discord #develop channel](https://discord.gg/NsatcWJ). The owners or the team maintainers may invite the contributor. A maintainer should spend some time on code reviews. If a maintainer has no time to do that, they should apply to leave the maintainers team and we will give them the honor of being a member of the [advisors team](https://github.com/orgs/go-gitea/teams/advisors). Of course, if an advisor has time to code review, we will gladly welcome them back to the maintainers team. If a maintainer is inactive for more than 3 months and forgets to leave the maintainers team, the owners may move him or her from the maintainers team to the advisors team.
 ## Owners
 Since Gitea is a pure community organization without any company support, to keep the development healthy we will elect three owners every year. All contributors may vote to elect up to three candidates, one of which will be the main owner, and the other two the assistant owners. When the new owners have been elected, the old owners will give up ownership to the newly elected owners. If an owner is unable to do so, the other owners will assist in ceding ownership to the newly elected owners.
 After the election, the new owners should proactively agree with our [CONTRIBUTING](CONTRIBUTING.md) requirements on the [Discord #general channel](https://discord.gg/NsatcWJ). Below are the words to speak:
 ```
 I'm honored to having been elected an owner of Gitea, I agree with [CONTRIBUTING](CONTRIBUTING.md). I will spend part of my time on Gitea and lead the development of Gitea.
 ```
 To honor the past owners, here's the history of the owners and the time they served:
 * 2016-11-04 ~ 2017-12-31
  * [Lunny Xiao](https://github.com/lunny) <xiaolunwen@gmail.com>
  * [Thomas Boerger](https://github.com/tboerger) <thomas@webhippie.de>
  * [Kim Carlbäcker](https://github.com/bkcsoft) <kim.carlbacker@gmail.com>
 ## Versions
 Gitea has the `master` branch as a tip branch and has version branches such as `v0.9`. `v0.9` is a release branch and we will tag `v0.9.0` for binary download. If `v0.9.0` has bugs, we will accept pull requests on the `v0.9` branch and publish a `v0.9.1` tag, after bringing the bug fix also to the master branch.
 Since the `master` branch is a tip version, if you wish to use Gitea in production, please download the latest release tag version. All the branches will be protected via GitHub, all the PRs to every branch must be reviewed by two maintainers and must pass the automatic tests.
 ## Copyright
 Code that you contribute should use the standard copyright header:
 ```
 // Copyright 2017 The Gitea Authors. All rights reserved.
 // Use of this source code is governed by a MIT-style
 // license that can be found in the LICENSE file.
 ```
 Files in the repository contain copyright from the year they are added to the year they are last changed. If the copyright author is changed, just paste the header below the old one.
--- a/vendor/code.gitea.io/git/DCO
+++ b/vendor/code.gitea.io/git/DCO
@ -1,36 +0,0 @@
 Developer Certificate of Origin
 Version 1.1
 Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
 660 York Street, Suite 102,
 San Francisco, CA 94110 USA
 Everyone is permitted to copy and distribute verbatim copies of this
 license document, but changing it is not allowed.
 Developer's Certificate of Origin 1.1
 By making a contribution to this project, I certify that:
 (a) The contribution was created in whole or in part by me and I
    have the right to submit it under the open source license
    indicated in the file; or
 (b) The contribution is based upon previous work that, to the best
    of my knowledge, is covered under an appropriate open source
    license and I have the right under that license to submit that
    work with modifications, whether created in whole or in part
    by me, under the same open source license (unless I am
    permitted to submit under a different license), as indicated
    in the file; or
 (c) The contribution was provided directly to me by some other
    person who certified (a), (b) or (c) and I have not modified
    it.
 (d) I understand and agree that this project and the contribution
    are public and that a record of the contribution (including all
    personal information I submit with it, including my sign-off) is
    maintained indefinitely and may be redistributed consistent with
    this project or the open source license(s) involved.
--- a/vendor/code.gitea.io/git/MAINTAINERS
+++ b/vendor/code.gitea.io/git/MAINTAINERS
@ -1,21 +0,0 @@
 Alexey Makhov <amakhov@avito.ru> (@makhov)
 Andrey Nering <andrey.nering@gmail.com> (@andreynering)
 Bo-Yi Wu <appleboy.tw@gmail.com> (@appleboy)
 Ethan Koenig <ethantkoenig@gmail.com> (@ethantkoenig)
 Kees de Vries <bouwko@gmail.com> (@Bwko)
 Kim Carlbäcker <kim.carlbacker@gmail.com> (@bkcsoft)
 LefsFlare <nobody@nobody.tld> (@LefsFlarey)
 Lunny Xiao <xiaolunwen@gmail.com> (@lunny)
 Matthias Loibl <mail@matthiasloibl.com> (@metalmatze)
 Morgan Bazalgette <the@howl.moe> (@thehowl)
 Rachid Zarouali <nobody@nobody.tld> (@xinity)
 Rémy Boulanouar <admin@dblk.org> (@DblK)
 Sandro Santilli <strk@kbt.io> (@strk)
 Thibault Meyer <meyer.thibault@gmail.com> (@0xbaadf00d)
 Thomas Boerger <thomas@webhippie.de> (@tboerger)
 Lauris Bukšis-Haberkorns <lauris@nix.lv> (@lafriks)
 Antoine Girard <sapk@sapk.fr> (@sapk)
 Jonas Östanbäck <jonas.ostanback@gmail.com> (@cez81)
 David Schneiderbauer <dschneiderbauer@gmail.com> (@daviian)
 Peter Žeby <morlinest@gmail.com> (@morlinest)
 Jonas Franz <info@jonasfranz.software> (@JonasFranzDEV)
--- a/vendor/code.gitea.io/git/Makefile
+++ b/vendor/code.gitea.io/git/Makefile
@ -1,44 +0,0 @@
 IMPORT := code.gitea.io/git
 PACKAGES ?= $(shell go list -e ./... | grep -v /vendor/ | grep -v /benchmark/)
 GENERATE ?= code.gitea.io/git
 .PHONY: all
 all: clean test build
 .PHONY: clean
 clean:
 	go clean -i ./...
 generate:
 	@which mockery > /dev/null; if [ $$? -ne 0 ]; then \
 		go get -u github.com/vektra/mockery/...; \
 	fi
 	go generate $(GENERATE)
 .PHONY: fmt
 fmt:
 	find . -name "*.go" -type f ! -path "./vendor/*" ! -path "./benchmark/*" | xargs gofmt -s -w
 .PHONY: vet
 vet:
 	go vet $(PACKAGES)
 .PHONY: lint
 lint:
 	@which golint > /dev/null; if [ $$? -ne 0 ]; then \
 		go get -u github.com/golang/lint/golint; \
 	fi
 	for PKG in $(PACKAGES); do golint -set_exit_status $$PKG || exit 1; done;
 .PHONY: test
 test:
 	for PKG in $(PACKAGES); do go test -cover -coverprofile $$GOPATH/src/$$PKG/coverage.out $$PKG || exit 1; done;
 .PHONY: bench
 bench:
 	go test -run=XXXXXX -benchtime=10s -bench=. || exit 1
 .PHONY: build
 build:
 	go build .
--- a/vendor/code.gitea.io/git/README.md
+++ b/vendor/code.gitea.io/git/README.md
@ -1,25 +0,0 @@
 # Git Shell
 [![Build Status](http://drone.gitea.io/api/badges/go-gitea/git/status.svg)](http://drone.gitea.io/go-gitea/git)
 [![Join the chat at https://img.shields.io/discord/322538954119184384.svg](https://img.shields.io/discord/322538954119184384.svg)](https://discord.gg/NsatcWJ)
 [![](https://images.microbadger.com/badges/image/gitea/gitea.svg)](http://microbadger.com/images/gitea/gitea "Get your own image badge on microbadger.com")
 [![Coverage Status](https://coverage.gitea.io/badges/go-gitea/git/coverage.svg)](https://coverage.gitea.io/go-gitea/git)
 [![Go Report Card](https://goreportcard.com/badge/code.gitea.io/git)](https://goreportcard.com/report/code.gitea.io/git)
 [![GoDoc](https://godoc.org/code.gitea.io/git?status.svg)](https://godoc.org/code.gitea.io/git)
 This project is a Go module to access Git through shell commands. For further
 informations take a look at the current [documentation](https://godoc.org/code.gitea.io/git).
 ## Contributing
 Fork -> Patch -> Push -> Pull Request
 ## Authors
 * [Maintainers](https://github.com/orgs/go-gitea/people)
 * [Contributors](https://github.com/go-gitea/git/graphs/contributors)
 ## License
 This project is under the MIT License. See the [LICENSE](LICENSE) file for the
 full license text.
--- a/vendor/code.gitea.io/git/repo_blame.go
+++ b/vendor/code.gitea.io/git/repo_blame.go
@ -4,7 +4,21 @@
 package git
 import "fmt"
 // FileBlame return the Blame object of file
 func (repo *Repository) FileBlame(revision, path, file string) ([]byte, error) {
-	return NewCommand("blame", "--root", file).RunInDirBytes(path)
+	return NewCommand("blame", "--root", "--", file).RunInDirBytes(path)
 }
 // LineBlame returns the latest commit at the given line
 func (repo *Repository) LineBlame(revision, path, file string, line uint) (*Commit, error) {
 	res, err := NewCommand("blame", fmt.Sprintf("-L %d,%d", line, line), "-p", revision, "--", file).RunInDir(path)
 	if err != nil {
 		return nil, err
 	}
 	if len(res) < 40 {
 		return nil, fmt.Errorf("invalid result of blame: %s", res)
 	}
 	return repo.GetCommit(string(res[:40]))
 }
--- a/vendor/github.com/PuerkitoBio/goquery/README.md
+++ b/vendor/github.com/PuerkitoBio/goquery/README.md
@ -1,126 +0,0 @@
 # goquery - a little like that j-thing, only in Go 
 [![build status](https://secure.travis-ci.org/PuerkitoBio/goquery.png)](http://travis-ci.org/PuerkitoBio/goquery) [![GoDoc](https://godoc.org/github.com/PuerkitoBio/goquery?status.png)](http://godoc.org/github.com/PuerkitoBio/goquery) [![Sourcegraph Badge](https://sourcegraph.com/github.com/PuerkitoBio/goquery/-/badge.svg)](https://sourcegraph.com/github.com/PuerkitoBio/goquery?badge)
 goquery brings a syntax and a set of features similar to [jQuery][] to the [Go language][go]. It is based on Go's [net/html package][html] and the CSS Selector library [cascadia][]. Since the net/html parser returns nodes, and not a full-featured DOM tree, jQuery's stateful manipulation functions (like height(), css(), detach()) have been left off.
 Also, because the net/html parser requires UTF-8 encoding, so does goquery: it is the caller's responsibility to ensure that the source document provides UTF-8 encoded HTML. See the [wiki][] for various options to do this.
 Syntax-wise, it is as close as possible to jQuery, with the same function names when possible, and that warm and fuzzy chainable interface. jQuery being the ultra-popular library that it is, I felt that writing a similar HTML-manipulating library was better to follow its API than to start anew (in the same spirit as Go's `fmt` package), even though some of its methods are less than intuitive (looking at you, [index()][index]...).
 ## Installation
 Please note that because of the net/html dependency, goquery requires Go1.1+.
    $ go get github.com/PuerkitoBio/goquery
 (optional) To run unit tests:
    $ cd $GOPATH/src/github.com/PuerkitoBio/goquery
    $ go test
 (optional) To run benchmarks (warning: it runs for a few minutes):
    $ cd $GOPATH/src/github.com/PuerkitoBio/goquery
    $ go test -bench=".*"
 ## Changelog
 **Note that goquery's API is now stable, and will not break.**
 *    **2017-02-12 (v1.1.0)** : Add `SetHtml` and `SetText` (thanks to @glebtv).
 *    **2016-12-29 (v1.0.2)** : Optimize allocations for `Selection.Text` (thanks to @radovskyb).
 *    **2016-08-28 (v1.0.1)** : Optimize performance for large documents.
 *    **2016-07-27 (v1.0.0)** : Tag version 1.0.0.
 *    **2016-06-15** : Invalid selector strings internally compile to a `Matcher` implementation that never matches any node (instead of a panic). So for example, `doc.Find("~")` returns an empty `*Selection` object.
 *    **2016-02-02** : Add `NodeName` utility function similar to the DOM's `nodeName` property. It returns the tag name of the first element in a selection, and other relevant values of non-element nodes (see godoc for details). Add `OuterHtml` utility function similar to the DOM's `outerHTML` property (named `OuterHtml` in small caps for consistency with the existing `Html` method on the `Selection`).
 *    **2015-04-20** : Add `AttrOr` helper method to return the attribute's value or a default value if absent. Thanks to [piotrkowalczuk][piotr].
 *    **2015-02-04** : Add more manipulation functions - Prepend* - thanks again to [Andrew Stone][thatguystone].
 *    **2014-11-28** : Add more manipulation functions - ReplaceWith*, Wrap* and Unwrap - thanks again to [Andrew Stone][thatguystone].
 *    **2014-11-07** : Add manipulation functions (thanks to [Andrew Stone][thatguystone]) and `*Matcher` functions, that receive compiled cascadia selectors instead of selector strings, thus avoiding potential panics thrown by goquery via `cascadia.MustCompile` calls. This results in better performance (selectors can be compiled once and reused) and more idiomatic error handling (you can handle cascadia's compilation errors, instead of recovering from panics, which had been bugging me for a long time). Note that the actual type expected is a `Matcher` interface, that `cascadia.Selector` implements. Other matcher implementations could be used.
 *    **2014-11-06** : Change import paths of net/html to golang.org/x/net/html (see https://groups.google.com/forum/#!topic/golang-nuts/eD8dh3T9yyA). Make sure to update your code to use the new import path too when you call goquery with `html.Node`s.
 *    **v0.3.2** : Add `NewDocumentFromReader()` (thanks jweir) which allows creating a goquery document from an io.Reader.
 *    **v0.3.1** : Add `NewDocumentFromResponse()` (thanks assassingj) which allows creating a goquery document from an http response.
 *    **v0.3.0** : Add `EachWithBreak()` which allows to break out of an `Each()` loop by returning false. This function was added instead of changing the existing `Each()` to avoid breaking compatibility.
 *    **v0.2.1** : Make go-getable, now that [go.net/html is Go1.0-compatible][gonet] (thanks to @matrixik for pointing this out).
 *    **v0.2.0** : Add support for negative indices in Slice(). **BREAKING CHANGE** `Document.Root` is removed, `Document` is now a `Selection` itself (a selection of one, the root element, just like `Document.Root` was before). Add jQuery's Closest() method.
 *    **v0.1.1** : Add benchmarks to use as baseline for refactorings, refactor Next...() and Prev...() methods to use the new html package's linked list features (Next/PrevSibling, FirstChild). Good performance boost (40+% in some cases).
 *    **v0.1.0** : Initial release.
 ## API
 goquery exposes two structs, `Document` and `Selection`, and the `Matcher` interface. Unlike jQuery, which is loaded as part of a DOM document, and thus acts on its containing document, goquery doesn't know which HTML document to act upon. So it needs to be told, and that's what the `Document` type is for. It holds the root document node as the initial Selection value to manipulate.
 jQuery often has many variants for the same function (no argument, a selector string argument, a jQuery object argument, a DOM element argument, ...). Instead of exposing the same features in goquery as a single method with variadic empty interface arguments, statically-typed signatures are used following this naming convention:
 *    When the jQuery equivalent can be called with no argument, it has the same name as jQuery for the no argument signature (e.g.: `Prev()`), and the version with a selector string argument is called `XxxFiltered()` (e.g.: `PrevFiltered()`)
 *    When the jQuery equivalent **requires** one argument, the same name as jQuery is used for the selector string version (e.g.: `Is()`)
 *    The signatures accepting a jQuery object as argument are defined in goquery as `XxxSelection()` and take a `*Selection` object as argument (e.g.: `FilterSelection()`)
 *    The signatures accepting a DOM element as argument in jQuery are defined in goquery as `XxxNodes()` and take a variadic argument of type `*html.Node` (e.g.: `FilterNodes()`)
 *    The signatures accepting a function as argument in jQuery are defined in goquery as `XxxFunction()` and take a function as argument (e.g.: `FilterFunction()`)
 *    The goquery methods that can be called with a selector string have a corresponding version that take a `Matcher` interface and are defined as `XxxMatcher()` (e.g.: `IsMatcher()`)
 Utility functions that are not in jQuery but are useful in Go are implemented as functions (that take a `*Selection` as parameter), to avoid a potential naming clash on the `*Selection`'s methods (reserved for jQuery-equivalent behaviour).
 The complete [godoc reference documentation can be found here][doc].
 Please note that Cascadia's selectors do not necessarily match all supported selectors of jQuery (Sizzle). See the [cascadia project][cascadia] for details. Invalid selector strings compile to a `Matcher` that fails to match any node. Behaviour of the various functions that take a selector string as argument follows from that fact, e.g. (where `~` is an invalid selector string):
 * `Find("~")` returns an empty selection because the selector string doesn't match anything.
 * `Add("~")` returns a new selection that holds the same nodes as the original selection, because it didn't add any node (selector string didn't match anything).
 * `ParentsFiltered("~")` returns an empty selection because the selector string doesn't match anything.
 * `ParentsUntil("~")` returns all parents of the selection because the selector string didn't match any element to stop before the top element.
 ## Examples
 See some tips and tricks in the [wiki][].
 Adapted from example_test.go:
 ```Go
 package main
 import (
  "fmt"
  "log"
  "github.com/PuerkitoBio/goquery"
 )
 func ExampleScrape() {
  doc, err := goquery.NewDocument("http://metalsucks.net")
  if err != nil {
    log.Fatal(err)
  }
  // Find the review items
  doc.Find(".sidebar-reviews article .content-block").Each(func(i int, s *goquery.Selection) {
    // For each item found, get the band and title
    band := s.Find("a").Text()
    title := s.Find("i").Text()
    fmt.Printf("Review %d: %s - %s\n", i, band, title)
  })
 }
 func main() {
  ExampleScrape()
 }
 ```
 ## License
 The [BSD 3-Clause license][bsd], the same as the [Go language][golic]. Cascadia's license is [here][caslic].
 [jquery]: http://jquery.com/
 [go]: http://golang.org/
 [cascadia]: https://github.com/andybalholm/cascadia
 [bsd]: http://opensource.org/licenses/BSD-3-Clause
 [golic]: http://golang.org/LICENSE
 [caslic]: https://github.com/andybalholm/cascadia/blob/master/LICENSE
 [doc]: http://godoc.org/github.com/PuerkitoBio/goquery
 [index]: http://api.jquery.com/index/
 [gonet]: https://github.com/golang/net/
 [html]: http://godoc.org/golang.org/x/net/html
 [wiki]: https://github.com/PuerkitoBio/goquery/wiki/Tips-and-tricks
 [thatguystone]: https://github.com/thatguystone
 [piotr]: https://github.com/piotrkowalczuk
--- a/vendor/github.com/RoaringBitmap/roaring/Makefile
+++ b/vendor/github.com/RoaringBitmap/roaring/Makefile
@ -1,121 +0,0 @@
 .PHONY: help all test format fmtcheck vet lint     qa deps clean nuke rle backrle ser fetch-real-roaring-datasets
 # Display general help about this command
 help:
 	@echo ""
 	@echo "The following commands are available:"
 	@echo ""
 	@echo "    make qa          : Run all the tests"
 	@echo "    make test        : Run the unit tests"
 	@echo ""
 	@echo "    make format      : Format the source code"
 	@echo "    make fmtcheck    : Check if the source code has been formatted"
 	@echo "    make vet         : Check for suspicious constructs"
 	@echo "    make lint        : Check for style errors"
 	@echo ""
 	@echo "    make deps        : Get the dependencies"
 	@echo "    make clean       : Remove any build artifact"
 	@echo "    make nuke        : Deletes any intermediate file"
 	@echo ""
 	@echo "    make fuzz-smat   : Fuzzy testing with smat"
 	@echo "    make fuzz-stream : Fuzzy testing with stream deserialization"
 	@echo "    make fuzz-buffer : Fuzzy testing with buffer deserialization"
 	@echo ""
 # Alias for help target
 all: help
 test:
 	go test
 	go test -race -run TestConcurrent*
 # Format the source code
 format:
 	@find ./ -type f -name "*.go" -exec gofmt -w {} \;
 # Check if the source code has been formatted
 fmtcheck:
 	@mkdir -p target
 	@find ./ -type f -name "*.go" -exec gofmt -d {} \; | tee target/format.diff
 	@test ! -s target/format.diff || { echo "ERROR: the source code has not been formatted - please use 'make format' or 'gofmt'"; exit 1; }
 # Check for syntax errors
 vet:
 	GOPATH=$(GOPATH) go vet ./...
 # Check for style errors
 lint:
 	GOPATH=$(GOPATH) PATH=$(GOPATH)/bin:$(PATH) golint ./...
 # Alias to run all quality-assurance checks
 qa: fmtcheck test vet lint
 # --- INSTALL ---
 # Get the dependencies
 deps:
 	GOPATH=$(GOPATH) go get github.com/smartystreets/goconvey/convey
 	GOPATH=$(GOPATH) go get github.com/willf/bitset
 	GOPATH=$(GOPATH) go get github.com/golang/lint/golint
 	GOPATH=$(GOPATH) go get github.com/mschoch/smat
 	GOPATH=$(GOPATH) go get github.com/dvyukov/go-fuzz/go-fuzz
 	GOPATH=$(GOPATH) go get github.com/dvyukov/go-fuzz/go-fuzz-build
 	GOPATH=$(GOPATH) go get github.com/glycerine/go-unsnap-stream
 	GOPATH=$(GOPATH) go get github.com/philhofer/fwd
 	GOPATH=$(GOPATH) go get github.com/jtolds/gls
 fuzz-smat:
 	go test -tags=gofuzz -run=TestGenerateSmatCorpus
 	go-fuzz-build -func FuzzSmat github.com/RoaringBitmap/roaring
 	go-fuzz -bin=./roaring-fuzz.zip -workdir=workdir/ -timeout=200
 fuzz-stream:
 	go-fuzz-build -func FuzzSerializationStream github.com/RoaringBitmap/roaring
 	go-fuzz -bin=./roaring-fuzz.zip -workdir=workdir/ -timeout=200
 fuzz-buffer:
 	go-fuzz-build -func FuzzSerializationBuffer github.com/RoaringBitmap/roaring
 	go-fuzz -bin=./roaring-fuzz.zip -workdir=workdir/ -timeout=200
 # Remove any build artifact
 clean:
 	GOPATH=$(GOPATH) go clean ./...
 # Deletes any intermediate file
 nuke:
 	rm -rf ./target
 	GOPATH=$(GOPATH) go clean -i ./...
 rle:
 	cp rle.go rle16.go
 	perl -pi -e 's/32/16/g' rle16.go
 	cp rle_test.go rle16_test.go
 	perl -pi -e 's/32/16/g' rle16_test.go
 backrle:
 	cp rle16.go rle.go
 	perl -pi -e 's/16/32/g' rle.go
 	perl -pi -e 's/2032/2016/g' rle.go
 ser: rle
 	go generate
 cover:
 	go test -coverprofile=coverage.out
 	go tool cover -html=coverage.out
 fetch-real-roaring-datasets:
 	# pull github.com/RoaringBitmap/real-roaring-datasets -> testdata/real-roaring-datasets
 	git submodule init
 	git submodule update
--- a/vendor/github.com/RoaringBitmap/roaring/README.md
+++ b/vendor/github.com/RoaringBitmap/roaring/README.md
@ -1,246 +0,0 @@
 roaring [![Build Status](https://travis-ci.org/RoaringBitmap/roaring.png)](https://travis-ci.org/RoaringBitmap/roaring) [![Coverage Status](https://coveralls.io/repos/github/RoaringBitmap/roaring/badge.svg?branch=master)](https://coveralls.io/github/RoaringBitmap/roaring?branch=master) [![GoDoc](https://godoc.org/github.com/RoaringBitmap/roaring?status.svg)](https://godoc.org/github.com/RoaringBitmap/roaring) [![Go Report Card](https://goreportcard.com/badge/RoaringBitmap/roaring)](https://goreportcard.com/report/github.com/RoaringBitmap/roaring)
 =============
 This is a go version of the Roaring bitmap data structure. 
 Roaring bitmaps are used by several major systems such as [Apache Lucene][lucene] and derivative systems such as [Solr][solr] and
 [Elasticsearch][elasticsearch], [Metamarkets' Druid][druid], [LinkedIn Pinot][pinot], [Netflix Atlas][atlas],  [Apache Spark][spark], [OpenSearchServer][opensearchserver], [Cloud Torrent][cloudtorrent], [Whoosh][whoosh],  [Pilosa][pilosa],  [Microsoft Visual Studio Team Services (VSTS)][vsts], and eBay's [Apache Kylin][kylin].
 [lucene]: https://lucene.apache.org/
 [solr]: https://lucene.apache.org/solr/
 [elasticsearch]: https://www.elastic.co/products/elasticsearch
 [druid]: http://druid.io/
 [spark]: https://spark.apache.org/
 [opensearchserver]: http://www.opensearchserver.com
 [cloudtorrent]: https://github.com/jpillora/cloud-torrent
 [whoosh]: https://bitbucket.org/mchaput/whoosh/wiki/Home
 [pilosa]: https://www.pilosa.com/
 [kylin]: http://kylin.apache.org/
 [pinot]: http://github.com/linkedin/pinot/wiki
 [vsts]: https://www.visualstudio.com/team-services/
 [atlas]: https://github.com/Netflix/atlas
 Roaring bitmaps are found to work well in many important applications:
 > Use Roaring for bitmap compression whenever possible. Do not use other bitmap compression methods ([Wang et al., SIGMOD 2017](http://db.ucsd.edu/wp-content/uploads/2017/03/sidm338-wangA.pdf))
 The ``roaring`` Go library is used by
 * [Cloud Torrent](https://github.com/jpillora/cloud-torrent): a self-hosted remote torrent client
 * [runv](https://github.com/hyperhq/runv): an Hypervisor-based runtime for the Open Containers Initiative
 * [InfluxDB](https://www.influxdata.com)
 * [Pilosa](https://www.pilosa.com/)
 * [Bleve](http://www.blevesearch.com)
 This library is used in production in several systems, it is part of the [Awesome Go collection](https://awesome-go.com).
 There are also  [Java](https://github.com/RoaringBitmap/RoaringBitmap) and [C/C++](https://github.com/RoaringBitmap/CRoaring) versions.  The Java, C, C++ and Go version are binary compatible: e.g,  you can save bitmaps
 from a Java program and load them back in Go, and vice versa. We have a [format specification](https://github.com/RoaringBitmap/RoaringFormatSpec).
 This code is licensed under Apache License, Version 2.0 (ASL2.0).
 Copyright 2016-... by the authors.
 ### References
 - Daniel Lemire, Owen Kaser, Nathan Kurz, Luca Deri, Chris O'Hara, François Saint-Jacques, Gregory Ssi-Yan-Kai, Roaring Bitmaps: Implementation of an Optimized Software Library, Software: Practice and Experience 48 (4), 2018 [arXiv:1709.07821](https://arxiv.org/abs/1709.07821)
 -  Samy Chambi, Daniel Lemire, Owen Kaser, Robert Godin,
 Better bitmap performance with Roaring bitmaps,
 Software: Practice and Experience 46 (5), 2016.
 http://arxiv.org/abs/1402.6407 This paper used data from http://lemire.me/data/realroaring2014.html
 - Daniel Lemire, Gregory Ssi-Yan-Kai, Owen Kaser, Consistently faster and smaller compressed bitmaps with Roaring, Software: Practice and Experience 46 (11), 2016. http://arxiv.org/abs/1603.06549
 ### Dependencies
 Dependencies are fetched automatically by giving the `-t` flag to `go get`.
 they include
  - github.com/smartystreets/goconvey/convey
  - github.com/willf/bitset
  - github.com/mschoch/smat
  - github.com/glycerine/go-unsnap-stream
  - github.com/philhofer/fwd
  - github.com/jtolds/gls
 Note that the smat library requires Go 1.6 or better.
 #### Installation
  - go get -t github.com/RoaringBitmap/roaring
 ### Example
 Here is a simplified but complete example:
 ```go
 package main
 import (
    "fmt"
    "github.com/RoaringBitmap/roaring"
    "bytes"
 )
 func main() {
    // example inspired by https://github.com/fzandona/goroar
    fmt.Println("==roaring==")
    rb1 := roaring.BitmapOf(1, 2, 3, 4, 5, 100, 1000)
    fmt.Println(rb1.String())
    rb2 := roaring.BitmapOf(3, 4, 1000)
    fmt.Println(rb2.String())
    rb3 := roaring.New()
    fmt.Println(rb3.String())
    fmt.Println("Cardinality: ", rb1.GetCardinality())
    fmt.Println("Contains 3? ", rb1.Contains(3))
    rb1.And(rb2)
    rb3.Add(1)
    rb3.Add(5)
    rb3.Or(rb1)
    // computes union of the three bitmaps in parallel using 4 workers  
    roaring.ParOr(4, rb1, rb2, rb3)
    // computes intersection of the three bitmaps in parallel using 4 workers  
    roaring.ParAnd(4, rb1, rb2, rb3)
    // prints 1, 3, 4, 5, 1000
    i := rb3.Iterator()
    for i.HasNext() {
        fmt.Println(i.Next())
    }
    fmt.Println()
    // next we include an example of serialization
    buf := new(bytes.Buffer)
    rb1.WriteTo(buf) // we omit error handling
    newrb:= roaring.New()
    newrb.ReadFrom(buf)
    if rb1.Equals(newrb) {
    	fmt.Println("I wrote the content to a byte stream and read it back.")
    }
 }
 ```
 If you wish to use serialization and handle errors, you might want to
 consider the following sample of code:
 ```go
 	rb := BitmapOf(1, 2, 3, 4, 5, 100, 1000)
 	buf := new(bytes.Buffer)
 	size,err:=rb.WriteTo(buf)
 	if err != nil {
 		t.Errorf("Failed writing")
 	}
 	newrb:= New()
 	size,err=newrb.ReadFrom(buf)
 	if err != nil {
 		t.Errorf("Failed reading")
 	}
 	if ! rb.Equals(newrb) {
 		t.Errorf("Cannot retrieve serialized version")
 	}
 ```
 Given N integers in [0,x), then the serialized size in bytes of
 a Roaring bitmap should never exceed this bound:
 `` 8 + 9 * ((long)x+65535)/65536 + 2 * N ``
 That is, given a fixed overhead for the universe size (x), Roaring
 bitmaps never use more than 2 bytes per integer. You can call
 ``BoundSerializedSizeInBytes`` for a more precise estimate.
 ### Documentation
 Current documentation is available at http://godoc.org/github.com/RoaringBitmap/roaring
 ### Goroutine safety
 In general, it should not generally be considered safe to access
 the same bitmaps using different goroutines--they are left
 unsynchronized for performance. Should you want to access
 a Bitmap from more than one goroutine, you should
 provide synchronization. Typically this is done by using channels to pass
 the *Bitmap around (in Go style; so there is only ever one owner),
 or by using `sync.Mutex` to serialize operations on Bitmaps.
 ### Coverage
 We test our software. For a report on our test coverage, see
 https://coveralls.io/github/RoaringBitmap/roaring?branch=master
 ### Benchmark
 Type
         go test -bench Benchmark -run -
 To run benchmarks on [Real Roaring Datasets](https://github.com/RoaringBitmap/real-roaring-datasets)
 run the following:
 ```sh
 go get github.com/RoaringBitmap/real-roaring-datasets
 BENCH_REAL_DATA=1 go test -bench BenchmarkRealData -run -
 ```
 ### Iterative use
 You can use roaring with gore:
 - go get -u github.com/motemen/gore
 - Make sure that ``$GOPATH/bin`` is in your ``$PATH``.
 - go get github/RoaringBitmap/roaring
 ```go
 $ gore
 gore version 0.2.6  :help for help
 gore> :import github.com/RoaringBitmap/roaring
 gore> x:=roaring.New()
 gore> x.Add(1)
 gore> x.String()
 "{1}"
 ```
 ### Fuzzy testing
 You can help us test further the library with fuzzy testing:
         go get github.com/dvyukov/go-fuzz/go-fuzz
         go get github.com/dvyukov/go-fuzz/go-fuzz-build
         go test -tags=gofuzz -run=TestGenerateSmatCorpus
         go-fuzz-build github.com/RoaringBitmap/roaring
         go-fuzz -bin=./roaring-fuzz.zip -workdir=workdir/ -timeout=200
 Let it run, and if the # of crashers is > 0, check out the reports in
 the workdir where you should be able to find the panic goroutine stack
 traces.
 ### Alternative in Go
 There is a Go version wrapping the C/C++ implementation https://github.com/RoaringBitmap/gocroaring
 For an alternative implementation in Go, see https://github.com/fzandona/goroar
 The two versions were written independently.
 ### Mailing list/discussion group
 https://groups.google.com/forum/#!forum/roaring-bitmaps
--- a/vendor/github.com/Smerity/govarint/README.md
+++ b/vendor/github.com/Smerity/govarint/README.md
@ -1,67 +0,0 @@
 # Govarint
 This project aims to provide a simple API for the performant encoding and decoding of 32 and 64 bit integers using a variety of algorithms.
 [![](http://i.imgur.com/mpgC23U.jpg)](https://www.flickr.com/photos/tsevis/8648521649/)
 ## Usage
 Each integer encoding algorithm conforms to an encoding and decoding interface.
 The interfaces also specify the size of the unsigned integer, either 32 or 64 bits, and will be referred to as XX below.
 To create an encoder:
    NewU32Base128Encoder(w io.Writer)
    NewU64Base128Encoder(w io.Writer)
    NewU32GroupVarintEncoder(w io.Writer)
 For encoders, the only two commands are `PutUXX` and `Close`.
 `Close` must be called as some integer encoding algorithms write in multiples.
    var buf bytes.Buffer
    enc := NewU32Base128Encoder(&buf)
    enc.PutU32(117)
    enc.PutU32(343)
    enc.Close()
 To create a decoder:
    NewU32Base128Decoder(r io.ByteReader)
    NewU64Base128Decoder(r io.ByteReader)
    NewU32GroupVarintDecoder(r io.ByteReader)
 For decoders, the only command is `GetUXX`.
 `GetUXX` returns the value and any potential errors.
 When reading is complete, `GetUXX` will return an `EOF` (End Of File).
    dec := NewU32Base128Decoder(&buf)
    x, err := dec.GetU32()
 ## Use Cases
 Using fixed width integers, such as uint32 and uint64, usually waste large amounts of space, especially when encoding small values.
 Optimally, smaller numbers should take less space to represent.
 Using integer encoding algorithms is especially common in specific applications, such as storing edge lists or indexes for search engines.
 In these situations, you have a sorted list of numbers that you want to keep as compactly as possible in memory.
 Additionally, by storing only the difference between the given number and the previous (delta encoding), the numbers are quite small, and thus compress well.
 For an explicit example, the Web Data Commons Hyperlink Graph contains 128 billion edges linking page A to page B, where each page is represented by a 32 bit integer.
 By converting all these edges to 64 bit integers (32 | 32), sorting them, and then using delta encoding, memory usage can be reduced from 64 bits per edge down to only 9 bits per edge using the Base128 integer encoding algorithm.
 This figure improves even further if compressed using conventional compression algorithms (3 bits per edge).
 ## Encodings supported
 `govarint` supports:
 + Base128 [32, 64] - each byte uses 7 bits for encoding the integer and 1 bit for indicating if the integer requires another byte
 + Group Varint [32] - integers are encoded in blocks of four - one byte encodes the size of the following four integers, then the values of the four integers follows
 Group Varint consistently beats Base128 in decompression speed but Base128 may offer improved compression ratios depending on the distribution of the supplied integers.
 ## Tests
    go test -v -bench=.
 ## License
 MIT License, as per `LICENSE`
--- a/vendor/github.com/Unknwon/cae/README.md
+++ b/vendor/github.com/Unknwon/cae/README.md
@ -1,37 +0,0 @@
 Compression and Archive Extensions
 ==================================
 [![Go Walker](http://gowalker.org/api/v1/badge)](http://gowalker.org/github.com/Unknwon/cae)
 [中文文档](README_ZH.md)
 Package cae implements PHP-like Compression and Archive Extensions.
 But this package has some modifications depends on Go-style.
 Reference: [PHP:Compression and Archive Extensions](http://www.php.net/manual/en/refs.compression.php).
 Code Convention: based on [Go Code Convention](https://github.com/Unknwon/go-code-convention).
 ### Implementations
 Package `zip`([Go Walker](http://gowalker.org/github.com/Unknwon/cae/zip)) and `tz`([Go Walker](http://gowalker.org/github.com/Unknwon/cae/tz)) both enable you to transparently read or write ZIP/TAR.GZ compressed archives and the files inside them.
 - Features:
 	- Add file or directory from everywhere to archive, no one-to-one limitation.
 	- Extract part of entries, not all at once. 
 	- Stream data directly into `io.Writer` without any file system storage.
 ### Test cases and Coverage
 All subpackages use [GoConvey](http://goconvey.co/) to write test cases, and coverage is more than 80 percent.
 ### Use cases
 - [Gogs](https://github.com/gogits/gogs): self hosted Git service in the Go Programming Language.
 - [GoBlog](https://github.com/fuxiaohei/GoBlog): personal blogging application.
 - [GoBuild](https://github.com/shxsun/gobuild/): online Go cross-platform compilation and download service.
 ## License
 This project is under Apache v2 License. See the [LICENSE](LICENSE) file for the full license text.
--- a/vendor/github.com/Unknwon/cae/README_ZH.md
+++ b/vendor/github.com/Unknwon/cae/README_ZH.md
@ -1,29 +0,0 @@
 压缩与打包扩展
 =============
 [![Go Walker](http://gowalker.org/api/v1/badge)](http://gowalker.org/github.com/Unknwon/cae)
 包 cae 实现了 PHP 风格的压缩与打包扩展。
 但本包依据 Go 语言的风格进行了一些修改。
 引用：[PHP:Compression and Archive Extensions](http://www.php.net/manual/en/refs.compression.php)
 编码规范：基于 [Go 编码规范](https://github.com/Unknwon/go-code-convention)
 ### 实现
 包 `zip`([Go Walker](http://gowalker.org/github.com/Unknwon/cae/zip)) 和 `tz`([Go Walker](http://gowalker.org/github.com/Unknwon/cae/tz)) 都允许你轻易的读取或写入 ZIP/TAR.GZ 压缩档案和其内部文件。
 - 特性：
 	- 将任意位置的文件或目录加入档案，没有一对一的操作限制。
 	- 只解压部分文件，而非一次性解压全部。 
 	- 将数据以流的形式直接写入 `io.Writer` 而不需经过文件系统的存储。
 ### 测试用例与覆盖率
 所有子包均采用 [GoConvey](http://goconvey.co/) 来书写测试用例，覆盖率均超过 80%。
 ## 授权许可
 本项目采用 Apache v2 开源授权许可证，完整的授权说明已放置在 [LICENSE](LICENSE) 文件中。
--- a/vendor/github.com/Unknwon/cae/tz/testdata/test.lnk
+++ b/vendor/github.com/Unknwon/cae/tz/testdata/test.lnk
@ -0,0 +1 @@
 test.zip
--- a/vendor/github.com/Unknwon/cae/tz/testdata/testdir.lnk
+++ b/vendor/github.com/Unknwon/cae/tz/testdata/testdir.lnk
@ -0,0 +1 @@
 testdir
--- a/vendor/github.com/Unknwon/cae/zip/testdata/test.lnk
+++ b/vendor/github.com/Unknwon/cae/zip/testdata/test.lnk
@ -0,0 +1 @@
 test.zip
--- a/vendor/github.com/Unknwon/cae/zip/testdata/testdir.lnk
+++ b/vendor/github.com/Unknwon/cae/zip/testdata/testdir.lnk
@ -0,0 +1 @@
 testdir
--- a/vendor/github.com/Unknwon/com/README.md
+++ b/vendor/github.com/Unknwon/com/README.md
@ -1,20 +0,0 @@
 Common Functions
 ================
 [![Build Status](https://travis-ci.org/Unknwon/com.svg)](https://travis-ci.org/Unknwon/com) [![Go Walker](http://gowalker.org/api/v1/badge)](http://gowalker.org/github.com/Unknwon/com)
 This is an open source project for commonly used functions for the Go programming language.
 This package need >= **go 1.2**
 Code Convention: based on [Go Code Convention](https://github.com/Unknwon/go-code-convention).
 ## Contribute
 Your contribute is welcome, but you have to check following steps after you added some functions and commit them:
 1. Make sure you wrote user-friendly comments for **all functions** .
 2. Make sure you wrote test cases with any possible condition for **all functions** in file `*_test.go`.
 3. Make sure you wrote benchmarks for **all functions** in file `*_test.go`.
 4. Make sure you wrote useful examples for **all functions** in file `example_test.go`.
 5. Make sure you ran `go test` and got **PASS** .
--- a/vendor/github.com/Unknwon/i18n/Makefile
+++ b/vendor/github.com/Unknwon/i18n/Makefile
@ -1,12 +0,0 @@
 .PHONY: build test bench vet
 build: vet bench
 test:
 	go test -v -cover
 bench:
 	go test -v -cover -test.bench=. -test.benchmem
 vet:
 	go vet
--- a/vendor/github.com/Unknwon/i18n/README.md
+++ b/vendor/github.com/Unknwon/i18n/README.md
@ -1,136 +0,0 @@
 i18n [![GoDoc](https://godoc.org/github.com/Unknwon/i18n?status.svg)](https://godoc.org/github.com/Unknwon/i18n) [![Sourcegraph](https://sourcegraph.com/github.com/Unknwon/i18n/-/badge.svg)](https://sourcegraph.com/github.com/Unknwon/i18n?badge)
 ====
 Package i18n is for app Internationalization and Localization.
 ## Introduction
 This package provides multiple-language options to improve user experience. Sites like [Go Walker](http://gowalker.org) and [gogs.io](http://gogs.io) are using this module to implement Chinese and English user interfaces.
 You can use following command to install this module:
    go get github.com/Unknwon/i18n
 ## Usage
 First of all, you have to import this package:
 ```go
 import "github.com/Unknwon/i18n"
 ```
 The format of locale files is very like INI format configuration file, which is basically key-value pairs. But this module has some improvements. Every language corresponding to a locale file, for example, under `conf/locale` folder of [gogsweb](https://github.com/gogits/gogsweb/tree/master/conf/locale), there are two files called `locale_en-US.ini` and `locale_zh-CN.ini`.
 The name and extensions of locale files can be anything, but we strongly recommend you to follow the style of gogsweb.
 ## Minimal example
 Here are two simplest locale file examples:
 File `locale_en-US.ini`:
 ```ini
 hi = hello, %s
 bye = goodbye
 ```
 File `locale_zh-CN.ini`:
 ```ini
 hi = 您好，%s
 bye = 再见
 ```
 ### Do Translation
 There are two ways to do translation depends on which way is the best fit for your application or framework.
 Directly use package function to translate:
 ```go
 i18n.Tr("en-US", "hi", "Unknwon")
 i18n.Tr("en-US", "bye")
 ```
 Or create a struct and embed it:
 ```go
 type MyController struct{
    // ...other fields
    i18n.Locale
 }
 //...
 func ... {
    c := &MyController{
        Locale: i18n.Locale{"en-US"},
    }
    _ = c.Tr("hi", "Unknwon")
    _ = c.Tr("bye")
 }
 ```
 Code above will produce correspondingly:
 - English `en-US`：`hello, Unknwon`, `goodbye`
 - Chinese `zh-CN`：`您好，Unknwon`, `再见`
 ## Section
 For different pages, one key may map to different values. Therefore, i18n module also uses the section feature of INI format configuration to achieve section.
 For example, the key name is `about`, and we want to show `About` in the home page and `About Us` in about page. Then you can do following:
 Content in locale file:
 ```ini
 about = About
 [about]
 about = About Us
 ```
 Get `about` in home page:
 ```go
 i18n.Tr("en-US", "about")
 ```
 Get `about` in about page:
 ```go
 i18n.Tr("en-US", "about.about")
 ```
 ### Ambiguity
 Because dot `.` is sign of section in both [INI parser](https://github.com/go-ini/ini) and locale files, so when your key name contains `.` will cause ambiguity. At this point, you just need to add one more `.` in front of the key.
 For example, the key name is `about.`, then we can use:
 ```go
 i18n.Tr("en-US", ".about.")
 ```
 to get expect result.
 ## Helper tool
 Module i18n provides a command line helper tool beei18n for simplify steps of your development. You can install it as follows:
 	go get github.com/Unknwon/i18n/ui18n
 ### Sync locale files
 Command `sync` allows you use a exist local file as the template to create or sync other locale files:
 	ui18n sync srouce_file.ini other1.ini other2.ini
 This command can operate 1 or more files in one command.
 ## More information
 - The first locale you load to the module is considered as **default locale**.
 - When matching non-default locale and didn't find the string, i18n will have a second try on default locale.
 - If i18n still cannot find string in the default locale, raw string will be returned. For instance, when the string is `hi` and it does not exist in locale file, simply return `hi` as output.
--- a/vendor/github.com/Unknwon/paginater/README.md
+++ b/vendor/github.com/Unknwon/paginater/README.md
@ -1,65 +0,0 @@
 Paginater [![Build Status](https://drone.io/github.com/Unknwon/paginater/status.png)](https://drone.io/github.com/Unknwon/paginater/latest) [![](http://gocover.io/_badge/github.com/Unknwon/paginater)](http://gocover.io/github.com/Unknwon/paginater)
 =========
 Package paginater is a helper module for custom pagination calculation.
 ## Installation
 	go get github.com/Unknwon/paginater
 ## Getting Started
 The following code shows an example of how to use paginater:
 ```go
 package main
 import "github.com/Unknwon/paginater"
 func main() {
 	// Arguments:
 	// - Total number of rows
 	// - Number of rows in one page
 	// - Current page number 
 	// - Number of page links
 	p := paginater.New(45, 10, 3, 3)
 	// Then use p as a template object named "Page" in "demo.html"
 	// ...
 }
 ```
 `demo.html`
 ```html
 {{if not .Page.IsFirst}}[First](1){{end}}
 {{if .Page.HasPrevious}}[Previous]({{.Page.Previous}}){{end}}
 {{range .Page.Pages}}
 	{{if eq .Num -1}}
 	...
 	{{else}}
 	{{.Num}}{{if .IsCurrent}}(current){{end}}
 	{{end}}
 {{end}}
 {{if .Page.HasNext}}[Next]({{.Page.Next}}){{end}}
 {{if not .Page.IsLast}}[Last]({{.Page.TotalPages}}){{end}}
 ```
 Possible output:
 ```
 [First](1) [Previous](2) ... 2 3(current) 4 ... [Next](4) [Last](5)
 ```
 As you may guess, if the `Page` value is `-1`, you should print `...` in the HTML as common practice.
 ## Getting Help
 - [API Documentation](https://gowalker.org/github.com/Unknwon/paginater)
 - [File An Issue](https://github.com/Unknwon/paginater/issues/new)
 ## License
 This project is under Apache v2 License. See the [LICENSE](LICENSE) file for the full license text.
--- a/vendor/github.com/andybalholm/cascadia/README.md
+++ b/vendor/github.com/andybalholm/cascadia/README.md
@ -1,7 +0,0 @@
 # cascadia
 [![](https://travis-ci.org/andybalholm/cascadia.svg)](https://travis-ci.org/andybalholm/cascadia)
 The Cascadia package implements CSS selectors for use with the parse trees produced by the html package.
 To test CSS selectors without writing Go code, check out [cascadia](https://github.com/suntong/cascadia) the command line tool, a thin wrapper around this package.
--- a/vendor/github.com/blevesearch/bleve/CONTRIBUTING.md
+++ b/vendor/github.com/blevesearch/bleve/CONTRIBUTING.md
@ -1,16 +0,0 @@
 # Contributing to Bleve
 We look forward to your contributions, but ask that you first review these guidelines.
 ### Sign the CLA
 As Bleve is a Couchbase project we require contributors accept the [Couchbase Contributor License Agreement](http://review.couchbase.org/static/individual_agreement.html). To sign this agreement log into the Couchbase [code review tool](http://review.couchbase.org/). The Bleve project does not use this code review tool but it is still used to track acceptance of the contributor license agreements.
 ### Submitting a Pull Request
 All types of contributions are welcome, but please keep the following in mind:
 - If you're planning a large change, you should really discuss it in a github issue or on the google group first. This helps avoid duplicate effort and spending time on something that may not be merged.
 - Existing tests should continue to pass, new tests for the contribution are nice to have.
 - All code should have gone through `go fmt`
 - All code should pass `go vet`
--- a/vendor/github.com/blevesearch/bleve/README.md
+++ b/vendor/github.com/blevesearch/bleve/README.md
@ -1,67 +0,0 @@
 # ![bleve](docs/bleve.png) bleve
 [![Build Status](https://travis-ci.org/blevesearch/bleve.svg?branch=master)](https://travis-ci.org/blevesearch/bleve) [![Coverage Status](https://coveralls.io/repos/github/blevesearch/bleve/badge.svg?branch=master)](https://coveralls.io/github/blevesearch/bleve?branch=master) [![GoDoc](https://godoc.org/github.com/blevesearch/bleve?status.svg)](https://godoc.org/github.com/blevesearch/bleve)
 [![Join the chat at https://gitter.im/blevesearch/bleve](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/blevesearch/bleve?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![codebeat](https://codebeat.co/badges/38a7cbc9-9cf5-41c0-a315-0746178230f4)](https://codebeat.co/projects/github-com-blevesearch-bleve)
 [![Go Report Card](https://goreportcard.com/badge/blevesearch/bleve)](https://goreportcard.com/report/blevesearch/bleve)
 [![Sourcegraph](https://sourcegraph.com/github.com/blevesearch/bleve/-/badge.svg)](https://sourcegraph.com/github.com/blevesearch/bleve?badge)  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 modern text indexing in go - [blevesearch.com](http://www.blevesearch.com/)
 Try out bleve live by [searching the bleve website](http://www.blevesearch.com/search/?q=bleve).
 ## Features
 * Index any go data structure (including JSON)
 * Intelligent defaults backed up by powerful configuration
 * Supported field types:
    * Text, Numeric, Date
 * Supported query types:
    * Term, Phrase, Match, Match Phrase, Prefix
    * Conjunction, Disjunction, Boolean
    * Numeric Range, Date Range
    * Simple query [syntax](http://www.blevesearch.com/docs/Query-String-Query/) for human entry
 * tf-idf Scoring
 * Search result match highlighting
 * Supports Aggregating Facets:
    * Terms Facet
    * Numeric Range Facet
    * Date Range Facet
 ## Discussion
 Discuss usage and development of bleve in the [google group](https://groups.google.com/forum/#!forum/bleve).
 ## Indexing
 ```go
 message := struct{
 	Id   string
 	From string
 	Body string
 }{
 	Id:   "example",
 	From: "marty.schoch@gmail.com",
 	Body: "bleve indexing is easy",
 }
 mapping := bleve.NewIndexMapping()
 index, err := bleve.New("example.bleve", mapping)
 if err != nil {
 	panic(err)
 }
 index.Index(message.Id, message)
 ```
 ## Querying
 ```go
 index, _ := bleve.Open("example.bleve")
 query := bleve.NewQueryStringQuery("bleve")
 searchRequest := bleve.NewSearchRequest(query)
 searchResult, _ := index.Search(searchRequest)
 ```
 ## License
 Apache License Version 2.0
--- a/vendor/github.com/blevesearch/bleve/analysis/test_words.txt
+++ b/vendor/github.com/blevesearch/bleve/analysis/test_words.txt
@ -1,7 +0,0 @@
 # full line comment
 marty
 steve # trailing comment
 | different format of comment
 dustin
 siri | different style trailing comment
 multiple words	with different	whitespace
--- a/vendor/github.com/blevesearch/bleve/geo/README.md
+++ b/vendor/github.com/blevesearch/bleve/geo/README.md
@ -1,9 +0,0 @@
 # geo support in bleve
 First, all of this geo code is a Go adaptation of the [Lucene 5.3.2 sandbox geo support](https://lucene.apache.org/core/5_3_2/sandbox/org/apache/lucene/util/package-summary.html).
 ## Notes
 - All of the APIs will use float64 for lon/lat values.
 - When describing a point in function arguments or return values, we always use the order lon, lat.
 - High level APIs will use TopLeft and BottomRight to describe bounding boxes.  This may not map cleanly to min/max lon/lat when crossing the dateline.  The lower level APIs will use min/max lon/lat and require the higher-level code to split boxes accordingly.
--- a/vendor/github.com/blevesearch/bleve/index/scorch/README.md
+++ b/vendor/github.com/blevesearch/bleve/index/scorch/README.md
@ -1,367 +0,0 @@
 # scorch
 ## Definitions
 Batch
 - A collection of Documents to mutate in the index.
 Document
 - Has a unique identifier (arbitrary bytes).
 - Is comprised of a list of fields.
 Field
 - Has a name (string).
 - Has a type (text, number, date, geopoint).
 - Has a value (depending on type).
 - Can be indexed, stored, or both.
 - If indexed, can be analyzed.
 -m If indexed, can optionally store term vectors.
 ## Scope
 Scorch *MUST* implement the bleve.index API without requiring any changes to this API.
 Scorch *MAY* introduce new interfaces, which can be discovered to allow use of new capabilities not in the current API.
 ## Implementation
 The scorch implementation starts with the concept of a segmented index.
 A segment is simply a slice, subset, or portion of the entire index.  A segmented index is one which is composed of one or more segments.  Although segments are created in a particular order, knowing this ordering is not required to achieve correct semantics when querying.  Because there is no ordering, this means that when searching an index, you can (and should) search all the segments concurrently.
 ### Internal Wrapper
 In order to accommodate the existing APIs while also improving the implementation, the scorch implementation includes some wrapper functionality that must be described.
 #### \_id field
 In scorch, field 0 is prearranged to be named \_id.  All documents have a value for this field, which is the documents external identifier.  In this version the field *MUST* be both indexed AND stored.  The scorch wrapper adds this field, as it will not be present in the Document from the calling bleve code.
 NOTE: If a document already contains a field \_id, it will be replaced.  If this is problematic, the caller must ensure such a scenario does not happen.
 ### Proposed Structures
 ```
 type Segment interface {
  Dictionary(field string) TermDictionary
 }
 type TermDictionary interface {
  PostingsList(term string, excluding PostingsList) PostingsList
 }
 type PostingsList interface {
  Next() Posting
  And(other PostingsList) PostingsList
  Or(other PostingsList) PostingsList
 }
 type Posting interface {
  Number() uint64
  Frequency() uint64
  Norm() float64
  Locations() Locations
 }
 type Locations interface {
  Start() uint64
  End() uint64
  Pos() uint64
  ArrayPositions() ...
 }
 type DeletedDocs {
 }
 type SegmentSnapshot struct {
  segment Segment
  deleted PostingsList
 }
 type IndexSnapshot struct {
  segment []SegmentSnapshot
 }
 ```
 **What about errors?**
 **What about memory mgmnt or context?**
 **Postings List separate iterator to separate stateful from stateless**
 ### Mutating the Index
 The bleve.index API has methods for directly making individual mutations (Update/Delete/SetInternal/DeleteInternal), however for this first implementation, we assume that all of these calls can simply be turned into a Batch of size 1.  This may be highly inefficient, but it will be correct.  This decision is made based on the fact that Couchbase FTS always uses Batches.
 NOTE: As a side-effect of this decision, it should be clear that performance tuning may depend on the batch size, which may in-turn require changes in FTS.
 From this point forward, only Batch mutations will be discussed.
 Sequence of Operations:
 1.  For each document in the batch, search through all existing segments.  The goal is to build up a per-segment bitset which tells us which documents in that segment are obsoleted by the addition of the new segment we're currently building.  NOTE: we're not ready for this change to take effect yet, so rather than this operation mutating anything, they simply return bitsets, which we can apply later.  Logically, this is something like:
    ```
      foreach segment {
        dict := segment.Dictionary("\_id")
        postings := empty postings list
        foreach docID {
          postings = postings.Or(dict.PostingsList(docID, nil))
        }
      }
    ```
    NOTE: it is illustrated above as nested for loops, but some or all of these could be concurrently.  The end result is that for each segment, we have (possibly empty) bitset.
 2.  Also concurrent with 1, the documents in the batch are analyzed.  This analysis proceeds using the existing analyzer pool.
 3. (after 2 completes) Analyzed documents are fed into a function which builds a new Segment representing this information.
 4.  We now have everything we need to update the state of the system to include this new snapshot.
  -  Acquire a lock
  -  Create a new IndexSnapshot
  -  For each SegmentSnapshot in the IndexSnapshot, take the deleted PostingsList and OR it with the new postings list for this Segment.  Construct a new SegmentSnapshot for the segment using this new deleted PostingsList.  Append this SegmentSnapshot to the IndexSnapshot.
  -  Create a new SegmentSnapshot wrapping our new segment with nil deleted docs.
  -  Append the new SegmentSnapshot to the IndexSnapshot
  -  Release the lock
 An ASCII art example:
  ```
  0 - Empty Index
  No segments
  IndexSnapshot
    segments []
    deleted []
  1 - Index Batch [ A B C ]
  segment       0
  numbers   [ 1 2 3 ]
  \_id      [ A B C ]
  IndexSnapshot
    segments [ 0 ]
    deleted [ nil ]
  2 - Index Batch [ B' ]
  segment       0           1
  numbers   [ 1 2 3 ]     [ 1 ]
  \_id      [ A B C ]     [ B ]
  Compute bitset segment-0-deleted-by-1:
            [ 0 1 0 ]
  OR it with previous (nil) (call it 0-1)
            [ 0 1 0 ]
  IndexSnapshot
    segments [  0    1 ]
    deleted  [ 0-1 nil ]
  3 - Index Batch [ C' ]
    segment       0           1      2
    numbers   [ 1 2 3 ]     [ 1 ]  [ 1 ]
    \_id      [ A B C ]     [ B ]  [ C ]
    Compute bitset segment-0-deleted-by-2:
              [ 0 0 1 ]
    OR it with previous ([ 0 1 0 ]) (call it 0-12)
              [ 0 1 1 ]
  Compute bitset segment-1-deleted-by-2:
              [ 0 ]
  OR it with previous (nil)
              still just nil
    IndexSnapshot
      segments [  0    1    2 ]
      deleted  [ 0-12 nil  nil ]
  ```
 **is there opportunity to stop early when doc is found in one segment**
 **also, more efficient way to find bits for long lists of ids?**
 ### Searching
 In the bleve.index API all searching starts by getting an IndexReader, which represents a snapshot of the index at a point in time.
 As described in the section above, our index implementation maintains a pointer to the current IndexSnapshot.  When a caller gets an IndexReader, they get a copy of this pointer, and can use it as long as they like.  The IndexSnapshot contains SegmentSnapshots, which only contain pointers to immutable segments.  The deleted posting lists associated with a segment change over time, but the particular deleted posting list in YOUR snapshot is immutable.  This gives a stable view of the data.
 #### Term Search
 Term search is the only searching primitive exposed in today's bleve.index API.  This ultimately could limit our ability to take advantage of the indexing improvements, but it also means it will be easier to get a first version of this working.
 A term search for term T in field F will look something like this:
 ```
  searchResultPostings = empty
  foreach segment {
    dict := segment.Dictionary(F)
    segmentResultPostings = dict.PostingsList(T, segmentSnapshotDeleted)
    // make segmentLocal numbers into global numbers, and flip bits in searchResultPostings
  }
 ```
 The searchResultPostings will be a new implementation of the TermFieldReader inteface.
 As a reminder this interface is:
 ```
 // TermFieldReader is the interface exposing the enumeration of documents
 // containing a given term in a given field. Documents are returned in byte
 // lexicographic order over their identifiers.
 type TermFieldReader interface {
 	// Next returns the next document containing the term in this field, or nil
 	// when it reaches the end of the enumeration.  The preAlloced TermFieldDoc
 	// is optional, and when non-nil, will be used instead of allocating memory.
 	Next(preAlloced *TermFieldDoc) (*TermFieldDoc, error)
 	// Advance resets the enumeration at specified document or its immediate
 	// follower.
 	Advance(ID IndexInternalID, preAlloced *TermFieldDoc) (*TermFieldDoc, error)
 	// Count returns the number of documents contains the term in this field.
 	Count() uint64
 	Close() error
 }
 ```
 At first glance this appears problematic, we have no way to return documents in order of their identifiers.  But it turns out the wording of this perhaps too strong, or a bit ambiguous.  Originally, this referred to the external identifiers, but with the introduction of a distinction between internal/external identifiers, returning them in order of their internal identifiers is also acceptable.  **ASIDE**: the reason for this is that most callers just use Next() and literally don't care what the order is, they could be in any order and it would be fine.  There is only one search that cares and that is the ConjunctionSearcher, which relies on Next/Advance having very specific semantics.  Later in this document we will have a proposal to split into multiple interfaces:
 -  The weakest interface, only supports Next() no ordering at all.
 -  Ordered, supporting Advance()
 -  And/Or'able capable of internally efficiently doing these ops with like interfaces (if not capable then can always fall back to external walking)
 But, the good news is that we don't even have to do that for our first implementation.  As long as the global numbers we use for internal identifiers are consistent within this IndexSnapshot, then Next() will be ordered by ascending document number, and Advance() will still work correctly.
 NOTE: there is another place where we rely on the ordering of these hits, and that is in the "\_id" sort order.  Previously this was the natural order, and a NOOP for the collector, now it must be implemented by actually sorting on the "\_id" field.  We probably should introduce at least a marker interface to detect this.
 An ASCII art example:
 ```
 Let's start with the IndexSnapshot we ended with earlier:
 3 - Index Batch [ C' ]
  segment       0           1      2
  numbers   [ 1 2 3 ]     [ 1 ]  [ 1 ]
  \_id      [ A B C ]     [ B ]  [ C ]
  Compute bitset segment-0-deleted-by-2:
            [ 0 0 1 ]
  OR it with previous ([ 0 1 0 ]) (call it 0-12)
            [ 0 1 1 ]
 Compute bitset segment-1-deleted-by-2:
            [ 0 0 0 ]
 OR it with previous (nil)
            still just nil
  IndexSnapshot
    segments [  0    1    2 ]
    deleted  [ 0-12 nil  nil ]
 Now let's search for the term 'cat' in the field 'desc' and let's assume that Document C (both versions) would match it.
 Concurrently:
  - Segment 0
   - Get Term Dictionary For Field 'desc'
   - From it get Postings List for term 'cat' EXCLUDING 0-12
   - raw segment matches [ 0 0 1 ] but excluding [ 0 1 1 ] gives [ 0 0 0 ]
  - Segment 1
   - Get Term Dictionary For Field 'desc'
   - From it get Postings List for term 'cat' excluding nil
   - [ 0 ]
  - Segment 2
   - Get Term Dictionary For Field 'desc'
   - From it get Postings List for term 'cat' excluding nil
   - [ 1 ]
 Map local bitsets into global number space (global meaning cross-segment but still unique to this snapshot)
 IndexSnapshot already should have mapping something like:
 0 - Offset 0
 1 - Offset 3 (because segment 0 had 3 docs)
 2 - Offset 4 (becuase segment 1 had 1 doc)
 This maps to search result bitset:
 [ 0 0 0 0 1]
 Caller would call Next() and get doc number 5 (assuming 1 based indexing for now)
 Caller could then ask to get term locations, stored fields, external doc ID for document number 5.  Internally in the IndexSnapshot, we can now convert that back, and realize doc number 5 comes from segment 2, 5-4=1 so we're looking for doc number 1 in segment 2.  That happens to be C...
 ```
 #### Future improvements
 In the future, interfaces to detect these non-serially operating TermFieldReaders could expose their own And() and Or() up to the higher level Conjunction/Disjunction searchers.  Doing this alone offers some win, but also means there would be greater burden on the Searcher code rewriting logical expressions for maximum performance.
 Another related topic is that of peak memory usage.  With serially operating TermFieldReaders it was necessary to start them all at the same time and operate in unison.  However, with these non-serially operating TermFieldReaders we have the option of doing a few at a time, consolidating them, dispoting the intermediaries, and then doing a few more.  For very complex queries with many clauses this could reduce peak memory usage.
 ### Memory Tracking
 All segments must be able to produce two statistics, an estimate of their explicit memory usage, and their actual size on disk (if any).  For in-memory segments, disk usage could be zero, and the memory usage represents the entire information content.  For mmap-based disk segments, the memory could be as low as the size of tracking structure itself (say just a few pointers).
 This would allow the implementation to throttle or block incoming mutations when a threshold memory usage has (or would be) exceeded.
 ### Persistence
 Obviously, we want to support (but maybe not require) asynchronous persistence of segments.  My expectation is that segments are initially built in memory.  At some point they are persisted to disk.  This poses some interesting challenges.
 At runtime, the state of an index (it's IndexSnapshot) is not only the contents of the segments, but also the bitmasks of deleted documents.  These bitmasks indirectly encode an ordering in which the segments were added.  The reason is that the bitmasks encode which items have been obsoleted by other (subsequent or more future) segments.  In the runtime implementation we compute bitmask deltas and then merge them at the same time we bring the new segment in.  One idea is that we could take a similar approach on disk.  When we persist a segment, we persist the bitmask deltas of segments known to exist at that time, and eventually these can get merged up into a base segment deleted bitmask.
 This also relates to the topic rollback, addressed next...
 ### Rollback
 One desirable property in the Couchbase ecosystem is the ability to rollback to some previous (though typically not long ago) state.  One idea for keeping this property in this design is to protect some of the most recent segments from merging.  Then, if necessary, they could be "undone" to reveal previous states of the system.  In these scenarios "undone" has to properly undo the deleted bitmasks on the other segments.  Again, the current thinking is that rather than "undo" anything, it could be work that was deferred in the first place, thus making it easier to logically undo.
 Another possibly related approach would be to tie this into our existing snapshot mechanism.  Perhaps simulating a slow reader (holding onto index snapshots) for some period of time, can be the mechanism to achieve the desired end goal.
 ### Internal Storage
 The bleve.index API has support for "internal storage".  The ability to store information under a separate name space.
 This is not used for high volume storage, so it is tempting to think we could just put a small k/v store alongside the rest of the index.  But, the reality is that this storage is used to maintain key information related to the rollback scenario.  Because of this, its crucial that ordering and overwriting of key/value pairs correspond with actual segment persistence in the index.  Based on this, I believe its important to put the internal key/value pairs inside the segments themselves.  But, this also means that they must follow a similar "deleted" bitmask approach to obsolete values in older segments.  But, this also seems to substantially increase the complexity of the solution because of the separate name space, it would appear to require its own bitmask.  Further keys aren't numeric, which then implies yet another mapping from internal key to number, etc.
 More thought is required here.
 ### Merging
 The segmented index approach requires merging to prevent the number of segments from growing too large.
 Recent experience with LSMs has taught us that having the correct merge strategy can make a huge difference in the overall performance of the system.  In particular, a simple merge strategy which merges segments too aggressively can lead to high write amplification and unnecessarily rendering cached data useless.
 A few simple principles have been identified.
 - Roughly we merge multiple smaller segments into a single larger one.
 - The larger a segment gets the less likely we should be to ever merge it.
 - Segments with large numbers of deleted/obsoleted items are good candidates as the merge will result in a space savings.
 - Segments with all items deleted/obsoleted can be dropped.
 Merging of a segment should be able to proceed even if that segment is held by an ongoing snapshot, it should only delay the removal of it.
--- a/vendor/github.com/blevesearch/bleve/index/scorch/segment/zap/README.md
+++ b/vendor/github.com/blevesearch/bleve/index/scorch/segment/zap/README.md
@ -1,167 +0,0 @@
 # zap file format
 The file is written in the reverse order that we typically access data.  This helps us write in one pass since later sections of the file require file offsets of things we've already written.
 Current usage:
 - mmap the entire file
 - crc-32 bytes and version are in fixed position at end of the file
 - reading remainder of footer could be version specific
 - remainder of footer gives us:
  - 3 important offsets (docValue , fields index and stored data index)
  - 2 important values (number of docs and chunk factor)
 - field data is processed once and memoized onto the heap so that we never have to go back to disk for it
 - access to stored data by doc number means first navigating to the stored data index, then accessing a fixed position offset into that slice, which gives us the actual address of the data.  the first bytes of that section tell us the size of data so that we know where it ends.
 - access to all other indexed data follows the following pattern:
  - first know the field name -> convert to id
  - next navigate to term dictionary for that field
    - some operations stop here and do dictionary ops
  - next use dictionary to navigate to posting list for a specific term
  - walk posting list
  - if necessary, walk posting details as we go
  - if location info is desired, consult location bitmap to see if it is there
 ## stored fields section
 - for each document
  - preparation phase:
    - produce a slice of metadata bytes and data bytes
    - produce these slices in field id order
    - field value is appended to the data slice
    - metadata slice is govarint encoded with the following values for each field value
      - field id (uint16)
      - field type (byte)
      - field value start offset in uncompressed data slice (uint64)
      - field value length (uint64)
      - field number of array positions (uint64)
      - one additional value for each array position (uint64)
      - compress the data slice using snappy
  - file writing phase:
    - remember the start offset for this document
    - write out meta data length (varint uint64)
    - write out compressed data length (varint uint64)
    - write out the metadata bytes
    - write out the compressed data bytes
 ## stored fields idx
 - for each document
  - write start offset (remembered from previous section) of stored data (big endian uint64)
 With this index and a known document number, we have direct access to all the stored field data.
 ## posting details (freq/norm) section
 - for each posting list
  - produce a slice containing multiple consecutive chunks (each chunk is govarint stream)
  - produce a slice remembering offsets of where each chunk starts
  - preparation phase:
    - for each hit in the posting list
    - if this hit is in next chunk close out encoding of last chunk and record offset start of next
    - encode term frequency (uint64)
    - encode norm factor (float32)
  - file writing phase:
    - remember start position for this posting list details
    - write out number of chunks that follow (varint uint64)
    - write out length of each chunk (each a varint uint64)
    - write out the byte slice containing all the chunk data
 If you know the doc number you're interested in, this format lets you jump to the correct chunk (docNum/chunkFactor) directly and then seek within that chunk until you find it.
 ## posting details (location) section
 - for each posting list
  - produce a slice containing multiple consecutive chunks (each chunk is govarint stream)
  - produce a slice remembering offsets of where each chunk starts
  - preparation phase:
    - for each hit in the posting list
    - if this hit is in next chunk close out encoding of last chunk and record offset start of next
    - encode field (uint16)
    - encode field pos (uint64)
    - encode field start (uint64)
    - encode field end (uint64)
    - encode number of array positions to follow (uint64)
    - encode each array position (each uint64)
  - file writing phase:
    - remember start position for this posting list details
    - write out number of chunks that follow (varint uint64)
    - write out length of each chunk (each a varint uint64)
    - write out the byte slice containing all the chunk data
 If you know the doc number you're interested in, this format lets you jump to the correct chunk (docNum/chunkFactor) directly and then seek within that chunk until you find it.
 ## bitmaps of hits with location info
 - for each posting list
  - preparation phase:
    - encode roaring bitmap (inidicating which hits have location details indexed) posting list to bytes (so we know the length)
  - file writing phase:
    - remember the start position for this bitmap
    - write length of encoded roaring bitmap
    - write the serialized roaring bitmap data
 ## postings list section
 - for each posting list
  - preparation phase:
    - encode roaring bitmap posting list to bytes (so we know the length)
  - file writing phase:
    - remember the start position for this posting list
    - write freq/norm details offset (remembered from previous, as varint uint64)
    - write location details offset (remembered from previous, as varint uint64)
    - write location bitmap offset (remembered from pervious, as varint uint64)
    - write length of encoded roaring bitmap
    - write the serialized roaring bitmap data
 ## dictionary
 - for each field
  - preparation phase:
    - encode vellum FST with dictionary data pointing to file offset of posting list (remembered from previous)
  - file writing phase:
    - remember the start position of this persistDictionary
    - write length of vellum data (varint uint64)
    - write out vellum data
 ## fields section
 - for each field
  - file writing phase:
    - remember start offset for each field
    - write dictionary address (remembered from previous) (varint uint64)
    - write length of field name (varint uint64)
    - write field name bytes
 ## fields idx
 - for each field
  - file writing phase:
    - write big endian uint64 of start offset for each field
 NOTE: currently we don't know or record the length of this fields index.  Instead we rely on the fact that we know it immediately precedes a footer of known size.
 ## fields DocValue
 - for each field
  - preparation phase:
    - produce a slice containing multiple consecutive chunks, where each chunk is composed of a meta section followed by compressed columnar field data
    - produce a slice remembering the length of each chunk
  - file writing phase:
    - remember the start position of this first field DocValue offset in the footer
    - write out number of chunks that follow (varint uint64)
    - write out length of each chunk (each a varint uint64)
    - write out the byte slice containing all the chunk data
 NOTE: currently the meta header inside each chunk gives clue to the location offsets and size of the data pertaining to a given docID and any
 read operation leverage that meta information to extract the document specific data from the file.
 ## footer
 - file writing phase
  - write number of docs (big endian uint64)
  - write stored field index location (big endian uint64)
  - write field index location (big endian uint64)
  - write field docValue location (big endian uint64)
  - write out chunk factor (big endian uint32)
  - write out version (big endian uint32)
  - write out file CRC of everything preceding this (big endian uint32)
--- a/vendor/github.com/blevesearch/bleve/index/upsidedown/benchmark_all.sh
+++ b/vendor/github.com/blevesearch/bleve/index/upsidedown/benchmark_all.sh
@ -1,8 +0,0 @@
 #!/bin/sh
 BENCHMARKS=`grep "func Benchmark" *_test.go  | sed 's/.*func //' | sed s/\(.*{//`
 for BENCHMARK in $BENCHMARKS
 do
 	go test -v -run=xxx -bench=^$BENCHMARK$ -benchtime=10s -tags 'forestdb leveldb'  | grep -v ok | grep -v PASS
 done
--- a/vendor/github.com/blevesearch/bleve/index/upsidedown/upsidedown.proto
+++ b/vendor/github.com/blevesearch/bleve/index/upsidedown/upsidedown.proto
@ -1,14 +0,0 @@
 message BackIndexTermsEntry {
  required uint32 field = 1;
 	repeated string terms = 2;
 }
 message BackIndexStoreEntry {
 	required uint32 field = 1;
 	repeated uint64 arrayPositions = 2;
 }
 message BackIndexRowValue {
 	repeated BackIndexTermsEntry termsEntries = 1;
 	repeated BackIndexStoreEntry storedEntries = 2;
 }
--- a/vendor/github.com/blevesearch/bleve/search/facet/benchmark_data.txt
+++ b/vendor/github.com/blevesearch/bleve/search/facet/benchmark_data.txt
--- a/vendor/github.com/blevesearch/bleve/search/query/query_string.y
+++ b/vendor/github.com/blevesearch/bleve/search/query/query_string.y
@ -1,328 +0,0 @@
 %{
 package query
 import (
 	"fmt"
 	"strconv"
 	"strings"
 	"time"
 )
 func logDebugGrammar(format string, v ...interface{}) {
 	if debugParser {
    	logger.Printf(format, v...)
    }
 }
 %}
 %union {
 s string
 n int
 f float64
 q Query
 pf *float64}
 %token tSTRING tPHRASE tPLUS tMINUS tCOLON tBOOST tNUMBER tSTRING tGREATER tLESS
 tEQUAL tTILDE
 %type <s>                tSTRING
 %type <s>                tPHRASE
 %type <s>                tNUMBER
 %type <s>                posOrNegNumber
 %type <s>                tTILDE
 %type <s>                tBOOST
 %type <q>                searchBase
 %type <pf>                searchSuffix
 %type <n>                searchPrefix
 %%
 input:
 searchParts {
 	logDebugGrammar("INPUT")
 };
 searchParts:
 searchPart searchParts {
 	logDebugGrammar("SEARCH PARTS")
 }
 |
 searchPart {
 	logDebugGrammar("SEARCH PART")
 };
 searchPart:
 searchPrefix searchBase searchSuffix {
 	query := $2
 	if $3 != nil {
 		if query, ok := query.(BoostableQuery); ok {
 			query.SetBoost(*$3)
 			}
 	}
 	switch($1) {
 		case queryShould:
 			yylex.(*lexerWrapper).query.AddShould(query)
 		case queryMust:
 			yylex.(*lexerWrapper).query.AddMust(query)
 		case queryMustNot:
 			yylex.(*lexerWrapper).query.AddMustNot(query)
 	}
 };
 searchPrefix:
 /* empty */ {
 	$$ = queryShould
 }
 |
 tPLUS {
 	logDebugGrammar("PLUS")
 	$$ = queryMust
 }
 |
 tMINUS {
 	logDebugGrammar("MINUS")
 	$$ = queryMustNot
 };
 searchBase:
 tSTRING {
 	str := $1
 	logDebugGrammar("STRING - %s", str)
 	var q FieldableQuery
 	if strings.HasPrefix(str, "/") && strings.HasSuffix(str, "/") {
 	  q = NewRegexpQuery(str[1:len(str)-1])
 	} else if strings.ContainsAny(str, "*?"){
 	  q = NewWildcardQuery(str)
 	} else {
 	  q = NewMatchQuery(str)
 	}
 	$$ = q
 }
 |
 tSTRING tTILDE {
 	str := $1
 	fuzziness, err := strconv.ParseFloat($2, 64)
 	if err != nil {
 	  yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid fuzziness value: %v", err))
 	}
 	logDebugGrammar("FUZZY STRING - %s %f", str, fuzziness)
 	q := NewMatchQuery(str)
 	q.SetFuzziness(int(fuzziness))
 	$$ = q
 }
 |
 tSTRING tCOLON tSTRING tTILDE {
 	field := $1
 	str := $3
 	fuzziness, err := strconv.ParseFloat($4, 64)
 	if err != nil {
 		yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid fuzziness value: %v", err))
 	}
 	logDebugGrammar("FIELD - %s FUZZY STRING - %s %f", field, str, fuzziness)
 	q := NewMatchQuery(str)
 	q.SetFuzziness(int(fuzziness))
 	q.SetField(field)
 	$$ = q
 }
 |
 tNUMBER {
 	str := $1
 	logDebugGrammar("STRING - %s", str)
 	q1 := NewMatchQuery(str)
 	val, err := strconv.ParseFloat($1, 64)
 	if err != nil {
 		yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
 	}
 	inclusive := true
 	q2 := NewNumericRangeInclusiveQuery(&val, &val, &inclusive, &inclusive)
 	q := NewDisjunctionQuery([]Query{q1,q2})
 	q.queryStringMode = true
 	$$ = q
 }
 |
 tPHRASE {
 	phrase := $1
 	logDebugGrammar("PHRASE - %s", phrase)
 	q := NewMatchPhraseQuery(phrase)
 	$$ = q
 }
 |
 tSTRING tCOLON tSTRING {
 	field := $1
 	str := $3
 	logDebugGrammar("FIELD - %s STRING - %s", field, str)
 	var q FieldableQuery
 	if strings.HasPrefix(str, "/") && strings.HasSuffix(str, "/") {
 		q = NewRegexpQuery(str[1:len(str)-1])
 	} else if strings.ContainsAny(str, "*?"){
 	  q = NewWildcardQuery(str)
 	}  else {
 		q = NewMatchQuery(str)
 	}
 	q.SetField(field)
 	$$ = q
 }
 |
 tSTRING tCOLON posOrNegNumber {
 	field := $1
 	str := $3
 	logDebugGrammar("FIELD - %s STRING - %s", field, str)
 	q1 := NewMatchQuery(str)
 	q1.SetField(field)
 	val, err := strconv.ParseFloat($3, 64)
 	if err != nil {
 		yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
 	}
 	inclusive := true
 	q2 := NewNumericRangeInclusiveQuery(&val, &val, &inclusive, &inclusive)
 	q2.SetField(field)
 	q := NewDisjunctionQuery([]Query{q1,q2})
 	q.queryStringMode = true
 	$$ = q
 }
 |
 tSTRING tCOLON tPHRASE {
 	field := $1
 	phrase := $3
 	logDebugGrammar("FIELD - %s PHRASE - %s", field, phrase)
 	q := NewMatchPhraseQuery(phrase)
 	q.SetField(field)
 	$$ = q
 }
 |
 tSTRING tCOLON tGREATER posOrNegNumber {
 	field := $1
 	min, err := strconv.ParseFloat($4, 64)
 	if err != nil {
 		yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
 	}
 	minInclusive := false
 	logDebugGrammar("FIELD - GREATER THAN %f", min)
 	q := NewNumericRangeInclusiveQuery(&min, nil, &minInclusive, nil)
 	q.SetField(field)
 	$$ = q
 }
 |
 tSTRING tCOLON tGREATER tEQUAL posOrNegNumber {
 	field := $1
 	min, err := strconv.ParseFloat($5, 64)
 	if err != nil {
 		yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
 	}
 	minInclusive := true
 	logDebugGrammar("FIELD - GREATER THAN OR EQUAL %f", min)
 	q := NewNumericRangeInclusiveQuery(&min, nil, &minInclusive, nil)
 	q.SetField(field)
 	$$ = q
 }
 |
 tSTRING tCOLON tLESS posOrNegNumber {
 	field := $1
 	max, err := strconv.ParseFloat($4, 64)
 	if err != nil {
 		yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
 	}
 	maxInclusive := false
 	logDebugGrammar("FIELD - LESS THAN %f", max)
 	q := NewNumericRangeInclusiveQuery(nil, &max, nil, &maxInclusive)
 	q.SetField(field)
 	$$ = q
 }
 |
 tSTRING tCOLON tLESS tEQUAL posOrNegNumber {
 	field := $1
 	max, err := strconv.ParseFloat($5, 64)
 	if err != nil {
 		yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("error parsing number: %v", err))
 	}
 	maxInclusive := true
 	logDebugGrammar("FIELD - LESS THAN OR EQUAL %f", max)
 	q := NewNumericRangeInclusiveQuery(nil, &max, nil, &maxInclusive)
 	q.SetField(field)
 	$$ = q
 }
 |
 tSTRING tCOLON tGREATER tPHRASE {
 	field := $1
 	minInclusive := false
 	phrase := $4
 	logDebugGrammar("FIELD - GREATER THAN DATE %s", phrase)
 	minTime, err := queryTimeFromString(phrase)
 	if err != nil {
 	  yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err))
 	}
 	q := NewDateRangeInclusiveQuery(minTime, time.Time{}, &minInclusive, nil)
 	q.SetField(field)
 	$$ = q
 }
 |
 tSTRING tCOLON tGREATER tEQUAL tPHRASE {
 	field := $1
 	minInclusive := true
 	phrase := $5
 	logDebugGrammar("FIELD - GREATER THAN OR EQUAL DATE %s", phrase)
 	minTime, err := queryTimeFromString(phrase)
 	if err != nil {
 		yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err))
 	}
 	q := NewDateRangeInclusiveQuery(minTime, time.Time{}, &minInclusive, nil)
 	q.SetField(field)
 	$$ = q
 }
 |
 tSTRING tCOLON tLESS tPHRASE {
 	field := $1
 	maxInclusive := false
 	phrase := $4
 	logDebugGrammar("FIELD - LESS THAN DATE %s", phrase)
 	maxTime, err := queryTimeFromString(phrase)
 	if err != nil {
 		yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err))
 	}
 	q := NewDateRangeInclusiveQuery(time.Time{}, maxTime, nil, &maxInclusive)
 	q.SetField(field)
 	$$ = q
 }
 |
 tSTRING tCOLON tLESS tEQUAL tPHRASE {
 	field := $1
 	maxInclusive := true
 	phrase := $5
 	logDebugGrammar("FIELD - LESS THAN OR EQUAL DATE %s", phrase)
 	maxTime, err := queryTimeFromString(phrase)
 	if err != nil {
 		yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid time: %v", err))
 	}
 	q := NewDateRangeInclusiveQuery(time.Time{}, maxTime, nil, &maxInclusive)
 	q.SetField(field)
 	$$ = q
 };
 searchSuffix:
 /* empty */ {
 	$$ = nil
 }
 |
 tBOOST {
  $$ = nil
 	boost, err := strconv.ParseFloat($1, 64)
 	if err != nil {
 	  yylex.(*lexerWrapper).lex.Error(fmt.Sprintf("invalid boost value: %v", err))
 	} else {
 		$$ = &boost
 	}
 	logDebugGrammar("BOOST %f", boost)
 };
 posOrNegNumber:
 tNUMBER {
 	$$ = $1
 }
 |
 tMINUS tNUMBER {
 	$$ = "-" + $2
 };
--- a/vendor/github.com/blevesearch/go-porterstemmer/README.md
+++ b/vendor/github.com/blevesearch/go-porterstemmer/README.md
@ -1,118 +0,0 @@
 # This fork...
 I'm maintaining this fork because the original author was not replying to issues or pull requests.  For now I plan on maintaining this fork as necessary.
 ## Status
 [![Build Status](https://travis-ci.org/blevesearch/go-porterstemmer.svg?branch=master)](https://travis-ci.org/blevesearch/go-porterstemmer)
 [![Coverage Status](https://coveralls.io/repos/blevesearch/go-porterstemmer/badge.png?branch=HEAD)](https://coveralls.io/r/blevesearch/go-porterstemmer?branch=HEAD)
 # Go Porter Stemmer
 A native Go clean room implementation of the Porter Stemming Algorithm.
 This algorithm is of interest to people doing Machine Learning or
 Natural Language Processing (NLP).
 This is NOT a port. This is a native Go implementation from the human-readable
 description of the algorithm.
 I've tried to make it (more) efficient by NOT internally using string's, but
 instead internally using []rune's and using the same (array) buffer used by
 the []rune slice (and sub-slices) at all steps of the algorithm.
 For Porter Stemmer algorithm, see:
 http://tartarus.org/martin/PorterStemmer/def.txt      (URL #1)
 http://tartarus.org/martin/PorterStemmer/             (URL #2)
 # Departures
 Also, since when I initially implemented it, it failed the tests at...
 http://tartarus.org/martin/PorterStemmer/voc.txt      (URL #3)
 http://tartarus.org/martin/PorterStemmer/output.txt   (URL #4)
 ... after reading the human-readble text over and over again to try to figure out
 what the error I made was (and doing all sorts of things to debug it) I came to the
 conclusion that the some of these tests were wrong according to the human-readable
 description of the algorithm.
 This led me to wonder if maybe other people's code that was passing these tests had
 rules that were not in the human-readable description. Which led me to look at the source
 code here...
 http://tartarus.org/martin/PorterStemmer/c.txt        (URL #5)
 ... When I looked there I noticed that there are some items marked as a "DEPARTURE",
 which differ from the original algorithm. (There are 2 of these.)
 I implemented these departures, and the tests at URL #3 and URL #4 all passed.
 ## Usage
 To use this Golang library, use with something like:
    package main
    import (
      "fmt"
      "github.com/reiver/go-porterstemmer"
    )
    func main() {
      word := "Waxes"
      stem := porterstemmer.StemString(word)
      fmt.Printf("The word [%s] has the stem [%s].\n", word, stem)
    }
 Alternatively, if you want to be a bit more efficient, use []rune slices instead, with code like:
    package main
    import (
      "fmt"
      "github.com/reiver/go-porterstemmer"
    )
    func main() {
      word := []rune("Waxes")
      stem := porterstemmer.Stem(word)
      fmt.Printf("The word [%s] has the stem [%s].\n", string(word), string(stem))
    }
 Although NOTE that the above code may modify original slice (named "word" in the example) as a side
 effect, for efficiency reasons. And that the slice named "stem" in the example above may be a
 sub-slice of the slice named "word".
 Also alternatively, if you already know that your word is already lowercase (and you don't need
 this library to lowercase your word for you) you can instead use code like:
    package main
    import (
      "fmt"
      "github.com/reiver/go-porterstemmer"
    )
    func main() {
      word := []rune("waxes")
      stem := porterstemmer.StemWithoutLowerCasing(word)
      fmt.Printf("The word [%s] has the stem [%s].\n", string(word), string(stem))
    }
 Again NOTE (like with the previous example) that the above code may modify original slice (named
 "word" in the example) as a side effect, for efficiency reasons. And that the slice named "stem"
 in the example above may be a sub-slice of the slice named "word".
--- a/vendor/github.com/blevesearch/segment/README.md
+++ b/vendor/github.com/blevesearch/segment/README.md
@ -1,92 +0,0 @@
 # segment
 A Go library for performing Unicode Text Segmentation
 as described in [Unicode Standard Annex #29](http://www.unicode.org/reports/tr29/)
 ## Features
 * Currently only segmentation at Word Boundaries is supported.
 ## License
 Apache License Version 2.0
 ## Usage
 The functionality is exposed in two ways:
 1.  You can use a bufio.Scanner with the SplitWords implementation of SplitFunc.
 The SplitWords function will identify the appropriate word boundaries in the input
 text and the Scanner will return tokens at the appropriate place.
 		scanner := bufio.NewScanner(...)
 		scanner.Split(segment.SplitWords)
 		for scanner.Scan() {
 			tokenBytes := scanner.Bytes()
 		}
 		if err := scanner.Err(); err != nil {
 			t.Fatal(err)
 		}
 2.  Sometimes you would also like information returned about the type of token.
 To do this we have introduce a new type named Segmenter.  It works just like Scanner
 but additionally a token type is returned.
 		segmenter := segment.NewWordSegmenter(...)
 		for segmenter.Segment() {
 			tokenBytes := segmenter.Bytes())
 			tokenType := segmenter.Type()
 		}
 		if err := segmenter.Err(); err != nil {
 			t.Fatal(err)
 		}
 ## Choosing Implementation
 By default segment does NOT use the fastest runtime implementation.  The reason is that it adds approximately 5s to compilation time and may require more than 1GB of ram on the machine performing compilation.
 However, you can choose to build with the fastest runtime implementation by passing the build tag as follows:
 		-tags 'prod'
 ## Generating Code
 Several components in this package are generated.
 1.  Several Ragel rules files are generated from Unicode properties files.
 2.  Ragel machine is generated from the Ragel rules.
 3.  Test tables are generated from the Unicode test files.
 All of these can be generated by running:
 		go generate
 ## Fuzzing
 There is support for fuzzing the segment library with [go-fuzz](https://github.com/dvyukov/go-fuzz).
 1.  Install go-fuzz if you haven't already:
 		go get github.com/dvyukov/go-fuzz/go-fuzz
 		go get github.com/dvyukov/go-fuzz/go-fuzz-build
 2.  Build the package with go-fuzz:
 		go-fuzz-build github.com/blevesearch/segment
 3.  Convert the Unicode provided test cases into the initial corpus for go-fuzz:
 		go test -v -run=TestGenerateWordSegmentFuzz -tags gofuzz_generate
 4.  Run go-fuzz:
 		go-fuzz -bin=segment-fuzz.zip -workdir=workdir
 ## Status
 [![Build Status](https://travis-ci.org/blevesearch/segment.svg?branch=master)](https://travis-ci.org/blevesearch/segment)
 [![Coverage Status](https://img.shields.io/coveralls/blevesearch/segment.svg)](https://coveralls.io/r/blevesearch/segment?branch=master)
 [![GoDoc](https://godoc.org/github.com/blevesearch/segment?status.svg)](https://godoc.org/github.com/blevesearch/segment)
--- a/vendor/github.com/blevesearch/segment/segment_words.rl
+++ b/vendor/github.com/blevesearch/segment/segment_words.rl
@ -1,285 +0,0 @@
 //  Copyright (c) 2015 Couchbase, Inc.
 //  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
 //  except in compliance with the License. You may obtain a copy of the License at
 //    http://www.apache.org/licenses/LICENSE-2.0
 //  Unless required by applicable law or agreed to in writing, software distributed under the
 //  License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 //  either express or implied. See the License for the specific language governing permissions
 //  and limitations under the License.
 // +build BUILDTAGS
 package segment
 import (
  "fmt"
  "unicode/utf8"
 )
 var RagelFlags = "RAGELFLAGS"
 var ParseError = fmt.Errorf("unicode word segmentation parse error")
 // Word Types
 const (
  None = iota
  Number
  Letter
  Kana
  Ideo
 )
 %%{
  machine s;
  write data;
 }%%
 func segmentWords(data []byte, maxTokens int, atEOF bool, val [][]byte, types []int) ([][]byte, []int, int, error) {
  cs, p, pe := 0, 0, len(data)
  cap := maxTokens
  if cap < 0 {
    cap = 1000
  }
  if val == nil {
    val = make([][]byte, 0, cap)
  }
  if types == nil {
    types = make([]int, 0, cap)
  }
  // added for scanner
  ts := 0
  te := 0
  act := 0
  eof := pe
  _ = ts // compiler not happy
  _ = te
  _ = act
  // our state
  startPos := 0
  endPos := 0
  totalConsumed := 0
  %%{
  include SCRIPTS "ragel/uscript.rl";
  include WB "ragel/uwb.rl";
  action startToken {
    startPos = p
  }
  action endToken {
    endPos = p
  }
  action finishNumericToken {
    if !atEOF {
      return val, types, totalConsumed, nil
    }
    val = append(val, data[startPos:endPos+1])
    types = append(types, Number)
    totalConsumed = endPos+1
    if maxTokens > 0 && len(val) >= maxTokens {
      return val, types, totalConsumed, nil
    }
  }
  action finishHangulToken {
    if endPos+1 == pe && !atEOF {
      return val, types, totalConsumed, nil
    } else if dr, size := utf8.DecodeRune(data[endPos+1:]); dr == utf8.RuneError && size == 1 {
      return val, types, totalConsumed, nil
    }
    val = append(val, data[startPos:endPos+1])
    types = append(types, Letter)
    totalConsumed = endPos+1
    if maxTokens > 0 && len(val) >= maxTokens {
      return val, types, totalConsumed, nil
    }
  }
  action finishKatakanaToken {
    if endPos+1 == pe && !atEOF {
      return val, types, totalConsumed, nil
    } else if dr, size := utf8.DecodeRune(data[endPos+1:]); dr == utf8.RuneError && size == 1 {
      return val, types, totalConsumed, nil
    }
    val = append(val, data[startPos:endPos+1])
    types = append(types, Ideo)
    totalConsumed = endPos+1
    if maxTokens > 0 && len(val) >= maxTokens {
      return val, types, totalConsumed, nil
    }
  }
  action finishWordToken {
    if !atEOF {
      return val, types, totalConsumed, nil
    }
    val = append(val, data[startPos:endPos+1])
    types = append(types, Letter)
    totalConsumed = endPos+1
    if maxTokens > 0 && len(val) >= maxTokens {
      return val, types, totalConsumed, nil
    }
  }
  action finishHanToken {
    if endPos+1 == pe && !atEOF {
      return val, types, totalConsumed, nil
    } else if dr, size := utf8.DecodeRune(data[endPos+1:]); dr == utf8.RuneError && size == 1 {
      return val, types, totalConsumed, nil
    }
    val = append(val, data[startPos:endPos+1])
    types = append(types, Ideo)
    totalConsumed = endPos+1
    if maxTokens > 0 && len(val) >= maxTokens {
      return val, types, totalConsumed, nil
    }
  }
  action finishHiraganaToken {
    if endPos+1 == pe && !atEOF {
      return val, types, totalConsumed, nil
    } else if dr, size := utf8.DecodeRune(data[endPos+1:]); dr == utf8.RuneError && size == 1 {
      return val, types, totalConsumed, nil
    }
    val = append(val, data[startPos:endPos+1])
    types = append(types, Ideo)
    totalConsumed = endPos+1
    if maxTokens > 0 && len(val) >= maxTokens {
      return val, types, totalConsumed, nil
    }
  }
  action finishNoneToken {
    lastPos := startPos
    for lastPos <= endPos {
      _, size := utf8.DecodeRune(data[lastPos:])
      lastPos += size
    }
    endPos = lastPos -1
    p = endPos
    if endPos+1 == pe && !atEOF {
      return val, types, totalConsumed, nil
    } else if dr, size := utf8.DecodeRune(data[endPos+1:]); dr == utf8.RuneError && size == 1 {
      return val, types, totalConsumed, nil
    }
    // otherwise, consume this as well
    val = append(val, data[startPos:endPos+1])
    types = append(types, None)
    totalConsumed = endPos+1
    if maxTokens > 0 && len(val) >= maxTokens {
      return val, types, totalConsumed, nil
    }
  }
  HangulEx = Hangul ( Extend | Format )*;
  HebrewOrALetterEx = ( Hebrew_Letter | ALetter ) ( Extend | Format )*;
  NumericEx = Numeric ( Extend | Format )*;
  KatakanaEx = Katakana ( Extend | Format )*;
  MidLetterEx = ( MidLetter | MidNumLet | Single_Quote ) ( Extend | Format )*;
  MidNumericEx = ( MidNum | MidNumLet | Single_Quote ) ( Extend | Format )*;
  ExtendNumLetEx = ExtendNumLet ( Extend | Format )*;
  HanEx = Han ( Extend | Format )*;
  HiraganaEx = Hiragana ( Extend | Format )*;
  SingleQuoteEx = Single_Quote ( Extend | Format )*;
  DoubleQuoteEx = Double_Quote ( Extend | Format )*;
  HebrewLetterEx = Hebrew_Letter ( Extend | Format )*;
  RegionalIndicatorEx = Regional_Indicator ( Extend | Format )*;
  NLCRLF = Newline | CR | LF;
  OtherEx = ^(NLCRLF) ( Extend | Format )* ;
  # UAX#29 WB8.   Numeric × Numeric
  #        WB11.  Numeric (MidNum | MidNumLet | Single_Quote) × Numeric
  #       WB12.  Numeric × (MidNum | MidNumLet | Single_Quote) Numeric
  #       WB13a. (ALetter | Hebrew_Letter | Numeric | Katakana | ExtendNumLet) × ExtendNumLet
  #       WB13b. ExtendNumLet × (ALetter | Hebrew_Letter | Numeric | Katakana)
  #
  WordNumeric = ( ( ExtendNumLetEx )* NumericEx ( ( ( ExtendNumLetEx )* | MidNumericEx ) NumericEx )* ( ExtendNumLetEx )* ) >startToken @endToken;
  # subset of the below for typing purposes only!
  WordHangul = ( HangulEx )+ >startToken @endToken;
  WordKatakana = ( KatakanaEx )+ >startToken @endToken;
  # UAX#29 WB5.   (ALetter | Hebrew_Letter) × (ALetter | Hebrew_Letter)
  #       WB6.   (ALetter | Hebrew_Letter) × (MidLetter | MidNumLet | Single_Quote) (ALetter | Hebrew_Letter)
  #       WB7.   (ALetter | Hebrew_Letter) (MidLetter | MidNumLet | Single_Quote) × (ALetter | Hebrew_Letter)
  #       WB7a.  Hebrew_Letter × Single_Quote
  #       WB7b.  Hebrew_Letter × Double_Quote Hebrew_Letter
  #       WB7c.  Hebrew_Letter Double_Quote × Hebrew_Letter
  #       WB9.   (ALetter | Hebrew_Letter) × Numeric
  #       WB10.  Numeric × (ALetter | Hebrew_Letter)
  #       WB13.  Katakana × Katakana
  #       WB13a. (ALetter | Hebrew_Letter | Numeric | Katakana | ExtendNumLet) × ExtendNumLet
  #       WB13b. ExtendNumLet × (ALetter | Hebrew_Letter | Numeric | Katakana)
  #
  # Marty -deviated here to allow for (ExtendNumLetEx x ExtendNumLetEx) part of 13a
  #
  Word = ( ( ExtendNumLetEx )* ( KatakanaEx ( ( ExtendNumLetEx )* KatakanaEx )*
                             | ( HebrewLetterEx ( SingleQuoteEx | DoubleQuoteEx HebrewLetterEx )
                               | NumericEx ( ( ( ExtendNumLetEx )* | MidNumericEx ) NumericEx )*
                               | HebrewOrALetterEx ( ( ( ExtendNumLetEx )* | MidLetterEx ) HebrewOrALetterEx )*
                               |ExtendNumLetEx
                               )+
                             )
         (
          ( ExtendNumLetEx )+ ( KatakanaEx ( ( ExtendNumLetEx )* KatakanaEx )*
                              | ( HebrewLetterEx ( SingleQuoteEx | DoubleQuoteEx HebrewLetterEx )
                                | NumericEx ( ( ( ExtendNumLetEx )* | MidNumericEx ) NumericEx )*
                                | HebrewOrALetterEx ( ( ( ExtendNumLetEx )* | MidLetterEx ) HebrewOrALetterEx )*
                                )+
                              )
         )* ExtendNumLetEx*) >startToken @endToken;
  # UAX#29 WB14.  Any ÷ Any
  WordHan = HanEx >startToken @endToken;
  WordHiragana = HiraganaEx >startToken @endToken;
  WordExt = ( ( Extend | Format )* ) >startToken @endToken; # maybe plus not star
  WordCRLF = (CR LF) >startToken @endToken;
  WordCR = CR >startToken @endToken;
  WordLF = LF >startToken @endToken;
  WordNL = Newline >startToken @endToken;
  WordRegional = (RegionalIndicatorEx+) >startToken @endToken;
  Other = OtherEx >startToken @endToken;
  main := |*
    WordNumeric => finishNumericToken;
    WordHangul => finishHangulToken;
    WordKatakana => finishKatakanaToken;
    Word => finishWordToken;
    WordHan => finishHanToken;
    WordHiragana => finishHiraganaToken;
    WordRegional =>finishNoneToken;
    WordCRLF => finishNoneToken;
    WordCR => finishNoneToken;
    WordLF => finishNoneToken;
    WordNL => finishNoneToken;
    WordExt => finishNoneToken;
    Other => finishNoneToken;
  *|;
    write init;
    write exec;
  }%%
  if cs < s_first_final {
    return val, types, totalConsumed, ParseError
  }
  return val, types, totalConsumed, nil
 }
--- a/vendor/github.com/boltdb/bolt/Makefile
+++ b/vendor/github.com/boltdb/bolt/Makefile
@ -1,18 +0,0 @@
 BRANCH=`git rev-parse --abbrev-ref HEAD`
 COMMIT=`git rev-parse --short HEAD`
 GOLDFLAGS="-X main.branch $(BRANCH) -X main.commit $(COMMIT)"
 default: build
 race:
 	@go test -v -race -test.run="TestSimulate_(100op|1000op)"
 # go get github.com/kisielk/errcheck
 errcheck:
 	@errcheck -ignorepkg=bytes -ignore=os:Remove github.com/boltdb/bolt
 test: 
 	@go test -v -cover .
 	@go test -v ./cmd/bolt
 .PHONY: fmt test
--- a/vendor/github.com/boltdb/bolt/README.md
+++ b/vendor/github.com/boltdb/bolt/README.md
@ -1,915 +0,0 @@
 Bolt [![Coverage Status](https://coveralls.io/repos/boltdb/bolt/badge.svg?branch=master)](https://coveralls.io/r/boltdb/bolt?branch=master) [![GoDoc](https://godoc.org/github.com/boltdb/bolt?status.svg)](https://godoc.org/github.com/boltdb/bolt) ![Version](https://img.shields.io/badge/version-1.2.1-green.svg)
 ====
 Bolt is a pure Go key/value store inspired by [Howard Chu's][hyc_symas]
 [LMDB project][lmdb]. The goal of the project is to provide a simple,
 fast, and reliable database for projects that don't require a full database
 server such as Postgres or MySQL.
 Since Bolt is meant to be used as such a low-level piece of functionality,
 simplicity is key. The API will be small and only focus on getting values
 and setting values. That's it.
 [hyc_symas]: https://twitter.com/hyc_symas
 [lmdb]: http://symas.com/mdb/
 ## Project Status
 Bolt is stable, the API is fixed, and the file format is fixed. Full unit
 test coverage and randomized black box testing are used to ensure database
 consistency and thread safety. Bolt is currently used in high-load production
 environments serving databases as large as 1TB. Many companies such as
 Shopify and Heroku use Bolt-backed services every day.
 ## Table of Contents
 - [Getting Started](#getting-started)
  - [Installing](#installing)
  - [Opening a database](#opening-a-database)
  - [Transactions](#transactions)
    - [Read-write transactions](#read-write-transactions)
    - [Read-only transactions](#read-only-transactions)
    - [Batch read-write transactions](#batch-read-write-transactions)
    - [Managing transactions manually](#managing-transactions-manually)
  - [Using buckets](#using-buckets)
  - [Using key/value pairs](#using-keyvalue-pairs)
  - [Autoincrementing integer for the bucket](#autoincrementing-integer-for-the-bucket)
  - [Iterating over keys](#iterating-over-keys)
    - [Prefix scans](#prefix-scans)
    - [Range scans](#range-scans)
    - [ForEach()](#foreach)
  - [Nested buckets](#nested-buckets)
  - [Database backups](#database-backups)
  - [Statistics](#statistics)
  - [Read-Only Mode](#read-only-mode)
  - [Mobile Use (iOS/Android)](#mobile-use-iosandroid)
 - [Resources](#resources)
 - [Comparison with other databases](#comparison-with-other-databases)
  - [Postgres, MySQL, & other relational databases](#postgres-mysql--other-relational-databases)
  - [LevelDB, RocksDB](#leveldb-rocksdb)
  - [LMDB](#lmdb)
 - [Caveats & Limitations](#caveats--limitations)
 - [Reading the Source](#reading-the-source)
 - [Other Projects Using Bolt](#other-projects-using-bolt)
 ## Getting Started
 ### Installing
 To start using Bolt, install Go and run `go get`:
 ```sh
 $ go get github.com/boltdb/bolt/...
 ```
 This will retrieve the library and install the `bolt` command line utility into
 your `$GOBIN` path.
 ### Opening a database
 The top-level object in Bolt is a `DB`. It is represented as a single file on
 your disk and represents a consistent snapshot of your data.
 To open your database, simply use the `bolt.Open()` function:
 ```go
 package main
 import (
 	"log"
 	"github.com/boltdb/bolt"
 )
 func main() {
 	// Open the my.db data file in your current directory.
 	// It will be created if it doesn't exist.
 	db, err := bolt.Open("my.db", 0600, nil)
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer db.Close()
 	...
 }
 ```
 Please note that Bolt obtains a file lock on the data file so multiple processes
 cannot open the same database at the same time. Opening an already open Bolt
 database will cause it to hang until the other process closes it. To prevent
 an indefinite wait you can pass a timeout option to the `Open()` function:
 ```go
 db, err := bolt.Open("my.db", 0600, &bolt.Options{Timeout: 1 * time.Second})
 ```
 ### Transactions
 Bolt allows only one read-write transaction at a time but allows as many
 read-only transactions as you want at a time. Each transaction has a consistent
 view of the data as it existed when the transaction started.
 Individual transactions and all objects created from them (e.g. buckets, keys)
 are not thread safe. To work with data in multiple goroutines you must start
 a transaction for each one or use locking to ensure only one goroutine accesses
 a transaction at a time. Creating transaction from the `DB` is thread safe.
 Read-only transactions and read-write transactions should not depend on one
 another and generally shouldn't be opened simultaneously in the same goroutine.
 This can cause a deadlock as the read-write transaction needs to periodically
 re-map the data file but it cannot do so while a read-only transaction is open.
 #### Read-write transactions
 To start a read-write transaction, you can use the `DB.Update()` function:
 ```go
 err := db.Update(func(tx *bolt.Tx) error {
 	...
 	return nil
 })
 ```
 Inside the closure, you have a consistent view of the database. You commit the
 transaction by returning `nil` at the end. You can also rollback the transaction
 at any point by returning an error. All database operations are allowed inside
 a read-write transaction.
 Always check the return error as it will report any disk failures that can cause
 your transaction to not complete. If you return an error within your closure
 it will be passed through.
 #### Read-only transactions
 To start a read-only transaction, you can use the `DB.View()` function:
 ```go
 err := db.View(func(tx *bolt.Tx) error {
 	...
 	return nil
 })
 ```
 You also get a consistent view of the database within this closure, however,
 no mutating operations are allowed within a read-only transaction. You can only
 retrieve buckets, retrieve values, and copy the database within a read-only
 transaction.
 #### Batch read-write transactions
 Each `DB.Update()` waits for disk to commit the writes. This overhead
 can be minimized by combining multiple updates with the `DB.Batch()`
 function:
 ```go
 err := db.Batch(func(tx *bolt.Tx) error {
 	...
 	return nil
 })
 ```
 Concurrent Batch calls are opportunistically combined into larger
 transactions. Batch is only useful when there are multiple goroutines
 calling it.
 The trade-off is that `Batch` can call the given
 function multiple times, if parts of the transaction fail. The
 function must be idempotent and side effects must take effect only
 after a successful return from `DB.Batch()`.
 For example: don't display messages from inside the function, instead
 set variables in the enclosing scope:
 ```go
 var id uint64
 err := db.Batch(func(tx *bolt.Tx) error {
 	// Find last key in bucket, decode as bigendian uint64, increment
 	// by one, encode back to []byte, and add new key.
 	...
 	id = newValue
 	return nil
 })
 if err != nil {
 	return ...
 }
 fmt.Println("Allocated ID %d", id)
 ```
 #### Managing transactions manually
 The `DB.View()` and `DB.Update()` functions are wrappers around the `DB.Begin()`
 function. These helper functions will start the transaction, execute a function,
 and then safely close your transaction if an error is returned. This is the
 recommended way to use Bolt transactions.
 However, sometimes you may want to manually start and end your transactions.
 You can use the `DB.Begin()` function directly but **please** be sure to close
 the transaction.
 ```go
 // Start a writable transaction.
 tx, err := db.Begin(true)
 if err != nil {
    return err
 }
 defer tx.Rollback()
 // Use the transaction...
 _, err := tx.CreateBucket([]byte("MyBucket"))
 if err != nil {
    return err
 }
 // Commit the transaction and check for error.
 if err := tx.Commit(); err != nil {
    return err
 }
 ```
 The first argument to `DB.Begin()` is a boolean stating if the transaction
 should be writable.
 ### Using buckets
 Buckets are collections of key/value pairs within the database. All keys in a
 bucket must be unique. You can create a bucket using the `DB.CreateBucket()`
 function:
 ```go
 db.Update(func(tx *bolt.Tx) error {
 	b, err := tx.CreateBucket([]byte("MyBucket"))
 	if err != nil {
 		return fmt.Errorf("create bucket: %s", err)
 	}
 	return nil
 })
 ```
 You can also create a bucket only if it doesn't exist by using the
 `Tx.CreateBucketIfNotExists()` function. It's a common pattern to call this
 function for all your top-level buckets after you open your database so you can
 guarantee that they exist for future transactions.
 To delete a bucket, simply call the `Tx.DeleteBucket()` function.
 ### Using key/value pairs
 To save a key/value pair to a bucket, use the `Bucket.Put()` function:
 ```go
 db.Update(func(tx *bolt.Tx) error {
 	b := tx.Bucket([]byte("MyBucket"))
 	err := b.Put([]byte("answer"), []byte("42"))
 	return err
 })
 ```
 This will set the value of the `"answer"` key to `"42"` in the `MyBucket`
 bucket. To retrieve this value, we can use the `Bucket.Get()` function:
 ```go
 db.View(func(tx *bolt.Tx) error {
 	b := tx.Bucket([]byte("MyBucket"))
 	v := b.Get([]byte("answer"))
 	fmt.Printf("The answer is: %s\n", v)
 	return nil
 })
 ```
 The `Get()` function does not return an error because its operation is
 guaranteed to work (unless there is some kind of system failure). If the key
 exists then it will return its byte slice value. If it doesn't exist then it
 will return `nil`. It's important to note that you can have a zero-length value
 set to a key which is different than the key not existing.
 Use the `Bucket.Delete()` function to delete a key from the bucket.
 Please note that values returned from `Get()` are only valid while the
 transaction is open. If you need to use a value outside of the transaction
 then you must use `copy()` to copy it to another byte slice.
 ### Autoincrementing integer for the bucket
 By using the `NextSequence()` function, you can let Bolt determine a sequence
 which can be used as the unique identifier for your key/value pairs. See the
 example below.
 ```go
 // CreateUser saves u to the store. The new user ID is set on u once the data is persisted.
 func (s *Store) CreateUser(u *User) error {
    return s.db.Update(func(tx *bolt.Tx) error {
        // Retrieve the users bucket.
        // This should be created when the DB is first opened.
        b := tx.Bucket([]byte("users"))
        // Generate ID for the user.
        // This returns an error only if the Tx is closed or not writeable.
        // That can't happen in an Update() call so I ignore the error check.
        id, _ := b.NextSequence()
        u.ID = int(id)
        // Marshal user data into bytes.
        buf, err := json.Marshal(u)
        if err != nil {
            return err
        }
        // Persist bytes to users bucket.
        return b.Put(itob(u.ID), buf)
    })
 }
 // itob returns an 8-byte big endian representation of v.
 func itob(v int) []byte {
    b := make([]byte, 8)
    binary.BigEndian.PutUint64(b, uint64(v))
    return b
 }
 type User struct {
    ID int
    ...
 }
 ```
 ### Iterating over keys
 Bolt stores its keys in byte-sorted order within a bucket. This makes sequential
 iteration over these keys extremely fast. To iterate over keys we'll use a
 `Cursor`:
 ```go
 db.View(func(tx *bolt.Tx) error {
 	// Assume bucket exists and has keys
 	b := tx.Bucket([]byte("MyBucket"))
 	c := b.Cursor()
 	for k, v := c.First(); k != nil; k, v = c.Next() {
 		fmt.Printf("key=%s, value=%s\n", k, v)
 	}
 	return nil
 })
 ```
 The cursor allows you to move to a specific point in the list of keys and move
 forward or backward through the keys one at a time.
 The following functions are available on the cursor:
 ```
 First()  Move to the first key.
 Last()   Move to the last key.
 Seek()   Move to a specific key.
 Next()   Move to the next key.
 Prev()   Move to the previous key.
 ```
 Each of those functions has a return signature of `(key []byte, value []byte)`.
 When you have iterated to the end of the cursor then `Next()` will return a
 `nil` key.  You must seek to a position using `First()`, `Last()`, or `Seek()`
 before calling `Next()` or `Prev()`. If you do not seek to a position then
 these functions will return a `nil` key.
 During iteration, if the key is non-`nil` but the value is `nil`, that means
 the key refers to a bucket rather than a value.  Use `Bucket.Bucket()` to
 access the sub-bucket.
 #### Prefix scans
 To iterate over a key prefix, you can combine `Seek()` and `bytes.HasPrefix()`:
 ```go
 db.View(func(tx *bolt.Tx) error {
 	// Assume bucket exists and has keys
 	c := tx.Bucket([]byte("MyBucket")).Cursor()
 	prefix := []byte("1234")
 	for k, v := c.Seek(prefix); k != nil && bytes.HasPrefix(k, prefix); k, v = c.Next() {
 		fmt.Printf("key=%s, value=%s\n", k, v)
 	}
 	return nil
 })
 ```
 #### Range scans
 Another common use case is scanning over a range such as a time range. If you
 use a sortable time encoding such as RFC3339 then you can query a specific
 date range like this:
 ```go
 db.View(func(tx *bolt.Tx) error {
 	// Assume our events bucket exists and has RFC3339 encoded time keys.
 	c := tx.Bucket([]byte("Events")).Cursor()
 	// Our time range spans the 90's decade.
 	min := []byte("1990-01-01T00:00:00Z")
 	max := []byte("2000-01-01T00:00:00Z")
 	// Iterate over the 90's.
 	for k, v := c.Seek(min); k != nil && bytes.Compare(k, max) <= 0; k, v = c.Next() {
 		fmt.Printf("%s: %s\n", k, v)
 	}
 	return nil
 })
 ```
 Note that, while RFC3339 is sortable, the Golang implementation of RFC3339Nano does not use a fixed number of digits after the decimal point and is therefore not sortable.
 #### ForEach()
 You can also use the function `ForEach()` if you know you'll be iterating over
 all the keys in a bucket:
 ```go
 db.View(func(tx *bolt.Tx) error {
 	// Assume bucket exists and has keys
 	b := tx.Bucket([]byte("MyBucket"))
 	b.ForEach(func(k, v []byte) error {
 		fmt.Printf("key=%s, value=%s\n", k, v)
 		return nil
 	})
 	return nil
 })
 ```
 Please note that keys and values in `ForEach()` are only valid while
 the transaction is open. If you need to use a key or value outside of
 the transaction, you must use `copy()` to copy it to another byte
 slice.
 ### Nested buckets
 You can also store a bucket in a key to create nested buckets. The API is the
 same as the bucket management API on the `DB` object:
 ```go
 func (*Bucket) CreateBucket(key []byte) (*Bucket, error)
 func (*Bucket) CreateBucketIfNotExists(key []byte) (*Bucket, error)
 func (*Bucket) DeleteBucket(key []byte) error
 ```
 Say you had a multi-tenant application where the root level bucket was the account bucket. Inside of this bucket was a sequence of accounts which themselves are buckets. And inside the sequence bucket you could have many buckets pertaining to the Account itself (Users, Notes, etc) isolating the information into logical groupings.
 ```go
 // createUser creates a new user in the given account.
 func createUser(accountID int, u *User) error {
    // Start the transaction.
    tx, err := db.Begin(true)
    if err != nil {
        return err
    }
    defer tx.Rollback()
    // Retrieve the root bucket for the account.
    // Assume this has already been created when the account was set up.
    root := tx.Bucket([]byte(strconv.FormatUint(accountID, 10)))
    // Setup the users bucket.
    bkt, err := root.CreateBucketIfNotExists([]byte("USERS"))
    if err != nil {
        return err
    }
    // Generate an ID for the new user.
    userID, err := bkt.NextSequence()
    if err != nil {
        return err
    }
    u.ID = userID
    // Marshal and save the encoded user.
    if buf, err := json.Marshal(u); err != nil {
        return err
    } else if err := bkt.Put([]byte(strconv.FormatUint(u.ID, 10)), buf); err != nil {
        return err
    }
    // Commit the transaction.
    if err := tx.Commit(); err != nil {
        return err
    }
    return nil
 }
 ```
 ### Database backups
 Bolt is a single file so it's easy to backup. You can use the `Tx.WriteTo()`
 function to write a consistent view of the database to a writer. If you call
 this from a read-only transaction, it will perform a hot backup and not block
 your other database reads and writes.
 By default, it will use a regular file handle which will utilize the operating
 system's page cache. See the [`Tx`](https://godoc.org/github.com/boltdb/bolt#Tx)
 documentation for information about optimizing for larger-than-RAM datasets.
 One common use case is to backup over HTTP so you can use tools like `cURL` to
 do database backups:
 ```go
 func BackupHandleFunc(w http.ResponseWriter, req *http.Request) {
 	err := db.View(func(tx *bolt.Tx) error {
 		w.Header().Set("Content-Type", "application/octet-stream")
 		w.Header().Set("Content-Disposition", `attachment; filename="my.db"`)
 		w.Header().Set("Content-Length", strconv.Itoa(int(tx.Size())))
 		_, err := tx.WriteTo(w)
 		return err
 	})
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 	}
 }
 ```
 Then you can backup using this command:
 ```sh
 $ curl http://localhost/backup > my.db
 ```
 Or you can open your browser to `http://localhost/backup` and it will download
 automatically.
 If you want to backup to another file you can use the `Tx.CopyFile()` helper
 function.
 ### Statistics
 The database keeps a running count of many of the internal operations it
 performs so you can better understand what's going on. By grabbing a snapshot
 of these stats at two points in time we can see what operations were performed
 in that time range.
 For example, we could start a goroutine to log stats every 10 seconds:
 ```go
 go func() {
 	// Grab the initial stats.
 	prev := db.Stats()
 	for {
 		// Wait for 10s.
 		time.Sleep(10 * time.Second)
 		// Grab the current stats and diff them.
 		stats := db.Stats()
 		diff := stats.Sub(&prev)
 		// Encode stats to JSON and print to STDERR.
 		json.NewEncoder(os.Stderr).Encode(diff)
 		// Save stats for the next loop.
 		prev = stats
 	}
 }()
 ```
 It's also useful to pipe these stats to a service such as statsd for monitoring
 or to provide an HTTP endpoint that will perform a fixed-length sample.
 ### Read-Only Mode
 Sometimes it is useful to create a shared, read-only Bolt database. To this,
 set the `Options.ReadOnly` flag when opening your database. Read-only mode
 uses a shared lock to allow multiple processes to read from the database but
 it will block any processes from opening the database in read-write mode.
 ```go
 db, err := bolt.Open("my.db", 0666, &bolt.Options{ReadOnly: true})
 if err != nil {
 	log.Fatal(err)
 }
 ```
 ### Mobile Use (iOS/Android)
 Bolt is able to run on mobile devices by leveraging the binding feature of the
 [gomobile](https://github.com/golang/mobile) tool. Create a struct that will
 contain your database logic and a reference to a `*bolt.DB` with a initializing
 constructor that takes in a filepath where the database file will be stored.
 Neither Android nor iOS require extra permissions or cleanup from using this method.
 ```go
 func NewBoltDB(filepath string) *BoltDB {
 	db, err := bolt.Open(filepath+"/demo.db", 0600, nil)
 	if err != nil {
 		log.Fatal(err)
 	}
 	return &BoltDB{db}
 }
 type BoltDB struct {
 	db *bolt.DB
 	...
 }
 func (b *BoltDB) Path() string {
 	return b.db.Path()
 }
 func (b *BoltDB) Close() {
 	b.db.Close()
 }
 ```
 Database logic should be defined as methods on this wrapper struct.
 To initialize this struct from the native language (both platforms now sync
 their local storage to the cloud. These snippets disable that functionality for the
 database file):
 #### Android
 ```java
 String path;
 if (android.os.Build.VERSION.SDK_INT >=android.os.Build.VERSION_CODES.LOLLIPOP){
    path = getNoBackupFilesDir().getAbsolutePath();
 } else{
    path = getFilesDir().getAbsolutePath();
 }
 Boltmobiledemo.BoltDB boltDB = Boltmobiledemo.NewBoltDB(path)
 ```
 #### iOS
 ```objc
 - (void)demo {
    NSString* path = [NSSearchPathForDirectoriesInDomains(NSLibraryDirectory,
                                                          NSUserDomainMask,
                                                          YES) objectAtIndex:0];
 	GoBoltmobiledemoBoltDB * demo = GoBoltmobiledemoNewBoltDB(path);
 	[self addSkipBackupAttributeToItemAtPath:demo.path];
 	//Some DB Logic would go here
 	[demo close];
 }
 - (BOOL)addSkipBackupAttributeToItemAtPath:(NSString *) filePathString
 {
    NSURL* URL= [NSURL fileURLWithPath: filePathString];
    assert([[NSFileManager defaultManager] fileExistsAtPath: [URL path]]);
    NSError *error = nil;
    BOOL success = [URL setResourceValue: [NSNumber numberWithBool: YES]
                                  forKey: NSURLIsExcludedFromBackupKey error: &error];
    if(!success){
        NSLog(@"Error excluding %@ from backup %@", [URL lastPathComponent], error);
    }
    return success;
 }
 ```
 ## Resources
 For more information on getting started with Bolt, check out the following articles:
 * [Intro to BoltDB: Painless Performant Persistence](http://npf.io/2014/07/intro-to-boltdb-painless-performant-persistence/) by [Nate Finch](https://github.com/natefinch).
 * [Bolt -- an embedded key/value database for Go](https://www.progville.com/go/bolt-embedded-db-golang/) by Progville
 ## Comparison with other databases
 ### Postgres, MySQL, & other relational databases
 Relational databases structure data into rows and are only accessible through
 the use of SQL. This approach provides flexibility in how you store and query
 your data but also incurs overhead in parsing and planning SQL statements. Bolt
 accesses all data by a byte slice key. This makes Bolt fast to read and write
 data by key but provides no built-in support for joining values together.
 Most relational databases (with the exception of SQLite) are standalone servers
 that run separately from your application. This gives your systems
 flexibility to connect multiple application servers to a single database
 server but also adds overhead in serializing and transporting data over the
 network. Bolt runs as a library included in your application so all data access
 has to go through your application's process. This brings data closer to your
 application but limits multi-process access to the data.
 ### LevelDB, RocksDB
 LevelDB and its derivatives (RocksDB, HyperLevelDB) are similar to Bolt in that
 they are libraries bundled into the application, however, their underlying
 structure is a log-structured merge-tree (LSM tree). An LSM tree optimizes
 random writes by using a write ahead log and multi-tiered, sorted files called
 SSTables. Bolt uses a B+tree internally and only a single file. Both approaches
 have trade-offs.
 If you require a high random write throughput (>10,000 w/sec) or you need to use
 spinning disks then LevelDB could be a good choice. If your application is
 read-heavy or does a lot of range scans then Bolt could be a good choice.
 One other important consideration is that LevelDB does not have transactions.
 It supports batch writing of key/values pairs and it supports read snapshots
 but it will not give you the ability to do a compare-and-swap operation safely.
 Bolt supports fully serializable ACID transactions.
 ### LMDB
 Bolt was originally a port of LMDB so it is architecturally similar. Both use
 a B+tree, have ACID semantics with fully serializable transactions, and support
 lock-free MVCC using a single writer and multiple readers.
 The two projects have somewhat diverged. LMDB heavily focuses on raw performance
 while Bolt has focused on simplicity and ease of use. For example, LMDB allows
 several unsafe actions such as direct writes for the sake of performance. Bolt
 opts to disallow actions which can leave the database in a corrupted state. The
 only exception to this in Bolt is `DB.NoSync`.
 There are also a few differences in API. LMDB requires a maximum mmap size when
 opening an `mdb_env` whereas Bolt will handle incremental mmap resizing
 automatically. LMDB overloads the getter and setter functions with multiple
 flags whereas Bolt splits these specialized cases into their own functions.
 ## Caveats & Limitations
 It's important to pick the right tool for the job and Bolt is no exception.
 Here are a few things to note when evaluating and using Bolt:
 * Bolt is good for read intensive workloads. Sequential write performance is
  also fast but random writes can be slow. You can use `DB.Batch()` or add a
  write-ahead log to help mitigate this issue.
 * Bolt uses a B+tree internally so there can be a lot of random page access.
  SSDs provide a significant performance boost over spinning disks.
 * Try to avoid long running read transactions. Bolt uses copy-on-write so
  old pages cannot be reclaimed while an old transaction is using them.
 * Byte slices returned from Bolt are only valid during a transaction. Once the
  transaction has been committed or rolled back then the memory they point to
  can be reused by a new page or can be unmapped from virtual memory and you'll
  see an `unexpected fault address` panic when accessing it.
 * Bolt uses an exclusive write lock on the database file so it cannot be
  shared by multiple processes.
 * Be careful when using `Bucket.FillPercent`. Setting a high fill percent for
  buckets that have random inserts will cause your database to have very poor
  page utilization.
 * Use larger buckets in general. Smaller buckets causes poor page utilization
  once they become larger than the page size (typically 4KB).
 * Bulk loading a lot of random writes into a new bucket can be slow as the
  page will not split until the transaction is committed. Randomly inserting
  more than 100,000 key/value pairs into a single new bucket in a single
  transaction is not advised.
 * Bolt uses a memory-mapped file so the underlying operating system handles the
  caching of the data. Typically, the OS will cache as much of the file as it
  can in memory and will release memory as needed to other processes. This means
  that Bolt can show very high memory usage when working with large databases.
  However, this is expected and the OS will release memory as needed. Bolt can
  handle databases much larger than the available physical RAM, provided its
  memory-map fits in the process virtual address space. It may be problematic
  on 32-bits systems.
 * The data structures in the Bolt database are memory mapped so the data file
  will be endian specific. This means that you cannot copy a Bolt file from a
  little endian machine to a big endian machine and have it work. For most
  users this is not a concern since most modern CPUs are little endian.
 * Because of the way pages are laid out on disk, Bolt cannot truncate data files
  and return free pages back to the disk. Instead, Bolt maintains a free list
  of unused pages within its data file. These free pages can be reused by later
  transactions. This works well for many use cases as databases generally tend
  to grow. However, it's important to note that deleting large chunks of data
  will not allow you to reclaim that space on disk.
  For more information on page allocation, [see this comment][page-allocation].
 [page-allocation]: https://github.com/boltdb/bolt/issues/308#issuecomment-74811638
 ## Reading the Source
 Bolt is a relatively small code base (<3KLOC) for an embedded, serializable,
 transactional key/value database so it can be a good starting point for people
 interested in how databases work.
 The best places to start are the main entry points into Bolt:
 - `Open()` - Initializes the reference to the database. It's responsible for
  creating the database if it doesn't exist, obtaining an exclusive lock on the
  file, reading the meta pages, & memory-mapping the file.
 - `DB.Begin()` - Starts a read-only or read-write transaction depending on the
  value of the `writable` argument. This requires briefly obtaining the "meta"
  lock to keep track of open transactions. Only one read-write transaction can
  exist at a time so the "rwlock" is acquired during the life of a read-write
  transaction.
 - `Bucket.Put()` - Writes a key/value pair into a bucket. After validating the
  arguments, a cursor is used to traverse the B+tree to the page and position
  where they key & value will be written. Once the position is found, the bucket
  materializes the underlying page and the page's parent pages into memory as
  "nodes". These nodes are where mutations occur during read-write transactions.
  These changes get flushed to disk during commit.
 - `Bucket.Get()` - Retrieves a key/value pair from a bucket. This uses a cursor
  to move to the page & position of a key/value pair. During a read-only
  transaction, the key and value data is returned as a direct reference to the
  underlying mmap file so there's no allocation overhead. For read-write
  transactions, this data may reference the mmap file or one of the in-memory
  node values.
 - `Cursor` - This object is simply for traversing the B+tree of on-disk pages
  or in-memory nodes. It can seek to a specific key, move to the first or last
  value, or it can move forward or backward. The cursor handles the movement up
  and down the B+tree transparently to the end user.
 - `Tx.Commit()` - Converts the in-memory dirty nodes and the list of free pages
  into pages to be written to disk. Writing to disk then occurs in two phases.
  First, the dirty pages are written to disk and an `fsync()` occurs. Second, a
  new meta page with an incremented transaction ID is written and another
  `fsync()` occurs. This two phase write ensures that partially written data
  pages are ignored in the event of a crash since the meta page pointing to them
  is never written. Partially written meta pages are invalidated because they
  are written with a checksum.
 If you have additional notes that could be helpful for others, please submit
 them via pull request.
 ## Other Projects Using Bolt
 Below is a list of public, open source projects that use Bolt:
 * [BoltDbWeb](https://github.com/evnix/boltdbweb) - A web based GUI for BoltDB files.
 * [Operation Go: A Routine Mission](http://gocode.io) - An online programming game for Golang using Bolt for user accounts and a leaderboard.
 * [Bazil](https://bazil.org/) - A file system that lets your data reside where it is most convenient for it to reside.
 * [DVID](https://github.com/janelia-flyem/dvid) - Added Bolt as optional storage engine and testing it against Basho-tuned leveldb.
 * [Skybox Analytics](https://github.com/skybox/skybox) - A standalone funnel analysis tool for web analytics.
 * [Scuttlebutt](https://github.com/benbjohnson/scuttlebutt) - Uses Bolt to store and process all Twitter mentions of GitHub projects.
 * [Wiki](https://github.com/peterhellberg/wiki) - A tiny wiki using Goji, BoltDB and Blackfriday.
 * [ChainStore](https://github.com/pressly/chainstore) - Simple key-value interface to a variety of storage engines organized as a chain of operations.
 * [MetricBase](https://github.com/msiebuhr/MetricBase) - Single-binary version of Graphite.
 * [Gitchain](https://github.com/gitchain/gitchain) - Decentralized, peer-to-peer Git repositories aka "Git meets Bitcoin".
 * [event-shuttle](https://github.com/sclasen/event-shuttle) - A Unix system service to collect and reliably deliver messages to Kafka.
 * [ipxed](https://github.com/kelseyhightower/ipxed) - Web interface and api for ipxed.
 * [BoltStore](https://github.com/yosssi/boltstore) - Session store using Bolt.
 * [photosite/session](https://godoc.org/bitbucket.org/kardianos/photosite/session) - Sessions for a photo viewing site.
 * [LedisDB](https://github.com/siddontang/ledisdb) - A high performance NoSQL, using Bolt as optional storage.
 * [ipLocator](https://github.com/AndreasBriese/ipLocator) - A fast ip-geo-location-server using bolt with bloom filters.
 * [cayley](https://github.com/google/cayley) - Cayley is an open-source graph database using Bolt as optional backend.
 * [bleve](http://www.blevesearch.com/) - A pure Go search engine similar to ElasticSearch that uses Bolt as the default storage backend.
 * [tentacool](https://github.com/optiflows/tentacool) - REST api server to manage system stuff (IP, DNS, Gateway...) on a linux server.
 * [Seaweed File System](https://github.com/chrislusf/seaweedfs) - Highly scalable distributed key~file system with O(1) disk read.
 * [InfluxDB](https://influxdata.com) - Scalable datastore for metrics, events, and real-time analytics.
 * [Freehold](http://tshannon.bitbucket.org/freehold/) - An open, secure, and lightweight platform for your files and data.
 * [Prometheus Annotation Server](https://github.com/oliver006/prom_annotation_server) - Annotation server for PromDash & Prometheus service monitoring system.
 * [Consul](https://github.com/hashicorp/consul) - Consul is service discovery and configuration made easy. Distributed, highly available, and datacenter-aware.
 * [Kala](https://github.com/ajvb/kala) - Kala is a modern job scheduler optimized to run on a single node. It is persistent, JSON over HTTP API, ISO 8601 duration notation, and dependent jobs.
 * [drive](https://github.com/odeke-em/drive) - drive is an unofficial Google Drive command line client for \*NIX operating systems.
 * [stow](https://github.com/djherbis/stow) -  a persistence manager for objects
  backed by boltdb.
 * [buckets](https://github.com/joyrexus/buckets) - a bolt wrapper streamlining
  simple tx and key scans.
 * [mbuckets](https://github.com/abhigupta912/mbuckets) - A Bolt wrapper that allows easy operations on multi level (nested) buckets.
 * [Request Baskets](https://github.com/darklynx/request-baskets) - A web service to collect arbitrary HTTP requests and inspect them via REST API or simple web UI, similar to [RequestBin](http://requestb.in/) service
 * [Go Report Card](https://goreportcard.com/) - Go code quality report cards as a (free and open source) service.
 * [Boltdb Boilerplate](https://github.com/bobintornado/boltdb-boilerplate) - Boilerplate wrapper around bolt aiming to make simple calls one-liners.
 * [lru](https://github.com/crowdriff/lru) - Easy to use Bolt-backed Least-Recently-Used (LRU) read-through cache with chainable remote stores.
 * [Storm](https://github.com/asdine/storm) - Simple and powerful ORM for BoltDB.
 * [GoWebApp](https://github.com/josephspurrier/gowebapp) - A basic MVC web application in Go using BoltDB.
 * [SimpleBolt](https://github.com/xyproto/simplebolt) - A simple way to use BoltDB. Deals mainly with strings.
 * [Algernon](https://github.com/xyproto/algernon) - A HTTP/2 web server with built-in support for Lua. Uses BoltDB as the default database backend.
 * [MuLiFS](https://github.com/dankomiocevic/mulifs) - Music Library Filesystem creates a filesystem to organise your music files.
 * [GoShort](https://github.com/pankajkhairnar/goShort) - GoShort is a URL shortener written in Golang and BoltDB for persistent key/value storage and for routing it's using high performent HTTPRouter.
 * [torrent](https://github.com/anacrolix/torrent) - Full-featured BitTorrent client package and utilities in Go. BoltDB is a storage backend in development.
 * [gopherpit](https://github.com/gopherpit/gopherpit) - A web service to manage Go remote import paths with custom domains
 * [bolter](https://github.com/hasit/bolter) - Command-line app for viewing BoltDB file in your terminal.
 * [btcwallet](https://github.com/btcsuite/btcwallet) - A bitcoin wallet.
 * [dcrwallet](https://github.com/decred/dcrwallet) - A wallet for the Decred cryptocurrency.
 * [Ironsmith](https://github.com/timshannon/ironsmith) - A simple, script-driven continuous integration (build - > test -> release) tool, with no external dependencies
 * [BoltHold](https://github.com/timshannon/bolthold) - An embeddable NoSQL store for Go types built on BoltDB
 If you are using Bolt in a project please send a pull request to add it to the list.
--- a/vendor/github.com/boltdb/bolt/appveyor.yml
+++ b/vendor/github.com/boltdb/bolt/appveyor.yml
@ -1,18 +0,0 @@
 version: "{build}"
 os: Windows Server 2012 R2
 clone_folder: c:\gopath\src\github.com\boltdb\bolt
 environment:
  GOPATH: c:\gopath
 install:
  - echo %PATH%
  - echo %GOPATH%
  - go version
  - go env
  - go get -v -t ./...
 build_script:
  - go test -v ./...
--- a/vendor/github.com/boombuler/barcode/README.md
+++ b/vendor/github.com/boombuler/barcode/README.md
@ -1,18 +0,0 @@
 ##Introduction##
 This is a package for GO which can be used to create different types of barcodes.
 ##Supported Barcode Types##
 * Aztec Code
 * Codabar
 * Code 128
 * Code 39
 * EAN 8
 * EAN 13
 * Datamatrix
 * QR Codes
 * 2 of 5
 ##Documentation##
 See [GoDoc](https://godoc.org/github.com/boombuler/barcode)
 To create a barcode use the Encode function from one of the subpackages.
--- a/vendor/github.com/chaseadamsio/goorgeous/README.org
+++ b/vendor/github.com/chaseadamsio/goorgeous/README.org
@ -1,66 +0,0 @@
 #+TITLE: chaseadamsio/goorgeous
 [[https://travis-ci.org/chaseadamsio/goorgeous.svg?branch=master]]
 [[https://coveralls.io/repos/github/chaseadamsio/goorgeous/badge.svg?branch=master]]
 /goorgeous is a Go Org to HTML Parser./
 [[file:gopher_small.gif]] 
 *Pronounced: Go? Org? Yes!*
 #+BEGIN_QUOTE
 "Org mode is for keeping notes, maintaining TODO lists, planning projects, and authoring documents with a fast and effective plain-text system."
 - [[orgmode.org]]
 #+END_QUOTE
 The purpose of this package is to come as close as possible as parsing an =*.org= document into HTML, the same way one might publish [[http://orgmode.org/worg/org-tutorials/org-publish-html-tutorial.html][with org-publish-html from Emacs]]. 
 * Installation
 #+BEGIN_SRC sh
  go get -u github.com/chaseadamsio/goorgeous
 #+END_SRC
 * Usage
 ** Org Headers
 To retrieve the headers from a =[]byte=, call =OrgHeaders= and it will return a =map[string]interface{}=: 
 #+BEGIN_SRC go
  input := "#+title: goorgeous\n* Some Headline\n"
  out := goorgeous.OrgHeaders(input) 
 #+END_SRC
 #+BEGIN_SRC go
  map[string]interface{}{ 
          "title": "goorgeous"
  }
 #+END_SRC
 ** Org Content
 After importing =github.com/chaseadamsio/goorgeous=, you can call =Org= with a =[]byte= and it will return an =html= version of the content as a =[]byte=
 #+BEGIN_SRC go
  input := "#+TITLE: goorgeous\n* Some Headline\n"
  out := goorgeous.Org(input) 
 #+END_SRC
 =out= will be:
 #+BEGIN_SRC html
  <h1>Some Headline</h1>/n
 #+END_SRC
 * Why? 
 First off, I've become an unapologetic user of Emacs & ever since finding =org-mode= I use it for anything having to do with writing content, organizing my life and keeping documentation of my days/weeks/months.
 Although I like Emacs & =emacs-lisp=, I publish all of my html sites with [[https://gohugo.io][Hugo Static Site Generator]] and wanted to be able to write my content in =org-mode= in Emacs rather than markdown.
 Hugo's implementation of templating and speed are unmatched, so the only way I knew for sure I could continue to use Hugo and write in =org-mode= seamlessly was to write a golang parser for org content and submit a PR for Hugo to use it.
 * Acknowledgements
 I leaned heavily on russross' [[https://github.com/russross/blackfriday][blackfriday markdown renderer]] as both an example of how to write a parser (with some updates to leverage the go we know today) and reusing the blackfriday HTML Renderer so I didn't have to write my own!
--- a/vendor/github.com/chaseadamsio/goorgeous/gopher.gif
+++ b/vendor/github.com/chaseadamsio/goorgeous/gopher.gif
--- a/vendor/github.com/chaseadamsio/goorgeous/gopher_small.gif
+++ b/vendor/github.com/chaseadamsio/goorgeous/gopher_small.gif
--- a/vendor/github.com/couchbase/vellum/CONTRIBUTING.md
+++ b/vendor/github.com/couchbase/vellum/CONTRIBUTING.md
@ -1,16 +0,0 @@
 # Contributing to Vellum
 We look forward to your contributions, but ask that you first review these guidelines.
 ### Sign the CLA
 As Vellum is a Couchbase project we require contributors accept the [Couchbase Contributor License Agreement](http://review.couchbase.org/static/individual_agreement.html). To sign this agreement log into the Couchbase [code review tool](http://review.couchbase.org/). The Vellum project does not use this code review tool but it is still used to track acceptance of the contributor license agreements.
 ### Submitting a Pull Request
 All types of contributions are welcome, but please keep the following in mind:
 - If you're planning a large change, you should really discuss it in a github issue first. This helps avoid duplicate effort and spending time on something that may not be merged.
 - Existing tests should continue to pass, new tests for the contribution are nice to have.
 - All code should have gone through `go fmt`
 - All code should pass `go vet`
--- a/vendor/github.com/couchbase/vellum/README.md
+++ b/vendor/github.com/couchbase/vellum/README.md
@ -1,168 +0,0 @@
 # ![vellum](docs/logo.png) vellum
 [![Build Status](https://travis-ci.org/couchbase/vellum.svg?branch=master)](https://travis-ci.org/couchbase/vellum)
 [![Coverage Status](https://coveralls.io/repos/github/couchbase/vellum/badge.svg?branch=master)](https://coveralls.io/github/couchbase/vellum?branch=master)
 [![GoDoc](https://godoc.org/github.com/couchbase/vellum?status.svg)](https://godoc.org/github.com/couchbase/vellum)
 [![Go Report Card](https://goreportcard.com/badge/github.com/couchbase/vellum)](https://goreportcard.com/report/github.com/couchbase/vellum)
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 A Go library implementing an FST (finite state transducer) capable of:
  - mapping between keys ([]byte) and a value (uint64)
  - enumerating keys in lexicographic order
 Some additional goals of this implementation:
 - bounded memory use while building the FST
 - streaming out FST data while building
 - mmap FST runtime to support very large FTSs (optional)
 ## Usage
 ### Building an FST
 To build an FST, create a new builder using the `New()` method.  This method takes an `io.Writer` as an argument.  As the FST is being built, data will be streamed to the writer as soon as possible.  With this builder you **MUST** insert keys in lexicographic order.  Inserting keys out of order will result in an error.  After inserting the last key into the builder, you **MUST** call `Close()` on the builder.  This will flush all remaining data to the underlying writer.
 In memory:
 ```go
  var buf bytes.Buffer
  builder, err := vellum.New(&buf, nil)
  if err != nil {
    log.Fatal(err)
  }
 ```
 To disk:
 ```go
  f, err := os.Create("/tmp/vellum.fst")
  if err != nil {
    log.Fatal(err)
  }
  builder, err := vellum.New(f, nil)
  if err != nil {
    log.Fatal(err)
  }
 ```
 **MUST** insert keys in lexicographic order:
 ```go
 err = builder.Insert([]byte("cat"), 1)
 if err != nil {
  log.Fatal(err)
 }
 err = builder.Insert([]byte("dog"), 2)
 if err != nil {
  log.Fatal(err)
 }
 err = builder.Insert([]byte("fish"), 3)
 if err != nil {
  log.Fatal(err)
 }
 err = builder.Close()
 if err != nil {
  log.Fatal(err)
 }
 ```
 ### Using an FST
 After closing the builder, the data can be used to instantiate an FST.  If the data was written to disk, you can use the `Open()` method to mmap the file.  If the data is already in memory, or you wish to load/mmap the data yourself, you can instantiate the FST with the `Load()` method.
 Load in memory:
 ```go
  fst, err := vellum.Load(buf.Bytes())
  if err != nil {
    log.Fatal(err)
  }
 ```
 Open from disk:
 ```go
  fst, err := vellum.Open("/tmp/vellum.fst")
  if err != nil {
    log.Fatal(err)
  }
 ```
 Get key/value:
 ```go
  val, exists, err = fst.Get([]byte("dog"))
  if err != nil {
    log.Fatal(err)
  }
  if exists {
    fmt.Printf("contains dog with val: %d\n", val)
  } else {
    fmt.Printf("does not contain dog")
  }
 ```
 Iterate key/values:
 ```go
  itr, err := fst.Iterator(startKeyInclusive, endKeyExclusive)
  for err == nil {
    key, val := itr.Current()
    fmt.Printf("contains key: %s val: %d", key, val)
    err = itr.Next()
  }
  if err != nil {
    log.Fatal(err)
  }
 ```
 ### How does the FST get built?
 A full example of the implementation is beyond the scope of this README, but let's consider a small example where we want to insert 3 key/value pairs.
 First we insert "are" with the value 4.
 ![step1](docs/demo1.png)
 Next, we insert "ate" with the value 2.  
 ![step2](docs/demo2.png)
 Notice how the values associated with the transitions were adjusted so that by summing them while traversing we still get the expected value.
 At this point, we see that state 5 looks like state 3, and state 4 looks like state 2.  But, we cannot yet combine them because future inserts could change this.
 Now, we insert "see" with value 3.  Once it has been added, we now know that states 5 and 4 can longer change.  Since they are identical to 3 and 2, we replace them.
 ![step3](docs/demo3.png)
 Again, we see that states 7 and 8 appear to be identical to 2 and 3.
 Having inserted our last key, we call `Close()` on the builder.
 ![step4](docs/demo4.png)
 Now, states 7 and 8 can safely be replaced with 2 and 3.
 For additional information, see the references at the bottom of this document.
 ### What does the serialized format look like?
 We've broken out a separate document on the [vellum disk format v1](docs/format.md).
 ### What if I want to use this on a system that doesn't have mmap?
 The mmap library itself is guarded with system/architecture build tags, but we've also added an additional build tag in vellum.  If you'd like to Open() a file based representation of an FST, but not use mmap, you can build the library with the `nommap` build tag.  NOTE: if you do this, the entire FST will be read into memory.
 ### Can I use this with Unicode strings?
 Yes, however this implementation is only aware of the byte representation you choose.  In order to find matches, you must work with some canonical byte representation of the string.  In the future, some encoding-aware traversals may be possible on top of the lower-level byte transitions.
 ### How did this library come to be?
 In my work on the [Bleve](https://github.com/blevesearch/bleve) project I became aware of the power of the FST for many search-related tasks.  The obvious starting point for such a thing in Go was the [mafsa](https://github.com/smartystreets/mafsa) project.  While working with mafsa I encountered some issues.  First, it did not stream data to disk while building.  Second, it chose to use a rune as the fundamental unit of transition in the FST, but I felt using a byte would be more powerful in the end.  My hope is that higher-level encoding-aware traversals will be possible when necessary.  Finally, as I reported bugs and submitted PRs I learned that the mafsa project was mainly a research project and no longer being maintained.  I wanted to build something that could be used in production.  As the project advanced more and more techniques from the [BurntSushi/fst](https://github.com/BurntSushi/fst) were adapted to our implementation.
 ## Related Work
 Much credit goes to two existing projects:
 - [mafsa](https://github.com/smartystreets/mafsa)
 - [BurntSushi/fst](https://github.com/BurntSushi/fst)
 Most of the original implementation here started with my digging into the internals of mafsa.  As the implementation progressed, I continued to borrow ideas/approaches from the BurntSushi/fst library as well.
 For a great introduction to this topic, please read the blog post [Index 1,600,000,000 Keys with Automata and Rust](http://blog.burntsushi.net/transducers/)
--- a/vendor/github.com/denisenkom/go-mssqldb/README.md
+++ b/vendor/github.com/denisenkom/go-mssqldb/README.md
@ -1,95 +0,0 @@
 # A pure Go MSSQL driver for Go's database/sql package
 ## Install
    go get github.com/denisenkom/go-mssqldb
 ## Tests
 `go test` is used for testing. A running instance of MSSQL server is required.
 Environment variables are used to pass login information.
 Example:
    env HOST=localhost SQLUSER=sa SQLPASSWORD=sa DATABASE=test go test
 ## Connection Parameters
 * "server" - host or host\instance (default localhost)
 * "port" - used only when there is no instance in server (default 1433)
 * "failoverpartner" - host or host\instance (default is no partner). 
 * "failoverport" - used only when there is no instance in failoverpartner (default 1433)
 * "user id" - enter the SQL Server Authentication user id or the Windows Authentication user id in the DOMAIN\User format. On Windows, if user id is empty or missing Single-Sign-On is used.
 * "password"
 * "database"
 * "connection timeout" - in seconds (default is 30)
 * "dial timeout" - in seconds (default is 5)
 * "keepAlive" - in seconds; 0 to disable (default is 0)
 * "log" - logging flags (default 0/no logging, 63 for full logging)
  *  1 log errors
  *  2 log messages
  *  4 log rows affected
  *  8 trace sql statements
  * 16 log statement parameters
  * 32 log transaction begin/end
 * "encrypt"
  * disable - Data send between client and server is not encrypted.
  * false - Data sent between client and server is not encrypted beyond the login packet. (Default)
  * true - Data sent between client and server is encrypted.
 * "TrustServerCertificate"
  * false - Server certificate is checked. Default is false if encypt is specified.
  * true - Server certificate is not checked. Default is true if encrypt is not specified. If trust server certificate is true, driver accepts any certificate presented by the server and any host name in that certificate. In this mode, TLS is susceptible to man-in-the-middle attacks. This should be used only for testing.
 * "certificate" - The file that contains the public key certificate of the CA that signed the SQL Server certificate. The specified certificate overrides the go platform specific CA certificates.
 * "hostNameInCertificate" - Specifies the Common Name (CN) in the server certificate. Default value is the server host.
 * "ServerSPN" - The kerberos SPN (Service Principal Name) for the server. Default is MSSQLSvc/host:port.
 * "Workstation ID" - The workstation name (default is the host name)
 * "app name" - The application name (default is go-mssqldb)
 * "ApplicationIntent" - Can be given the value "ReadOnly" to initiate a read-only connection to an Availability Group listener.
 Example:
 ```go
    db, err := sql.Open("mssql", "server=localhost;user id=sa")
 ```
 ## Statement Parameters
 In the SQL statement text, literals may be replaced by a parameter that matches one of the following:
 * ?
 * ?nnn
 * :nnn
 * $nnn
 where nnn represents an integer that specifies a 1-indexed positional parameter. Ex:
 ```go
 db.Query("SELECT * FROM t WHERE a = ?3, b = ?2, c = ?1", "x", "y", "z")
 ```
 will expand to roughly
 ```sql
 SELECT * FROM t WHERE a = 'z', b = 'y', c = 'x'
 ```
 ## Features
 * Can be used with SQL Server 2005 or newer
 * Can be used with Microsoft Azure SQL Database
 * Can be used on all go supported platforms (e.g. Linux, Mac OS X and Windows)
 * Supports new date/time types: date, time, datetime2, datetimeoffset
 * Supports string parameters longer than 8000 characters
 * Supports encryption using SSL/TLS
 * Supports SQL Server and Windows Authentication
 * Supports Single-Sign-On on Windows
 * Supports connections to AlwaysOn Availability Group listeners, including re-direction to read-only replicas.
 * Supports query notifications
 ## Known Issues
 * SQL Server 2008 and 2008 R2 engine cannot handle login records when SSL encryption is not disabled.
 To fix SQL Server 2008 R2 issue, install SQL Server 2008 R2 Service Pack 2.
 To fix SQL Server 2008 issue, install Microsoft SQL Server 2008 Service Pack 3 and Cumulative update package 3 for SQL Server 2008 SP3.
 More information: http://support.microsoft.com/kb/2653857
--- a/vendor/github.com/dgrijalva/jwt-go/MIGRATION_GUIDE.md
+++ b/vendor/github.com/dgrijalva/jwt-go/MIGRATION_GUIDE.md
@ -1,97 +0,0 @@
 ## Migration Guide from v2 -> v3
 Version 3 adds several new, frequently requested features.  To do so, it introduces a few breaking changes.  We've worked to keep these as minimal as possible.  This guide explains the breaking changes and how you can quickly update your code.
 ### `Token.Claims` is now an interface type
 The most requested feature from the 2.0 verison of this library was the ability to provide a custom type to the JSON parser for claims. This was implemented by introducing a new interface, `Claims`, to replace `map[string]interface{}`.  We also included two concrete implementations of `Claims`: `MapClaims` and `StandardClaims`.
 `MapClaims` is an alias for `map[string]interface{}` with built in validation behavior.  It is the default claims type when using `Parse`.  The usage is unchanged except you must type cast the claims property.
 The old example for parsing a token looked like this..
 ```go
 	if token, err := jwt.Parse(tokenString, keyLookupFunc); err == nil {
 		fmt.Printf("Token for user %v expires %v", token.Claims["user"], token.Claims["exp"])
 	}
 ```
 is now directly mapped to...
 ```go
 	if token, err := jwt.Parse(tokenString, keyLookupFunc); err == nil {
 		claims := token.Claims.(jwt.MapClaims)
 		fmt.Printf("Token for user %v expires %v", claims["user"], claims["exp"])
 	}
 ```
 `StandardClaims` is designed to be embedded in your custom type.  You can supply a custom claims type with the new `ParseWithClaims` function.  Here's an example of using a custom claims type.
 ```go
 	type MyCustomClaims struct {
 		User string
 		*StandardClaims
 	}
 	if token, err := jwt.ParseWithClaims(tokenString, &MyCustomClaims{}, keyLookupFunc); err == nil {
 		claims := token.Claims.(*MyCustomClaims)
 		fmt.Printf("Token for user %v expires %v", claims.User, claims.StandardClaims.ExpiresAt)
 	}
 ```
 ### `ParseFromRequest` has been moved
 To keep this library focused on the tokens without becoming overburdened with complex request processing logic, `ParseFromRequest` and its new companion `ParseFromRequestWithClaims` have been moved to a subpackage, `request`.  The method signatues have also been augmented to receive a new argument: `Extractor`.
 `Extractors` do the work of picking the token string out of a request.  The interface is simple and composable.
 This simple parsing example:
 ```go
 	if token, err := jwt.ParseFromRequest(tokenString, req, keyLookupFunc); err == nil {
 		fmt.Printf("Token for user %v expires %v", token.Claims["user"], token.Claims["exp"])
 	}
 ```
 is directly mapped to:
 ```go
 	if token, err := request.ParseFromRequest(req, request.OAuth2Extractor, keyLookupFunc); err == nil {
 		claims := token.Claims.(jwt.MapClaims)
 		fmt.Printf("Token for user %v expires %v", claims["user"], claims["exp"])
 	}
 ```
 There are several concrete `Extractor` types provided for your convenience:
 * `HeaderExtractor` will search a list of headers until one contains content.
 * `ArgumentExtractor` will search a list of keys in request query and form arguments until one contains content.
 * `MultiExtractor` will try a list of `Extractors` in order until one returns content.
 * `AuthorizationHeaderExtractor` will look in the `Authorization` header for a `Bearer` token.
 * `OAuth2Extractor` searches the places an OAuth2 token would be specified (per the spec): `Authorization` header and `access_token` argument
 * `PostExtractionFilter` wraps an `Extractor`, allowing you to process the content before it's parsed.  A simple example is stripping the `Bearer ` text from a header
 ### RSA signing methods no longer accept `[]byte` keys
 Due to a [critical vulnerability](https://auth0.com/blog/2015/03/31/critical-vulnerabilities-in-json-web-token-libraries/), we've decided the convenience of accepting `[]byte` instead of `rsa.PublicKey` or `rsa.PrivateKey` isn't worth the risk of misuse.
 To replace this behavior, we've added two helper methods: `ParseRSAPrivateKeyFromPEM(key []byte) (*rsa.PrivateKey, error)` and `ParseRSAPublicKeyFromPEM(key []byte) (*rsa.PublicKey, error)`.  These are just simple helpers for unpacking PEM encoded PKCS1 and PKCS8 keys. If your keys are encoded any other way, all you need to do is convert them to the `crypto/rsa` package's types.
 ```go 
 	func keyLookupFunc(*Token) (interface{}, error) {
 		// Don't forget to validate the alg is what you expect:
 		if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok {
 			return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"])
 		}
 		// Look up key 
 		key, err := lookupPublicKey(token.Header["kid"])
 		if err != nil {
 			return nil, err
 		}
 		// Unpack key from PEM encoded PKCS8
 		return jwt.ParseRSAPublicKeyFromPEM(key)
 	}
 ```
--- a/vendor/github.com/dgrijalva/jwt-go/README.md
+++ b/vendor/github.com/dgrijalva/jwt-go/README.md
@ -1,85 +0,0 @@
 A [go](http://www.golang.org) (or 'golang' for search engine friendliness) implementation of [JSON Web Tokens](http://self-issued.info/docs/draft-ietf-oauth-json-web-token.html)
 [![Build Status](https://travis-ci.org/dgrijalva/jwt-go.svg?branch=master)](https://travis-ci.org/dgrijalva/jwt-go)
 **BREAKING CHANGES:*** Version 3.0.0 is here. It includes _a lot_ of changes including a few that break the API.  We've tried to break as few things as possible, so there should just be a few type signature changes.  A full list of breaking changes is available in `VERSION_HISTORY.md`.  See `MIGRATION_GUIDE.md` for more information on updating your code.
 **NOTICE:** A vulnerability in JWT was [recently published](https://auth0.com/blog/2015/03/31/critical-vulnerabilities-in-json-web-token-libraries/).  As this library doesn't force users to validate the `alg` is what they expected, it's possible your usage is effected.  There will be an update soon to remedy this, and it will likey require backwards-incompatible changes to the API.  In the short term, please make sure your implementation verifies the `alg` is what you expect.
 ## What the heck is a JWT?
 JWT.io has [a great introduction](https://jwt.io/introduction) to JSON Web Tokens.
 In short, it's a signed JSON object that does something useful (for example, authentication).  It's commonly used for `Bearer` tokens in Oauth 2.  A token is made of three parts, separated by `.`'s.  The first two parts are JSON objects, that have been [base64url](http://tools.ietf.org/html/rfc4648) encoded.  The last part is the signature, encoded the same way.
 The first part is called the header.  It contains the necessary information for verifying the last part, the signature.  For example, which encryption method was used for signing and what key was used.
 The part in the middle is the interesting bit.  It's called the Claims and contains the actual stuff you care about.  Refer to [the RFC](http://self-issued.info/docs/draft-jones-json-web-token.html) for information about reserved keys and the proper way to add your own.
 ## What's in the box?
 This library supports the parsing and verification as well as the generation and signing of JWTs.  Current supported signing algorithms are HMAC SHA, RSA, RSA-PSS, and ECDSA, though hooks are present for adding your own.
 ## Examples
 See [the project documentation](https://godoc.org/github.com/dgrijalva/jwt-go) for examples of usage:
 * [Simple example of parsing and validating a token](https://godoc.org/github.com/dgrijalva/jwt-go#example-Parse--Hmac)
 * [Simple example of building and signing a token](https://godoc.org/github.com/dgrijalva/jwt-go#example-New--Hmac)
 * [Directory of Examples](https://godoc.org/github.com/dgrijalva/jwt-go#pkg-examples)
 ## Extensions
 This library publishes all the necessary components for adding your own signing methods.  Simply implement the `SigningMethod` interface and register a factory method using `RegisterSigningMethod`.  
 Here's an example of an extension that integrates with the Google App Engine signing tools: https://github.com/someone1/gcp-jwt-go
 ## Compliance
 This library was last reviewed to comply with [RTF 7519](http://www.rfc-editor.org/info/rfc7519) dated May 2015 with a few notable differences: 
 * In order to protect against accidental use of [Unsecured JWTs](http://self-issued.info/docs/draft-ietf-oauth-json-web-token.html#UnsecuredJWT), tokens using `alg=none` will only be accepted if the constant `jwt.UnsafeAllowNoneSignatureType` is provided as the key.
 ## Project Status & Versioning
 This library is considered production ready.  Feedback and feature requests are appreciated.  The API should be considered stable.  There should be very few backwards-incompatible changes outside of major version updates (and only with good reason).
 This project uses [Semantic Versioning 2.0.0](http://semver.org).  Accepted pull requests will land on `master`.  Periodically, versions will be tagged from `master`.  You can find all the releases on [the project releases page](https://github.com/dgrijalva/jwt-go/releases).
 While we try to make it obvious when we make breaking changes, there isn't a great mechanism for pushing announcements out to users.  You may want to use this alternative package include: `gopkg.in/dgrijalva/jwt-go.v2`.  It will do the right thing WRT semantic versioning.
 ## Usage Tips
 ### Signing vs Encryption
 A token is simply a JSON object that is signed by its author. this tells you exactly two things about the data:
 * The author of the token was in the possession of the signing secret
 * The data has not been modified since it was signed
 It's important to know that JWT does not provide encryption, which means anyone who has access to the token can read its contents. If you need to protect (encrypt) the data, there is a companion spec, `JWE`, that provides this functionality. JWE is currently outside the scope of this library.
 ### Choosing a Signing Method
 There are several signing methods available, and you should probably take the time to learn about the various options before choosing one.  The principal design decision is most likely going to be symmetric vs asymmetric.
 Symmetric signing methods, such as HSA, use only a single secret. This is probably the simplest signing method to use since any `[]byte` can be used as a valid secret. They are also slightly computationally faster to use, though this rarely is enough to matter. Symmetric signing methods work the best when both producers and consumers of tokens are trusted, or even the same system. Since the same secret is used to both sign and validate tokens, you can't easily distribute the key for validation.
 Asymmetric signing methods, such as RSA, use different keys for signing and verifying tokens. This makes it possible to produce tokens with a private key, and allow any consumer to access the public key for verification.
 ### JWT and OAuth
 It's worth mentioning that OAuth and JWT are not the same thing. A JWT token is simply a signed JSON object. It can be used anywhere such a thing is useful. There is some confusion, though, as JWT is the most common type of bearer token used in OAuth2 authentication.
 Without going too far down the rabbit hole, here's a description of the interaction of these technologies:
 * OAuth is a protocol for allowing an identity provider to be separate from the service a user is logging in to.  For example, whenever you use Facebook to log into a different service (Yelp, Spotify, etc), you are using OAuth.
 * OAuth defines several options for passing around authentication data. One popular method is called a "bearer token". A bearer token is simply a string that _should_ only be held by an authenticated user. Thus, simply presenting this token proves your identity. You can probably derive from here why a JWT might make a good bearer token.
 * Because bearer tokens are used for authentication, it's important they're kept secret. This is why transactions that use bearer tokens typically happen over SSL.
 ## More
 Documentation can be found [on godoc.org](http://godoc.org/github.com/dgrijalva/jwt-go).
 The command line utility included in this project (cmd/jwt) provides a straightforward example of token creation and parsing as well as a useful tool for debugging your own integration.  You'll also find several implementation examples in to documentation.
--- a/vendor/github.com/dgrijalva/jwt-go/VERSION_HISTORY.md
+++ b/vendor/github.com/dgrijalva/jwt-go/VERSION_HISTORY.md
@ -1,105 +0,0 @@
 ## `jwt-go` Version History
 #### 3.0.0
 * **Compatibility Breaking Changes**: See MIGRATION_GUIDE.md for tips on updating your code
 	* Dropped support for `[]byte` keys when using RSA signing methods.  This convenience feature could contribute to security vulnerabilities involving mismatched key types with signing methods.
 	* `ParseFromRequest` has been moved to `request` subpackage and usage has changed
 	* The `Claims` property on `Token` is now type `Claims` instead of `map[string]interface{}`.  The default value is type `MapClaims`, which is an alias to `map[string]interface{}`.  This makes it possible to use a custom type when decoding claims.
 * Other Additions and Changes
 	* Added `Claims` interface type to allow users to decode the claims into a custom type
 	* Added `ParseWithClaims`, which takes a third argument of type `Claims`.  Use this function instead of `Parse` if you have a custom type you'd like to decode into.
 	* Dramatically improved the functionality and flexibility of `ParseFromRequest`, which is now in the `request` subpackage
 	* Added `ParseFromRequestWithClaims` which is the `FromRequest` equivalent of `ParseWithClaims`
 	* Added new interface type `Extractor`, which is used for extracting JWT strings from http requests.  Used with `ParseFromRequest` and `ParseFromRequestWithClaims`.
 	* Added several new, more specific, validation errors to error type bitmask
 	* Moved examples from README to executable example files
 	* Signing method registry is now thread safe
 	* Added new property to `ValidationError`, which contains the raw error returned by calls made by parse/verify (such as those returned by keyfunc or json parser)
 #### 2.7.0
 This will likely be the last backwards compatible release before 3.0.0, excluding essential bug fixes.
 * Added new option `-show` to the `jwt` command that will just output the decoded token without verifying
 * Error text for expired tokens includes how long it's been expired
 * Fixed incorrect error returned from `ParseRSAPublicKeyFromPEM`
 * Documentation updates
 #### 2.6.0
 * Exposed inner error within ValidationError
 * Fixed validation errors when using UseJSONNumber flag
 * Added several unit tests
 #### 2.5.0
 * Added support for signing method none.  You shouldn't use this.  The API tries to make this clear.
 * Updated/fixed some documentation
 * Added more helpful error message when trying to parse tokens that begin with `BEARER `
 #### 2.4.0
 * Added new type, Parser, to allow for configuration of various parsing parameters
 	* You can now specify a list of valid signing methods.  Anything outside this set will be rejected.
 	* You can now opt to use the `json.Number` type instead of `float64` when parsing token JSON
 * Added support for [Travis CI](https://travis-ci.org/dgrijalva/jwt-go)
 * Fixed some bugs with ECDSA parsing
 #### 2.3.0
 * Added support for ECDSA signing methods
 * Added support for RSA PSS signing methods (requires go v1.4)
 #### 2.2.0
 * Gracefully handle a `nil` `Keyfunc` being passed to `Parse`.  Result will now be the parsed token and an error, instead of a panic.
 #### 2.1.0
 Backwards compatible API change that was missed in 2.0.0.
 * The `SignedString` method on `Token` now takes `interface{}` instead of `[]byte`
 #### 2.0.0
 There were two major reasons for breaking backwards compatibility with this update.  The first was a refactor required to expand the width of the RSA and HMAC-SHA signing implementations.  There will likely be no required code changes to support this change.
 The second update, while unfortunately requiring a small change in integration, is required to open up this library to other signing methods.  Not all keys used for all signing methods have a single standard on-disk representation.  Requiring `[]byte` as the type for all keys proved too limiting.  Additionally, this implementation allows for pre-parsed tokens to be reused, which might matter in an application that parses a high volume of tokens with a small set of keys.  Backwards compatibilty has been maintained for passing `[]byte` to the RSA signing methods, but they will also accept `*rsa.PublicKey` and `*rsa.PrivateKey`.
 It is likely the only integration change required here will be to change `func(t *jwt.Token) ([]byte, error)` to `func(t *jwt.Token) (interface{}, error)` when calling `Parse`.
 * **Compatibility Breaking Changes**
 	* `SigningMethodHS256` is now `*SigningMethodHMAC` instead of `type struct`
 	* `SigningMethodRS256` is now `*SigningMethodRSA` instead of `type struct`
 	* `KeyFunc` now returns `interface{}` instead of `[]byte`
 	* `SigningMethod.Sign` now takes `interface{}` instead of `[]byte` for the key
 	* `SigningMethod.Verify` now takes `interface{}` instead of `[]byte` for the key
 * Renamed type `SigningMethodHS256` to `SigningMethodHMAC`.  Specific sizes are now just instances of this type.
    * Added public package global `SigningMethodHS256`
    * Added public package global `SigningMethodHS384`
    * Added public package global `SigningMethodHS512`
 * Renamed type `SigningMethodRS256` to `SigningMethodRSA`.  Specific sizes are now just instances of this type.
    * Added public package global `SigningMethodRS256`
    * Added public package global `SigningMethodRS384`
    * Added public package global `SigningMethodRS512`
 * Moved sample private key for HMAC tests from an inline value to a file on disk.  Value is unchanged.
 * Refactored the RSA implementation to be easier to read
 * Exposed helper methods `ParseRSAPrivateKeyFromPEM` and `ParseRSAPublicKeyFromPEM`
 #### 1.0.2
 * Fixed bug in parsing public keys from certificates
 * Added more tests around the parsing of keys for RS256
 * Code refactoring in RS256 implementation.  No functional changes
 #### 1.0.1
 * Fixed panic if RS256 signing method was passed an invalid key
 #### 1.0.0
 * First versioned release
 * API stabilized
 * Supports creating, signing, parsing, and validating JWT tokens
 * Supports RS256 and HS256 signing methods
--- a/vendor/github.com/edsrzf/mmap-go/README.md
+++ b/vendor/github.com/edsrzf/mmap-go/README.md
@ -1,12 +0,0 @@
 mmap-go
 =======
 mmap-go is a portable mmap package for the [Go programming language](http://golang.org).
 It has been tested on Linux (386, amd64), OS X, and Windows (386). It should also
 work on other Unix-like platforms, but hasn't been tested with them. I'm interested
 to hear about the results.
 I haven't been able to add more features without adding significant complexity,
 so mmap-go doesn't support mprotect, mincore, and maybe a few other things.
 If you're running on a Unix-like platform and need some of these features,
 I suggest Gustavo Niemeyer's [gommap](http://labix.org/gommap).
--- a/vendor/github.com/elazarl/go-bindata-assetfs/README.md
+++ b/vendor/github.com/elazarl/go-bindata-assetfs/README.md
@ -1,46 +0,0 @@
 # go-bindata-assetfs
 Serve embedded files from [jteeuwen/go-bindata](https://github.com/jteeuwen/go-bindata) with `net/http`.
 [GoDoc](http://godoc.org/github.com/elazarl/go-bindata-assetfs)
 ### Installation
 Install with
    $ go get github.com/jteeuwen/go-bindata/...
    $ go get github.com/elazarl/go-bindata-assetfs/...
 ### Creating embedded data
 Usage is identical to [jteeuwen/go-bindata](https://github.com/jteeuwen/go-bindata) usage,
 instead of running `go-bindata` run `go-bindata-assetfs`.
 The tool will create a `bindata_assetfs.go` file, which contains the embedded data.
 A typical use case is
    $ go-bindata-assetfs data/...
 ### Using assetFS in your code
 The generated file provides an `assetFS()` function that returns a `http.Filesystem`
 wrapping the embedded files. What you usually want to do is:
    http.Handle("/", http.FileServer(assetFS()))
 This would run an HTTP server serving the embedded files.
 ## Without running binary tool
 You can always just run the `go-bindata` tool, and then
 use
     import "github.com/elazarl/go-bindata-assetfs"
     ...
     http.Handle("/",
        http.FileServer(
        &assetfs.AssetFS{Asset: Asset, AssetDir: AssetDir, AssetInfo: AssetInfo, Prefix: "data"}))
 to serve files embedded from the `data` directory.
--- a/vendor/github.com/ethantkoenig/rupture/Gopkg.lock
+++ b/vendor/github.com/ethantkoenig/rupture/Gopkg.lock
@ -1,173 +0,0 @@
 # This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
 [[projects]]
  name = "github.com/RoaringBitmap/roaring"
  packages = ["."]
  revision = "84551f0e309d6f9bafa428ef39b31ab7f16ff7b8"
  version = "v0.4.1"
 [[projects]]
  branch = "master"
  name = "github.com/Smerity/govarint"
  packages = ["."]
  revision = "7265e41f48f15fd61751e16da866af3c704bb3ab"
 [[projects]]
  name = "github.com/blevesearch/bleve"
  packages = [
    ".",
    "analysis",
    "analysis/analyzer/standard",
    "analysis/datetime/flexible",
    "analysis/datetime/optional",
    "analysis/lang/en",
    "analysis/token/lowercase",
    "analysis/token/porter",
    "analysis/token/stop",
    "analysis/tokenizer/unicode",
    "document",
    "geo",
    "index",
    "index/scorch",
    "index/scorch/mergeplan",
    "index/scorch/segment",
    "index/scorch/segment/mem",
    "index/scorch/segment/zap",
    "index/store",
    "index/store/boltdb",
    "index/store/gtreap",
    "index/upsidedown",
    "mapping",
    "numeric",
    "registry",
    "search",
    "search/collector",
    "search/facet",
    "search/highlight",
    "search/highlight/format/html",
    "search/highlight/fragmenter/simple",
    "search/highlight/highlighter/html",
    "search/highlight/highlighter/simple",
    "search/query",
    "search/scorer",
    "search/searcher"
  ]
  revision = "a3b125508b4443344b596888ca58467b6c9310b9"
 [[projects]]
  branch = "master"
  name = "github.com/blevesearch/go-porterstemmer"
  packages = ["."]
  revision = "23a2c8e5cf1f380f27722c6d2ae8896431dc7d0e"
 [[projects]]
  branch = "master"
  name = "github.com/blevesearch/segment"
  packages = ["."]
  revision = "762005e7a34fd909a84586299f1dd457371d36ee"
 [[projects]]
  branch = "master"
  name = "github.com/boltdb/bolt"
  packages = ["."]
  revision = "9da31745363232bc1e27dbab3569e77383a51585"
 [[projects]]
  branch = "master"
  name = "github.com/couchbase/vellum"
  packages = [
    ".",
    "regexp",
    "utf8"
  ]
  revision = "ed84a675e24ed0a0bf6859b1ddec7e7c858354bd"
 [[projects]]
  name = "github.com/davecgh/go-spew"
  packages = ["spew"]
  revision = "346938d642f2ec3594ed81d874461961cd0faa76"
  version = "v1.1.0"
 [[projects]]
  branch = "master"
  name = "github.com/edsrzf/mmap-go"
  packages = ["."]
  revision = "0bce6a6887123b67a60366d2c9fe2dfb74289d2e"
 [[projects]]
  branch = "master"
  name = "github.com/glycerine/go-unsnap-stream"
  packages = ["."]
  revision = "62a9a9eb44fd8932157b1a8ace2149eff5971af6"
 [[projects]]
  name = "github.com/golang/protobuf"
  packages = ["proto"]
  revision = "925541529c1fa6821df4e44ce2723319eb2be768"
  version = "v1.0.0"
 [[projects]]
  branch = "master"
  name = "github.com/golang/snappy"
  packages = ["."]
  revision = "553a641470496b2327abcac10b36396bd98e45c9"
 [[projects]]
  branch = "master"
  name = "github.com/mschoch/smat"
  packages = ["."]
  revision = "90eadee771aeab36e8bf796039b8c261bebebe4f"
 [[projects]]
  name = "github.com/philhofer/fwd"
  packages = ["."]
  revision = "bb6d471dc95d4fe11e432687f8b70ff496cf3136"
  version = "v1.0.0"
 [[projects]]
  name = "github.com/pmezard/go-difflib"
  packages = ["difflib"]
  revision = "792786c7400a136282c1664665ae0a8db921c6c2"
  version = "v1.0.0"
 [[projects]]
  branch = "master"
  name = "github.com/steveyen/gtreap"
  packages = ["."]
  revision = "0abe01ef9be25c4aedc174758ec2d917314d6d70"
 [[projects]]
  name = "github.com/stretchr/testify"
  packages = ["assert"]
  revision = "12b6f73e6084dad08a7c6e575284b177ecafbc71"
  version = "v1.2.1"
 [[projects]]
  branch = "master"
  name = "github.com/tinylib/msgp"
  packages = ["msgp"]
  revision = "03a79185462ad029a6e7e05b2f3f3e0498d0a6c0"
 [[projects]]
  branch = "master"
  name = "github.com/willf/bitset"
  packages = ["."]
  revision = "1a37ad96e8c1a11b20900a232874843b5174221f"
 [[projects]]
  name = "golang.org/x/net"
  packages = ["context"]
  revision = "309822c5b9b9f80db67f016069a12628d94fad34"
 [[projects]]
  name = "golang.org/x/sys"
  packages = ["unix"]
  revision = "3dbebcf8efb6a5011a60c2b4591c1022a759af8a"
 [solve-meta]
  analyzer-name = "dep"
  analyzer-version = 1
  inputs-digest = "61c759f0c1136cadf86ae8a30bb78edf33fc844cdcb2316469b4ae14a8d051b0"
  solver-name = "gps-cdcl"
  solver-version = 1
--- a/vendor/github.com/ethantkoenig/rupture/Gopkg.toml
+++ b/vendor/github.com/ethantkoenig/rupture/Gopkg.toml
@ -1,34 +0,0 @@
 # Gopkg.toml example
 #
 # Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
 # for detailed Gopkg.toml documentation.
 #
 # required = ["github.com/user/thing/cmd/thing"]
 # ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
 #
 # [[constraint]]
 #   name = "github.com/user/project"
 #   version = "1.0.0"
 #
 # [[constraint]]
 #   name = "github.com/user/project2"
 #   branch = "dev"
 #   source = "github.com/myfork/project2"
 #
 # [[override]]
 #   name = "github.com/x/y"
 #   version = "2.4.0"
 #
 # [prune]
 #   non-go = false
 #   go-tests = true
 #   unused-packages = true
 [[constraint]]
  name = "github.com/stretchr/testify"
  version = "1.2.1"
 [prune]
  go-tests = true
  unused-packages = true
--- a/vendor/github.com/ethantkoenig/rupture/README.md
+++ b/vendor/github.com/ethantkoenig/rupture/README.md
@ -1,13 +0,0 @@
 # rupture
 [![Build Status](https://travis-ci.org/ethantkoenig/rupture.svg?branch=master)](https://travis-ci.org/ethantkoenig/rupture) [![GoDoc](https://godoc.org/github.com/ethantkoenig/rupture?status.svg)](https://godoc.org/github.com/ethantkoenig/rupture) [![Go Report Card](https://goreportcard.com/badge/blevesearch/bleve)](https://goreportcard.com/report/blevesearch/bleve)
 An explosive companion to the [bleve indexing library](https://www.github.com/blevesearch/bleve)
 ## Features
 `rupture` includes the following additions to `bleve`:
 - __Flushing batches__: Batches of operation which automatically flush to the underlying bleve index.
 - __Sharded indices__: An index-like abstraction built on top of several underlying indices. Sharded indices provide lower write latencies for indices with large amounts of data.
 - __Index metadata__: Track index version for easily managing migrations and schema changes.
--- a/vendor/github.com/facebookgo/clock/README.md
+++ b/vendor/github.com/facebookgo/clock/README.md
@ -1,104 +0,0 @@
 clock [![Build Status](https://drone.io/github.com/benbjohnson/clock/status.png)](https://drone.io/github.com/benbjohnson/clock/latest) [![Coverage Status](https://coveralls.io/repos/benbjohnson/clock/badge.png?branch=master)](https://coveralls.io/r/benbjohnson/clock?branch=master) [![GoDoc](https://godoc.org/github.com/benbjohnson/clock?status.png)](https://godoc.org/github.com/benbjohnson/clock) ![Project status](http://img.shields.io/status/experimental.png?color=red)
 =====
 Clock is a small library for mocking time in Go. It provides an interface
 around the standard library's [`time`][time] package so that the application
 can use the realtime clock while tests can use the mock clock.
 [time]: http://golang.org/pkg/time/
 ## Usage
 ### Realtime Clock
 Your application can maintain a `Clock` variable that will allow realtime and
 mock clocks to be interchangable. For example, if you had an `Application` type:
 ```go
 import "github.com/benbjohnson/clock"
 type Application struct {
 	Clock clock.Clock
 }
 ```
 You could initialize it to use the realtime clock like this:
 ```go
 var app Application
 app.Clock = clock.New()
 ...
 ```
 Then all timers and time-related functionality should be performed from the
 `Clock` variable.
 ### Mocking time
 In your tests, you will want to use a `Mock` clock:
 ```go
 import (
 	"testing"
 	"github.com/benbjohnson/clock"
 )
 func TestApplication_DoSomething(t *testing.T) {
 	mock := clock.NewMock()
 	app := Application{Clock: mock}
 	...
 }
 ```
 Now that you've initialized your application to use the mock clock, you can
 adjust the time programmatically. The mock clock always starts from the Unix
 epoch (midnight, Jan 1, 1970 UTC).
 ### Controlling time
 The mock clock provides the same functions that the standard library's `time`
 package provides. For example, to find the current time, you use the `Now()`
 function:
 ```go
 mock := clock.NewMock()
 // Find the current time.
 mock.Now().UTC() // 1970-01-01 00:00:00 +0000 UTC
 // Move the clock forward.
 mock.Add(2 * time.Hour)
 // Check the time again. It's 2 hours later!
 mock.Now().UTC() // 1970-01-01 02:00:00 +0000 UTC
 ```
 Timers and Tickers are also controlled by this same mock clock. They will only
 execute when the clock is moved forward:
 ```
 mock := clock.NewMock()
 count := 0
 // Kick off a timer to increment every 1 mock second.
 go func() {
    ticker := clock.Ticker(1 * time.Second)
    for {
        <-ticker.C
        count++
    }
 }()
 runtime.Gosched()
 // Move the clock forward 10 second.
 mock.Add(10 * time.Second)
 // This prints 10.
 fmt.Println(count)
 ```
--- a/vendor/github.com/facebookgo/httpdown/readme.md
+++ b/vendor/github.com/facebookgo/httpdown/readme.md
@ -1,41 +0,0 @@
 httpdown [![Build Status](https://secure.travis-ci.org/facebookgo/httpdown.png)](https://travis-ci.org/facebookgo/httpdown)
 ========
 Documentation: https://godoc.org/github.com/facebookgo/httpdown
 Package httpdown provides a library that makes it easy to build a HTTP server
 that can be shutdown gracefully (that is, without dropping any connections).
 If you want graceful restart and not just graceful shutdown, look at the
 [grace](https://github.com/facebookgo/grace) package which uses this package
 underneath but also provides graceful restart.
 Usage
 -----
 Demo HTTP Server with graceful termination:
 https://github.com/facebookgo/httpdown/blob/master/httpdown_example/main.go
 1. Install the demo application
        go get github.com/facebookgo/httpdown/httpdown_example
 1. Start it in the first terminal
        httpdown_example
   This will output something like:
        2014/11/18 21:57:50 serving on http://127.0.0.1:8080/ with pid 17
 1. In a second terminal start a slow HTTP request
        curl 'http://localhost:8080/?duration=20s'
 1. In a third terminal trigger a graceful shutdown (using the pid from your output):
        kill -TERM 17
 This will demonstrate that the slow request was served before the server was
 shutdown. You could also have used `Ctrl-C` instead of `kill` as the example
 application triggers graceful shutdown on TERM or INT signals.
--- a/vendor/github.com/facebookgo/stats/readme.md
+++ b/vendor/github.com/facebookgo/stats/readme.md
@ -1,4 +0,0 @@
 stats [![Build Status](https://secure.travis-ci.org/facebookgo/stats.png)](https://travis-ci.org/facebookgo/stats)
 =====
 Documentation: https://godoc.org/github.com/facebookgo/stats
--- a/vendor/github.com/glycerine/go-unsnap-stream/README.md
+++ b/vendor/github.com/glycerine/go-unsnap-stream/README.md
@ -1,20 +0,0 @@
 go-unsnap-stream
 ================
 This is a small golang library for decoding and encoding the snappy *streaming* format, specified here: https://github.com/google/snappy/blob/master/framing_format.txt
 Note that the *streaming or framing format* for snappy is different from snappy itself. Think of it as a train of boxcars: the streaming format breaks your data in chunks, applies snappy to each chunk alone, then puts a thin wrapper around the chunk, and sends it along in turn. You can begin decoding before receiving everything. And memory requirements for decoding are sane.
 Strangely, though the streaming format was first proposed in Go[1][2], it was never upated, and I could not locate any other library for Go that would handle the streaming/framed snappy format. Hence this implementation of the spec. There is a command line tool[3] that has a C implementation, but this is the only Go implementation that I am aware of. The reference for the framing/streaming spec seems to be the python implementation[4].
 For binary compatibility with the python implementation, one could use the C-snappy compressor/decompressor code directly; using github.com/dgryski/go-csnappy. In fact we did this for a while to verify byte-for-byte compatiblity, as the native Go implementation produces slightly different binary compression (still conformant with the standard of course), which made test-diffs harder, and some have complained about it being slower than the C.
 However, while the c-snappy was useful for checking compatibility, it introduced dependencies on external C libraries (both the c-snappy library and the C standard library). Our go binary executable that used the go-unsnap-stream library was no longer standalone, and deployment was painful if not impossible if the target had a different C standard library. So we've gone back to using the snappy-go implementation (entirely in Go) for ease of deployment. See the comments at the top of unsnap.go if you wish to use c-snappy instead.
 [1] https://groups.google.com/forum/#!msg/snappy-compression/qvLNe2cSH9s/R19oBC-p7g4J
 [2] https://codereview.appspot.com/5167058
 [3] https://github.com/kubo/snzip
 [4] https://pypi.python.org/pypi/python-snappy
--- a/vendor/github.com/glycerine/go-unsnap-stream/binary.dat
+++ b/vendor/github.com/glycerine/go-unsnap-stream/binary.dat
--- a/vendor/github.com/glycerine/go-unsnap-stream/binary.dat.snappy
+++ b/vendor/github.com/glycerine/go-unsnap-stream/binary.dat.snappy
--- a/vendor/github.com/glycerine/go-unsnap-stream/unenc.txt
+++ b/vendor/github.com/glycerine/go-unsnap-stream/unenc.txt
@ -1 +0,0 @@
 hello_snappy
--- a/vendor/github.com/glycerine/go-unsnap-stream/unenc.txt.snappy
+++ b/vendor/github.com/glycerine/go-unsnap-stream/unenc.txt.snappy
--- a/vendor/github.com/go-macaron/bindata/README.md
+++ b/vendor/github.com/go-macaron/bindata/README.md
@ -1,16 +0,0 @@
 # bindata [![Build Status](https://travis-ci.org/go-macaron/bindata.svg?branch=master)](https://travis-ci.org/go-macaron/bindata) [![](http://gocover.io/_badge/github.com/go-macaron/bindata)](http://gocover.io/github.com/go-macaron/bindata)
 Package bindata is a helper module that allows to use in-memory static and template files for Macaron via [go-bindata](https://github.com/jteeuwen/go-bindata).
 ### Installation
 	go get github.com/go-macaron/bindata
 ## Getting Help
 - [API Reference](https://gowalker.org/github.com/go-macaron/bindata)
 - [Documentation](http://go-macaron.com/docs/middlewares/bindata)
 ## License
 This project is under the Apache License, Version 2.0. See the [LICENSE](LICENSE) file for the full license text.
--- a/vendor/github.com/go-macaron/binding/README.md
+++ b/vendor/github.com/go-macaron/binding/README.md
@ -1,20 +0,0 @@
 # binding [![Build Status](https://travis-ci.org/go-macaron/binding.svg?branch=master)](https://travis-ci.org/go-macaron/binding) [![](http://gocover.io/_badge/github.com/go-macaron/binding)](http://gocover.io/github.com/go-macaron/binding)
 Middleware binding provides request data binding and validation for [Macaron](https://github.com/go-macaron/macaron).
 ### Installation
 	go get github.com/go-macaron/binding
 ## Getting Help
 - [API Reference](https://gowalker.org/github.com/go-macaron/binding)
 - [Documentation](http://go-macaron.com/docs/middlewares/binding)
 ## Credits
 This package is a modified version of [martini-contrib/binding](https://github.com/martini-contrib/binding).
 ## License
 This project is under the Apache License, Version 2.0. See the [LICENSE](LICENSE) file for the full license text.
--- a/vendor/github.com/go-macaron/cache/README.md
+++ b/vendor/github.com/go-macaron/cache/README.md
@ -1,20 +0,0 @@
 # cache [![Build Status](https://travis-ci.org/go-macaron/cache.svg?branch=master)](https://travis-ci.org/go-macaron/cache) [![](http://gocover.io/_badge/github.com/go-macaron/cache)](http://gocover.io/github.com/go-macaron/cache)
 Middleware cache provides cache management for [Macaron](https://github.com/go-macaron/macaron). It can use many cache adapters, including memory, file, Redis, Memcache, PostgreSQL, MySQL, Ledis and Nodb.
 ### Installation
 	go get github.com/go-macaron/cache
 ## Getting Help
 - [API Reference](https://gowalker.org/github.com/go-macaron/cache)
 - [Documentation](http://go-macaron.com/docs/middlewares/cache)
 ## Credits
 This package is a modified version of [beego/cache](https://github.com/astaxie/beego/tree/master/cache).
 ## License
 This project is under the Apache License, Version 2.0. See the [LICENSE](LICENSE) file for the full license text.
--- a/vendor/github.com/go-macaron/cache/memcache/memcache.goconvey
+++ b/vendor/github.com/go-macaron/cache/memcache/memcache.goconvey
@ -1 +0,0 @@
 ignore
--- a/vendor/github.com/go-macaron/cache/redis/redis.goconvey
+++ b/vendor/github.com/go-macaron/cache/redis/redis.goconvey
@ -1 +0,0 @@
 ignore
--- a/vendor/github.com/go-macaron/captcha/README.md
+++ b/vendor/github.com/go-macaron/captcha/README.md
@ -1,16 +0,0 @@
 # captcha [![Build Status](https://travis-ci.org/go-macaron/captcha.svg?branch=master)](https://travis-ci.org/go-macaron/captcha)
 Middleware captcha provides captcha service for [Macaron](https://github.com/go-macaron/macaron).
 ### Installation
 	go get github.com/go-macaron/captcha
 ## Getting Help
 - [API Reference](https://gowalker.org/github.com/go-macaron/captcha)
 - [Documentation](http://go-macaron.com/docs/middlewares/captcha)
 ## License
 This project is under the Apache License, Version 2.0. See the [LICENSE](LICENSE) file for the full license text.
--- a/vendor/github.com/go-macaron/csrf/README.md
+++ b/vendor/github.com/go-macaron/csrf/README.md
@ -1,18 +0,0 @@
 # csrf [![Build Status](https://travis-ci.org/go-macaron/csrf.svg?branch=master)](https://travis-ci.org/go-macaron/csrf) [![](http://gocover.io/_badge/github.com/go-macaron/csrf)](http://gocover.io/github.com/go-macaron/csrf)
 Middleware csrf generates and validates CSRF tokens for [Macaron](https://github.com/go-macaron/macaron).
 [API Reference](https://gowalker.org/github.com/go-macaron/csrf)
 ### Installation
 	go get github.com/go-macaron/csrf
 ## Getting Help
 - [API Reference](https://gowalker.org/github.com/go-macaron/csrf)
 - [Documentation](http://go-macaron.com/docs/middlewares/csrf)
 ## License
 This project is under the Apache License, Version 2.0. See the [LICENSE](LICENSE) file for the full license text.
--- a/vendor/github.com/go-macaron/gzip/README.md
+++ b/vendor/github.com/go-macaron/gzip/README.md
@ -1,20 +0,0 @@
 # gzip [![Build Status](https://travis-ci.org/go-macaron/gzip.svg?branch=master)](https://travis-ci.org/go-macaron/gzip) [![](http://gocover.io/_badge/github.com/go-macaron/gzip)](http://gocover.io/github.com/go-macaron/gzip)
 Middleware gzip provides compress to responses for [Macaron](https://github.com/go-macaron/macaron).
 ### Installation
 	go get github.com/go-macaron/gzip
 ## Getting Help
 - [API Reference](https://gowalker.org/github.com/go-macaron/gzip)
 - [Documentation](http://go-macaron.com/docs/middlewares/gzip)
 ## Credits
 This package is a modified version of [martini-contrib/gzip](https://github.com/martini-contrib/gzip).
 ## License
 This project is under the Apache License, Version 2.0. See the [LICENSE](LICENSE) file for the full license text.
--- a/vendor/github.com/go-macaron/i18n/README.md
+++ b/vendor/github.com/go-macaron/i18n/README.md
@ -1,16 +0,0 @@
 # i18n [![Build Status](https://travis-ci.org/go-macaron/i18n.svg?branch=master)](https://travis-ci.org/go-macaron/i18n) [![](http://gocover.io/_badge/github.com/go-macaron/i18n)](http://gocover.io/github.com/go-macaron/i18n)
 Middleware i18n provides app Internationalization and Localization for [Macaron](https://github.com/go-macaron/macaron).
 ### Installation
 	go get github.com/go-macaron/i18n
 ## Getting Help
 - [API Reference](https://gowalker.org/github.com/go-macaron/i18n)
 - [Documentation](http://go-macaron.com/docs/middlewares/i18n)
 ## License
 This project is under the Apache License, Version 2.0. See the [LICENSE](LICENSE) file for the full license text.
--- a/vendor/github.com/go-macaron/inject/README.md
+++ b/vendor/github.com/go-macaron/inject/README.md
@ -1,11 +0,0 @@
 # inject [![Build Status](https://travis-ci.org/go-macaron/inject.svg?branch=master)](https://travis-ci.org/go-macaron/inject) [![](http://gocover.io/_badge/github.com/go-macaron/inject)](http://gocover.io/github.com/go-macaron/inject)
 Package inject provides utilities for mapping and injecting dependencies in various ways.
 **This a modified version of [codegangsta/inject](https://github.com/codegangsta/inject) for special purpose of Macaron**
 **Please use the original version if you need dependency injection feature**
 ## License
 This project is under the Apache License, Version 2.0. See the [LICENSE](LICENSE) file for the full license text.
--- a/vendor/github.com/go-macaron/session/README.md
+++ b/vendor/github.com/go-macaron/session/README.md
@ -1,20 +0,0 @@
 # session [![Build Status](https://travis-ci.org/go-macaron/session.svg?branch=master)](https://travis-ci.org/go-macaron/session) [![](http://gocover.io/_badge/github.com/go-macaron/session)](http://gocover.io/github.com/go-macaron/session)
 Middleware session provides session management for [Macaron](https://github.com/go-macaron/macaron). It can use many session providers, including memory, file, Redis, Memcache, PostgreSQL, MySQL, Couchbase, Ledis and Nodb.
 ### Installation
 	go get github.com/go-macaron/session
 ## Getting Help
 - [API Reference](https://gowalker.org/github.com/go-macaron/session)
 - [Documentation](http://go-macaron.com/docs/middlewares/session)
 ## Credits
 This package is a modified version of [beego/session](https://github.com/astaxie/beego/tree/master/session).
 ## License
 This project is under the Apache License, Version 2.0. See the [LICENSE](LICENSE) file for the full license text.
--- a/vendor/github.com/go-macaron/session/redis/redis.goconvey
+++ b/vendor/github.com/go-macaron/session/redis/redis.goconvey
@ -1 +0,0 @@
 ignore
--- a/vendor/github.com/go-macaron/toolbox/README.md
+++ b/vendor/github.com/go-macaron/toolbox/README.md
@ -1,110 +0,0 @@
 toolbox
 =======
 Middleware toolbox provides health chcek, pprof, profile and statistic services for [Macaron](https://github.com/go-macaron/macaron).
 [API Reference](https://gowalker.org/github.com/go-macaron/toolbox)
 ### Installation
 	go get github.com/go-macaron/toolbox
 ## Usage
 ```go
 // main.go
 import (
 	"gopkg.in/macaron.v1"
 	"github.com/go-macaron/toolbox"
 )
 func main() {
  	m := macaron.Classic()
  	m.Use(toolbox.Toolboxer(m))
 	m.Run()
 }
 ```
 Open your browser and visit `http://localhost:4000/debug` to see the effects.
 ## Options
 `toolbox.Toolboxer` comes with a variety of configuration options:
 ```go
 type dummyChecker struct {
 }
 func (dc *dummyChecker) Desc() string {
 	return "Dummy checker"
 }
 func (dc *dummyChecker) Check() error {
 	return nil
 }
 // ...
 m.Use(toolbox.Toolboxer(m, toolbox.Options{
 	URLPrefix:			"/debug",			// URL prefix for toolbox dashboard.
 	HealthCheckURL:		"/healthcheck", 	// URL for health check request.
 	HealthCheckers: []HealthChecker{
 		new(dummyChecker),
 	},										// Health checkers.
 	HealthCheckFuncs: []*toolbox.HealthCheckFuncDesc{
 		&toolbox.HealthCheckFuncDesc{
 			Desc: "Database connection",
 			Func: func() error { return "OK" },
 		},
 	},										// Health check functions.
 	PprofURLPrefix:		"/debug/pprof/", 	// URL prefix of pprof.
 	ProfileURLPrefix:	"/debug/profile/", 	// URL prefix of profile.
 	ProfilePath:		"profile", 			// Path store profile files.
 }))
 // ...
 ```
 ## Route Statistic
 Toolbox also comes with a route call statistic functionality:
 ```go
 import (
 	"os"
 	"time"
 	//...
 	"github.com/go-macaron/toolbox"
 )
 func main() {
 	//...
 	m.Get("/", func(t toolbox.Toolbox) {
 		start := time.Now()
 		// Other operations.
 		t.AddStatistics("GET", "/", time.Since(start))
 	})
 	m.Get("/dump", func(t toolbox.Toolbox) {
 		t.GetMap(os.Stdout)
 	})
 }
 ```
 Output take from test:
 ```
 +---------------------------------------------------+------------+------------------+------------------+------------------+------------------+------------------+
 | Request URL                                       | Method     | Times            | Total Used(s)    | Max Used(μs)     | Min Used(μs)     | Avg Used(μs)     |
 +---------------------------------------------------+------------+------------------+------------------+------------------+------------------+------------------+
 | /api/user                                         | POST       |                2 |         0.000122 |       120.000000 |         2.000000 |        61.000000 |
 | /api/user                                         | GET        |                1 |         0.000013 |        13.000000 |        13.000000 |        13.000000 |
 | /api/user                                         | DELETE     |                1 |         0.000001 |         1.400000 |         1.400000 |         1.400000 |
 | /api/admin                                        | POST       |                1 |         0.000014 |        14.000000 |        14.000000 |        14.000000 |
 | /api/user/unknwon                                 | POST       |                1 |         0.000012 |        12.000000 |        12.000000 |        12.000000 |
 +---------------------------------------------------+------------+------------------+------------------+------------------+------------------+------------------+
 ```
 ## License
 This project is under Apache v2 License. See the [LICENSE](LICENSE) file for the full license text.
--- a/vendor/github.com/go-sql-driver/mysql/CHANGELOG.md
+++ b/vendor/github.com/go-sql-driver/mysql/CHANGELOG.md
@ -1,114 +0,0 @@
 ## HEAD
 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)
 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)
 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)
 ## 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/ISSUE_TEMPLATE.md
+++ b/vendor/github.com/go-sql-driver/mysql/ISSUE_TEMPLATE.md
@ -1,21 +0,0 @@
 ### Issue description
 Tell us what should happen and what happens instead
 ### Example code
 ```go
 If possible, please enter some example code here to reproduce the issue.
 ```
 ### Error log
 ```
 If you have an error log, please paste it here.
 ```
 ### Configuration
 *Driver version (or git SHA):*
 *Go version:* run `go version` in your console
 *Server version:* E.g. MySQL 5.6, MariaDB 10.0.20
 *Server OS:* E.g. Debian 8.1 (Jessie), Windows 10
--- a/vendor/github.com/go-sql-driver/mysql/PULL_REQUEST_TEMPLATE.md
+++ b/vendor/github.com/go-sql-driver/mysql/PULL_REQUEST_TEMPLATE.md
@ -1,9 +0,0 @@
 ### Description
 Please explain the changes you made here.
 ### Checklist
 - [ ] Code compiles correctly
 - [ ] Created tests which fail without the change (if possible)
 - [ ] All tests passing
 - [ ] Extended the README / documentation, if necessary
 - [ ] Added myself / the copyright holder to the AUTHORS file
--- a/vendor/github.com/go-sql-driver/mysql/README.md
+++ b/vendor/github.com/go-sql-driver/mysql/README.md
@ -1,439 +0,0 @@
 # Go-MySQL-Driver
 A MySQL-Driver for Go's [database/sql](http://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")
 **Latest stable Release:** [Version 1.2 (June 03, 2014)](https://github.com/go-sql-driver/mysql/releases)
 [![Build Status](https://travis-ci.org/go-sql-driver/mysql.png?branch=master)](https://travis-ci.org/go-sql-driver/mysql)
 ---------------------------------------
  * [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)
    * [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](http://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`](http://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.2 or higher
  * MySQL (4.1+), MariaDB, Percona Server, Google CloudSQL or Sphinx (2.2.3+)
 ---------------------------------------
 ## Installation
 Simple install the package to your [$GOPATH](http://code.google.com/p/go-wiki/wiki/GOPATH "GOPATH") with the [go tool](http://golang.org/cmd/go/ "go command") from shell:
 ```bash
 $ go get github.com/go-sql-driver/mysql
 ```
 Make sure [Git is installed](http://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`](http://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](http://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 `host` is a literal IPv6 address, it must be enclosed in square brackets.
 The functions [net.JoinHostPort](http://golang.org/pkg/net/#JoinHostPort) and [net.SplitHostPort](http://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:        false
 ```
 `allowNativePasswords=true` allows the usage of the 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](http://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](http://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:       0
 ```
 Max packet size allowed in bytes. Use `maxAllowedPacket=0` to automatically fetch the `max_allowed_packet` variable from server.
 ##### `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`
 ##### `readTimeout`
 ```
 Type:           decimal number
 Default:        0
 ```
 I/O read timeout. The value must be a decimal number with an unit suffix ( *"ms"*, *"s"*, *"m"*, *"h"* ), such as *"30s"*, *"0.5m"* or *"1m30s"*.
 ##### `strict`
 ```
 Type:           bool
 Valid Values:   true, false
 Default:        false
 ```
 `strict=true` enables a driver-side strict mode in which MySQL warnings are treated as errors. This mode should not be used in production as it may lead to data corruption in certain situations.
 A server-side strict mode, which is safe for production use, can be set via the [`sql_mode`](https://dev.mysql.com/doc/refman/5.7/en/sql-mode.html) system variable.
 By default MySQL also treats notes as warnings. Use [`sql_notes=false`](http://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html#sysvar_sql_notes) to ignore notes.
 ##### `timeout`
 ```
 Type:           decimal number
 Default:        OS default
 ```
 *Driver* side connection timeout. The value must be a decimal number with an unit suffix ( *"ms"*, *"s"*, *"m"*, *"h"* ), such as *"30s"*, *"0.5m"* or *"1m30s"*. To set a server side timeout, use the parameter [`wait_timeout`](http://dev.mysql.com/doc/refman/5.6/en/server-system-variables.html#sysvar_wait_timeout).
 ##### `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`](http://godoc.org/github.com/go-sql-driver/mysql#RegisterTLSConfig).
 ##### `writeTimeout`
 ```
 Type:           decimal number
 Default:        0
 ```
 I/O write timeout. The value must be a decimal number with an unit suffix ( *"ms"*, *"s"*, *"m"*, *"h"* ), such as *"30s"*, *"0.5m"* or *"1m30s"*.
 ##### System Variables
 All other parameters are interpreted as system variables:
  * `autocommit`: `"SET autocommit=<value>"`
  * [`time_zone`](https://dev.mysql.com/doc/refman/5.5/en/time-zone-support.html): `"SET time_zone=<value>"`
  * [`tx_isolation`](https://dev.mysql.com/doc/refman/5.5/en/server-system-variables.html#sysvar_tx_isolation): `"SET tx_isolation=<value>"`
  * `param`: `"SET <param>=<value>"`
 *The values must be [url.QueryEscape](http://golang.org/pkg/net/url/#QueryEscape)'ed!*
 #### 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@/
 ```
 ### `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](http://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 programm.
 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](http://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`](http://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](http://www.mozilla.org/MPL/2.0/FAQ.html) 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-xorm/builder/README.md
+++ b/vendor/github.com/go-xorm/builder/README.md
@ -1,175 +0,0 @@
 # SQL builder
 [![CircleCI](https://circleci.com/gh/go-xorm/builder/tree/master.svg?style=svg)](https://circleci.com/gh/go-xorm/builder/tree/master)
 Package builder is a lightweight and fast SQL builder for Go and XORM.
 Make sure you have installed Go 1.1+ and then:
    go get github.com/go-xorm/builder
 # Insert
 ```Go
 sql, args, err := Insert(Eq{"c": 1, "d": 2}).Into("table1").ToSQL()
 ```
 # Select
 ```Go
 sql, args, err := Select("c, d").From("table1").Where(Eq{"a": 1}).ToSQL()
 sql, args, err = Select("c, d").From("table1").LeftJoin("table2", Eq{"table1.id": 1}.And(Lt{"table2.id": 3})).
 		RightJoin("table3", "table2.id = table3.tid").Where(Eq{"a": 1}).ToSQL()
 ```
 # Update
 ```Go
 sql, args, err := Update(Eq{"a": 2}).From("table1").Where(Eq{"a": 1}).ToSQL()
 ```
 # Delete
 ```Go
 sql, args, err := Delete(Eq{"a": 1}).From("table1").ToSQL()
 ```
 # Conditions
 * `Eq` is a redefine of a map, you can give one or more conditions to `Eq`
 ```Go
 import . "github.com/go-xorm/builder"
 sql, args, _ := ToSQL(Eq{"a":1})
 // a=? [1]
 sql, args, _ := ToSQL(Eq{"b":"c"}.And(Eq{"c": 0}))
 // b=? AND c=? ["c", 0]
 sql, args, _ := ToSQL(Eq{"b":"c", "c":0})
 // b=? AND c=? ["c", 0]
 sql, args, _ := ToSQL(Eq{"b":"c"}.Or(Eq{"b":"d"}))
 // b=? OR b=? ["c", "d"]
 sql, args, _ := ToSQL(Eq{"b": []string{"c", "d"}})
 // b IN (?,?) ["c", "d"]
 sql, args, _ := ToSQL(Eq{"b": 1, "c":[]int{2, 3}})
 // b=? AND c IN (?,?) [1, 2, 3]
 ```
 * `Neq` is the same to `Eq`
 ```Go
 import . "github.com/go-xorm/builder"
 sql, args, _ := ToSQL(Neq{"a":1})
 // a<>? [1]
 sql, args, _ := ToSQL(Neq{"b":"c"}.And(Neq{"c": 0}))
 // b<>? AND c<>? ["c", 0]
 sql, args, _ := ToSQL(Neq{"b":"c", "c":0})
 // b<>? AND c<>? ["c", 0]
 sql, args, _ := ToSQL(Neq{"b":"c"}.Or(Neq{"b":"d"}))
 // b<>? OR b<>? ["c", "d"]
 sql, args, _ := ToSQL(Neq{"b": []string{"c", "d"}})
 // b NOT IN (?,?) ["c", "d"]
 sql, args, _ := ToSQL(Neq{"b": 1, "c":[]int{2, 3}})
 // b<>? AND c NOT IN (?,?) [1, 2, 3]
 ```
 * `Gt`, `Gte`, `Lt`, `Lte`
 ```Go
 import . "github.com/go-xorm/builder"
 sql, args, _ := ToSQL(Gt{"a", 1}.And(Gte{"b", 2}))
 // a>? AND b>=? [1, 2]
 sql, args, _ := ToSQL(Lt{"a", 1}.Or(Lte{"b", 2}))
 // a<? OR b<=? [1, 2]
 ```
 * `Like`
 ```Go
 import . "github.com/go-xorm/builder"
 sql, args, _ := ToSQL(Like{"a", "c"})
 // a LIKE ? [%c%]
 ```
 * `Expr` you can customerize your sql with `Expr`
 ```Go
 import . "github.com/go-xorm/builder"
 sql, args, _ := ToSQL(Expr("a = ? ", 1))
 // a = ? [1]
 sql, args, _ := ToSQL(Eq{"a": Expr("select id from table where c = ?", 1)})
 // a=(select id from table where c = ?) [1]
 ```
 * `In` and `NotIn`
 ```Go
 import . "github.com/go-xorm/builder"
 sql, args, _ := ToSQL(In("a", 1, 2, 3))
 // a IN (?,?,?) [1,2,3]
 sql, args, _ := ToSQL(In("a", []int{1, 2, 3}))
 // a IN (?,?,?) [1,2,3]
 sql, args, _ := ToSQL(In("a", Expr("select id from b where c = ?", 1))))
 // a IN (select id from b where c = ?) [1]
 ```
 * `IsNull` and `NotNull`
 ```Go
 import . "github.com/go-xorm/builder"
 sql, args, _ := ToSQL(IsNull{"a"})
 // a IS NULL []
 sql, args, _ := ToSQL(NotNull{"b"})
 	// b IS NOT NULL []
 ```
 * `And(conds ...Cond)`, And can connect one or more condtions via And
 ```Go
 import . "github.com/go-xorm/builder"
 sql, args, _ := ToSQL(And(Eq{"a":1}, Like{"b", "c"}, Neq{"d", 2}))
 // a=? AND b LIKE ? AND d<>? [1, %c%, 2]
 ```
 * `Or(conds ...Cond)`, Or can connect one or more conditions via Or
 ```Go
 import . "github.com/go-xorm/builder"
 sql, args, _ := ToSQL(Or(Eq{"a":1}, Like{"b", "c"}, Neq{"d", 2}))
 // a=? OR b LIKE ? OR d<>? [1, %c%, 2]
 sql, args, _ := ToSQL(Or(Eq{"a":1}, And(Like{"b", "c"}, Neq{"d", 2})))
 // a=? OR (b LIKE ? AND d<>?) [1, %c%, 2]
 ```
 * `Between`
 ```Go
 import . "github.com/go-xorm/builder"
 sql, args, _ := ToSQL(Between{"a", 1, 2})
 // a BETWEEN 1 AND 2
 ```
 * Define yourself conditions
 Since `Cond` is an interface.
 ```Go
 type Cond interface {
 	WriteTo(Writer) error
 	And(...Cond) Cond
 	Or(...Cond) Cond
 	IsValid() bool
 }
 ```
 You can define yourself conditions and compose with other `Cond`.
--- a/vendor/github.com/go-xorm/builder/circle.yml
+++ b/vendor/github.com/go-xorm/builder/circle.yml
@ -1,12 +0,0 @@
 dependencies:
  override:
    # './...' is a relative pattern which means all subdirectories
    - go get -t -d -v ./...
    - go build -v
    - go get -u github.com/golang/lint/golint
 test:
  override:
    # './...' is a relative pattern which means all subdirectories
    - golint ./...
    - go test -v -race
--- a/vendor/github.com/go-xorm/core/README.md
+++ b/vendor/github.com/go-xorm/core/README.md
@ -1,116 +0,0 @@
 Core is a lightweight wrapper of sql.DB.
 [![CircleCI](https://circleci.com/gh/go-xorm/core/tree/master.svg?style=svg)](https://circleci.com/gh/go-xorm/core/tree/master)
 # Open
 ```Go
 db, _ := core.Open(db, connstr)
 ```
 # SetMapper
 ```Go
 db.SetMapper(SameMapper())
 ```
 ## Scan usage
 ### Scan
 ```Go
 rows, _ := db.Query()
 for rows.Next() {
    rows.Scan()
 }
 ```
 ### ScanMap
 ```Go
 rows, _ := db.Query()
 for rows.Next() {
    rows.ScanMap()
 ```
 ### ScanSlice
 You can use `[]string`, `[][]byte`, `[]interface{}`, `[]*string`, `[]sql.NullString` to ScanSclice. Notice, slice's length should be equal or less than select columns.
 ```Go
 rows, _ := db.Query()
 cols, _ := rows.Columns()
 for rows.Next() {
    var s = make([]string, len(cols))
    rows.ScanSlice(&s)
 }
 ```
 ```Go
 rows, _ := db.Query()
 cols, _ := rows.Columns()
 for rows.Next() {
    var s = make([]*string, len(cols))
    rows.ScanSlice(&s)
 }
 ```
 ### ScanStruct
 ```Go
 rows, _ := db.Query()
 for rows.Next() {
    rows.ScanStructByName()
    rows.ScanStructByIndex()
 }
 ```
 ## Query usage
 ```Go
 rows, err := db.Query("select * from table where name = ?", name)
 user = User{
    Name:"lunny",
 }
 rows, err := db.QueryStruct("select * from table where name = ?Name",
            &user)
 var user = map[string]interface{}{
    "name": "lunny",
 }
 rows, err = db.QueryMap("select * from table where name = ?name",
            &user)
 ```
 ## QueryRow usage
 ```Go
 row := db.QueryRow("select * from table where name = ?", name)
 user = User{
    Name:"lunny",
 }
 row := db.QueryRowStruct("select * from table where name = ?Name",
            &user)
 var user = map[string]interface{}{
    "name": "lunny",
 }
 row = db.QueryRowMap("select * from table where name = ?name",
            &user)
 ```
 ## Exec usage
 ```Go
 db.Exec("insert into user (`name`, title, age, alias, nick_name,created) values (?,?,?,?,?,?)", name, title, age, alias...)
 user = User{
    Name:"lunny",
    Title:"test",
    Age: 18,
 }
 result, err = db.ExecStruct("insert into user (`name`, title, age, alias, nick_name,created) values (?Name,?Title,?Age,?Alias,?NickName,?Created)",
            &user)
 var user = map[string]interface{}{
    "Name": "lunny",
    "Title": "test",
    "Age": 18,
 }
 result, err = db.ExecMap("insert into user (`name`, title, age, alias, nick_name,created) values (?Name,?Title,?Age,?Alias,?NickName,?Created)",
            &user)
 ```
--- a/vendor/github.com/go-xorm/core/benchmark.sh
+++ b/vendor/github.com/go-xorm/core/benchmark.sh
@ -1 +0,0 @@
 go test -v -bench=. -run=XXX
--- a/vendor/github.com/go-xorm/core/circle.yml
+++ b/vendor/github.com/go-xorm/core/circle.yml
@ -1,15 +0,0 @@
 dependencies:
  override:
    # './...' is a relative pattern which means all subdirectories
    - go get -t -d -v ./...
    - go build -v
 database:
  override:
    - mysql -u root -e "CREATE DATABASE core_test DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci"
 test:
  override:
    # './...' is a relative pattern which means all subdirectories
    - go test -v -race
    - go test -v -race --dbtype=sqlite3
--- a/vendor/github.com/go-xorm/tidb/README.md
+++ b/vendor/github.com/go-xorm/tidb/README.md
@ -1,24 +0,0 @@
 tidb driver and dialect for github.com/go-xorm/xorm
 ========
 Currently, we can support tidb for allmost all the operations.
 # How to use
 Just like other supports of xorm, but you should import the three packages:
 ```Go
 import (
    _ "github.com/pingcap/tidb"
    _ "github.com/go-xorm/tidb"
    "github.com/go-xorm/xorm"
 )
 //The formate of DataSource name is store://uri/dbname
 // for goleveldb as store
 xorm.NewEngine("tidb", "goleveldb://./tidb/tidb")
 // for memory as store
 xorm.NewEngine("tidb", "memory://tidb/tidb")
 // for boltdb as store
 xorm.NewEngine("tidb", "boltdb://./tidb/tidb")
 ```
--- a/vendor/github.com/go-xorm/xorm/CONTRIBUTING.md
+++ b/vendor/github.com/go-xorm/xorm/CONTRIBUTING.md
@ -1,46 +0,0 @@
 ## Contributing to xorm
 `xorm` has a backlog of [pull requests](https://help.github.com/articles/using-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.
 * [fork a repo](https://help.github.com/articles/fork-a-repo)
 * [creating a pull request ](https://help.github.com/articles/creating-a-pull-request)
 ### Language
 Since `xorm` is a world-wide open source project, please describe your issues or code changes in English as soon as possible.
 ### Sign your codes with comments
 ```
 // !<you github id>! your comments
 e.g.,
 // !lunny! this is comments made by lunny
 ```
 ### Patch review
 Help review existing open [pull requests](https://help.github.com/articles/using-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 xorm), 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 can find some example test file like [session_get_test.go](https://github.com/go-xorm/xorm/blob/master/session_get_test.go)).
 If you implements a new database interface, you maybe need to add a test_<databasename>.sh file.
 For example, [mysql_test.go](https://github.com/go-xorm/xorm/blob/master/test_mysql.sh)
 ### 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/go-xorm/xorm/README.md
+++ b/vendor/github.com/go-xorm/xorm/README.md
@ -1,430 +0,0 @@
 [中文](https://github.com/go-xorm/xorm/blob/master/README_CN.md)
 Xorm is a simple and powerful ORM for Go.
 [![CircleCI](https://circleci.com/gh/go-xorm/xorm.svg?style=shield)](https://circleci.com/gh/go-xorm/xorm) [![codecov](https://codecov.io/gh/go-xorm/xorm/branch/master/graph/badge.svg)](https://codecov.io/gh/go-xorm/xorm)
 [![](https://goreportcard.com/badge/github.com/go-xorm/xorm)](https://goreportcard.com/report/github.com/go-xorm/xorm) 
 [![Join the chat at https://img.shields.io/discord/323460943201959939.svg](https://img.shields.io/discord/323460943201959939.svg)](https://discord.gg/HuR2CF3)
 # Features
 * Struct <-> Table Mapping Support
 * Chainable APIs
 * Transaction Support
 * Both ORM and raw SQL operation Support
 * Sync database schema Support
 * Query Cache speed up
 * Database Reverse support, See [Xorm Tool README](https://github.com/go-xorm/cmd/blob/master/README.md)
 * Simple cascade loading support
 * Optimistic Locking support
 * SQL Builder support via [github.com/go-xorm/builder](https://github.com/go-xorm/builder)
 * Automatical Read/Write seperatelly
 # Drivers Support
 Drivers for Go's sql package which currently support database/sql includes:
 * Mysql: [github.com/go-sql-driver/mysql](https://github.com/go-sql-driver/mysql)
 * MyMysql: [github.com/ziutek/mymysql/godrv](https://github.com/ziutek/mymysql/tree/master/godrv)
 * Postgres: [github.com/lib/pq](https://github.com/lib/pq)
 * Tidb: [github.com/pingcap/tidb](https://github.com/pingcap/tidb)
 * SQLite: [github.com/mattn/go-sqlite3](https://github.com/mattn/go-sqlite3)
 * MsSql: [github.com/denisenkom/go-mssqldb](https://github.com/denisenkom/go-mssqldb)
 * Oracle: [github.com/mattn/go-oci8](https://github.com/mattn/go-oci8) (experiment)
 # Changelog
 * **v0.6.4**
    * Automatical Read/Write seperatelly
    * Query/QueryString/QueryInterface and action with Where/And
    * Get support non-struct variables
    * BufferSize on Iterate
    * fix some other bugs.
 * **v0.6.3**
    * merge tests to main project
    * add `Exist` function
    * add `SumInt` function
    * Mysql now support read and create column comment.
    * fix time related bugs.
    * fix some other bugs.
 * **v0.6.2**
    * refactor tag parse methods
    * add Scan features to Get
    * add QueryString method
 [More changes ...](https://github.com/go-xorm/manual-en-US/tree/master/chapter-16)
 # Installation
 	go get github.com/go-xorm/xorm
 # Documents
 * [Manual](http://xorm.io/docs)
 * [GoDoc](http://godoc.org/github.com/go-xorm/xorm)
 * [GoWalker](http://gowalker.org/github.com/go-xorm/xorm)
 # Quick Start
 * Create Engine
 ```Go
 engine, err := xorm.NewEngine(driverName, dataSourceName)
 ```
 * Define a struct and Sync2 table struct to database
 ```Go
 type User struct {
    Id int64
    Name string
    Salt string
    Age int
    Passwd string `xorm:"varchar(200)"`
    Created time.Time `xorm:"created"`
    Updated time.Time `xorm:"updated"`
 }
 err := engine.Sync2(new(User))
 ```
 * Create Engine Group
 ```Go
 dataSourceNameSlice := []string{masterDataSourceName, slave1DataSourceName, slave2DataSourceName}
 engineGroup, err := xorm.NewEngineGroup(driverName, dataSourceNameSlice)
 ```
 ```Go
 masterEngine, err := xorm.NewEngine(driverName, masterDataSourceName)
 slave1Engine, err := xorm.NewEngine(driverName, slave1DataSourceName)
 slave2Engine, err := xorm.NewEngine(driverName, slave2DataSourceName)
 engineGroup, err := xorm.NewEngineGroup(masterEngine, []*Engine{slave1Engine, slave2Engine})
 ```
 Then all place where `engine` you can just use `engineGroup`.
 * `Query` runs a SQL string, the returned results is `[]map[string][]byte`, `QueryString` returns `[]map[string]string`, `QueryInterface` returns `[]map[string]interface{}`.
 ```Go
 results, err := engine.Query("select * from user")
 results, err := engine.Where("a = 1").Query()
 results, err := engine.QueryString("select * from user")
 results, err := engine.Where("a = 1").QueryString()
 results, err := engine.QueryInterface("select * from user")
 results, err := engine.Where("a = 1").QueryInterface()
 ```
 * `Exec` runs a SQL string, it returns `affected` and `error`
 ```Go
 affected, err := engine.Exec("update user set age = ? where name = ?", age, name)
 ```
 * `Insert` one or multiple records to database
 ```Go
 affected, err := engine.Insert(&user)
 // INSERT INTO struct () values ()
 affected, err := engine.Insert(&user1, &user2)
 // INSERT INTO struct1 () values ()
 // INSERT INTO struct2 () values ()
 affected, err := engine.Insert(&users)
 // INSERT INTO struct () values (),(),()
 affected, err := engine.Insert(&user1, &users)
 // INSERT INTO struct1 () values ()
 // INSERT INTO struct2 () values (),(),()
 ```
 * `Get` query one record from database
 ```Go
 has, err := engine.Get(&user)
 // SELECT * FROM user LIMIT 1
 has, err := engine.Where("name = ?", name).Desc("id").Get(&user)
 // SELECT * FROM user WHERE name = ? ORDER BY id DESC LIMIT 1
 var name string
 has, err := engine.Where("id = ?", id).Cols("name").Get(&name)
 // SELECT name FROM user WHERE id = ?
 var id int64
 has, err := engine.Where("name = ?", name).Cols("id").Get(&id)
 has, err := engine.SQL("select id from user").Get(&id)
 // SELECT id FROM user WHERE name = ?
 var valuesMap = make(map[string]string)
 has, err := engine.Where("id = ?", id).Get(&valuesMap)
 // SELECT * FROM user WHERE id = ?
 var valuesSlice = make([]interface{}, len(cols))
 has, err := engine.Where("id = ?", id).Cols(cols...).Get(&valuesSlice)
 // SELECT col1, col2, col3 FROM user WHERE id = ?
 ```
 * `Exist` check if one record exist on table
 ```Go
 has, err := testEngine.Exist(new(RecordExist))
 // SELECT * FROM record_exist LIMIT 1
 has, err = testEngine.Exist(&RecordExist{
 		Name: "test1",
 	})
 // SELECT * FROM record_exist WHERE name = ? LIMIT 1
 has, err = testEngine.Where("name = ?", "test1").Exist(&RecordExist{})
 // SELECT * FROM record_exist WHERE name = ? LIMIT 1
 has, err = testEngine.SQL("select * from record_exist where name = ?", "test1").Exist()
 // select * from record_exist where name = ?
 has, err = testEngine.Table("record_exist").Exist()
 // SELECT * FROM record_exist LIMIT 1
 has, err = testEngine.Table("record_exist").Where("name = ?", "test1").Exist()
 // SELECT * FROM record_exist WHERE name = ? LIMIT 1
 ```
 * `Find` query multiple records from database, also you can use join and extends
 ```Go
 var users []User
 err := engine.Where("name = ?", name).And("age > 10").Limit(10, 0).Find(&users)
 // SELECT * FROM user WHERE name = ? AND age > 10 limit 10 offset 0
 type Detail struct {
    Id int64
    UserId int64 `xorm:"index"`
 }
 type UserDetail struct {
    User `xorm:"extends"`
    Detail `xorm:"extends"`
 }
 var users []UserDetail
 err := engine.Table("user").Select("user.*, detail.*").
    Join("INNER", "detail", "detail.user_id = user.id").
    Where("user.name = ?", name).Limit(10, 0).
    Find(&users)
 // SELECT user.*, detail.* FROM user INNER JOIN detail WHERE user.name = ? limit 10 offset 0
 ```
 * `Iterate` and `Rows` query multiple records and record by record handle, there are two methods Iterate and Rows
 ```Go
 err := engine.Iterate(&User{Name:name}, func(idx int, bean interface{}) error {
    user := bean.(*User)
    return nil
 })
 // SELECT * FROM user
 err := engine.BufferSize(100).Iterate(&User{Name:name}, func(idx int, bean interface{}) error {
    user := bean.(*User)
    return nil
 })
 // SELECT * FROM user Limit 0, 100
 // SELECT * FROM user Limit 101, 100
 rows, err := engine.Rows(&User{Name:name})
 // SELECT * FROM user
 defer rows.Close()
 bean := new(Struct)
 for rows.Next() {
    err = rows.Scan(bean)
 }
 ```
 * `Update` update one or more records, default will update non-empty and non-zero fields except when you use Cols, AllCols and so on.
 ```Go
 affected, err := engine.Id(1).Update(&user)
 // UPDATE user SET ... Where id = ?
 affected, err := engine.Update(&user, &User{Name:name})
 // UPDATE user SET ... Where name = ?
 var ids = []int64{1, 2, 3}
 affected, err := engine.In("id", ids).Update(&user)
 // UPDATE user SET ... Where id IN (?, ?, ?)
 // force update indicated columns by Cols
 affected, err := engine.Id(1).Cols("age").Update(&User{Name:name, Age: 12})
 // UPDATE user SET age = ?, updated=? Where id = ?
 // force NOT update indicated columns by Omit
 affected, err := engine.Id(1).Omit("name").Update(&User{Name:name, Age: 12})
 // UPDATE user SET age = ?, updated=? Where id = ?
 affected, err := engine.Id(1).AllCols().Update(&user)
 // UPDATE user SET name=?,age=?,salt=?,passwd=?,updated=? Where id = ?
 ```
 * `Delete` delete one or more records, Delete MUST have condition
 ```Go
 affected, err := engine.Where(...).Delete(&user)
 // DELETE FROM user Where ...
 affected, err := engine.ID(2).Delete(&user)
 // DELETE FROM user Where id = ?
 ```
 * `Count` count records
 ```Go
 counts, err := engine.Count(&user)
 // SELECT count(*) AS total FROM user
 ```
 * `Sum` sum functions
 ```Go
 agesFloat64, err := engine.Sum(&user, "age")
 // SELECT sum(age) AS total FROM user
 agesInt64, err := engine.SumInt(&user, "age")
 // SELECT sum(age) AS total FROM user
 sumFloat64Slice, err := engine.Sums(&user, "age", "score")
 // SELECT sum(age), sum(score) FROM user
 sumInt64Slice, err := engine.SumsInt(&user, "age", "score")
 // SELECT sum(age), sum(score) FROM user
 ```
 * Query conditions builder
 ```Go
 err := engine.Where(builder.NotIn("a", 1, 2).And(builder.In("b", "c", "d", "e"))).Find(&users)
 // SELECT id, name ... FROM user WHERE a NOT IN (?, ?) AND b IN (?, ?, ?)
 ```
 * Multiple operations in one go routine, no transation here but resue session memory
 ```Go
 session := engine.NewSession()
 defer session.Close()
 user1 := Userinfo{Username: "xiaoxiao", Departname: "dev", Alias: "lunny", Created: time.Now()}
 if _, err := session.Insert(&user1); err != nil {
    return err
 }
 user2 := Userinfo{Username: "yyy"}
 if _, err := session.Where("id = ?", 2).Update(&user2); err != nil {
    return err
 }
 if _, err := session.Exec("delete from userinfo where username = ?", user2.Username); err != nil {
    return err
 }
 return nil
 ```
 * Transation should on one go routine. There is transaction and resue session memory
 ```Go
 session := engine.NewSession()
 defer session.Close()
 // add Begin() before any action
 if err := session.Begin(); err != nil {
    // if returned then will rollback automatically
    return err
 }
 user1 := Userinfo{Username: "xiaoxiao", Departname: "dev", Alias: "lunny", Created: time.Now()}
 if _, err := session.Insert(&user1); err != nil {
    return err
 }
 user2 := Userinfo{Username: "yyy"}
 if _, err := session.Where("id = ?", 2).Update(&user2); err != nil {
    return err
 }
 if _, err := session.Exec("delete from userinfo where username = ?", user2.Username); err != nil {
    return err
 }
 // add Commit() after all actions
 return session.Commit()
 ```
 # Cases
 * [studygolang](http://studygolang.com/) - [github.com/studygolang/studygolang](https://github.com/studygolang/studygolang)
 * [Gitea](http://gitea.io) - [github.com/go-gitea/gitea](http://github.com/go-gitea/gitea)
 * [Gogs](http://try.gogits.org) - [github.com/gogits/gogs](http://github.com/gogits/gogs)
 * [grafana](https://grafana.com/) - [github.com/grafana/grafana](http://github.com/grafana/grafana)
 * [github.com/m3ng9i/qreader](https://github.com/m3ng9i/qreader)
 * [Wego](http://github.com/go-tango/wego)
 * [Docker.cn](https://docker.cn/)
 * [Xorm Adapter](https://github.com/casbin/xorm-adapter) for [Casbin](https://github.com/casbin/casbin) - [github.com/casbin/xorm-adapter](https://github.com/casbin/xorm-adapter)
 * [Gorevel](http://gorevel.cn/) - [github.com/goofcc/gorevel](http://github.com/goofcc/gorevel)
 * [Gowalker](http://gowalker.org) - [github.com/Unknwon/gowalker](http://github.com/Unknwon/gowalker)
 * [Gobuild.io](http://gobuild.io) - [github.com/shxsun/gobuild](http://github.com/shxsun/gobuild)
 * [Sudo China](http://sudochina.com) - [github.com/insionng/toropress](http://github.com/insionng/toropress)
 * [Godaily](http://godaily.org) - [github.com/govc/godaily](http://github.com/govc/godaily)
 * [YouGam](http://www.yougam.com/)
 * [GoCMS - github.com/zzboy/GoCMS](https://github.com/zzdboy/GoCMS)
 * [GoBBS - gobbs.domolo.com](http://gobbs.domolo.com/)
 * [go-blog](http://wangcheng.me) - [github.com/easykoo/go-blog](https://github.com/easykoo/go-blog)
 # Discuss
 Please visit [Xorm on Google Groups](https://groups.google.com/forum/#!forum/xorm)
 # Contributing
 If you want to pull request, please see [CONTRIBUTING](https://github.com/go-xorm/xorm/blob/master/CONTRIBUTING.md)
 # LICENSE
 BSD License
 [http://creativecommons.org/licenses/BSD/](http://creativecommons.org/licenses/BSD/)
--- a/vendor/github.com/go-xorm/xorm/README_CN.md
+++ b/vendor/github.com/go-xorm/xorm/README_CN.md
@ -1,435 +0,0 @@
 # xorm
 [English](https://github.com/go-xorm/xorm/blob/master/README.md)
 xorm是一个简单而强大的Go语言ORM库. 通过它可以使数据库操作非常简便。
 [![CircleCI](https://circleci.com/gh/go-xorm/xorm.svg?style=shield)](https://circleci.com/gh/go-xorm/xorm) [![codecov](https://codecov.io/gh/go-xorm/xorm/branch/master/graph/badge.svg)](https://codecov.io/gh/go-xorm/xorm)
 [![](https://goreportcard.com/badge/github.com/go-xorm/xorm)](https://goreportcard.com/report/github.com/go-xorm/xorm)
 [![Join the chat at https://img.shields.io/discord/323460943201959939.svg](https://img.shields.io/discord/323460943201959939.svg)](https://discord.gg/HuR2CF3)
 ## 特性
 * 支持Struct和数据库表之间的灵活映射，并支持自动同步
 * 事务支持
 * 同时支持原始SQL语句和ORM操作的混合执行
 * 使用连写来简化调用
 * 支持使用Id, In, Where, Limit, Join, Having, Table, Sql, Cols等函数和结构体等方式作为条件
 * 支持级联加载Struct
 * 支持缓存
 * 支持根据数据库自动生成xorm的结构体
 * 支持记录版本（即乐观锁）
 * 内置SQL Builder支持
 ## 驱动支持
 目前支持的Go数据库驱动和对应的数据库如下：
 * Mysql: [github.com/go-sql-driver/mysql](https://github.com/go-sql-driver/mysql)
 * MyMysql: [github.com/ziutek/mymysql/godrv](https://github.com/ziutek/mymysql/godrv)
 * Postgres: [github.com/lib/pq](https://github.com/lib/pq)
 * Tidb: [github.com/pingcap/tidb](https://github.com/pingcap/tidb)
 * SQLite: [github.com/mattn/go-sqlite3](https://github.com/mattn/go-sqlite3)
 * MsSql: [github.com/denisenkom/go-mssqldb](https://github.com/denisenkom/go-mssqldb)
 * MsSql: [github.com/lunny/godbc](https://github.com/lunny/godbc)
 * Oracle: [github.com/mattn/go-oci8](https://github.com/mattn/go-oci8) (试验性支持)
 ## 更新日志
 * **v0.6.3**
    * 合并单元测试到主工程
    * 新增`Exist`方法
    * 新增`SumInt`方法
    * Mysql新增读取和创建字段注释支持
    * 新增`SetConnMaxLifetime`方法
    * 修正了时间相关的Bug
    * 修复了一些其它Bug
 * **v0.6.2**
    * 重构Tag解析方式
    * Get方法新增类似Scan的特性
    * 新增 QueryString 方法
 * **v0.6.0**
    * 去除对 ql 的支持
    * 新增条件查询分析器 [github.com/go-xorm/builder](https://github.com/go-xorm/builder), 从因此 `Where, And, Or` 函数
 将可以用 `builder.Cond` 作为条件组合
    * 新增 Sum, SumInt, SumInt64 和 NotIn 函数
    * Bug修正
 * **v0.5.0**
    * logging接口进行不兼容改变
    * Bug修正
 [更多更新日志...](https://github.com/go-xorm/manual-zh-CN/tree/master/chapter-16)
 ## 安装
 	go get github.com/go-xorm/xorm
 ## 文档
 * [操作指南](http://xorm.io/docs)
 * [GoWalker代码文档](http://gowalker.org/github.com/go-xorm/xorm)
 * [Godoc代码文档](http://godoc.org/github.com/go-xorm/xorm)
 # 快速开始
 * 第一步创建引擎，driverName, dataSourceName和database/sql接口相同
 ```Go
 engine, err := xorm.NewEngine(driverName, dataSourceName)
 ```
 * 定义一个和表同步的结构体，并且自动同步结构体到数据库
 ```Go
 type User struct {
    Id int64
    Name string
    Salt string
    Age int
    Passwd string `xorm:"varchar(200)"`
    Created time.Time `xorm:"created"`
    Updated time.Time `xorm:"updated"`
 }
 err := engine.Sync2(new(User))
 ```
 * 创建Engine组
 ```Go
 dataSourceNameSlice := []string{masterDataSourceName, slave1DataSourceName, slave2DataSourceName}
 engineGroup, err := xorm.NewEngineGroup(driverName, dataSourceNameSlice)
 ```
 ```Go
 masterEngine, err := xorm.NewEngine(driverName, masterDataSourceName)
 slave1Engine, err := xorm.NewEngine(driverName, slave1DataSourceName)
 slave2Engine, err := xorm.NewEngine(driverName, slave2DataSourceName)
 engineGroup, err := xorm.NewEngineGroup(masterEngine, []*Engine{slave1Engine, slave2Engine})
 ```
 所有使用 `engine` 都可以简单的用 `engineGroup` 来替换。
 * `Query` 最原始的也支持SQL语句查询，返回的结果类型为 []map[string][]byte。`QueryString` 返回 []map[string]string, `QueryInterface` 返回 `[]map[string]interface{}`.
 ```Go
 results, err := engine.Query("select * from user")
 results, err := engine.Where("a = 1").Query()
 results, err := engine.QueryString("select * from user")
 results, err := engine.Where("a = 1").QueryString()
 results, err := engine.QueryInterface("select * from user")
 results, err := engine.Where("a = 1").QueryInterface()
 ```
 * `Exec` 执行一个SQL语句
 ```Go
 affected, err := engine.Exec("update user set age = ? where name = ?", age, name)
 ```
 * `Insert` 插入一条或者多条记录
 ```Go
 affected, err := engine.Insert(&user)
 // INSERT INTO struct () values ()
 affected, err := engine.Insert(&user1, &user2)
 // INSERT INTO struct1 () values ()
 // INSERT INTO struct2 () values ()
 affected, err := engine.Insert(&users)
 // INSERT INTO struct () values (),(),()
 affected, err := engine.Insert(&user1, &users)
 // INSERT INTO struct1 () values ()
 // INSERT INTO struct2 () values (),(),()
 ```
 * `Get` 查询单条记录
 ```Go
 has, err := engine.Get(&user)
 // SELECT * FROM user LIMIT 1
 has, err := engine.Where("name = ?", name).Desc("id").Get(&user)
 // SELECT * FROM user WHERE name = ? ORDER BY id DESC LIMIT 1
 var name string
 has, err := engine.Where("id = ?", id).Cols("name").Get(&name)
 // SELECT name FROM user WHERE id = ?
 var id int64
 has, err := engine.Where("name = ?", name).Cols("id").Get(&id)
 has, err := engine.SQL("select id from user").Get(&id)
 // SELECT id FROM user WHERE name = ?
 var valuesMap = make(map[string]string)
 has, err := engine.Where("id = ?", id).Get(&valuesMap)
 // SELECT * FROM user WHERE id = ?
 var valuesSlice = make([]interface{}, len(cols))
 has, err := engine.Where("id = ?", id).Cols(cols...).Get(&valuesSlice)
 // SELECT col1, col2, col3 FROM user WHERE id = ?
 ```
 * `Exist` 检测记录是否存在
 ```Go
 has, err := testEngine.Exist(new(RecordExist))
 // SELECT * FROM record_exist LIMIT 1
 has, err = testEngine.Exist(&RecordExist{
 		Name: "test1",
 	})
 // SELECT * FROM record_exist WHERE name = ? LIMIT 1
 has, err = testEngine.Where("name = ?", "test1").Exist(&RecordExist{})
 // SELECT * FROM record_exist WHERE name = ? LIMIT 1
 has, err = testEngine.SQL("select * from record_exist where name = ?", "test1").Exist()
 // select * from record_exist where name = ?
 has, err = testEngine.Table("record_exist").Exist()
 // SELECT * FROM record_exist LIMIT 1
 has, err = testEngine.Table("record_exist").Where("name = ?", "test1").Exist()
 // SELECT * FROM record_exist WHERE name = ? LIMIT 1
 ```
 * `Find` 查询多条记录，当然可以使用Join和extends来组合使用
 ```Go
 var users []User
 err := engine.Where("name = ?", name).And("age > 10").Limit(10, 0).Find(&users)
 // SELECT * FROM user WHERE name = ? AND age > 10 limit 10 offset 0
 type Detail struct {
    Id int64
    UserId int64 `xorm:"index"`
 }
 type UserDetail struct {
    User `xorm:"extends"`
    Detail `xorm:"extends"`
 }
 var users []UserDetail
 err := engine.Table("user").Select("user.*, detail.*")
    Join("INNER", "detail", "detail.user_id = user.id").
    Where("user.name = ?", name).Limit(10, 0).
    Find(&users)
 // SELECT user.*, detail.* FROM user INNER JOIN detail WHERE user.name = ? limit 10 offset 0
 ```
 * `Iterate` 和 `Rows` 根据条件遍历数据库，可以有两种方式: Iterate and Rows
 ```Go
 err := engine.Iterate(&User{Name:name}, func(idx int, bean interface{}) error {
    user := bean.(*User)
    return nil
 })
 // SELECT * FROM user
 err := engine.BufferSize(100).Iterate(&User{Name:name}, func(idx int, bean interface{}) error {
    user := bean.(*User)
    return nil
 })
 // SELECT * FROM user Limit 0, 100
 // SELECT * FROM user Limit 101, 100
 rows, err := engine.Rows(&User{Name:name})
 // SELECT * FROM user
 defer rows.Close()
 bean := new(Struct)
 for rows.Next() {
    err = rows.Scan(bean)
 }
 ```
 * `Update` 更新数据，除非使用Cols,AllCols函数指明，默认只更新非空和非0的字段
 ```Go
 affected, err := engine.Id(1).Update(&user)
 // UPDATE user SET ... Where id = ?
 affected, err := engine.Update(&user, &User{Name:name})
 // UPDATE user SET ... Where name = ?
 var ids = []int64{1, 2, 3}
 affected, err := engine.In(ids).Update(&user)
 // UPDATE user SET ... Where id IN (?, ?, ?)
 // force update indicated columns by Cols
 affected, err := engine.Id(1).Cols("age").Update(&User{Name:name, Age: 12})
 // UPDATE user SET age = ?, updated=? Where id = ?
 // force NOT update indicated columns by Omit
 affected, err := engine.Id(1).Omit("name").Update(&User{Name:name, Age: 12})
 // UPDATE user SET age = ?, updated=? Where id = ?
 affected, err := engine.Id(1).AllCols().Update(&user)
 // UPDATE user SET name=?,age=?,salt=?,passwd=?,updated=? Where id = ?
 ```
 * `Delete` 删除记录，需要注意，删除必须至少有一个条件，否则会报错。要清空数据库可以用EmptyTable
 ```Go
 affected, err := engine.Where(...).Delete(&user)
 // DELETE FROM user Where ...
 affected, err := engine.ID(2).Delete(&user)
 // DELETE FROM user Where id = ?
 ```
 * `Count` 获取记录条数
 ```Go
 counts, err := engine.Count(&user)
 // SELECT count(*) AS total FROM user
 ```
 * `Sum` 求和函数
 ```Go
 agesFloat64, err := engine.Sum(&user, "age")
 // SELECT sum(age) AS total FROM user
 agesInt64, err := engine.SumInt(&user, "age")
 // SELECT sum(age) AS total FROM user
 sumFloat64Slice, err := engine.Sums(&user, "age", "score")
 // SELECT sum(age), sum(score) FROM user
 sumInt64Slice, err := engine.SumsInt(&user, "age", "score")
 // SELECT sum(age), sum(score) FROM user
 ```
 * 条件编辑器
 ```Go
 err := engine.Where(builder.NotIn("a", 1, 2).And(builder.In("b", "c", "d", "e"))).Find(&users)
 // SELECT id, name ... FROM user WHERE a NOT IN (?, ?) AND b IN (?, ?, ?)
 ```
 * 在一个Go程中多次操作数据库，但没有事务
 ```Go
 session := engine.NewSession()
 defer session.Close()
 user1 := Userinfo{Username: "xiaoxiao", Departname: "dev", Alias: "lunny", Created: time.Now()}
 if _, err := session.Insert(&user1); err != nil {
    return err
 }
 user2 := Userinfo{Username: "yyy"}
 if _, err := session.Where("id = ?", 2).Update(&user2); err != nil {
    return err
 }
 if _, err := session.Exec("delete from userinfo where username = ?", user2.Username); err != nil {
    return err
 }
 return nil
 ```
 * 在一个Go程中有事务
 ```Go
 session := engine.NewSession()
 defer session.Close()
 // add Begin() before any action
 if err := session.Begin(); err != nil {
    // if returned then will rollback automatically
    return err
 }
 user1 := Userinfo{Username: "xiaoxiao", Departname: "dev", Alias: "lunny", Created: time.Now()}
 if _, err := session.Insert(&user1); err != nil {
    return err
 }
 user2 := Userinfo{Username: "yyy"}
 if _, err := session.Where("id = ?", 2).Update(&user2); err != nil {
    return err
 }
 if _, err := session.Exec("delete from userinfo where username = ?", user2.Username); err != nil {
    return err
 }
 // add Commit() after all actions
 return session.Commit()
 ```
 # 案例
 * [Go语言中文网](http://studygolang.com/) - [github.com/studygolang/studygolang](https://github.com/studygolang/studygolang)
 * [Gitea](http://gitea.io) - [github.com/go-gitea/gitea](http://github.com/go-gitea/gitea)
 * [Gogs](http://try.gogits.org) - [github.com/gogits/gogs](http://github.com/gogits/gogs)
 * [grafana](https://grafana.com/) - [github.com/grafana/grafana](http://github.com/grafana/grafana)
 * [github.com/m3ng9i/qreader](https://github.com/m3ng9i/qreader)
 * [Wego](http://github.com/go-tango/wego)
 * [Docker.cn](https://docker.cn/)
 * [Xorm Adapter](https://github.com/casbin/xorm-adapter) for [Casbin](https://github.com/casbin/casbin) - [github.com/casbin/xorm-adapter](https://github.com/casbin/xorm-adapter)
 * [Gowalker](http://gowalker.org) - [github.com/Unknwon/gowalker](http://github.com/Unknwon/gowalker)
 * [Gobuild.io](http://gobuild.io) - [github.com/shxsun/gobuild](http://github.com/shxsun/gobuild)
 * [Sudo China](http://sudochina.com) - [github.com/insionng/toropress](http://github.com/insionng/toropress)
 * [Godaily](http://godaily.org) - [github.com/govc/godaily](http://github.com/govc/godaily)
 * [YouGam](http://www.yougam.com/)
 * [GoCMS - github.com/zzboy/GoCMS](https://github.com/zzdboy/GoCMS)
 * [GoBBS - gobbs.domolo.com](http://gobbs.domolo.com/)
 * [go-blog](http://wangcheng.me) - [github.com/easykoo/go-blog](https://github.com/easykoo/go-blog)
 ## 讨论
 请加入QQ群：280360085 进行讨论。
 ## 贡献
 如果您也想为Xorm贡献您的力量，请查看 [CONTRIBUTING](https://github.com/go-xorm/xorm/blob/master/CONTRIBUTING.md)
 ## LICENSE
 BSD License
 [http://creativecommons.org/licenses/BSD/](http://creativecommons.org/licenses/BSD/)
--- a/vendor/github.com/go-xorm/xorm/circle.yml
+++ b/vendor/github.com/go-xorm/xorm/circle.yml
@ -1,38 +0,0 @@
 dependencies:
  override:
    # './...' is a relative pattern which means all subdirectories
    - go get -t -d -v ./...
    - go get -t -d -v github.com/go-xorm/tests
    - go get -u github.com/go-xorm/core
    - go get -u github.com/go-xorm/builder
    - go build -v
 database:
  override:
    - mysql -u root -e "CREATE DATABASE xorm_test DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci"
    - mysql -u root -e "CREATE DATABASE xorm_test1 DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci"
    - mysql -u root -e "CREATE DATABASE xorm_test2 DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci"
    - mysql -u root -e "CREATE DATABASE xorm_test3 DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci"
    - createdb -p 5432 -e -U postgres xorm_test
    - createdb -p 5432 -e -U postgres xorm_test1
    - createdb -p 5432 -e -U postgres xorm_test2
    - createdb -p 5432 -e -U postgres xorm_test3
 test:
  override:
    # './...' is a relative pattern which means all subdirectories
    - go get -u github.com/wadey/gocovmerge;
    - go test -v -race -db="sqlite3" -conn_str="./test.db" -coverprofile=coverage1-1.txt -covermode=atomic
    - go test -v -race -db="sqlite3" -conn_str="./test.db" -cache=true -coverprofile=coverage1-2.txt -covermode=atomic
    - go test -v -race -db="mysql" -conn_str="root:@/xorm_test" -coverprofile=coverage2-1.txt -covermode=atomic
    - go test -v -race -db="mysql" -conn_str="root:@/xorm_test" -cache=true -coverprofile=coverage2-2.txt -covermode=atomic
    - go test -v -race -db="mymysql" -conn_str="xorm_test/root/" -coverprofile=coverage3-1.txt -covermode=atomic
    - go test -v -race -db="mymysql" -conn_str="xorm_test/root/" -cache=true -coverprofile=coverage3-2.txt -covermode=atomic
    - go test -v -race -db="postgres" -conn_str="dbname=xorm_test sslmode=disable" -coverprofile=coverage4-1.txt -covermode=atomic
    - go test -v -race -db="postgres" -conn_str="dbname=xorm_test sslmode=disable" -cache=true -coverprofile=coverage4-2.txt -covermode=atomic
    - gocovmerge coverage1-1.txt coverage1-2.txt coverage2-1.txt coverage2-2.txt coverage3-1.txt coverage3-2.txt coverage4-1.txt coverage4-2.txt > coverage.txt
    - cd /home/ubuntu/.go_workspace/src/github.com/go-xorm/tests && ./sqlite3.sh
    - cd /home/ubuntu/.go_workspace/src/github.com/go-xorm/tests && ./mysql.sh
    - cd /home/ubuntu/.go_workspace/src/github.com/go-xorm/tests && ./postgres.sh
  post:
    - bash <(curl -s https://codecov.io/bash)
--- a/vendor/github.com/go-xorm/xorm/gen_reserved.sh
+++ b/vendor/github.com/go-xorm/xorm/gen_reserved.sh
@ -1,6 +0,0 @@
 #!/bin/bash
 if [ -f $1 ];then
    cat $1| awk '{printf("\""$1"\":true,\n")}' 
 else
    echo "argument $1 if not a file!"
 fi
--- a/vendor/github.com/go-xorm/xorm/pg_reserved.txt
+++ b/vendor/github.com/go-xorm/xorm/pg_reserved.txt
@ -1,746 +0,0 @@
 A	 	non-reserved	non-reserved	 
 ABORT	non-reserved	 	 	 
 ABS	 	reserved	reserved	 
 ABSENT	 	non-reserved	non-reserved	 
 ABSOLUTE	non-reserved	non-reserved	non-reserved	reserved
 ACCESS	non-reserved	 	 	 
 ACCORDING	 	non-reserved	non-reserved	 
 ACTION	non-reserved	non-reserved	non-reserved	reserved
 ADA	 	non-reserved	non-reserved	non-reserved
 ADD	non-reserved	non-reserved	non-reserved	reserved
 ADMIN	non-reserved	non-reserved	non-reserved	 
 AFTER	non-reserved	non-reserved	non-reserved	 
 AGGREGATE	non-reserved	 	 	 
 ALL	reserved	reserved	reserved	reserved
 ALLOCATE	 	reserved	reserved	reserved
 ALSO	non-reserved	 	 	 
 ALTER	non-reserved	reserved	reserved	reserved
 ALWAYS	non-reserved	non-reserved	non-reserved	 
 ANALYSE	reserved	 	 	 
 ANALYZE	reserved	 	 	 
 AND	reserved	reserved	reserved	reserved
 ANY	reserved	reserved	reserved	reserved
 ARE	 	reserved	reserved	reserved
 ARRAY	reserved	reserved	reserved	 
 ARRAY_AGG	 	reserved	reserved	 
 ARRAY_MAX_CARDINALITY	 	reserved	 	 
 AS	reserved	reserved	reserved	reserved
 ASC	reserved	non-reserved	non-reserved	reserved
 ASENSITIVE	 	reserved	reserved	 
 ASSERTION	non-reserved	non-reserved	non-reserved	reserved
 ASSIGNMENT	non-reserved	non-reserved	non-reserved	 
 ASYMMETRIC	reserved	reserved	reserved	 
 AT	non-reserved	reserved	reserved	reserved
 ATOMIC	 	reserved	reserved	 
 ATTRIBUTE	non-reserved	non-reserved	non-reserved	 
 ATTRIBUTES	 	non-reserved	non-reserved	 
 AUTHORIZATION	reserved (can be function or type)	reserved	reserved	reserved
 AVG	 	reserved	reserved	reserved
 BACKWARD	non-reserved	 	 	 
 BASE64	 	non-reserved	non-reserved	 
 BEFORE	non-reserved	non-reserved	non-reserved	 
 BEGIN	non-reserved	reserved	reserved	reserved
 BEGIN_FRAME	 	reserved	 	 
 BEGIN_PARTITION	 	reserved	 	 
 BERNOULLI	 	non-reserved	non-reserved	 
 BETWEEN	non-reserved (cannot be function or type)	reserved	reserved	reserved
 BIGINT	non-reserved (cannot be function or type)	reserved	reserved	 
 BINARY	reserved (can be function or type)	reserved	reserved	 
 BIT	non-reserved (cannot be function or type)	 	 	reserved
 BIT_LENGTH	 	 	 	reserved
 BLOB	 	reserved	reserved	 
 BLOCKED	 	non-reserved	non-reserved	 
 BOM	 	non-reserved	non-reserved	 
 BOOLEAN	non-reserved (cannot be function or type)	reserved	reserved	 
 BOTH	reserved	reserved	reserved	reserved
 BREADTH	 	non-reserved	non-reserved	 
 BY	non-reserved	reserved	reserved	reserved
 C	 	non-reserved	non-reserved	non-reserved
 CACHE	non-reserved	 	 	 
 CALL	 	reserved	reserved	 
 CALLED	non-reserved	reserved	reserved	 
 CARDINALITY	 	reserved	reserved	 
 CASCADE	non-reserved	non-reserved	non-reserved	reserved
 CASCADED	non-reserved	reserved	reserved	reserved
 CASE	reserved	reserved	reserved	reserved
 CAST	reserved	reserved	reserved	reserved
 CATALOG	non-reserved	non-reserved	non-reserved	reserved
 CATALOG_NAME	 	non-reserved	non-reserved	non-reserved
 CEIL	 	reserved	reserved	 
 CEILING	 	reserved	reserved	 
 CHAIN	non-reserved	non-reserved	non-reserved	 
 CHAR	non-reserved (cannot be function or type)	reserved	reserved	reserved
 CHARACTER	non-reserved (cannot be function or type)	reserved	reserved	reserved
 CHARACTERISTICS	non-reserved	non-reserved	non-reserved	 
 CHARACTERS	 	non-reserved	non-reserved	 
 CHARACTER_LENGTH	 	reserved	reserved	reserved
 CHARACTER_SET_CATALOG	 	non-reserved	non-reserved	non-reserved
 CHARACTER_SET_NAME	 	non-reserved	non-reserved	non-reserved
 CHARACTER_SET_SCHEMA	 	non-reserved	non-reserved	non-reserved
 CHAR_LENGTH	 	reserved	reserved	reserved
 CHECK	reserved	reserved	reserved	reserved
 CHECKPOINT	non-reserved	 	 	 
 CLASS	non-reserved	 	 	 
 CLASS_ORIGIN	 	non-reserved	non-reserved	non-reserved
 CLOB	 	reserved	reserved	 
 CLOSE	non-reserved	reserved	reserved	reserved
 CLUSTER	non-reserved	 	 	 
 COALESCE	non-reserved (cannot be function or type)	reserved	reserved	reserved
 COBOL	 	non-reserved	non-reserved	non-reserved
 COLLATE	reserved	reserved	reserved	reserved
 COLLATION	reserved (can be function or type)	non-reserved	non-reserved	reserved
 COLLATION_CATALOG	 	non-reserved	non-reserved	non-reserved
 COLLATION_NAME	 	non-reserved	non-reserved	non-reserved
 COLLATION_SCHEMA	 	non-reserved	non-reserved	non-reserved
 COLLECT	 	reserved	reserved	 
 COLUMN	reserved	reserved	reserved	reserved
 COLUMNS	 	non-reserved	non-reserved	 
 COLUMN_NAME	 	non-reserved	non-reserved	non-reserved
 COMMAND_FUNCTION	 	non-reserved	non-reserved	non-reserved
 COMMAND_FUNCTION_CODE	 	non-reserved	non-reserved	 
 COMMENT	non-reserved	 	 	 
 COMMENTS	non-reserved	 	 	 
 COMMIT	non-reserved	reserved	reserved	reserved
 COMMITTED	non-reserved	non-reserved	non-reserved	non-reserved
 CONCURRENTLY	reserved (can be function or type)	 	 	 
 CONDITION	 	reserved	reserved	 
 CONDITION_NUMBER	 	non-reserved	non-reserved	non-reserved
 CONFIGURATION	non-reserved	 	 	 
 CONNECT	 	reserved	reserved	reserved
 CONNECTION	non-reserved	non-reserved	non-reserved	reserved
 CONNECTION_NAME	 	non-reserved	non-reserved	non-reserved
 CONSTRAINT	reserved	reserved	reserved	reserved
 CONSTRAINTS	non-reserved	non-reserved	non-reserved	reserved
 CONSTRAINT_CATALOG	 	non-reserved	non-reserved	non-reserved
 CONSTRAINT_NAME	 	non-reserved	non-reserved	non-reserved
 CONSTRAINT_SCHEMA	 	non-reserved	non-reserved	non-reserved
 CONSTRUCTOR	 	non-reserved	non-reserved	 
 CONTAINS	 	reserved	non-reserved	 
 CONTENT	non-reserved	non-reserved	non-reserved	 
 CONTINUE	non-reserved	non-reserved	non-reserved	reserved
 CONTROL	 	non-reserved	non-reserved	 
 CONVERSION	non-reserved	 	 	 
 CONVERT	 	reserved	reserved	reserved
 COPY	non-reserved	 	 	 
 CORR	 	reserved	reserved	 
 CORRESPONDING	 	reserved	reserved	reserved
 COST	non-reserved	 	 	 
 COUNT	 	reserved	reserved	reserved
 COVAR_POP	 	reserved	reserved	 
 COVAR_SAMP	 	reserved	reserved	 
 CREATE	reserved	reserved	reserved	reserved
 CROSS	reserved (can be function or type)	reserved	reserved	reserved
 CSV	non-reserved	 	 	 
 CUBE	 	reserved	reserved	 
 CUME_DIST	 	reserved	reserved	 
 CURRENT	non-reserved	reserved	reserved	reserved
 CURRENT_CATALOG	reserved	reserved	reserved	 
 CURRENT_DATE	reserved	reserved	reserved	reserved
 CURRENT_DEFAULT_TRANSFORM_GROUP	 	reserved	reserved	 
 CURRENT_PATH	 	reserved	reserved	 
 CURRENT_ROLE	reserved	reserved	reserved	 
 CURRENT_ROW	 	reserved	 	 
 CURRENT_SCHEMA	reserved (can be function or type)	reserved	reserved	 
 CURRENT_TIME	reserved	reserved	reserved	reserved
 CURRENT_TIMESTAMP	reserved	reserved	reserved	reserved
 CURRENT_TRANSFORM_GROUP_FOR_TYPE	 	reserved	reserved	 
 CURRENT_USER	reserved	reserved	reserved	reserved
 CURSOR	non-reserved	reserved	reserved	reserved
 CURSOR_NAME	 	non-reserved	non-reserved	non-reserved
 CYCLE	non-reserved	reserved	reserved	 
 DATA	non-reserved	non-reserved	non-reserved	non-reserved
 DATABASE	non-reserved	 	 	 
 DATALINK	 	reserved	reserved	 
 DATE	 	reserved	reserved	reserved
 DATETIME_INTERVAL_CODE	 	non-reserved	non-reserved	non-reserved
 DATETIME_INTERVAL_PRECISION	 	non-reserved	non-reserved	non-reserved
 DAY	non-reserved	reserved	reserved	reserved
 DB	 	non-reserved	non-reserved	 
 DEALLOCATE	non-reserved	reserved	reserved	reserved
 DEC	non-reserved (cannot be function or type)	reserved	reserved	reserved
 DECIMAL	non-reserved (cannot be function or type)	reserved	reserved	reserved
 DECLARE	non-reserved	reserved	reserved	reserved
 DEFAULT	reserved	reserved	reserved	reserved
 DEFAULTS	non-reserved	non-reserved	non-reserved	 
 DEFERRABLE	reserved	non-reserved	non-reserved	reserved
 DEFERRED	non-reserved	non-reserved	non-reserved	reserved
 DEFINED	 	non-reserved	non-reserved	 
 DEFINER	non-reserved	non-reserved	non-reserved	 
 DEGREE	 	non-reserved	non-reserved	 
 DELETE	non-reserved	reserved	reserved	reserved
 DELIMITER	non-reserved	 	 	 
 DELIMITERS	non-reserved	 	 	 
 DENSE_RANK	 	reserved	reserved	 
 DEPTH	 	non-reserved	non-reserved	 
 DEREF	 	reserved	reserved	 
 DERIVED	 	non-reserved	non-reserved	 
 DESC	reserved	non-reserved	non-reserved	reserved
 DESCRIBE	 	reserved	reserved	reserved
 DESCRIPTOR	 	non-reserved	non-reserved	reserved
 DETERMINISTIC	 	reserved	reserved	 
 DIAGNOSTICS	 	non-reserved	non-reserved	reserved
 DICTIONARY	non-reserved	 	 	 
 DISABLE	non-reserved	 	 	 
 DISCARD	non-reserved	 	 	 
 DISCONNECT	 	reserved	reserved	reserved
 DISPATCH	 	non-reserved	non-reserved	 
 DISTINCT	reserved	reserved	reserved	reserved
 DLNEWCOPY	 	reserved	reserved	 
 DLPREVIOUSCOPY	 	reserved	reserved	 
 DLURLCOMPLETE	 	reserved	reserved	 
 DLURLCOMPLETEONLY	 	reserved	reserved	 
 DLURLCOMPLETEWRITE	 	reserved	reserved	 
 DLURLPATH	 	reserved	reserved	 
 DLURLPATHONLY	 	reserved	reserved	 
 DLURLPATHWRITE	 	reserved	reserved	 
 DLURLSCHEME	 	reserved	reserved	 
 DLURLSERVER	 	reserved	reserved	 
 DLVALUE	 	reserved	reserved	 
 DO	reserved	 	 	 
 DOCUMENT	non-reserved	non-reserved	non-reserved	 
 DOMAIN	non-reserved	non-reserved	non-reserved	reserved
 DOUBLE	non-reserved	reserved	reserved	reserved
 DROP	non-reserved	reserved	reserved	reserved
 DYNAMIC	 	reserved	reserved	 
 DYNAMIC_FUNCTION	 	non-reserved	non-reserved	non-reserved
 DYNAMIC_FUNCTION_CODE	 	non-reserved	non-reserved	 
 EACH	non-reserved	reserved	reserved	 
 ELEMENT	 	reserved	reserved	 
 ELSE	reserved	reserved	reserved	reserved
 EMPTY	 	non-reserved	non-reserved	 
 ENABLE	non-reserved	 	 	 
 ENCODING	non-reserved	non-reserved	non-reserved	 
 ENCRYPTED	non-reserved	 	 	 
 END	reserved	reserved	reserved	reserved
 END-EXEC	 	reserved	reserved	reserved
 END_FRAME	 	reserved	 	 
 END_PARTITION	 	reserved	 	 
 ENFORCED	 	non-reserved	 	 
 ENUM	non-reserved	 	 	 
 EQUALS	 	reserved	non-reserved	 
 ESCAPE	non-reserved	reserved	reserved	reserved
 EVENT	non-reserved	 	 	 
 EVERY	 	reserved	reserved	 
 EXCEPT	reserved	reserved	reserved	reserved
 EXCEPTION	 	 	 	reserved
 EXCLUDE	non-reserved	non-reserved	non-reserved	 
 EXCLUDING	non-reserved	non-reserved	non-reserved	 
 EXCLUSIVE	non-reserved	 	 	 
 EXEC	 	reserved	reserved	reserved
 EXECUTE	non-reserved	reserved	reserved	reserved
 EXISTS	non-reserved (cannot be function or type)	reserved	reserved	reserved
 EXP	 	reserved	reserved	 
 EXPLAIN	non-reserved	 	 	 
 EXPRESSION	 	non-reserved	 	 
 EXTENSION	non-reserved	 	 	 
 EXTERNAL	non-reserved	reserved	reserved	reserved
 EXTRACT	non-reserved (cannot be function or type)	reserved	reserved	reserved
 FALSE	reserved	reserved	reserved	reserved
 FAMILY	non-reserved	 	 	 
 FETCH	reserved	reserved	reserved	reserved
 FILE	 	non-reserved	non-reserved	 
 FILTER	 	reserved	reserved	 
 FINAL	 	non-reserved	non-reserved	 
 FIRST	non-reserved	non-reserved	non-reserved	reserved
 FIRST_VALUE	 	reserved	reserved	 
 FLAG	 	non-reserved	non-reserved	 
 FLOAT	non-reserved (cannot be function or type)	reserved	reserved	reserved
 FLOOR	 	reserved	reserved	 
 FOLLOWING	non-reserved	non-reserved	non-reserved	 
 FOR	reserved	reserved	reserved	reserved
 FORCE	non-reserved	 	 	 
 FOREIGN	reserved	reserved	reserved	reserved
 FORTRAN	 	non-reserved	non-reserved	non-reserved
 FORWARD	non-reserved	 	 	 
 FOUND	 	non-reserved	non-reserved	reserved
 FRAME_ROW	 	reserved	 	 
 FREE	 	reserved	reserved	 
 FREEZE	reserved (can be function or type)	 	 	 
 FROM	reserved	reserved	reserved	reserved
 FS	 	non-reserved	non-reserved	 
 FULL	reserved (can be function or type)	reserved	reserved	reserved
 FUNCTION	non-reserved	reserved	reserved	 
 FUNCTIONS	non-reserved	 	 	 
 FUSION	 	reserved	reserved	 
 G	 	non-reserved	non-reserved	 
 GENERAL	 	non-reserved	non-reserved	 
 GENERATED	 	non-reserved	non-reserved	 
 GET	 	reserved	reserved	reserved
 GLOBAL	non-reserved	reserved	reserved	reserved
 GO	 	non-reserved	non-reserved	reserved
 GOTO	 	non-reserved	non-reserved	reserved
 GRANT	reserved	reserved	reserved	reserved
 GRANTED	non-reserved	non-reserved	non-reserved	 
 GREATEST	non-reserved (cannot be function or type)	 	 	 
 GROUP	reserved	reserved	reserved	reserved
 GROUPING	 	reserved	reserved	 
 GROUPS	 	reserved	 	 
 HANDLER	non-reserved	 	 	 
 HAVING	reserved	reserved	reserved	reserved
 HEADER	non-reserved	 	 	 
 HEX	 	non-reserved	non-reserved	 
 HIERARCHY	 	non-reserved	non-reserved	 
 HOLD	non-reserved	reserved	reserved	 
 HOUR	non-reserved	reserved	reserved	reserved
 ID	 	non-reserved	non-reserved	 
 IDENTITY	non-reserved	reserved	reserved	reserved
 IF	non-reserved	 	 	 
 IGNORE	 	non-reserved	non-reserved	 
 ILIKE	reserved (can be function or type)	 	 	 
 IMMEDIATE	non-reserved	non-reserved	non-reserved	reserved
 IMMEDIATELY	 	non-reserved	 	 
 IMMUTABLE	non-reserved	 	 	 
 IMPLEMENTATION	 	non-reserved	non-reserved	 
 IMPLICIT	non-reserved	 	 	 
 IMPORT	 	reserved	reserved	 
 IN	reserved	reserved	reserved	reserved
 INCLUDING	non-reserved	non-reserved	non-reserved	 
 INCREMENT	non-reserved	non-reserved	non-reserved	 
 INDENT	 	non-reserved	non-reserved	 
 INDEX	non-reserved	 	 	 
 INDEXES	non-reserved	 	 	 
 INDICATOR	 	reserved	reserved	reserved
 INHERIT	non-reserved	 	 	 
 INHERITS	non-reserved	 	 	 
 INITIALLY	reserved	non-reserved	non-reserved	reserved
 INLINE	non-reserved	 	 	 
 INNER	reserved (can be function or type)	reserved	reserved	reserved
 INOUT	non-reserved (cannot be function or type)	reserved	reserved	 
 INPUT	non-reserved	non-reserved	non-reserved	reserved
 INSENSITIVE	non-reserved	reserved	reserved	reserved
 INSERT	non-reserved	reserved	reserved	reserved
 INSTANCE	 	non-reserved	non-reserved	 
 INSTANTIABLE	 	non-reserved	non-reserved	 
 INSTEAD	non-reserved	non-reserved	non-reserved	 
 INT	non-reserved (cannot be function or type)	reserved	reserved	reserved
 INTEGER	non-reserved (cannot be function or type)	reserved	reserved	reserved
 INTEGRITY	 	non-reserved	non-reserved	 
 INTERSECT	reserved	reserved	reserved	reserved
 INTERSECTION	 	reserved	reserved	 
 INTERVAL	non-reserved (cannot be function or type)	reserved	reserved	reserved
 INTO	reserved	reserved	reserved	reserved
 INVOKER	non-reserved	non-reserved	non-reserved	 
 IS	reserved (can be function or type)	reserved	reserved	reserved
 ISNULL	reserved (can be function or type)	 	 	 
 ISOLATION	non-reserved	non-reserved	non-reserved	reserved
 JOIN	reserved (can be function or type)	reserved	reserved	reserved
 K	 	non-reserved	non-reserved	 
 KEY	non-reserved	non-reserved	non-reserved	reserved
 KEY_MEMBER	 	non-reserved	non-reserved	 
 KEY_TYPE	 	non-reserved	non-reserved	 
 LABEL	non-reserved	 	 	 
 LAG	 	reserved	reserved	 
 LANGUAGE	non-reserved	reserved	reserved	reserved
 LARGE	non-reserved	reserved	reserved	 
 LAST	non-reserved	non-reserved	non-reserved	reserved
 LAST_VALUE	 	reserved	reserved	 
 LATERAL	reserved	reserved	reserved	 
 LC_COLLATE	non-reserved	 	 	 
 LC_CTYPE	non-reserved	 	 	 
 LEAD	 	reserved	reserved	 
 LEADING	reserved	reserved	reserved	reserved
 LEAKPROOF	non-reserved	 	 	 
 LEAST	non-reserved (cannot be function or type)	 	 	 
 LEFT	reserved (can be function or type)	reserved	reserved	reserved
 LENGTH	 	non-reserved	non-reserved	non-reserved
 LEVEL	non-reserved	non-reserved	non-reserved	reserved
 LIBRARY	 	non-reserved	non-reserved	 
 LIKE	reserved (can be function or type)	reserved	reserved	reserved
 LIKE_REGEX	 	reserved	reserved	 
 LIMIT	reserved	non-reserved	non-reserved	 
 LINK	 	non-reserved	non-reserved	 
 LISTEN	non-reserved	 	 	 
 LN	 	reserved	reserved	 
 LOAD	non-reserved	 	 	 
 LOCAL	non-reserved	reserved	reserved	reserved
 LOCALTIME	reserved	reserved	reserved	 
 LOCALTIMESTAMP	reserved	reserved	reserved	 
 LOCATION	non-reserved	non-reserved	non-reserved	 
 LOCATOR	 	non-reserved	non-reserved	 
 LOCK	non-reserved	 	 	 
 LOWER	 	reserved	reserved	reserved
 M	 	non-reserved	non-reserved	 
 MAP	 	non-reserved	non-reserved	 
 MAPPING	non-reserved	non-reserved	non-reserved	 
 MATCH	non-reserved	reserved	reserved	reserved
 MATCHED	 	non-reserved	non-reserved	 
 MATERIALIZED	non-reserved	 	 	 
 MAX	 	reserved	reserved	reserved
 MAXVALUE	non-reserved	non-reserved	non-reserved	 
 MAX_CARDINALITY	 	 	reserved	 
 MEMBER	 	reserved	reserved	 
 MERGE	 	reserved	reserved	 
 MESSAGE_LENGTH	 	non-reserved	non-reserved	non-reserved
 MESSAGE_OCTET_LENGTH	 	non-reserved	non-reserved	non-reserved
 MESSAGE_TEXT	 	non-reserved	non-reserved	non-reserved
 METHOD	 	reserved	reserved	 
 MIN	 	reserved	reserved	reserved
 MINUTE	non-reserved	reserved	reserved	reserved
 MINVALUE	non-reserved	non-reserved	non-reserved	 
 MOD	 	reserved	reserved	 
 MODE	non-reserved	 	 	 
 MODIFIES	 	reserved	reserved	 
 MODULE	 	reserved	reserved	reserved
 MONTH	non-reserved	reserved	reserved	reserved
 MORE	 	non-reserved	non-reserved	non-reserved
 MOVE	non-reserved	 	 	 
 MULTISET	 	reserved	reserved	 
 MUMPS	 	non-reserved	non-reserved	non-reserved
 NAME	non-reserved	non-reserved	non-reserved	non-reserved
 NAMES	non-reserved	non-reserved	non-reserved	reserved
 NAMESPACE	 	non-reserved	non-reserved	 
 NATIONAL	non-reserved (cannot be function or type)	reserved	reserved	reserved
 NATURAL	reserved (can be function or type)	reserved	reserved	reserved
 NCHAR	non-reserved (cannot be function or type)	reserved	reserved	reserved
 NCLOB	 	reserved	reserved	 
 NESTING	 	non-reserved	non-reserved	 
 NEW	 	reserved	reserved	 
 NEXT	non-reserved	non-reserved	non-reserved	reserved
 NFC	 	non-reserved	non-reserved	 
 NFD	 	non-reserved	non-reserved	 
 NFKC	 	non-reserved	non-reserved	 
 NFKD	 	non-reserved	non-reserved	 
 NIL	 	non-reserved	non-reserved	 
 NO	non-reserved	reserved	reserved	reserved
 NONE	non-reserved (cannot be function or type)	reserved	reserved	 
 NORMALIZE	 	reserved	reserved	 
 NORMALIZED	 	non-reserved	non-reserved	 
 NOT	reserved	reserved	reserved	reserved
 NOTHING	non-reserved	 	 	 
 NOTIFY	non-reserved	 	 	 
 NOTNULL	reserved (can be function or type)	 	 	 
 NOWAIT	non-reserved	 	 	 
 NTH_VALUE	 	reserved	reserved	 
 NTILE	 	reserved	reserved	 
 NULL	reserved	reserved	reserved	reserved
 NULLABLE	 	non-reserved	non-reserved	non-reserved
 NULLIF	non-reserved (cannot be function or type)	reserved	reserved	reserved
 NULLS	non-reserved	non-reserved	non-reserved	 
 NUMBER	 	non-reserved	non-reserved	non-reserved
 NUMERIC	non-reserved (cannot be function or type)	reserved	reserved	reserved
 OBJECT	non-reserved	non-reserved	non-reserved	 
 OCCURRENCES_REGEX	 	reserved	reserved	 
 OCTETS	 	non-reserved	non-reserved	 
 OCTET_LENGTH	 	reserved	reserved	reserved
 OF	non-reserved	reserved	reserved	reserved
 OFF	non-reserved	non-reserved	non-reserved	 
 OFFSET	reserved	reserved	reserved	 
 OIDS	non-reserved	 	 	 
 OLD	 	reserved	reserved	 
 ON	reserved	reserved	reserved	reserved
 ONLY	reserved	reserved	reserved	reserved
 OPEN	 	reserved	reserved	reserved
 OPERATOR	non-reserved	 	 	 
 OPTION	non-reserved	non-reserved	non-reserved	reserved
 OPTIONS	non-reserved	non-reserved	non-reserved	 
 OR	reserved	reserved	reserved	reserved
 ORDER	reserved	reserved	reserved	reserved
 ORDERING	 	non-reserved	non-reserved	 
 ORDINALITY	 	non-reserved	non-reserved	 
 OTHERS	 	non-reserved	non-reserved	 
 OUT	non-reserved (cannot be function or type)	reserved	reserved	 
 OUTER	reserved (can be function or type)	reserved	reserved	reserved
 OUTPUT	 	non-reserved	non-reserved	reserved
 OVER	reserved (can be function or type)	reserved	reserved	 
 OVERLAPS	reserved (can be function or type)	reserved	reserved	reserved
 OVERLAY	non-reserved (cannot be function or type)	reserved	reserved	 
 OVERRIDING	 	non-reserved	non-reserved	 
 OWNED	non-reserved	 	 	 
 OWNER	non-reserved	 	 	 
 P	 	non-reserved	non-reserved	 
 PAD	 	non-reserved	non-reserved	reserved
 PARAMETER	 	reserved	reserved	 
 PARAMETER_MODE	 	non-reserved	non-reserved	 
 PARAMETER_NAME	 	non-reserved	non-reserved	 
 PARAMETER_ORDINAL_POSITION	 	non-reserved	non-reserved	 
 PARAMETER_SPECIFIC_CATALOG	 	non-reserved	non-reserved	 
 PARAMETER_SPECIFIC_NAME	 	non-reserved	non-reserved	 
 PARAMETER_SPECIFIC_SCHEMA	 	non-reserved	non-reserved	 
 PARSER	non-reserved	 	 	 
 PARTIAL	non-reserved	non-reserved	non-reserved	reserved
 PARTITION	non-reserved	reserved	reserved	 
 PASCAL	 	non-reserved	non-reserved	non-reserved
 PASSING	non-reserved	non-reserved	non-reserved	 
 PASSTHROUGH	 	non-reserved	non-reserved	 
 PASSWORD	non-reserved	 	 	 
 PATH	 	non-reserved	non-reserved	 
 PERCENT	 	reserved	 	 
 PERCENTILE_CONT	 	reserved	reserved	 
 PERCENTILE_DISC	 	reserved	reserved	 
 PERCENT_RANK	 	reserved	reserved	 
 PERIOD	 	reserved	 	 
 PERMISSION	 	non-reserved	non-reserved	 
 PLACING	reserved	non-reserved	non-reserved	 
 PLANS	non-reserved	 	 	 
 PLI	 	non-reserved	non-reserved	non-reserved
 PORTION	 	reserved	 	 
 POSITION	non-reserved (cannot be function or type)	reserved	reserved	reserved
 POSITION_REGEX	 	reserved	reserved	 
 POWER	 	reserved	reserved	 
 PRECEDES	 	reserved	 	 
 PRECEDING	non-reserved	non-reserved	non-reserved	 
 PRECISION	non-reserved (cannot be function or type)	reserved	reserved	reserved
 PREPARE	non-reserved	reserved	reserved	reserved
 PREPARED	non-reserved	 	 	 
 PRESERVE	non-reserved	non-reserved	non-reserved	reserved
 PRIMARY	reserved	reserved	reserved	reserved
 PRIOR	non-reserved	non-reserved	non-reserved	reserved
 PRIVILEGES	non-reserved	non-reserved	non-reserved	reserved
 PROCEDURAL	non-reserved	 	 	 
 PROCEDURE	non-reserved	reserved	reserved	reserved
 PROGRAM	non-reserved	 	 	 
 PUBLIC	 	non-reserved	non-reserved	reserved
 QUOTE	non-reserved	 	 	 
 RANGE	non-reserved	reserved	reserved	 
 RANK	 	reserved	reserved	 
 READ	non-reserved	non-reserved	non-reserved	reserved
 READS	 	reserved	reserved	 
 REAL	non-reserved (cannot be function or type)	reserved	reserved	reserved
 REASSIGN	non-reserved	 	 	 
 RECHECK	non-reserved	 	 	 
 RECOVERY	 	non-reserved	non-reserved	 
 RECURSIVE	non-reserved	reserved	reserved	 
 REF	non-reserved	reserved	reserved	 
 REFERENCES	reserved	reserved	reserved	reserved
 REFERENCING	 	reserved	reserved	 
 REFRESH	non-reserved	 	 	 
 REGR_AVGX	 	reserved	reserved	 
 REGR_AVGY	 	reserved	reserved	 
 REGR_COUNT	 	reserved	reserved	 
 REGR_INTERCEPT	 	reserved	reserved	 
 REGR_R2	 	reserved	reserved	 
 REGR_SLOPE	 	reserved	reserved	 
 REGR_SXX	 	reserved	reserved	 
 REGR_SXY	 	reserved	reserved	 
 REGR_SYY	 	reserved	reserved	 
 REINDEX	non-reserved	 	 	 
 RELATIVE	non-reserved	non-reserved	non-reserved	reserved
 RELEASE	non-reserved	reserved	reserved	 
 RENAME	non-reserved	 	 	 
 REPEATABLE	non-reserved	non-reserved	non-reserved	non-reserved
 REPLACE	non-reserved	 	 	 
 REPLICA	non-reserved	 	 	 
 REQUIRING	 	non-reserved	non-reserved	 
 RESET	non-reserved	 	 	 
 RESPECT	 	non-reserved	non-reserved	 
 RESTART	non-reserved	non-reserved	non-reserved	 
 RESTORE	 	non-reserved	non-reserved	 
 RESTRICT	non-reserved	non-reserved	non-reserved	reserved
 RESULT	 	reserved	reserved	 
 RETURN	 	reserved	reserved	 
 RETURNED_CARDINALITY	 	non-reserved	non-reserved	 
 RETURNED_LENGTH	 	non-reserved	non-reserved	non-reserved
 RETURNED_OCTET_LENGTH	 	non-reserved	non-reserved	non-reserved
 RETURNED_SQLSTATE	 	non-reserved	non-reserved	non-reserved
 RETURNING	reserved	non-reserved	non-reserved	 
 RETURNS	non-reserved	reserved	reserved	 
 REVOKE	non-reserved	reserved	reserved	reserved
 RIGHT	reserved (can be function or type)	reserved	reserved	reserved
 ROLE	non-reserved	non-reserved	non-reserved	 
 ROLLBACK	non-reserved	reserved	reserved	reserved
 ROLLUP	 	reserved	reserved	 
 ROUTINE	 	non-reserved	non-reserved	 
 ROUTINE_CATALOG	 	non-reserved	non-reserved	 
 ROUTINE_NAME	 	non-reserved	non-reserved	 
 ROUTINE_SCHEMA	 	non-reserved	non-reserved	 
 ROW	non-reserved (cannot be function or type)	reserved	reserved	 
 ROWS	non-reserved	reserved	reserved	reserved
 ROW_COUNT	 	non-reserved	non-reserved	non-reserved
 ROW_NUMBER	 	reserved	reserved	 
 RULE	non-reserved	 	 	 
 SAVEPOINT	non-reserved	reserved	reserved	 
 SCALE	 	non-reserved	non-reserved	non-reserved
 SCHEMA	non-reserved	non-reserved	non-reserved	reserved
 SCHEMA_NAME	 	non-reserved	non-reserved	non-reserved
 SCOPE	 	reserved	reserved	 
 SCOPE_CATALOG	 	non-reserved	non-reserved	 
 SCOPE_NAME	 	non-reserved	non-reserved	 
 SCOPE_SCHEMA	 	non-reserved	non-reserved	 
 SCROLL	non-reserved	reserved	reserved	reserved
 SEARCH	non-reserved	reserved	reserved	 
 SECOND	non-reserved	reserved	reserved	reserved
 SECTION	 	non-reserved	non-reserved	reserved
 SECURITY	non-reserved	non-reserved	non-reserved	 
 SELECT	reserved	reserved	reserved	reserved
 SELECTIVE	 	non-reserved	non-reserved	 
 SELF	 	non-reserved	non-reserved	 
 SENSITIVE	 	reserved	reserved	 
 SEQUENCE	non-reserved	non-reserved	non-reserved	 
 SEQUENCES	non-reserved	 	 	 
 SERIALIZABLE	non-reserved	non-reserved	non-reserved	non-reserved
 SERVER	non-reserved	non-reserved	non-reserved	 
 SERVER_NAME	 	non-reserved	non-reserved	non-reserved
 SESSION	non-reserved	non-reserved	non-reserved	reserved
 SESSION_USER	reserved	reserved	reserved	reserved
 SET	non-reserved	reserved	reserved	reserved
 SETOF	non-reserved (cannot be function or type)	 	 	 
 SETS	 	non-reserved	non-reserved	 
 SHARE	non-reserved	 	 	 
 SHOW	non-reserved	 	 	 
 SIMILAR	reserved (can be function or type)	reserved	reserved	 
 SIMPLE	non-reserved	non-reserved	non-reserved	 
 SIZE	 	non-reserved	non-reserved	reserved
 SMALLINT	non-reserved (cannot be function or type)	reserved	reserved	reserved
 SNAPSHOT	non-reserved	 	 	 
 SOME	reserved	reserved	reserved	reserved
 SOURCE	 	non-reserved	non-reserved	 
 SPACE	 	non-reserved	non-reserved	reserved
 SPECIFIC	 	reserved	reserved	 
 SPECIFICTYPE	 	reserved	reserved	 
 SPECIFIC_NAME	 	non-reserved	non-reserved	 
 SQL	 	reserved	reserved	reserved
 SQLCODE	 	 	 	reserved
 SQLERROR	 	 	 	reserved
 SQLEXCEPTION	 	reserved	reserved	 
 SQLSTATE	 	reserved	reserved	reserved
 SQLWARNING	 	reserved	reserved	 
 SQRT	 	reserved	reserved	 
 STABLE	non-reserved	 	 	 
 STANDALONE	non-reserved	non-reserved	non-reserved	 
 START	non-reserved	reserved	reserved	 
 STATE	 	non-reserved	non-reserved	 
 STATEMENT	non-reserved	non-reserved	non-reserved	 
 STATIC	 	reserved	reserved	 
 STATISTICS	non-reserved	 	 	 
 STDDEV_POP	 	reserved	reserved	 
 STDDEV_SAMP	 	reserved	reserved	 
 STDIN	non-reserved	 	 	 
 STDOUT	non-reserved	 	 	 
 STORAGE	non-reserved	 	 	 
 STRICT	non-reserved	 	 	 
 STRIP	non-reserved	non-reserved	non-reserved	 
 STRUCTURE	 	non-reserved	non-reserved	 
 STYLE	 	non-reserved	non-reserved	 
 SUBCLASS_ORIGIN	 	non-reserved	non-reserved	non-reserved
 SUBMULTISET	 	reserved	reserved	 
 SUBSTRING	non-reserved (cannot be function or type)	reserved	reserved	reserved
 SUBSTRING_REGEX	 	reserved	reserved	 
 SUCCEEDS	 	reserved	 	 
 SUM	 	reserved	reserved	reserved
 SYMMETRIC	reserved	reserved	reserved	 
 SYSID	non-reserved	 	 	 
 SYSTEM	non-reserved	reserved	reserved	 
 SYSTEM_TIME	 	reserved	 	 
 SYSTEM_USER	 	reserved	reserved	reserved
 T	 	non-reserved	non-reserved	 
 TABLE	reserved	reserved	reserved	reserved
 TABLES	non-reserved	 	 	 
 TABLESAMPLE	 	reserved	reserved	 
 TABLESPACE	non-reserved	 	 	 
 TABLE_NAME	 	non-reserved	non-reserved	non-reserved
 TEMP	non-reserved	 	 	 
 TEMPLATE	non-reserved	 	 	 
 TEMPORARY	non-reserved	non-reserved	non-reserved	reserved
 TEXT	non-reserved	 	 	 
 THEN	reserved	reserved	reserved	reserved
 TIES	 	non-reserved	non-reserved	 
 TIME	non-reserved (cannot be function or type)	reserved	reserved	reserved
 TIMESTAMP	non-reserved (cannot be function or type)	reserved	reserved	reserved
 TIMEZONE_HOUR	 	reserved	reserved	reserved
 TIMEZONE_MINUTE	 	reserved	reserved	reserved
 TO	reserved	reserved	reserved	reserved
 TOKEN	 	non-reserved	non-reserved	 
 TOP_LEVEL_COUNT	 	non-reserved	non-reserved	 
 TRAILING	reserved	reserved	reserved	reserved
 TRANSACTION	non-reserved	non-reserved	non-reserved	reserved
 TRANSACTIONS_COMMITTED	 	non-reserved	non-reserved	 
 TRANSACTIONS_ROLLED_BACK	 	non-reserved	non-reserved	 
 TRANSACTION_ACTIVE	 	non-reserved	non-reserved	 
 TRANSFORM	 	non-reserved	non-reserved	 
 TRANSFORMS	 	non-reserved	non-reserved	 
 TRANSLATE	 	reserved	reserved	reserved
 TRANSLATE_REGEX	 	reserved	reserved	 
 TRANSLATION	 	reserved	reserved	reserved
 TREAT	non-reserved (cannot be function or type)	reserved	reserved	 
 TRIGGER	non-reserved	reserved	reserved	 
 TRIGGER_CATALOG	 	non-reserved	non-reserved	 
 TRIGGER_NAME	 	non-reserved	non-reserved	 
 TRIGGER_SCHEMA	 	non-reserved	non-reserved	 
 TRIM	non-reserved (cannot be function or type)	reserved	reserved	reserved
 TRIM_ARRAY	 	reserved	reserved	 
 TRUE	reserved	reserved	reserved	reserved
 TRUNCATE	non-reserved	reserved	reserved	 
 TRUSTED	non-reserved	 	 	 
 TYPE	non-reserved	non-reserved	non-reserved	non-reserved
 TYPES	non-reserved	 	 	 
 UESCAPE	 	reserved	reserved	 
 UNBOUNDED	non-reserved	non-reserved	non-reserved	 
 UNCOMMITTED	non-reserved	non-reserved	non-reserved	non-reserved
 UNDER	 	non-reserved	non-reserved	 
 UNENCRYPTED	non-reserved	 	 	 
 UNION	reserved	reserved	reserved	reserved
 UNIQUE	reserved	reserved	reserved	reserved
 UNKNOWN	non-reserved	reserved	reserved	reserved
 UNLINK	 	non-reserved	non-reserved	 
 UNLISTEN	non-reserved	 	 	 
 UNLOGGED	non-reserved	 	 	 
 UNNAMED	 	non-reserved	non-reserved	non-reserved
 UNNEST	 	reserved	reserved	 
 UNTIL	non-reserved	 	 	 
 UNTYPED	 	non-reserved	non-reserved	 
 UPDATE	non-reserved	reserved	reserved	reserved
 UPPER	 	reserved	reserved	reserved
 URI	 	non-reserved	non-reserved	 
 USAGE	 	non-reserved	non-reserved	reserved
 USER	reserved	reserved	reserved	reserved
 USER_DEFINED_TYPE_CATALOG	 	non-reserved	non-reserved	 
 USER_DEFINED_TYPE_CODE	 	non-reserved	non-reserved	 
 USER_DEFINED_TYPE_NAME	 	non-reserved	non-reserved	 
 USER_DEFINED_TYPE_SCHEMA	 	non-reserved	non-reserved	 
 USING	reserved	reserved	reserved	reserved
 VACUUM	non-reserved	 	 	 
 VALID	non-reserved	non-reserved	non-reserved	 
 VALIDATE	non-reserved	 	 	 
 VALIDATOR	non-reserved	 	 	 
 VALUE	non-reserved	reserved	reserved	reserved
 VALUES	non-reserved (cannot be function or type)	reserved	reserved	reserved
 VALUE_OF	 	reserved	 	 
 VARBINARY	 	reserved	reserved	 
 VARCHAR	non-reserved (cannot be function or type)	reserved	reserved	reserved
 VARIADIC	reserved	 	 	 
 VARYING	non-reserved	reserved	reserved	reserved
 VAR_POP	 	reserved	reserved	 
 VAR_SAMP	 	reserved	reserved	 
 VERBOSE	reserved (can be function or type)	 	 	 
 VERSION	non-reserved	non-reserved	non-reserved	 
 VERSIONING	 	reserved	 	 
 VIEW	non-reserved	non-reserved	non-reserved	reserved
 VOLATILE	non-reserved	 	 	 
 WHEN	reserved	reserved	reserved	reserved
 WHENEVER	 	reserved	reserved	reserved
 WHERE	reserved	reserved	reserved	reserved
 WHITESPACE	non-reserved	non-reserved	non-reserved	 
 WIDTH_BUCKET	 	reserved	reserved	 
 WINDOW	reserved	reserved	reserved	 
 WITH	reserved	reserved	reserved	reserved
 WITHIN	 	reserved	reserved	 
 WITHOUT	non-reserved	reserved	reserved	 
 WORK	non-reserved	non-reserved	non-reserved	reserved
 WRAPPER	non-reserved	non-reserved	non-reserved	 
 WRITE	non-reserved	non-reserved	non-reserved	reserved
 XML	non-reserved	reserved	reserved	 
 XMLAGG	 	reserved	reserved	 
 XMLATTRIBUTES	non-reserved (cannot be function or type)	reserved	reserved	 
 XMLBINARY	 	reserved	reserved	 
 XMLCAST	 	reserved	reserved	 
 XMLCOMMENT	 	reserved	reserved	 
 XMLCONCAT	non-reserved (cannot be function or type)	reserved	reserved	 
 XMLDECLARATION	 	non-reserved	non-reserved	 
 XMLDOCUMENT	 	reserved	reserved	 
 XMLELEMENT	non-reserved (cannot be function or type)	reserved	reserved	 
 XMLEXISTS	non-reserved (cannot be function or type)	reserved	reserved	 
 XMLFOREST	non-reserved (cannot be function or type)	reserved	reserved	 
 XMLITERATE	 	reserved	reserved	 
 XMLNAMESPACES	 	reserved	reserved	 
 XMLPARSE	non-reserved (cannot be function or type)	reserved	reserved	 
 XMLPI	non-reserved (cannot be function or type)	reserved	reserved	 
 XMLQUERY	 	reserved	reserved	 
 XMLROOT	non-reserved (cannot be function or type)	 	 	 
 XMLSCHEMA	 	non-reserved	non-reserved	 
 XMLSERIALIZE	non-reserved (cannot be function or type)	reserved	reserved	 
 XMLTABLE	 	reserved	reserved	 
 XMLTEXT	 	reserved	reserved	 
 XMLVALIDATE	 	reserved	reserved	 
 YEAR	non-reserved	reserved	reserved	reserved
 YES	non-reserved	non-reserved	non-reserved	 
 ZONE	non-reserved	non-reserved	non-reserved	reserved
--- a/vendor/github.com/go-xorm/xorm/test_mssql.sh
+++ b/vendor/github.com/go-xorm/xorm/test_mssql.sh
@ -1 +0,0 @@
 go test -db=mssql -conn_str="server=192.168.1.58;user id=sa;password=123456;database=xorm_test"
--- a/vendor/github.com/go-xorm/xorm/test_mssql_cache.sh
+++ b/vendor/github.com/go-xorm/xorm/test_mssql_cache.sh
@ -1 +0,0 @@
 go test -db=mssql -conn_str="server=192.168.1.58;user id=sa;password=123456;database=xorm_test" -cache=true
--- a/vendor/github.com/go-xorm/xorm/test_mymysql.sh
+++ b/vendor/github.com/go-xorm/xorm/test_mymysql.sh
@ -1 +0,0 @@
 go test -db=mymysql -conn_str="xorm_test/root/"
--- a/vendor/github.com/go-xorm/xorm/test_mymysql_cache.sh
+++ b/vendor/github.com/go-xorm/xorm/test_mymysql_cache.sh
@ -1 +0,0 @@
 go test -db=mymysql -conn_str="xorm_test/root/" -cache=true
--- a/vendor/github.com/go-xorm/xorm/test_mysql.sh
+++ b/vendor/github.com/go-xorm/xorm/test_mysql.sh
@ -1 +0,0 @@
 go test -db=mysql -conn_str="root:@/xorm_test"
--- a/vendor/github.com/go-xorm/xorm/test_mysql_cache.sh
+++ b/vendor/github.com/go-xorm/xorm/test_mysql_cache.sh
@ -1 +0,0 @@
 go test -db=mysql -conn_str="root:@/xorm_test" -cache=true
--- a/vendor/github.com/go-xorm/xorm/test_postgres.sh
+++ b/vendor/github.com/go-xorm/xorm/test_postgres.sh
@ -1 +0,0 @@
 go test -db=postgres -conn_str="dbname=xorm_test sslmode=disable"
--- a/Show More
+++ b/Show More
		`@ -1 +0,0 @@`
			`go test -db=mssql -conn_str="server=192.168.1.58;user id=sa;password=123456;database=xorm_test"`
		`@ -1 +0,0 @@`
			`go test -db=mymysql -conn_str="xorm_test/root/"`
		`@ -1 +0,0 @@`
			`go test -db=mysql -conn_str="root:@/xorm_test"`
		`@ -1 +0,0 @@`
			`go test -db=postgres -conn_str="dbname=xorm_test sslmode=disable"`