- update mod

- update xml

.gitignore

@@ -4,4 +4,8 @@
 .idea
 .vscode
 *.log
-gomod.sh
+*_test.go
+*.txt
+*.text
+go_mod.sh
+/vendor/

LICENSE

@@ -1,6 +1,6 @@
-The MIT License (MIT)
+MIT License
 
-Copyright (c) 2015 - Jinzhu
+Copyright (c) 2018 李光春
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,25 +1,17 @@
 <h1>
-<a href="https://www.dtapp.net/">Golang Dorm</a>
+<a href="https://www.dtapp.net/">Golang</a>
 </h1>
 
-📦 Golang Dorm
+📦 Golang 数据库
 
 [comment]: <> (go)
 [![godoc](https://pkg.go.dev/badge/go.dtapp.net/dorm?status.svg)](https://pkg.go.dev/go.dtapp.net/dorm)
 [![goproxy.cn](https://goproxy.cn/stats/go.dtapp.net/dorm/badges/download-count.svg)](https://goproxy.cn/stats/go.dtapp.net/dorm)
 [![goreportcard.com](https://goreportcard.com/badge/go.dtapp.net/dorm)](https://goreportcard.com/report/go.dtapp.net/dorm)
-[![deps.dev](https://img.shields.io/badge/deps-go-red.svg)](https://deps.dev/go/go.dtapp.net/dorm)
+[![deps.dev](https://img.shields.io/badge/deps-go-red.svg)](https://deps.dev/go/go.dtapp.net%2Fdorm)
 
-#### 安装使用
+#### 安装
 
 ```shell
-go get -v -u go.dtapp.net/dorm
+go get -v -u go.dtapp.net/dorm@v1.0.59
 ```
-
-#### 导入
-
-```go
-import (
-    "go.dtapp.net/dorm"
-)
-```

go.mod

@@ -1,40 +1,57 @@
 module go.dtapp.net/dorm
 
-go 1.18
+go 1.22.1
 
 require (
-	github.com/go-redis/redis/v8 v8.11.5
-	github.com/sirupsen/logrus v1.8.1
-	go.mongodb.org/mongo-driver v1.9.1
-	gorm.io/driver/mysql v1.3.4
-	gorm.io/driver/postgres v1.3.7
-	gorm.io/gorm v1.23.6
+	github.com/redis/go-redis/v9 v9.5.1
+	github.com/sirupsen/logrus v1.9.3
+	go.dtapp.net/gojson v1.0.4
+	go.dtapp.net/gotime v1.0.8
+	go.mongodb.org/mongo-driver v1.15.0
+	gorm.io/driver/mysql v1.5.6
+	gorm.io/driver/postgres v1.5.7
+	gorm.io/gen v0.3.26
+	gorm.io/gorm v1.25.10
 )
 
 require (
-	github.com/cespare/xxhash/v2 v2.1.2 // indirect
+	filippo.io/edwards25519 v1.1.0 // indirect
+	github.com/basgys/goxml2json v1.1.0 // indirect
+	github.com/bytedance/sonic v1.11.6 // indirect
+	github.com/bytedance/sonic/loader v0.1.1 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/cloudwego/base64x v0.1.4 // indirect
+	github.com/cloudwego/iasm v0.2.0 // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
-	github.com/go-sql-driver/mysql v1.6.0 // indirect
-	github.com/go-stack/stack v1.8.1 // indirect
+	github.com/go-sql-driver/mysql v1.8.1 // indirect
+	github.com/goccy/go-json v0.10.2 // indirect
 	github.com/golang/snappy v0.0.4 // indirect
-	github.com/jackc/chunkreader/v2 v2.0.1 // indirect
-	github.com/jackc/pgconn v1.12.1 // indirect
-	github.com/jackc/pgio v1.0.0 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
-	github.com/jackc/pgproto3/v2 v2.3.0 // indirect
-	github.com/jackc/pgservicefile v0.0.0-20200714003250-2b9c44734f2b // indirect
-	github.com/jackc/pgtype v1.11.0 // indirect
-	github.com/jackc/pgx/v4 v4.16.1 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20231201235250-de7065d80cb9 // indirect
+	github.com/jackc/pgx/v5 v5.5.5 // indirect
+	github.com/jackc/puddle/v2 v2.2.1 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
-	github.com/klauspost/compress v1.15.6 // indirect
-	github.com/pkg/errors v0.9.1 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/compress v1.17.8 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/montanaflynn/stats v0.7.1 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/xdg-go/pbkdf2 v1.0.0 // indirect
-	github.com/xdg-go/scram v1.1.1 // indirect
-	github.com/xdg-go/stringprep v1.0.3 // indirect
-	github.com/youmark/pkcs8 v0.0.0-20201027041543-1326539a0a0a // indirect
-	golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e // indirect
-	golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f // indirect
-	golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c // indirect
-	golang.org/x/text v0.3.7 // indirect
+	github.com/xdg-go/scram v1.1.2 // indirect
+	github.com/xdg-go/stringprep v1.0.4 // indirect
+	github.com/youmark/pkcs8 v0.0.0-20240424034433-3c2c7870ae76 // indirect
+	golang.org/x/arch v0.7.0 // indirect
+	golang.org/x/crypto v0.22.0 // indirect
+	golang.org/x/mod v0.17.0 // indirect
+	golang.org/x/net v0.24.0 // indirect
+	golang.org/x/sync v0.7.0 // indirect
+	golang.org/x/sys v0.19.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
+	golang.org/x/tools v0.20.0 // indirect
+	gorm.io/datatypes v1.2.0 // indirect
+	gorm.io/hints v1.1.2 // indirect
+	gorm.io/plugin/dbresolver v1.5.1 // indirect
 )

go.sum

@@ -1,249 +1,179 @@
-github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/Masterminds/semver/v3 v3.1.1 h1:hLg3sBzpNErnxhQtUy/mmLR2I9foDujNK030IGemrRc=
-github.com/Masterminds/semver/v3 v3.1.1/go.mod h1:VPu/7SZ7ePZ3QOrcuXROw5FAcLl4a0cBrbBpGY/8hQs=
-github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE=
-github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/cockroachdb/apd v1.1.0 h1:3LFP3629v+1aKXU5Q37mxmRxX/pIu1nijXydLShEq5I=
-github.com/cockroachdb/apd v1.1.0/go.mod h1:8Sl8LxpKi29FqWXR16WEFZRNSz3SoPzUzeMeY4+DwBQ=
-github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
-github.com/coreos/go-systemd v0.0.0-20190719114852-fd7a80b32e1f/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
-github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
+filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
+filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
+github.com/basgys/goxml2json v1.1.0 h1:4ln5i4rseYfXNd86lGEB+Vi652IsIXIvggKM/BhUKVw=
+github.com/basgys/goxml2json v1.1.0/go.mod h1:wH7a5Np/Q4QoECFIU8zTQlZwZkrilY0itPfecMw41Dw=
+github.com/bitly/go-simplejson v0.5.1 h1:xgwPbetQScXt1gh9BmoJ6j9JMr3TElvuIyjR8pgdoow=
+github.com/bitly/go-simplejson v0.5.1/go.mod h1:YOPVLzCfwK14b4Sff3oP1AmGhI9T9Vsg84etUnlyp+Q=
+github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
+github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
+github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
+github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
+github.com/bytedance/sonic v1.11.6 h1:oUp34TzMlL+OY1OUWxHqsdkgC/Zfc85zGqw9siXjrc0=
+github.com/bytedance/sonic v1.11.6/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
+github.com/bytedance/sonic/loader v0.1.1 h1:c+e5Pt1k/cy5wMveRDyk2X4B9hF4g7an8N3zCYjJFNM=
+github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y=
+github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
+github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg=
+github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
-github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
-github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
-github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
-github.com/go-redis/redis/v8 v8.11.5 h1:AcZZR7igkdvfVmQTPnu9WE37LRrO/YrBH5zWyjDC0oI=
-github.com/go-redis/redis/v8 v8.11.5/go.mod h1:gREzHqY1hg6oD9ngVRbLStwAWKhA0FEgq8Jd4h5lpwo=
-github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfCHuOE=
 github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
-github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/go-stack/stack v1.8.1 h1:ntEHSVwIt7PNXNpgPmVfMrNhLtgjlmnZha2kOpuRiDw=
-github.com/go-stack/stack v1.8.1/go.mod h1:dcoOX6HbPZSZptuspn9bctJ+N/CnF5gGygcUP3XYfe4=
-github.com/gofrs/uuid v4.0.0+incompatible h1:1SD/1F5pU8p29ybwgQSwpQk+mwdRrXCYuPhW6m+TnJw=
-github.com/gofrs/uuid v4.0.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
-github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/go-sql-driver/mysql v1.7.0/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
+github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y=
+github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
+github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
+github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 h1:au07oEsX2xN0ktxqI+Sida1w446QrXBRJ0nee3SNZlA=
+github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0=
+github.com/golang-sql/sqlexp v0.1.0 h1:ZCD6MBpcuOVfGVqsEmY5/4FtYiKz6tSyUv9LPEDei6A=
+github.com/golang-sql/sqlexp v0.1.0/go.mod h1:J4ad9Vo8ZCWQ2GMrC4UCQy1JpCbwU9m3EOqtpKwwwHI=
 github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
 github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/go-cmp v0.5.2 h1:X2ev0eStA3AbceY54o37/0PQ/UWqKEiiO2dKL5OPaFM=
 github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
-github.com/jackc/chunkreader v1.0.0 h1:4s39bBR8ByfqH+DKm8rQA3E1LHZWB9XWcrz8fqaZbe0=
-github.com/jackc/chunkreader v1.0.0/go.mod h1:RT6O25fNZIuasFJRyZ4R/Y2BbhasbmZXF9QQ7T3kePo=
-github.com/jackc/chunkreader/v2 v2.0.0/go.mod h1:odVSm741yZoC3dpHEUXIqA9tQRhFrgOHwnPIn9lDKlk=
-github.com/jackc/chunkreader/v2 v2.0.1 h1:i+RDz65UE+mmpjTfyz0MoVTnzeYxroil2G82ki7MGG8=
-github.com/jackc/chunkreader/v2 v2.0.1/go.mod h1:odVSm741yZoC3dpHEUXIqA9tQRhFrgOHwnPIn9lDKlk=
-github.com/jackc/pgconn v0.0.0-20190420214824-7e0022ef6ba3/go.mod h1:jkELnwuX+w9qN5YIfX0fl88Ehu4XC3keFuOJJk9pcnA=
-github.com/jackc/pgconn v0.0.0-20190824142844-760dd75542eb/go.mod h1:lLjNuW/+OfW9/pnVKPazfWOgNfH2aPem8YQ7ilXGvJE=
-github.com/jackc/pgconn v0.0.0-20190831204454-2fabfa3c18b7/go.mod h1:ZJKsE/KZfsUgOEh9hBm+xYTstcNHg7UPMVJqRfQxq4s=
-github.com/jackc/pgconn v1.8.0/go.mod h1:1C2Pb36bGIP9QHGBYCjnyhqu7Rv3sGshaQUvmfGIB/o=
-github.com/jackc/pgconn v1.9.0/go.mod h1:YctiPyvzfU11JFxoXokUOOKQXQmDMoJL9vJzHH8/2JY=
-github.com/jackc/pgconn v1.9.1-0.20210724152538-d89c8390a530/go.mod h1:4z2w8XhRbP1hYxkpTuBjTS3ne3J48K83+u0zoyvg2pI=
-github.com/jackc/pgconn v1.12.1 h1:rsDFzIpRk7xT4B8FufgpCCeyjdNpKyghZeSefViE5W8=
-github.com/jackc/pgconn v1.12.1/go.mod h1:ZkhRC59Llhrq3oSfrikvwQ5NaxYExr6twkdkMLaKono=
-github.com/jackc/pgio v1.0.0 h1:g12B9UwVnzGhueNavwioyEEpAmqMe1E/BN9ES+8ovkE=
-github.com/jackc/pgio v1.0.0/go.mod h1:oP+2QK2wFfUWgr+gxjoBH9KGBb31Eio69xUb0w5bYf8=
-github.com/jackc/pgmock v0.0.0-20190831213851-13a1b77aafa2/go.mod h1:fGZlG77KXmcq05nJLRkk0+p82V8B8Dw8KN2/V9c/OAE=
-github.com/jackc/pgmock v0.0.0-20201204152224-4fe30f7445fd/go.mod h1:hrBW0Enj2AZTNpt/7Y5rr2xe/9Mn757Wtb2xeBzPv2c=
-github.com/jackc/pgmock v0.0.0-20210724152146-4ad1a8207f65 h1:DadwsjnMwFjfWc9y5Wi/+Zz7xoE5ALHsRQlOctkOiHc=
-github.com/jackc/pgmock v0.0.0-20210724152146-4ad1a8207f65/go.mod h1:5R2h2EEX+qri8jOWMbJCtaPWkrrNc7OHwsp2TCqp7ak=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
-github.com/jackc/pgproto3 v1.1.0 h1:FYYE4yRw+AgI8wXIinMlNjBbp/UitDJwfj5LqqewP1A=
-github.com/jackc/pgproto3 v1.1.0/go.mod h1:eR5FA3leWg7p9aeAqi37XOTgTIbkABlvcPB3E5rlc78=
-github.com/jackc/pgproto3/v2 v2.0.0-alpha1.0.20190420180111-c116219b62db/go.mod h1:bhq50y+xrl9n5mRYyCBFKkpRVTLYJVWeCc+mEAI3yXA=
-github.com/jackc/pgproto3/v2 v2.0.0-alpha1.0.20190609003834-432c2951c711/go.mod h1:uH0AWtUmuShn0bcesswc4aBTWGvw0cAxIJp+6OB//Wg=
-github.com/jackc/pgproto3/v2 v2.0.0-rc3/go.mod h1:ryONWYqW6dqSg1Lw6vXNMXoBJhpzvWKnT95C46ckYeM=
-github.com/jackc/pgproto3/v2 v2.0.0-rc3.0.20190831210041-4c03ce451f29/go.mod h1:ryONWYqW6dqSg1Lw6vXNMXoBJhpzvWKnT95C46ckYeM=
-github.com/jackc/pgproto3/v2 v2.0.6/go.mod h1:WfJCnwN3HIg9Ish/j3sgWXnAfK8A9Y0bwXYU5xKaEdA=
-github.com/jackc/pgproto3/v2 v2.1.1/go.mod h1:WfJCnwN3HIg9Ish/j3sgWXnAfK8A9Y0bwXYU5xKaEdA=
-github.com/jackc/pgproto3/v2 v2.3.0 h1:brH0pCGBDkBW07HWlN/oSBXrmo3WB0UvZd1pIuDcL8Y=
-github.com/jackc/pgproto3/v2 v2.3.0/go.mod h1:WfJCnwN3HIg9Ish/j3sgWXnAfK8A9Y0bwXYU5xKaEdA=
-github.com/jackc/pgservicefile v0.0.0-20200714003250-2b9c44734f2b h1:C8S2+VttkHFdOOCXJe+YGfa4vHYwlt4Zx+IVXQ97jYg=
-github.com/jackc/pgservicefile v0.0.0-20200714003250-2b9c44734f2b/go.mod h1:vsD4gTJCa9TptPL8sPkXrLZ+hDuNrZCnj29CQpr4X1E=
-github.com/jackc/pgtype v0.0.0-20190421001408-4ed0de4755e0/go.mod h1:hdSHsc1V01CGwFsrv11mJRHWJ6aifDLfdV3aVjFF0zg=
-github.com/jackc/pgtype v0.0.0-20190824184912-ab885b375b90/go.mod h1:KcahbBH1nCMSo2DXpzsoWOAfFkdEtEJpPbVLq8eE+mc=
-github.com/jackc/pgtype v0.0.0-20190828014616-a8802b16cc59/go.mod h1:MWlu30kVJrUS8lot6TQqcg7mtthZ9T0EoIBFiJcmcyw=
-github.com/jackc/pgtype v1.8.1-0.20210724151600-32e20a603178/go.mod h1:C516IlIV9NKqfsMCXTdChteoXmwgUceqaLfjg2e3NlM=
-github.com/jackc/pgtype v1.11.0 h1:u4uiGPz/1hryuXzyaBhSk6dnIyyG2683olG2OV+UUgs=
-github.com/jackc/pgtype v1.11.0/go.mod h1:LUMuVrfsFfdKGLw+AFFVv6KtHOFMwRgDDzBt76IqCA4=
-github.com/jackc/pgx/v4 v4.0.0-20190420224344-cc3461e65d96/go.mod h1:mdxmSJJuR08CZQyj1PVQBHy9XOp5p8/SHH6a0psbY9Y=
-github.com/jackc/pgx/v4 v4.0.0-20190421002000-1b8f0016e912/go.mod h1:no/Y67Jkk/9WuGR0JG/JseM9irFbnEPbuWV2EELPNuM=
-github.com/jackc/pgx/v4 v4.0.0-pre1.0.20190824185557-6972a5742186/go.mod h1:X+GQnOEnf1dqHGpw7JmHqHc1NxDoalibchSk9/RWuDc=
-github.com/jackc/pgx/v4 v4.12.1-0.20210724153913-640aa07df17c/go.mod h1:1QD0+tgSXP7iUjYm9C1NxKhny7lq6ee99u/z+IHFcgs=
-github.com/jackc/pgx/v4 v4.16.1 h1:JzTglcal01DrghUqt+PmzWsZx/Yh7SC/CTQmSBMTd0Y=
-github.com/jackc/pgx/v4 v4.16.1/go.mod h1:SIhx0D5hoADaiXZVyv+3gSm3LCIIINTVO0PficsvWGQ=
-github.com/jackc/puddle v0.0.0-20190413234325-e4ced69a3a2b/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
-github.com/jackc/puddle v0.0.0-20190608224051-11cab39313c9/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
-github.com/jackc/puddle v1.1.3/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
-github.com/jackc/puddle v1.2.1/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
+github.com/jackc/pgservicefile v0.0.0-20231201235250-de7065d80cb9 h1:L0QtFUgDarD7Fpv9jeVMgy/+Ec0mtnmYuImjTz6dtDA=
+github.com/jackc/pgservicefile v0.0.0-20231201235250-de7065d80cb9/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
+github.com/jackc/pgx/v5 v5.5.5 h1:amBjrZVmksIdNjxGW/IiIMzxMKZFelXbUoPNb+8sjQw=
+github.com/jackc/pgx/v5 v5.5.5/go.mod h1:ez9gk+OAat140fv9ErkZDYFWmXLfV+++K0uAOiwgm1A=
+github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
+github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
 github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
 github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
 github.com/jinzhu/now v1.1.4/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
 github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
 github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
-github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
-github.com/klauspost/compress v1.15.6 h1:6D9PcO8QWu0JyaQ2zUMmu16T1T+zjjEpP91guRsvDfY=
-github.com/klauspost/compress v1.15.6/go.mod h1:PhcZ0MbTNciWF3rruxRgKxI5NkcHHrHUDtV4Yw2GlzU=
-github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/pty v1.1.8/go.mod h1:O1sed60cT9XZ5uDucP5qwvh+TE3NnUj51EiZO/lmSfw=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
-github.com/lib/pq v1.1.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
-github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
-github.com/lib/pq v1.10.2 h1:AqzbZs4ZoCBp+GtejcpCpcxM3zlSMx29dXbUSeVtJb8=
-github.com/lib/pq v1.10.2/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
-github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ=
-github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
-github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
-github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
-github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
-github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc=
-github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
-github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE=
-github.com/onsi/gomega v1.18.1 h1:M1GfJqGRrBrrGGsbxzV5dqM2U2ApXefZCQpkukxYRLE=
-github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/klauspost/compress v1.17.8 h1:YcnTYrq7MikUT7k0Yb5eceMmALQPYBW/Xltxn0NAMnU=
+github.com/klauspost/compress v1.17.8/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
+github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM=
+github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
+github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
+github.com/mattn/go-sqlite3 v1.14.15/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg=
+github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y=
+github.com/mattn/go-sqlite3 v1.14.16/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg=
+github.com/microsoft/go-mssqldb v0.17.0 h1:Fto83dMZPnYv1Zwx5vHHxpNraeEaUlQ/hhHLgZiaenE=
+github.com/microsoft/go-mssqldb v0.17.0/go.mod h1:OkoNGhGEs8EZqchVTtochlXruEhEOaO4S0d2sB5aeGQ=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/montanaflynn/stats v0.7.1 h1:etflOAAHORrCC44V+aR6Ftzort912ZU+YLiSTuV8eaE=
+github.com/montanaflynn/stats v0.7.1/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
-github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ=
-github.com/rs/zerolog v1.13.0/go.mod h1:YbFCdg8HfsridGWAh22vktObvhZbQsZXe4/zB0OKkWU=
-github.com/rs/zerolog v1.15.0/go.mod h1:xYTKnLHcpfU2225ny5qZjxnj9NvkumZYjJHlAThCjNc=
-github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
-github.com/shopspring/decimal v0.0.0-20180709203117-cd690d0c9e24/go.mod h1:M+9NzErvs504Cn4c5DxATwIqPbtswREoFCre64PpcG4=
-github.com/shopspring/decimal v1.2.0 h1:abSATXmQEYyShuxI4/vyW3tV1MrKAJzCZ/0zLUXYbsQ=
-github.com/shopspring/decimal v1.2.0/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o=
-github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q=
-github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
-github.com/sirupsen/logrus v1.8.1 h1:dJKuHgqk1NNQlqoA6BTlM1Wf9DOH3NBjQyu0h9+AZZE=
-github.com/sirupsen/logrus v1.8.1/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
+github.com/redis/go-redis/v9 v9.5.1 h1:H1X4D3yHPaYrkL5X06Wh6xNVM/pX0Ft4RV0vMGvLBh8=
+github.com/redis/go-redis/v9 v9.5.1/go.mod h1:hdY0cQFCN4fnSYT6TkisLufl/4W5UIXyv0b/CLO2V2M=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
-github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/tidwall/pretty v1.0.0 h1:HsD+QiTn7sK6flMKIvNmpqz1qrpP3Ps6jOKIKMooyg4=
-github.com/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
+github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
 github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c=
 github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI=
-github.com/xdg-go/scram v1.0.2/go.mod h1:1WAq6h33pAW+iRreB34OORO2Nf7qel3VV3fjBj+hCSs=
-github.com/xdg-go/scram v1.1.1 h1:VOMT+81stJgXW3CpHyqHN3AXDYIMsx56mEFrB37Mb/E=
-github.com/xdg-go/scram v1.1.1/go.mod h1:RaEWvsqvNKKvBPvcKeFjrG2cJqOkHTiyTpzz23ni57g=
-github.com/xdg-go/stringprep v1.0.2/go.mod h1:8F9zXuvzgwmyT5DUm4GUfZGDdT3W+LCvS6+da4O5kxM=
-github.com/xdg-go/stringprep v1.0.3 h1:kdwGpVNwPFtjs98xCGkHjQtGKh86rDcRZN17QEMCOIs=
-github.com/xdg-go/stringprep v1.0.3/go.mod h1:W3f5j4i+9rC0kuIEJL0ky1VpHXQU3ocBgklLGvcBnW8=
-github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d/go.mod h1:rHwXgn7JulP+udvsHwJoVG1YGAP6VLg4y9I5dyZdqmA=
-github.com/youmark/pkcs8 v0.0.0-20201027041543-1326539a0a0a h1:fZHgsYlfvtyqToslyjUt3VOPF4J7aK/3MPcK7xp3PDk=
-github.com/youmark/pkcs8 v0.0.0-20201027041543-1326539a0a0a/go.mod h1:ul22v+Nro/R083muKhosV54bj5niojjWZvU8xrevuH4=
-github.com/zenazn/goji v0.9.0/go.mod h1:7S9M489iMyHBNxwZnk9/EHS098H4/F6TATF2mIxtB1Q=
-go.mongodb.org/mongo-driver v1.9.1 h1:m078y9v7sBItkt1aaoe2YlvWEXcD263e1a4E1fBrJ1c=
-go.mongodb.org/mongo-driver v1.9.1/go.mod h1:0sQWfOeY63QTntERDJJ/0SuKK0T1uVSgKCuAROlKEPY=
-go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
-go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
-go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
-go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
-go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
-go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4=
-go.uber.org/multierr v1.5.0/go.mod h1:FeouvMocqHpRaaGuG9EjoKcStLC43Zu/fmqdUMPcKYU=
-go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA=
-go.uber.org/zap v1.9.1/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
-go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
-go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM=
+github.com/xdg-go/scram v1.1.2 h1:FHX5I5B4i4hKRVRBCFRxq1iQRej7WO3hhBuJf+UUySY=
+github.com/xdg-go/scram v1.1.2/go.mod h1:RT/sEzTbU5y00aCK8UOx6R7YryM0iF1N2MOmC3kKLN4=
+github.com/xdg-go/stringprep v1.0.4 h1:XLI/Ng3O1Atzq0oBs3TWm+5ZVgkq2aqdlvP9JtoZ6c8=
+github.com/xdg-go/stringprep v1.0.4/go.mod h1:mPGuuIYwz7CmR2bT9j4GbQqutWS1zV24gijq1dTyGkM=
+github.com/youmark/pkcs8 v0.0.0-20240424034433-3c2c7870ae76 h1:tBiBTKHnIjovYoLX/TPkcf+OjqqKGQrPtGT3Foz+Pgo=
+github.com/youmark/pkcs8 v0.0.0-20240424034433-3c2c7870ae76/go.mod h1:SQliXeA7Dhkt//vS29v3zpbEwoa+zb2Cn5xj5uO4K5U=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+go.dtapp.net/gojson v1.0.4 h1:9en9iyOOLWoEIo2eKhqt3/Djh/3HhwsTpXxgI9efPRo=
+go.dtapp.net/gojson v1.0.4/go.mod h1:G9CMVzNSRkbNzIic/vJqHCOyKtw6BW2YM8Vyn64zfM0=
+go.dtapp.net/gotime v1.0.8 h1:ngKBp7j3Ime1t2jU94gUeshPX1StV5E2x4STlzDMmLU=
+go.dtapp.net/gotime v1.0.8/go.mod h1:BQT911XSfaJDBYPiEKGFwMjvgnZtx1F3nWu4GTg5ISY=
+go.mongodb.org/mongo-driver v1.15.0 h1:rJCKC8eEliewXjZGf0ddURtl7tTVy1TK3bfl0gkUSLc=
+go.mongodb.org/mongo-driver v1.15.0/go.mod h1:Vzb0Mk/pa7e6cWw85R4F/endUC3u0U9jGcNU603k65c=
+golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/arch v0.7.0 h1:pskyeJh/3AmoQ8CPE95vxHLqp1G1GfGNXTmcl9NEKTc=
+golang.org/x/arch v0.7.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20190411191339-88737f569e3a/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE=
-golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20201203163018-be400aefbc4c/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
-golang.org/x/crypto v0.0.0-20201216223049-8b5274cf687f/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
-golang.org/x/crypto v0.0.0-20210616213533-5ff15b29337e/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e h1:T8NU3HyQ8ClP4SEE+KbFlg6n0NhuTsN4MyznaarGsZM=
-golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
-golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/crypto v0.22.0 h1:g1v0xeRhjcugydODzvb3mEM9SQ0HGp9s/nh3COQ/C30=
+golang.org/x/crypto v0.22.0/go.mod h1:vr6Su+7cTlO45qkww3VDJlzDn0ctJvRgYbC2NvXHt+M=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA=
+golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2 h1:CIJ76btIcR3eFI5EgSo6k1qKw9KJexJuRLI9G7Hp5wE=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.24.0 h1:1PcaxkF854Fu3+lvBIx5SYn9wRlBzzcnHZSiaFFAb0w=
+golang.org/x/net v0.24.0/go.mod h1:2Q7sJY5mzlzWjKtYUEXSlBWCdyaioyXzRB2RtU8KVE8=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f h1:Ax0t5p6N38Ga0dThY21weqDEyz2oklo4IvDkpigvkD8=
-golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
+golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c h1:aFV+BgZ4svzjfabn8ERpuB4JI4N6/rdy1iusx77G3oU=
-golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.19.0 h1:q5f1RH2jigJ1MoAWp2KTp3gm5zAGFUTarQZ5U386+4o=
+golang.org/x/sys v0.19.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190425163242-31fd60d6bfdc/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190531172133-b3315ee88b7d/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190823170909-c4a336ef6a2f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/xerrors v0.0.0-20190410155217-1f06c39b4373/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20190513163551-3ee3066db522/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.20.0 h1:hz/CVckiOxybQvFw6h7b/q80NTr9IUQb4s1IIzW7KNY=
+golang.org/x/tools v0.20.0/go.mod h1:WvitBU7JJf6A4jOdg4S1tviW9bhUxkgeCui/0JHctQg=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-gopkg.in/inconshreveable/log15.v2 v2.0.0-20180818164646-67afb5ed74ec/go.mod h1:aPpfJ7XW+gOuirDoZ8gHhLh3kZ1B08FtV2bbmy7Jv3s=
-gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gorm.io/driver/mysql v1.3.4 h1:/KoBMgsUHC3bExsekDcmNYaBnfH2WNeFuXqqrqMc98Q=
-gorm.io/driver/mysql v1.3.4/go.mod h1:s4Tq0KmD0yhPGHbZEwg1VPlH0vT/GBHJZorPzhcxBUE=
-gorm.io/driver/postgres v1.3.7 h1:FKF6sIMDHDEvvMF/XJvbnCl0nu6KSKUaPXevJ4r+VYQ=
-gorm.io/driver/postgres v1.3.7/go.mod h1:f02ympjIcgtHEGFMZvdgTxODZ9snAHDb4hXfigBVuNI=
-gorm.io/gorm v1.23.4/go.mod h1:l2lP/RyAtc1ynaTjFksBde/O8v9oOGIApu2/xRitmZk=
-gorm.io/gorm v1.23.6 h1:KFLdNgri4ExFFGTRGGFWON2P1ZN28+9SJRN8voOoYe0=
-gorm.io/gorm v1.23.6/go.mod h1:l2lP/RyAtc1ynaTjFksBde/O8v9oOGIApu2/xRitmZk=
-honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gorm.io/datatypes v1.2.0 h1:5YT+eokWdIxhJgWHdrb2zYUimyk0+TaFth+7a0ybzco=
+gorm.io/datatypes v1.2.0/go.mod h1:o1dh0ZvjIjhH/bngTpypG6lVRJ5chTBxE09FH/71k04=
+gorm.io/driver/mysql v1.4.3/go.mod h1:sSIebwZAVPiT+27jK9HIwvsqOGKx3YMPmrA3mBJR10c=
+gorm.io/driver/mysql v1.5.6 h1:Ld4mkIickM+EliaQZQx3uOJDJHtrd70MxAUqWqlx3Y8=
+gorm.io/driver/mysql v1.5.6/go.mod h1:sEtPWMiqiN1N1cMXoXmBbd8C6/l+TESwriotuRRpkDM=
+gorm.io/driver/postgres v1.5.7 h1:8ptbNJTDbEmhdr62uReG5BGkdQyeasu/FZHxI0IMGnM=
+gorm.io/driver/postgres v1.5.7/go.mod h1:3e019WlBaYI5o5LIdNV+LyxCMNtLOQETBXL2h4chKpA=
+gorm.io/driver/sqlite v1.5.0 h1:zKYbzRCpBrT1bNijRnxLDJWPjVfImGEn0lSnUY5gZ+c=
+gorm.io/driver/sqlite v1.5.0/go.mod h1:kDMDfntV9u/vuMmz8APHtHF0b4nyBB7sfCieC6G8k8I=
+gorm.io/driver/sqlserver v1.4.1 h1:t4r4r6Jam5E6ejqP7N82qAJIJAht27EGT41HyPfXRw0=
+gorm.io/driver/sqlserver v1.4.1/go.mod h1:DJ4P+MeZbc5rvY58PnmN1Lnyvb5gw5NPzGshHDnJLig=
+gorm.io/gen v0.3.26 h1:sFf1j7vNStimPRRAtH4zz5NiHM+1dr6eA9aaRdplyhY=
+gorm.io/gen v0.3.26/go.mod h1:a5lq5y3w4g5LMxBcw0wnO6tYUCdNutWODq5LrIt75LE=
+gorm.io/gorm v1.23.8/go.mod h1:l2lP/RyAtc1ynaTjFksBde/O8v9oOGIApu2/xRitmZk=
+gorm.io/gorm v1.24.7-0.20230306060331-85eaf9eeda11/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k=
+gorm.io/gorm v1.25.0/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k=
+gorm.io/gorm v1.25.2/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k=
+gorm.io/gorm v1.25.7/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=
+gorm.io/gorm v1.25.10 h1:dQpO+33KalOA+aFYGlK+EfxcI5MbO7EP2yYygwh9h+s=
+gorm.io/gorm v1.25.10/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=
+gorm.io/hints v1.1.2 h1:b5j0kwk5p4+3BtDtYqqfY+ATSxjj+6ptPgVveuynn9o=
+gorm.io/hints v1.1.2/go.mod h1:/ARdpUHAtyEMCh5NNi3tI7FsGh+Cj/MIUlvNxCNCFWg=
+gorm.io/plugin/dbresolver v1.5.1 h1:s9Dj9f7r+1rE3nx/Ywzc85nXptUEaeOO0pt27xdopM8=
+gorm.io/plugin/dbresolver v1.5.1/go.mod h1:l4Cn87EHLEYuqUncpEeTC2tTJQkjngPSD+lo8hIvcT0=
+nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=
+rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=

goem_sql.go

@@ -0,0 +1,18 @@
+package dorm
+
+import "database/sql"
+
+// Ping ping
+func (c *GormClient) Ping() error {
+	return c.sqlDd.Ping()
+}
+
+// Close 关闭
+func (c *GormClient) Close() error {
+	return c.sqlDd.Close()
+}
+
+// Stats 返回数据库统计信息
+func (c *GormClient) Stats() sql.DBStats {
+	return c.sqlDd.Stats()
+}

gorm.go

@@ -1,132 +1,54 @@
 package dorm
 
 import (
-	"errors"
+	"database/sql"
 	"fmt"
 	"github.com/sirupsen/logrus"
-	"gorm.io/driver/mysql"
-	"gorm.io/driver/postgres"
 	"gorm.io/gorm"
-	"gorm.io/gorm/logger"
 	"os"
 	"path"
 	"time"
 )
 
-type ConfigGormClient struct {
-	Dns    string // 地址
-	Log    bool   // 日志
-	LogUrl string // 日志路径
+// GormClientFun *GormClient 驱动
+type GormClientFun func() *GormClient
+
+// GormClientTableFun
+// *GormClient 驱动
+// string 表名
+type GormClientTableFun func() (*GormClient, string)
+
+// GormClientConfig 配置
+type GormClientConfig struct {
+	Dns                    string // 地址
+	LogStatus              bool   // 日志 - 状态
+	LogPath                string // 日志 - 路径
+	LogSlow                int64  // 日志 - 慢SQL阈值
+	LogLevel               string // 日志 - 级别
+	ConnSetMaxIdle         int    // 连接 - 设置空闲连接池中连接的最大数量
+	ConnSetMaxOpen         int    // 连接 - 设置打开数据库连接的最大数量
+	ConnSetConnMaxLifetime int64  // 连接 - 设置了连接可复用的最大时间
 }
 
+// GormClient
+// https://gorm.io/zh_CN/docs/index.html
 type GormClient struct {
-	Db     *gorm.DB          // 驱动
-	config *ConfigGormClient // 配置
-}
-
-func NewGormMysqlClient(config *ConfigGormClient) (*GormClient, error) {
-
-	c := &GormClient{}
-	c.config = config
-
-	// 判断路径
-	if c.config.LogUrl == "" {
-		logsUrl = "/logs/mysql"
-	}
-
-	var err error
-
-	if c.config.Log == true {
-		c.Db, err = gorm.Open(mysql.Open(c.config.Dns), &gorm.Config{
-			Logger: logger.New(
-				writer{},
-				logger.Config{
-					SlowThreshold:             time.Second, // 慢 SQL 阈值
-					LogLevel:                  logger.Info, // 日志级别
-					IgnoreRecordNotFoundError: true,        // 忽略ErrRecordNotFound（记录未找到）错误
-					Colorful:                  false,       // 禁用彩色打印
-				},
-			),
-		})
-	} else {
-		c.Db, err = gorm.Open(mysql.Open(c.config.Dns), &gorm.Config{})
-	}
-
-	if err != nil {
-		return nil, errors.New(fmt.Sprintf("连接失败：%v", err))
-	}
-
-	sqlDB, err := c.Db.DB()
-	if err != nil {
-		return nil, errors.New(fmt.Sprintf("检查连接失败：%v", err))
-	}
-
-	sqlDB.SetMaxIdleConns(10)                   // 设置空闲连接池中连接的最大数量
-	sqlDB.SetMaxOpenConns(100)                  // 设置打开数据库连接的最大数量。
-	sqlDB.SetConnMaxLifetime(time.Second * 600) // 设置了连接可复用的最大时间。
-
-	return c, nil
-}
-
-func NewGormPostgresClient(config *ConfigGormClient) (*GormClient, error) {
-
-	c := &GormClient{}
-	c.config = config
-
-	// 判断路径
-	if c.config.LogUrl == "" {
-		logsUrl = "/logs/postgresql"
-	}
-
-	var err error
-
-	if c.config.Log == true {
-		c.Db, err = gorm.Open(postgres.Open(c.config.Dns), &gorm.Config{
-			Logger: logger.New(
-				writer{},
-				logger.Config{
-					SlowThreshold:             time.Second, // 慢 SQL 阈值
-					LogLevel:                  logger.Info, // 日志级别
-					IgnoreRecordNotFoundError: true,        // 忽略ErrRecordNotFound（记录未找到）错误
-					Colorful:                  false,       // 禁用彩色打印
-				},
-			),
-		})
-	} else {
-		c.Db, err = gorm.Open(postgres.Open(c.config.Dns), &gorm.Config{})
-	}
-
-	if err != nil {
-		return nil, errors.New(fmt.Sprintf("连接失败：%v", err))
-	}
-
-	sqlDB, err := c.Db.DB()
-	if err != nil {
-		return nil, errors.New(fmt.Sprintf("检查连接失败：%v", err))
-	}
-
-	sqlDB.SetMaxIdleConns(10)                   // 设置空闲连接池中连接的最大数量
-	sqlDB.SetMaxOpenConns(100)                  // 设置打开数据库连接的最大数量。
-	sqlDB.SetConnMaxLifetime(time.Second * 600) // 设置了连接可复用的最大时间。
-
-	return c, nil
-}
-
-func (c *GormClient) GetDb() *gorm.DB {
-	return c.Db
+	db     *gorm.DB          // 驱动
+	config *GormClientConfig // 配置
+	sqlDd  *sql.DB
 }
 
 type writer struct{}
 
 // 日志路径
-var logsUrl = ""
+var logsURL = ""
 
 func (w writer) Printf(format string, args ...interface{}) {
 
 	now := time.Now()
 	logFilePath := ""
 	if dir, err := os.Getwd(); err == nil {
-		logFilePath = dir + logsUrl
+		logFilePath = dir + logsURL
 	}
 	if err := os.MkdirAll(logFilePath, 0777); err != nil {
 		fmt.Println(err.Error())

gorm_error.go

@@ -0,0 +1,8 @@
+package dorm
+
+import "gorm.io/gorm"
+
+var (
+	// GormNotFound 没有数据
+	GormNotFound = gorm.ErrRecordNotFound
+)

gorm_gen.go

@@ -0,0 +1,29 @@
+package dorm
+
+import (
+	"gorm.io/gen"
+	"gorm.io/gorm"
+)
+
+// GormGenClientFun *GormClient 驱动
+type GormGenClientFun func() *GormGenClient
+
+// GormGenClientTableFun
+// *GormClient 驱动
+// string 表名
+type GormGenClientTableFun func() (*GormGenClient, string)
+
+// GormGenClientConfig 配置
+type GormGenClientConfig struct {
+	Dns    string     // dns地址
+	Db     *gorm.DB   // db驱动
+	Config gen.Config // gen配置
+}
+
+// GormGenClient
+// https://gorm.io/zh_CN/gen/index.html
+type GormGenClient struct {
+	db        *gorm.DB             // 驱动
+	generator *gen.Generator       // 驱动
+	config    *GormGenClientConfig // 配置
+}

gorm_gen_get.go

@@ -0,0 +1,16 @@
+package dorm
+
+import (
+	"gorm.io/gen"
+	"gorm.io/gorm"
+)
+
+// GetDb 获取驱动
+func (c *GormGenClient) GetDb() *gorm.DB {
+	return c.db
+}
+
+// GetGenerator 获取驱动
+func (c *GormGenClient) GetGenerator() *gen.Generator {
+	return c.generator
+}

gorm_gen_mysql.go

@@ -0,0 +1,25 @@
+package dorm
+
+import (
+	"context"
+	"gorm.io/driver/mysql"
+	"gorm.io/gen"
+	"gorm.io/gorm"
+)
+
+// NewGormGenMysqlClient 创建GormGenClient实例 mysql
+func NewGormGenMysqlClient(ctx context.Context, config *GormGenClientConfig) (*GormGenClient, error) {
+
+	c := &GormGenClient{config: config}
+
+	c.generator = gen.NewGenerator(config.Config)
+
+	if c.config.Dns != "" {
+		c.db, _ = gorm.Open(mysql.Open(c.config.Dns), &gorm.Config{})
+		c.generator.UseDB(c.db)
+	} else {
+		c.generator.UseDB(c.config.Db)
+	}
+
+	return c, nil
+}

gorm_gen_postgres.go

@@ -0,0 +1,25 @@
+package dorm
+
+import (
+	"context"
+	"gorm.io/driver/postgres"
+	"gorm.io/gen"
+	"gorm.io/gorm"
+)
+
+// NewGormGenPostgresClient 创建GormGenClient实例 postgres
+func NewGormGenPostgresClient(ctx context.Context, config *GormGenClientConfig) (*GormGenClient, error) {
+
+	c := &GormGenClient{config: config}
+
+	c.generator = gen.NewGenerator(config.Config)
+
+	if c.config.Dns != "" {
+		c.db, _ = gorm.Open(postgres.Open(c.config.Dns), &gorm.Config{})
+		c.generator.UseDB(c.db)
+	} else {
+		c.generator.UseDB(c.config.Db)
+	}
+
+	return c, nil
+}

gorm_gen_postgresql.go

@@ -0,0 +1,25 @@
+package dorm
+
+import (
+	"context"
+	"gorm.io/driver/postgres"
+	"gorm.io/gen"
+	"gorm.io/gorm"
+)
+
+// NewGormGenPostgresqlClient 创建GormGenClient实例 postgresql
+func NewGormGenPostgresqlClient(ctx context.Context, config *GormGenClientConfig) (*GormGenClient, error) {
+
+	c := &GormGenClient{config: config}
+
+	c.generator = gen.NewGenerator(config.Config)
+
+	if c.config.Dns != "" {
+		c.db, _ = gorm.Open(postgres.Open(c.config.Dns), &gorm.Config{})
+		c.generator.UseDB(c.db)
+	} else {
+		c.generator.UseDB(c.config.Db)
+	}
+
+	return c, nil
+}

gorm_get.go

@@ -0,0 +1,16 @@
+package dorm
+
+import (
+	"database/sql"
+	"gorm.io/gorm"
+)
+
+// GetDb 获取驱动
+func (c *GormClient) GetDb() *gorm.DB {
+	return c.db
+}
+
+// GetSqlDb 获取驱动
+func (c *GormClient) GetSqlDb() *sql.DB {
+	return c.sqlDd
+}

gorm_mysql.go

@@ -0,0 +1,91 @@
+package dorm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"go.dtapp.net/gotime"
+	"gorm.io/driver/mysql"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+	"time"
+)
+
+// NewGormMysqlClient 创建GormClient实例 mysql
+func NewGormMysqlClient(ctx context.Context, config *GormClientConfig) (*GormClient, error) {
+
+	var err error
+	c := &GormClient{config: config}
+
+	// 判断路径
+	if c.config.LogPath == "" {
+		logsURL = "/logs/mysql"
+	} else {
+		logsURL = c.config.LogPath
+	}
+
+	if c.config.LogStatus {
+		var slowThreshold time.Duration
+		var logLevel logger.LogLevel
+		if c.config.LogSlow == 0 {
+			slowThreshold = 100 * time.Millisecond
+		} else {
+			slowThreshold = time.Duration(c.config.LogSlow)
+		}
+		if c.config.LogLevel == "Error" {
+			logLevel = logger.Error
+		} else if c.config.LogLevel == "Warn" {
+			logLevel = logger.Warn
+		} else {
+			logLevel = logger.Info
+		}
+		c.db, err = gorm.Open(mysql.Open(c.config.Dns), &gorm.Config{
+			Logger: logger.New(
+				writer{},
+				logger.Config{
+					SlowThreshold:             slowThreshold, // 慢SQL阈值
+					LogLevel:                  logLevel,      // 日志级别
+					IgnoreRecordNotFoundError: true,          // 忽略ErrRecordNotFound（记录未找到）错误
+					Colorful:                  true,          // 禁用彩色打印
+				},
+			),
+			NowFunc: func() time.Time {
+				return gotime.Current().Now().Local()
+			},
+		})
+	} else {
+		c.db, err = gorm.Open(mysql.Open(c.config.Dns), &gorm.Config{})
+	}
+
+	if err != nil {
+		return nil, errors.New(fmt.Sprintf("连接失败：%v", err))
+	}
+
+	c.sqlDd, err = c.db.DB()
+	if err != nil {
+		return nil, errors.New(fmt.Sprintf("获取通用数据库对象失败：%v", err))
+	}
+
+	// 设置空闲连接池中连接的最大数量
+	if c.config.ConnSetMaxIdle == 0 {
+		c.sqlDd.SetMaxIdleConns(10)
+	} else {
+		c.sqlDd.SetMaxIdleConns(c.config.ConnSetMaxIdle)
+	}
+
+	// 设置打开数据库连接的最大数量
+	if c.config.ConnSetMaxOpen == 0 {
+		c.sqlDd.SetMaxOpenConns(100)
+	} else {
+		c.sqlDd.SetMaxOpenConns(c.config.ConnSetMaxOpen)
+	}
+
+	// 设置了连接可复用的最大时间
+	if c.config.ConnSetConnMaxLifetime == 0 {
+		c.sqlDd.SetConnMaxLifetime(time.Second * 600)
+	} else {
+		c.sqlDd.SetConnMaxLifetime(time.Duration(c.config.ConnSetConnMaxLifetime))
+	}
+
+	return c, nil
+}

gorm_postgres.go

@@ -0,0 +1,92 @@
+package dorm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"go.dtapp.net/gotime"
+	"gorm.io/driver/postgres"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+	"time"
+)
+
+// NewGormPostgresClient 创建GormClient实例 postgres
+func NewGormPostgresClient(ctx context.Context, config *GormClientConfig) (*GormClient, error) {
+
+	var err error
+	c := &GormClient{}
+	c.config = config
+
+	// 判断路径
+	if c.config.LogPath == "" {
+		logsURL = "/logs/postgresql"
+	} else {
+		logsURL = c.config.LogPath
+	}
+
+	if c.config.LogStatus {
+		var slowThreshold time.Duration
+		var logLevel logger.LogLevel
+		if c.config.LogSlow == 0 {
+			slowThreshold = 100 * time.Millisecond
+		} else {
+			slowThreshold = time.Duration(c.config.LogSlow)
+		}
+		if c.config.LogLevel == "Error" {
+			logLevel = logger.Error
+		} else if c.config.LogLevel == "Warn" {
+			logLevel = logger.Warn
+		} else {
+			logLevel = logger.Info
+		}
+		c.db, err = gorm.Open(postgres.Open(c.config.Dns), &gorm.Config{
+			Logger: logger.New(
+				writer{},
+				logger.Config{
+					SlowThreshold:             slowThreshold, // 慢SQL阈值
+					LogLevel:                  logLevel,      // 日志级别
+					IgnoreRecordNotFoundError: true,          // 忽略ErrRecordNotFound（记录未找到）错误
+					Colorful:                  true,          // 禁用彩色打印
+				},
+			),
+			NowFunc: func() time.Time {
+				return gotime.Current().Now().Local()
+			},
+		})
+	} else {
+		c.db, err = gorm.Open(postgres.Open(c.config.Dns), &gorm.Config{})
+	}
+
+	if err != nil {
+		return nil, errors.New(fmt.Sprintf("连接失败：%v", err))
+	}
+
+	c.sqlDd, err = c.db.DB()
+	if err != nil {
+		return nil, errors.New(fmt.Sprintf("获取通用数据库对象失败：%v", err))
+	}
+
+	// 设置空闲连接池中连接的最大数量
+	if c.config.ConnSetMaxIdle == 0 {
+		c.sqlDd.SetMaxIdleConns(10)
+	} else {
+		c.sqlDd.SetMaxIdleConns(c.config.ConnSetMaxIdle)
+	}
+
+	// 设置打开数据库连接的最大数量
+	if c.config.ConnSetMaxOpen == 0 {
+		c.sqlDd.SetMaxOpenConns(100)
+	} else {
+		c.sqlDd.SetMaxOpenConns(c.config.ConnSetMaxOpen)
+	}
+
+	// 设置了连接可复用的最大时间
+	if c.config.ConnSetConnMaxLifetime == 0 {
+		c.sqlDd.SetConnMaxLifetime(time.Hour)
+	} else {
+		c.sqlDd.SetConnMaxLifetime(time.Duration(c.config.ConnSetConnMaxLifetime))
+	}
+
+	return c, nil
+}

gorm_postgresql.go

@@ -0,0 +1,92 @@
+package dorm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"go.dtapp.net/gotime"
+	"gorm.io/driver/postgres"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+	"time"
+)
+
+// NewGormPostgresqlClient 创建GormClient实例 postgresql
+func NewGormPostgresqlClient(ctx context.Context, config *GormClientConfig) (*GormClient, error) {
+
+	var err error
+	c := &GormClient{}
+	c.config = config
+
+	// 判断路径
+	if c.config.LogPath == "" {
+		logsURL = "/logs/postgresql"
+	} else {
+		logsURL = c.config.LogPath
+	}
+
+	if c.config.LogStatus {
+		var slowThreshold time.Duration
+		var logLevel logger.LogLevel
+		if c.config.LogSlow == 0 {
+			slowThreshold = 100 * time.Millisecond
+		} else {
+			slowThreshold = time.Duration(c.config.LogSlow)
+		}
+		if c.config.LogLevel == "Error" {
+			logLevel = logger.Error
+		} else if c.config.LogLevel == "Warn" {
+			logLevel = logger.Warn
+		} else {
+			logLevel = logger.Info
+		}
+		c.db, err = gorm.Open(postgres.Open(c.config.Dns), &gorm.Config{
+			Logger: logger.New(
+				writer{},
+				logger.Config{
+					SlowThreshold:             slowThreshold, // 慢SQL阈值
+					LogLevel:                  logLevel,      // 日志级别
+					IgnoreRecordNotFoundError: true,          // 忽略ErrRecordNotFound（记录未找到）错误
+					Colorful:                  true,          // 禁用彩色打印
+				},
+			),
+			NowFunc: func() time.Time {
+				return gotime.Current().Now().Local()
+			},
+		})
+	} else {
+		c.db, err = gorm.Open(postgres.Open(c.config.Dns), &gorm.Config{})
+	}
+
+	if err != nil {
+		return nil, errors.New(fmt.Sprintf("连接失败：%v", err))
+	}
+
+	c.sqlDd, err = c.db.DB()
+	if err != nil {
+		return nil, errors.New(fmt.Sprintf("获取通用数据库对象失败：%v", err))
+	}
+
+	// 设置空闲连接池中连接的最大数量
+	if c.config.ConnSetMaxIdle == 0 {
+		c.sqlDd.SetMaxIdleConns(10)
+	} else {
+		c.sqlDd.SetMaxIdleConns(c.config.ConnSetMaxIdle)
+	}
+
+	// 设置打开数据库连接的最大数量
+	if c.config.ConnSetMaxOpen == 0 {
+		c.sqlDd.SetMaxOpenConns(100)
+	} else {
+		c.sqlDd.SetMaxOpenConns(c.config.ConnSetMaxOpen)
+	}
+
+	// 设置了连接可复用的最大时间
+	if c.config.ConnSetConnMaxLifetime == 0 {
+		c.sqlDd.SetConnMaxLifetime(time.Hour)
+	} else {
+		c.sqlDd.SetConnMaxLifetime(time.Duration(c.config.ConnSetConnMaxLifetime))
+	}
+
+	return c, nil
+}

gorm_transaction.go

@@ -0,0 +1,18 @@
+package dorm
+
+import "gorm.io/gorm"
+
+// Begin 开始事务，不需要创建 Session 对象
+func (c *GormClient) Begin() *gorm.DB {
+	return c.db.Begin()
+}
+
+// Rollback 回滚事务
+func (c *GormClient) Rollback() *gorm.DB {
+	return c.db.Rollback()
+}
+
+// Commit 提交事务
+func (c *GormClient) Commit() *gorm.DB {
+	return c.db.Commit()
+}

mongo.go

@@ -8,28 +8,52 @@ import (
 	"go.mongodb.org/mongo-driver/mongo/options"
 )
 
-type ConfigMongoClient struct {
-	Dns string // 地址
+// MongoClientFun *MongoClient 驱动
+// string 库名
+type MongoClientFun func() (*MongoClient, string)
+
+// MongoClientCollectionFun
+// *MongoClient 驱动
+// string 库名
+// string 集合
+type MongoClientCollectionFun func() (*MongoClient, string, string)
+
+// MongoClientConfig 实例配置
+type MongoClientConfig struct {
+	Dns          string // 地址
+	Opts         *options.ClientOptions
+	DatabaseName string // 库名
 }
 
+// MongoClient 实例
 type MongoClient struct {
-	Db     *mongo.Client      // 驱动
-	config *ConfigMongoClient // 配置
+	db                 *mongo.Client // 驱动
+	configDatabaseName string        // 库名
 }
 
-func NewMongoClient(config *ConfigMongoClient) (*MongoClient, error) {
+// NewMongoClient 创建实例
+func NewMongoClient(ctx context.Context, config *MongoClientConfig) (*MongoClient, error) {
 
+	var err error
 	c := &MongoClient{}
-	c.config = config
+
+	c.configDatabaseName = config.DatabaseName
 
 	// 连接到MongoDB
-	db, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(c.config.Dns))
-	if err != nil {
-		return nil, errors.New(fmt.Sprintf("连接失败：%v", err))
+	if config.Dns != "" {
+		c.db, err = mongo.Connect(ctx, options.Client().ApplyURI(config.Dns))
+		if err != nil {
+			return nil, errors.New(fmt.Sprintf("连接失败：%v", err))
+		}
+	} else {
+		c.db, err = mongo.Connect(ctx, config.Opts)
+		if err != nil {
+			return nil, errors.New(fmt.Sprintf("连接失败：%v", err))
+		}
 	}
 
 	// 检查连接
-	err = db.Ping(context.TODO(), nil)
+	err = c.db.Ping(ctx, nil)
 	if err != nil {
 		return nil, errors.New(fmt.Sprintf("检查连接失败：%v", err))
 	}
@@ -37,15 +61,7 @@ func NewMongoClient(config *ConfigMongoClient) (*MongoClient, error) {
 	return c, nil
 }
 
-func (c *MongoClient) GetDb() *mongo.Client {
-	return c.Db
-}
-
 // Close 关闭
-func (c *MongoClient) Close() error {
-	err := c.Db.Disconnect(context.TODO())
-	if err != nil {
-		return errors.New(fmt.Sprintf("关闭失败：%v", err))
-	}
-	return nil
+func (c *MongoClient) Close(ctx context.Context) error {
+	return c.db.Disconnect(ctx)
 }

mongo_collection.go

@@ -0,0 +1,60 @@
+package dorm
+
+import (
+	"context"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+type MongoCollectionOptions struct {
+	db                 *mongo.Client     // 驱动
+	configDatabaseName string            // 库名
+	dbCollection       *mongo.Collection // 集合
+}
+
+// Collection 选择集合
+func (cd *MongoDatabaseOptions) Collection(name string, opts ...*options.CollectionOptions) *MongoCollectionOptions {
+	return &MongoCollectionOptions{
+		db:                 cd.db,                                   // 驱动
+		configDatabaseName: cd.configDatabaseName,                   // 库名
+		dbCollection:       cd.dbDatabase.Collection(name, opts...), // 集合
+	}
+}
+
+// CreateOneIndexes 创建一个索引
+func (cc *MongoCollectionOptions) CreateOneIndexes(ctx context.Context, key string, value string) (string, error) {
+	return cc.dbCollection.Indexes().CreateOne(ctx, mongo.IndexModel{
+		Keys: bson.D{{
+			Key:   key,
+			Value: value,
+		}},
+	})
+}
+
+// CreateOneUniqueIndexes 创建一个唯一索引
+func (cc *MongoCollectionOptions) CreateOneUniqueIndexes(ctx context.Context, key string, value string) (string, error) {
+	return cc.dbCollection.Indexes().CreateOne(ctx, mongo.IndexModel{
+		Keys: bson.D{{
+			Key:   key,
+			Value: value,
+		}},
+		Options: options.Index().SetUnique(true),
+	})
+}
+
+// CreateOneUniqueIndexesOpts 创建一个索引
+func (cc *MongoCollectionOptions) CreateOneUniqueIndexesOpts(ctx context.Context, key string, value string, opts *options.IndexOptions) (string, error) {
+	return cc.dbCollection.Indexes().CreateOne(ctx, mongo.IndexModel{
+		Keys: bson.D{{
+			Key:   key,
+			Value: value,
+		}},
+		Options: opts,
+	})
+}
+
+// CreateManyIndexes 创建多个索引
+func (cc *MongoCollectionOptions) CreateManyIndexes(ctx context.Context, models []mongo.IndexModel) ([]string, error) {
+	return cc.dbCollection.Indexes().CreateMany(ctx, models)
+}

mongo_collection_curd.go

@@ -0,0 +1,100 @@
+package dorm
+
+import (
+	"context"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+// InsertOne 插入一个文档
+func (cc *MongoCollectionOptions) InsertOne(ctx context.Context, document interface{}, opts ...*options.InsertOneOptions) (*mongo.InsertOneResult, error) {
+	return cc.dbCollection.InsertOne(ctx, document, opts...)
+}
+
+// InsertMany 插入多个文档
+func (cc *MongoCollectionOptions) InsertMany(ctx context.Context, document []interface{}, opts ...*options.InsertManyOptions) (*mongo.InsertManyResult, error) {
+	return cc.dbCollection.InsertMany(ctx, document, opts...)
+}
+
+// DeleteOne 删除一个文档
+func (cc *MongoCollectionOptions) DeleteOne(ctx context.Context, filter interface{}, opts ...*options.DeleteOptions) (*mongo.DeleteResult, error) {
+	return cc.dbCollection.DeleteOne(ctx, filter, opts...)
+}
+
+// DeleteMany 删除多个文档
+func (cc *MongoCollectionOptions) DeleteMany(ctx context.Context, filter interface{}, opts ...*options.DeleteOptions) (*mongo.DeleteResult, error) {
+	return cc.dbCollection.DeleteMany(ctx, filter, opts...)
+}
+
+// UpdateByID 按ID更新
+func (cc *MongoCollectionOptions) UpdateByID(ctx context.Context, id interface{}, update interface{}, opts ...*options.UpdateOptions) (*mongo.UpdateResult, error) {
+	return cc.dbCollection.UpdateByID(ctx, id, update, opts...)
+}
+
+// UpdateOne 更新一个文档
+func (cc *MongoCollectionOptions) UpdateOne(ctx context.Context, filter interface{}, update interface{}, opts ...*options.UpdateOptions) (*mongo.UpdateResult, error) {
+	return cc.dbCollection.UpdateOne(ctx, filter, update, opts...)
+}
+
+// UpdateMany 更新多个文档
+func (cc *MongoCollectionOptions) UpdateMany(ctx context.Context, filter interface{}, update interface{}, opts ...*options.UpdateOptions) (*mongo.UpdateResult, error) {
+	return cc.dbCollection.UpdateMany(ctx, filter, update, opts...)
+}
+
+// ReplaceOne 替换一个文档
+func (cc *MongoCollectionOptions) ReplaceOne(ctx context.Context, filter interface{}, update interface{}, opts ...*options.ReplaceOptions) (*mongo.UpdateResult, error) {
+	return cc.dbCollection.ReplaceOne(ctx, filter, update, opts...)
+}
+
+// Aggregate 统计分析
+func (cc *MongoCollectionOptions) Aggregate(ctx context.Context, pipeline interface{}, opts ...*options.AggregateOptions) (*mongo.Cursor, error) {
+	return cc.dbCollection.Aggregate(ctx, pipeline, opts...)
+}
+
+// CountDocuments 计数文档
+func (cc *MongoCollectionOptions) CountDocuments(ctx context.Context, filter interface{}, opts ...*options.CountOptions) (int64, error) {
+	return cc.dbCollection.CountDocuments(ctx, filter, opts...)
+}
+
+// EstimatedDocumentCount 估计文档计数
+func (cc *MongoCollectionOptions) EstimatedDocumentCount(ctx context.Context, opts ...*options.EstimatedDocumentCountOptions) (int64, error) {
+	return cc.dbCollection.EstimatedDocumentCount(ctx, opts...)
+}
+
+func (cc *MongoCollectionOptions) Distinct(ctx context.Context, fieldName string, filter interface{}, opts ...*options.DistinctOptions) ([]interface{}, error) {
+	return cc.dbCollection.Distinct(ctx, fieldName, filter, opts...)
+}
+
+// Find 查询多个文档
+func (cc *MongoCollectionOptions) Find(ctx context.Context, filter interface{}, opts ...*options.FindOptions) (*mongo.Cursor, error) {
+	return cc.dbCollection.Find(ctx, filter, opts...)
+}
+
+// FindOne 查询一个文档
+func (cc *MongoCollectionOptions) FindOne(ctx context.Context, filter interface{}, opts ...*options.FindOneOptions) *mongo.SingleResult {
+	return cc.dbCollection.FindOne(ctx, filter, opts...)
+}
+
+func (cc *MongoCollectionOptions) FindOneAndDelete(ctx context.Context, filter interface{}, opts ...*options.FindOneAndDeleteOptions) *mongo.SingleResult {
+	return cc.dbCollection.FindOneAndDelete(ctx, filter, opts...)
+}
+
+func (cc *MongoCollectionOptions) FindOneAndReplace(ctx context.Context, filter interface{}, replacement interface{}, opts ...*options.FindOneAndReplaceOptions) *mongo.SingleResult {
+	return cc.dbCollection.FindOneAndReplace(ctx, filter, replacement, opts...)
+}
+
+func (cc *MongoCollectionOptions) FindOneAndUpdate(ctx context.Context, filter interface{}, replacement interface{}, opts ...*options.FindOneAndUpdateOptions) *mongo.SingleResult {
+	return cc.dbCollection.FindOneAndUpdate(ctx, filter, replacement, opts...)
+}
+
+func (cc *MongoCollectionOptions) Watch(ctx context.Context, pipeline interface{}, opts ...*options.ChangeStreamOptions) (*mongo.ChangeStream, error) {
+	return cc.dbCollection.Watch(ctx, pipeline, opts...)
+}
+
+func (cc *MongoCollectionOptions) Indexes(ctx context.Context) mongo.IndexView {
+	return cc.dbCollection.Indexes()
+}
+
+func (cc *MongoCollectionOptions) Drop(ctx context.Context) error {
+	return cc.dbCollection.Drop(ctx)
+}

mongo_database.go

@@ -0,0 +1,69 @@
+package dorm
+
+import (
+	"context"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+	"reflect"
+)
+
+type MongoDatabaseOptions struct {
+	db                 *mongo.Client   // 驱动
+	configDatabaseName string          // 库名
+	dbDatabase         *mongo.Database // 数据库
+}
+
+// Database 选择数据库
+func (c *MongoClient) Database(name string, opts ...*options.DatabaseOptions) *MongoDatabaseOptions {
+	return &MongoDatabaseOptions{
+		db:                 c.db,                         // 驱动
+		configDatabaseName: c.configDatabaseName,         // 库名
+		dbDatabase:         c.db.Database(name, opts...), // 数据库
+	}
+}
+
+// CreateCollection 创建集合
+func (cd *MongoDatabaseOptions) CreateCollection(ctx context.Context, name string, opts ...*options.CreateCollectionOptions) error {
+	return cd.dbDatabase.CreateCollection(ctx, name, opts...)
+}
+
+// CreateTimeSeriesCollection 创建时间序列集合
+func (cd *MongoDatabaseOptions) CreateTimeSeriesCollection(ctx context.Context, name string, timeField string) error {
+	return cd.dbDatabase.CreateCollection(ctx, name, options.CreateCollection().SetTimeSeriesOptions(options.TimeSeries().SetTimeField(timeField)))
+}
+
+// Model 传入模型自动获取库名和表名
+// https://studygolang.com/articles/896
+// DatabaseName 库名
+// CollectionName 集合名
+func (c *MongoClient) Model(value interface{}) *MongoCollectionOptions {
+
+	var databaseOptions *MongoDatabaseOptions
+	var collectionOptions *MongoCollectionOptions
+
+	val := reflect.ValueOf(value)
+
+	methodDatabaseNameValue := val.MethodByName("DatabaseName")
+	if methodDatabaseNameValue.IsValid() {
+		databaseName := methodDatabaseNameValue.Call(nil)[0].String()
+		databaseOptions = c.Database(databaseName)
+	} else {
+		databaseOptions = c.Database(c.configDatabaseName)
+	}
+
+	methodCollectionNameValue := val.MethodByName("CollectionName")
+	if methodCollectionNameValue.IsValid() {
+		collectionName := methodCollectionNameValue.Call(nil)[0].String()
+		collectionOptions = databaseOptions.Collection(collectionName)
+	} else {
+		methodTableNameValue := val.MethodByName("TableName")
+		if methodTableNameValue.IsValid() {
+			collectionName := methodTableNameValue.Call(nil)[0].String()
+			collectionOptions = databaseOptions.Collection(collectionName)
+		} else {
+			panic(NoConfigCollectionName)
+		}
+	}
+
+	return collectionOptions
+}

mongo_error.go

@@ -0,0 +1,8 @@
+package dorm
+
+import "errors"
+
+var (
+	NoConfigDatabaseName   = errors.New("没有配置库名")
+	NoConfigCollectionName = errors.New("没有配置集合名")
+)

mongo_get.go

@@ -0,0 +1,8 @@
+package dorm
+
+import "go.mongodb.org/mongo-driver/mongo"
+
+// GetDb 获取驱动
+func (c *MongoClient) GetDb() *mongo.Client {
+	return c.db
+}

mongo_session.go

@@ -0,0 +1,59 @@
+package dorm
+
+import (
+	"context"
+	"go.mongodb.org/mongo-driver/mongo"
+	"log"
+)
+
+type MongoSessionOptions struct {
+	db                 *mongo.Client        // 驱动
+	configDatabaseName string               // 库名
+	session            mongo.Session        // 会话
+	sessionContext     mongo.SessionContext // 会话上下文
+}
+
+// Begin 开始事务，会同时创建开始会话需要在退出时关闭会话
+func (c *MongoClient) Begin() *MongoSessionOptions {
+
+	var ctx = context.TODO()
+	var err error
+	ms := &MongoSessionOptions{}
+
+	ms.db = c.GetDb()
+	ms.configDatabaseName = c.configDatabaseName
+
+	// 开始会话
+	ms.session, err = ms.db.StartSession()
+	if err != nil {
+		log.Println("开始会话异常：", err)
+	}
+
+	// 会话上下文
+	ms.sessionContext = mongo.NewSessionContext(ctx, ms.session)
+
+	// 会话开启事务
+	err = ms.session.StartTransaction()
+
+	return ms
+}
+
+// Rollback 回滚事务
+func (cs *MongoSessionOptions) Rollback() {
+	var ctx = context.TODO()
+	err := cs.session.AbortTransaction(ctx)
+	if err != nil {
+		log.Println("回滚事务异常：", err)
+	}
+	cs.session.EndSession(ctx)
+}
+
+// Commit 提交事务
+func (cs *MongoSessionOptions) Commit() {
+	var ctx = context.TODO()
+	err := cs.session.CommitTransaction(ctx)
+	if err != nil {
+		log.Println("提交事务异常：", err)
+	}
+	cs.session.EndSession(ctx)
+}

mongo_session_collection.go

@@ -0,0 +1,25 @@
+package dorm
+
+import (
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+type MongoSessionCollectionOptions struct {
+	db                 *mongo.Client        // 驱动
+	configDatabaseName string               // 库名
+	session            mongo.Session        // 会话
+	sessionContext     mongo.SessionContext // 会话上下文
+	dbCollection       *mongo.Collection    // 集合
+}
+
+// Collection 选择集合
+func (csd *MongoSessionDatabaseOptions) Collection(name string, opts ...*options.CollectionOptions) *MongoSessionCollectionOptions {
+	return &MongoSessionCollectionOptions{
+		db:                 csd.db,                                   // 驱动
+		configDatabaseName: csd.configDatabaseName,                   // 库名
+		session:            csd.session,                              // 会话
+		sessionContext:     csd.sessionContext,                       // 会话上下文
+		dbCollection:       csd.dbDatabase.Collection(name, opts...), // 集合
+	}
+}

mongo_session_collection_curd.go

@@ -0,0 +1,99 @@
+package dorm
+
+import (
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+// InsertOne 插入一个文档
+func (csc *MongoSessionCollectionOptions) InsertOne(document interface{}, opts ...*options.InsertOneOptions) (*mongo.InsertOneResult, error) {
+	return csc.dbCollection.InsertOne(csc.sessionContext, document, opts...)
+}
+
+// InsertMany 插入多个文档
+func (csc *MongoSessionCollectionOptions) InsertMany(document []interface{}, opts ...*options.InsertManyOptions) (*mongo.InsertManyResult, error) {
+	return csc.dbCollection.InsertMany(csc.sessionContext, document, opts...)
+}
+
+// DeleteOne 删除一个文档
+func (csc *MongoSessionCollectionOptions) DeleteOne(filter interface{}, opts ...*options.DeleteOptions) (*mongo.DeleteResult, error) {
+	return csc.dbCollection.DeleteOne(csc.sessionContext, filter, opts...)
+}
+
+// DeleteMany 删除多个文档
+func (csc *MongoSessionCollectionOptions) DeleteMany(filter interface{}, opts ...*options.DeleteOptions) (*mongo.DeleteResult, error) {
+	return csc.dbCollection.DeleteMany(csc.sessionContext, filter, opts...)
+}
+
+// UpdateByID 按ID更新
+func (csc *MongoSessionCollectionOptions) UpdateByID(id interface{}, update interface{}, opts ...*options.UpdateOptions) (*mongo.UpdateResult, error) {
+	return csc.dbCollection.UpdateByID(csc.sessionContext, id, update, opts...)
+}
+
+// UpdateOne 更新一个文档
+func (csc *MongoSessionCollectionOptions) UpdateOne(filter interface{}, update interface{}, opts ...*options.UpdateOptions) (*mongo.UpdateResult, error) {
+	return csc.dbCollection.UpdateOne(csc.sessionContext, filter, update, opts...)
+}
+
+// UpdateMany 更新多个文档
+func (csc *MongoSessionCollectionOptions) UpdateMany(filter interface{}, update interface{}, opts ...*options.UpdateOptions) (*mongo.UpdateResult, error) {
+	return csc.dbCollection.UpdateMany(csc.sessionContext, filter, update, opts...)
+}
+
+// ReplaceOne 替换一个文档
+func (csc *MongoSessionCollectionOptions) ReplaceOne(filter interface{}, update interface{}, opts ...*options.ReplaceOptions) (*mongo.UpdateResult, error) {
+	return csc.dbCollection.ReplaceOne(csc.sessionContext, filter, update, opts...)
+}
+
+// Aggregate 统计分析
+func (csc *MongoSessionCollectionOptions) Aggregate(pipeline interface{}, opts ...*options.AggregateOptions) (*mongo.Cursor, error) {
+	return csc.dbCollection.Aggregate(csc.sessionContext, pipeline, opts...)
+}
+
+// CountDocuments 计数文档
+func (csc *MongoSessionCollectionOptions) CountDocuments(filter interface{}, opts ...*options.CountOptions) (int64, error) {
+	return csc.dbCollection.CountDocuments(csc.sessionContext, filter, opts...)
+}
+
+// EstimatedDocumentCount 估计文档计数
+func (csc *MongoSessionCollectionOptions) EstimatedDocumentCount(opts ...*options.EstimatedDocumentCountOptions) (int64, error) {
+	return csc.dbCollection.EstimatedDocumentCount(csc.sessionContext, opts...)
+}
+
+func (csc *MongoSessionCollectionOptions) Distinct(fieldName string, filter interface{}, opts ...*options.DistinctOptions) ([]interface{}, error) {
+	return csc.dbCollection.Distinct(csc.sessionContext, fieldName, filter, opts...)
+}
+
+// Find 查询多个文档
+func (csc *MongoSessionCollectionOptions) Find(filter interface{}, opts ...*options.FindOptions) (*mongo.Cursor, error) {
+	return csc.dbCollection.Find(csc.sessionContext, filter, opts...)
+}
+
+// FindOne 查询一个文档
+func (csc *MongoSessionCollectionOptions) FindOne(filter interface{}, opts ...*options.FindOneOptions) *mongo.SingleResult {
+	return csc.dbCollection.FindOne(csc.sessionContext, filter, opts...)
+}
+
+func (csc *MongoSessionCollectionOptions) FindOneAndDelete(filter interface{}, opts ...*options.FindOneAndDeleteOptions) *mongo.SingleResult {
+	return csc.dbCollection.FindOneAndDelete(csc.sessionContext, filter, opts...)
+}
+
+func (csc *MongoSessionCollectionOptions) FindOneAndReplace(filter interface{}, replacement interface{}, opts ...*options.FindOneAndReplaceOptions) *mongo.SingleResult {
+	return csc.dbCollection.FindOneAndReplace(csc.sessionContext, filter, replacement, opts...)
+}
+
+func (csc *MongoSessionCollectionOptions) FindOneAndUpdate(filter interface{}, replacement interface{}, opts ...*options.FindOneAndUpdateOptions) *mongo.SingleResult {
+	return csc.dbCollection.FindOneAndUpdate(csc.sessionContext, filter, replacement, opts...)
+}
+
+func (csc *MongoSessionCollectionOptions) Watch(pipeline interface{}, opts ...*options.ChangeStreamOptions) (*mongo.ChangeStream, error) {
+	return csc.dbCollection.Watch(csc.sessionContext, pipeline, opts...)
+}
+
+func (csc *MongoSessionCollectionOptions) Indexes() mongo.IndexView {
+	return csc.dbCollection.Indexes()
+}
+
+func (csc *MongoSessionCollectionOptions) Drop() error {
+	return csc.dbCollection.Drop(csc.sessionContext)
+}

mongo_session_database.go

@@ -0,0 +1,62 @@
+package dorm
+
+import (
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+	"reflect"
+)
+
+type MongoSessionDatabaseOptions struct {
+	db                 *mongo.Client        // 驱动
+	configDatabaseName string               // 库名
+	session            mongo.Session        // 会话
+	sessionContext     mongo.SessionContext // 会话上下文
+	dbDatabase         *mongo.Database      // 数据库
+}
+
+// Database 选择数据库
+func (cs *MongoSessionOptions) Database(name string, opts ...*options.DatabaseOptions) *MongoSessionDatabaseOptions {
+	return &MongoSessionDatabaseOptions{
+		db:                 cs.db,                         // 驱动
+		configDatabaseName: cs.configDatabaseName,         // 库名
+		session:            cs.session,                    // 会话
+		sessionContext:     cs.sessionContext,             // 会话上下文
+		dbDatabase:         cs.db.Database(name, opts...), // 数据库
+	}
+}
+
+// Model 传入模型自动获取库名和表名
+// https://studygolang.com/articles/896
+// DatabaseName 库名
+// CollectionName 集合名
+func (cs *MongoSessionOptions) Model(value interface{}) *MongoSessionCollectionOptions {
+
+	var sessionDatabaseOptions *MongoSessionDatabaseOptions
+	var sessionCollectionOptions *MongoSessionCollectionOptions
+
+	val := reflect.ValueOf(value)
+
+	methodDatabaseNameValue := val.MethodByName("DatabaseName")
+	if methodDatabaseNameValue.IsValid() {
+		databaseName := methodDatabaseNameValue.Call(nil)[0].String()
+		sessionDatabaseOptions = cs.Database(databaseName)
+	} else {
+		sessionDatabaseOptions = cs.Database(cs.configDatabaseName)
+	}
+
+	methodCollectionNameValue := val.MethodByName("CollectionName")
+	if methodCollectionNameValue.IsValid() {
+		collectionName := methodCollectionNameValue.Call(nil)[0].String()
+		sessionCollectionOptions = sessionDatabaseOptions.Collection(collectionName)
+	} else {
+		methodTableNameValue := val.MethodByName("TableName")
+		if methodTableNameValue.IsValid() {
+			collectionName := methodTableNameValue.Call(nil)[0].String()
+			sessionCollectionOptions = sessionDatabaseOptions.Collection(collectionName)
+		} else {
+			panic(NoConfigCollectionName)
+		}
+	}
+
+	return sessionCollectionOptions
+}

mongo_session_get.go

@@ -0,0 +1,18 @@
+package dorm
+
+import "go.mongodb.org/mongo-driver/mongo"
+
+// GetDb 获取驱动
+func (cs *MongoSessionOptions) GetDb() *mongo.Client {
+	return cs.db
+}
+
+// GetSession 获取会话
+func (cs *MongoSessionOptions) GetSession() mongo.Session {
+	return cs.session
+}
+
+// GetSessionContext 获取会话上下文
+func (cs *MongoSessionOptions) GetSessionContext() mongo.SessionContext {
+	return cs.sessionContext
+}

mongo_time.go

@@ -0,0 +1,85 @@
+package dorm
+
+import (
+	"go.dtapp.net/gotime"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/bsontype"
+	"time"
+)
+
+// BsonTime 时间类型
+type BsonTime time.Time
+
+// MarshalJSON 实现json序列化
+func (bt BsonTime) MarshalJSON() ([]byte, error) {
+
+	b := make([]byte, 0)
+	b = append(b, '"')
+	b = append(b, gotime.SetCurrent(time.Time(bt)).Bson()...)
+	b = append(b, '"')
+
+	return b, nil
+}
+
+// UnmarshalJSON 实现json反序列化
+func (bt *BsonTime) UnmarshalJSON(data []byte) (err error) {
+
+	if string(data) == "null" {
+		return nil
+	}
+
+	bsonTime := gotime.SetCurrentParse(string(data))
+	*bt = BsonTime(bsonTime.Time)
+
+	return nil
+}
+
+// Time 转时间
+func (bt BsonTime) Time() time.Time {
+	return gotime.SetCurrent(time.Time(bt)).Time
+}
+
+// Format 转时间字符串
+func (bt BsonTime) Format() string {
+	return gotime.SetCurrent(time.Time(bt)).Format()
+}
+
+// TimePro 转时间操作
+func (bt BsonTime) TimePro() gotime.Pro {
+	return gotime.SetCurrent(time.Time(bt))
+}
+
+// NewBsonTimeCurrent 创建当前时间
+func NewBsonTimeCurrent() BsonTime {
+	return BsonTime(gotime.Current().Time)
+}
+
+// NewBsonTimeFromTime 创建某个时间
+func NewBsonTimeFromTime(t time.Time) BsonTime {
+	return BsonTime(t)
+}
+
+// NewBsonTimeFromString 创建某个时间 字符串
+func NewBsonTimeFromString(t string) BsonTime {
+	return BsonTime(gotime.SetCurrentParse(t).Time)
+}
+
+// Value 时间类型
+func (bt BsonTime) Value() string {
+	return gotime.SetCurrent(time.Time(bt)).Bson()
+}
+
+// MarshalBSONValue 实现bson序列化
+func (bt BsonTime) MarshalBSONValue() (bsontype.Type, []byte, error) {
+	return bson.MarshalValue(gotime.SetCurrent(time.Time(bt)).Bson())
+}
+
+// UnmarshalBSONValue 实现bson反序列化
+func (bt *BsonTime) UnmarshalBSONValue(t bsontype.Type, data []byte) error {
+	t1 := gotime.SetCurrentParse(string(data))
+	//if string(data) == "" {
+	//	return errors.New(fmt.Sprintf("%s, %s, %s", "读取数据失败:", t, data))
+	//}
+	*bt = BsonTime(t1.Time)
+	return nil
+}

redis.go

@@ -4,41 +4,48 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"github.com/go-redis/redis/v8"
+	"github.com/redis/go-redis/v9"
 	"time"
 )
 
-type ConfigRedisClient struct {
-	Addr     string // 地址
-	Password string // 密码
-	DB       int    // 数据库
-	PoolSize int    // 连接池大小
+// RedisClientFun *RedisClient 驱动
+type RedisClientFun func() *RedisClient
+
+type RedisClientConfig struct {
+	Addr        string        // 地址
+	Password    string        // 密码
+	DB          int           // 数据库
+	PoolSize    int           // 连接池大小
+	ReadTimeout time.Duration // 读取超时
 }
 
+// RedisClient
+// https://redis.uptrace.dev/
 type RedisClient struct {
-	Db     *redis.Client      // 驱动
-	config *ConfigRedisClient // 配置
+	db *redis.Client // 驱动
 }
 
-func NewRedisClient(config *ConfigRedisClient) (*RedisClient, error) {
+// NewRedisClient 创建实例
+func NewRedisClient(config *RedisClientConfig) (*RedisClient, error) {
 
 	c := &RedisClient{}
-	c.config = config
-	if c.config.PoolSize == 0 {
-		c.config.PoolSize = 100
+	if config.PoolSize == 0 {
+		config.PoolSize = 100
 	}
 
-	c.Db = redis.NewClient(&redis.Options{
-		Addr:     c.config.Addr,     // 地址
-		Password: c.config.Password, // 密码
-		DB:       c.config.DB,       // 数据库
-		PoolSize: c.config.PoolSize, // 连接池大小
+	c.db = redis.NewClient(&redis.Options{
+		Addr:        config.Addr,        // 地址
+		Password:    config.Password,    // 密码
+		DB:          config.DB,          // 数据库
+		PoolSize:    config.PoolSize,    // 连接池大小
+		ReadTimeout: config.ReadTimeout, // 读取超时
 	})
 
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
 
-	_, err := c.Db.Ping(ctx).Result()
+	// 检测 Redis 连接是否正常连接
+	_, err := c.db.Ping(ctx).Result()
 	if err != nil {
 		return nil, errors.New(fmt.Sprintf("连接失败：%v", err))
 	}
@@ -46,6 +53,27 @@ func NewRedisClient(config *ConfigRedisClient) (*RedisClient, error) {
 	return c, nil
 }
 
-func (c *RedisClient) GetDb() *redis.Client {
-	return c.Db
+// NewRedisClientURL 创建实例
+func NewRedisClientURL(redisURL string) (*RedisClient, error) {
+
+	c := &RedisClient{}
+
+	opt, err := redis.ParseURL(redisURL)
+	if err != nil {
+		return c, nil
+	}
+
+	// 创建 Redis 客户端
+	c.db = redis.NewClient(opt)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	// 检测 Redis 连接是否正常连接
+	_, err = c.db.Ping(ctx).Result()
+	if err != nil {
+		return nil, errors.New(fmt.Sprintf("连接失败：%v", err))
+	}
+
+	return c, nil
 }

redis_cache.go

@@ -0,0 +1,96 @@
+package dorm
+
+import (
+	"context"
+	"go.dtapp.net/gojson"
+	"time"
+)
+
+// GttStringFunc String缓存结构
+type GttStringFunc func() string
+
+// GttInterfaceFunc Interface缓存结构
+type GttInterfaceFunc func() interface{}
+
+// RedisCacheConfig 配置
+type RedisCacheConfig struct {
+	Expiration time.Duration // 过期时间
+}
+
+// RedisClientCache https://github.com/go-redis/redis
+type RedisClientCache struct {
+	defaultExpiration time.Duration    // 过期时间
+	operation         *RedisClient     // 操作
+	GetterString      GttStringFunc    // 不存在的操作
+	GetterInterface   GttInterfaceFunc // 不存在的操作
+}
+
+// NewCache 实例化
+func (r *RedisClient) NewCache(config *RedisCacheConfig) *RedisClientCache {
+	return &RedisClientCache{
+		defaultExpiration: config.Expiration,
+		operation:         r,
+	}
+}
+
+// NewCacheDefaultExpiration 实例化
+func (r *RedisClient) NewCacheDefaultExpiration() *RedisClientCache {
+	return &RedisClientCache{
+		defaultExpiration: time.Minute * 30,
+		operation:         r,
+	}
+}
+
+// GetString 缓存操作
+func (rc *RedisClientCache) GetString(ctx context.Context, key string) (ret string) {
+
+	f := func() string {
+		return rc.GetterString()
+	}
+
+	// 如果不存在，则调用GetterString
+	ret, err := rc.operation.Get(ctx, key).Result()
+	if err != nil {
+		rc.operation.Set(ctx, key, f(), rc.defaultExpiration)
+		ret, _ = rc.operation.Get(ctx, key).Result()
+	}
+
+	return
+}
+
+// GetInterface 缓存操作
+func (rc *RedisClientCache) GetInterface(ctx context.Context, key string, result interface{}) {
+
+	f := func() string {
+		marshal, _ := gojson.Marshal(rc.GetterInterface())
+		return string(marshal)
+	}
+
+	// 如果不存在，则调用GetterInterface
+	ret, err := rc.operation.Get(ctx, key).Result()
+
+	if err != nil {
+		rc.operation.Set(ctx, key, f(), rc.defaultExpiration)
+		ret, _ = rc.operation.Get(ctx, key).Result()
+	}
+
+	err = gojson.Unmarshal([]byte(ret), result)
+
+	return
+}
+
+// GetInterfaceKey 获取key值
+func (rc *RedisClientCache) GetInterfaceKey(ctx context.Context, key string, result interface{}) error {
+	ret, err := rc.operation.Get(ctx, key).Result()
+	if err != nil {
+		return err
+	}
+	err = gojson.Unmarshal([]byte(ret), result)
+	return nil
+}
+
+// SetInterfaceKey 设置key值
+func (rc *RedisClientCache) SetInterfaceKey(ctx context.Context, key string, value interface{}) (string, error) {
+	marshal, _ := gojson.Marshal(value)
+	return rc.operation.Set(ctx, key, marshal, rc.defaultExpiration).Result()
+}

redis_curd.go

@@ -0,0 +1,158 @@
+package dorm
+
+import (
+	"context"
+	"github.com/redis/go-redis/v9"
+	"time"
+)
+
+// Set 设置一个key的值
+func (r *RedisClient) Set(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.StatusCmd {
+	return r.db.Set(ctx, key, value, expiration)
+}
+
+// Get 查询key的值
+func (r *RedisClient) Get(ctx context.Context, key string) *redis.StringCmd {
+	return r.db.Get(ctx, key)
+}
+
+// GetSet 设置一个key的值，并返回这个key的旧值
+func (r *RedisClient) GetSet(ctx context.Context, key string, value interface{}) *redis.StringCmd {
+	return r.db.GetSet(ctx, key, value)
+}
+
+// SetNX 如果key不存在，则设置这个key的值
+func (r *RedisClient) SetNX(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.BoolCmd {
+	return r.db.SetNX(ctx, key, value, expiration)
+}
+
+// MGet 批量查询key的值
+func (r *RedisClient) MGet(ctx context.Context, keys ...string) *redis.SliceCmd {
+	return r.db.MGet(ctx, keys...)
+}
+
+// MSet 批量设置key的值
+// MSet(map[string]interface{}{"key1": "value1", "key2": "value2"})
+func (r *RedisClient) MSet(ctx context.Context, values map[string]interface{}) *redis.StatusCmd {
+	return r.db.MSet(ctx, values)
+}
+
+// Incr 针对一个key的数值进行递增操作
+func (r *RedisClient) Incr(ctx context.Context, key string) *redis.IntCmd {
+	return r.db.Incr(ctx, key)
+}
+
+// IncrBy 针对一个key的数值进行递增操作，指定每次递增多少
+func (r *RedisClient) IncrBy(ctx context.Context, key string, value int64) *redis.IntCmd {
+	return r.db.IncrBy(ctx, key, value)
+}
+
+// Decr 针对一个key的数值进行递减操作
+func (r *RedisClient) Decr(ctx context.Context, key string) *redis.IntCmd {
+	return r.db.Decr(ctx, key)
+}
+
+// DecrBy 针对一个key的数值进行递减操作，指定每次递减多少
+func (r *RedisClient) DecrBy(ctx context.Context, key string, value int64) *redis.IntCmd {
+	return r.db.DecrBy(ctx, key, value)
+}
+
+// Del 删除key操作，支持批量删除
+func (r *RedisClient) Del(ctx context.Context, keys ...string) *redis.IntCmd {
+	return r.db.Del(ctx, keys...)
+}
+
+// Keys 按前缀获取所有key名
+func (r *RedisClient) Keys(ctx context.Context, prefix string) []string {
+	values, _ := r.db.Keys(ctx, prefix).Result()
+	keys := make([]string, 0, len(values))
+	if len(values) <= 0 {
+		return keys
+	}
+	for _, value := range values {
+		keys = append(keys, value)
+	}
+	return keys
+}
+
+// KeysValue 按前缀获取所有key值
+func (r *RedisClient) KeysValue(ctx context.Context, prefix string) *redis.SliceCmd {
+	values, _ := r.db.Keys(ctx, prefix).Result()
+	if len(values) <= 0 {
+		return &redis.SliceCmd{}
+	}
+	keys := make([]string, 0, len(values))
+	for _, value := range values {
+		keys = append(keys, value)
+	}
+	return r.MGet(ctx, keys...)
+}
+
+// AddKeyToSet 将值添加到集合
+func (r *RedisClient) AddKeyToSet(ctx context.Context, setKey string, value interface{}) error {
+	return r.db.SAdd(ctx, setKey, value).Err()
+}
+
+// GetAllKeysInSet 获取集合的所有元素
+func (r *RedisClient) GetAllKeysInSet(ctx context.Context, setKey string) ([]string, error) {
+	return r.db.SMembers(ctx, setKey).Result()
+}
+
+// DoesKeyExistInSet 检查值是否存在于集合中
+func (r *RedisClient) DoesKeyExistInSet(ctx context.Context, setKey string, targetKey interface{}) (bool, error) {
+	return r.db.SIsMember(ctx, setKey, targetKey).Result()
+}
+
+// RemoveKeyFromSet 从集合中删除指定的元素
+func (r *RedisClient) RemoveKeyFromSet(ctx context.Context, setKey string, targetKey interface{}) error {
+	return r.db.SRem(ctx, setKey, targetKey).Err()
+}
+
+// DeleteKeysWithPrefix 根据前缀删除key
+func (r *RedisClient) DeleteKeysWithPrefix(ctx context.Context, prefix string) error {
+	// 获取所有符合给定模式的键
+	keys, err := r.db.Keys(ctx, prefix+"*").Result()
+	if err != nil {
+		return err
+	}
+
+	// 删除所有匹配的键
+	if len(keys) > 0 {
+		_, err := r.db.Del(ctx, keys...).Result()
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// DeleteScanWithPrefix 根据前缀删除key
+func (r *RedisClient) DeleteScanWithPrefix(ctx context.Context, prefix string) error {
+	var cursor uint64
+	for {
+		// 使用 SCAN 迭代获取匹配模式的键
+		keys, nextCursor, err := r.db.Scan(ctx, cursor, prefix+"*", 10).Result()
+		if err != nil {
+			return err
+		}
+
+		// 删除当前迭代返回的键
+		if len(keys) > 0 {
+			_, err := r.db.Del(ctx, keys...).Result()
+			if err != nil {
+				return err
+			}
+		}
+
+		// 更新游标，继续迭代
+		cursor = nextCursor
+
+		// 如果迭代结束，退出循环
+		if cursor == 0 {
+			break
+		}
+	}
+
+	return nil
+}

redis_curd_channel.go

@@ -0,0 +1,31 @@
+package dorm
+
+import (
+	"context"
+	"github.com/redis/go-redis/v9"
+)
+
+// Subscribe 订阅channel
+func (r *RedisClient) Subscribe(ctx context.Context, channels ...string) *redis.PubSub {
+	return r.db.Subscribe(ctx, channels...)
+}
+
+// PSubscribe 订阅channel支持通配符匹配
+func (r *RedisClient) PSubscribe(ctx context.Context, channels ...string) *redis.PubSub {
+	return r.db.PSubscribe(ctx, channels...)
+}
+
+// Publish 将信息发送到指定的channel
+func (r *RedisClient) Publish(ctx context.Context, channel string, message interface{}) *redis.IntCmd {
+	return r.db.Publish(ctx, channel, message)
+}
+
+// PubSubChannels 查询活跃的channel
+func (r *RedisClient) PubSubChannels(ctx context.Context, pattern string) *redis.StringSliceCmd {
+	return r.db.PubSubChannels(ctx, pattern)
+}
+
+// PubSubNumSub 查询指定的channel有多少个订阅者
+func (r *RedisClient) PubSubNumSub(ctx context.Context, channels ...string) *redis.MapStringIntCmd {
+	return r.db.PubSubNumSub(ctx, channels...)
+}

redis_error.go

@@ -0,0 +1,8 @@
+package dorm
+
+import "errors"
+
+var (
+	// RedisKeysNotFound keys没有数据
+	RedisKeysNotFound = errors.New("ERR wrong number of arguments for 'mget' command")
+)

redis_get.go

@@ -0,0 +1,8 @@
+package dorm
+
+import "github.com/redis/go-redis/v9"
+
+// GetDb 获取驱动
+func (r *RedisClient) GetDb() *redis.Client {
+	return r.db
+}

redis_hash_operation.go

@@ -2,25 +2,25 @@ package dorm
 
 import (
 	"context"
-	"github.com/go-redis/redis/v8"
+	"github.com/redis/go-redis/v9"
 )
 
+// HashOperation Hash类型数据操作
 type HashOperation struct {
-	db  *redis.Client
-	ctx context.Context
+	db *redis.Client
 }
 
 // NewHashOperation hash类型数据操作 https://www.tizi365.com/archives/296.html
-func NewHashOperation(db *redis.Client, ctx context.Context) *HashOperation {
-	return &HashOperation{db: db, ctx: ctx}
+func NewHashOperation(db *redis.Client) *HashOperation {
+	return &HashOperation{db: db}
 }
 
 // Set 根据key和field字段设置，field字段的值
-func (cl *HashOperation) Set(key string, value interface{}) *redis.IntCmd {
-	return cl.db.HSet(cl.ctx, key, value)
+func (cl *HashOperation) Set(ctx context.Context, key string, value interface{}) *redis.IntCmd {
+	return cl.db.HSet(ctx, key, value)
 }
 
 // Get 根据key和field字段设置，field字段的值
-func (cl *HashOperation) Get(key, field string) *redis.StringCmd {
-	return cl.db.HGet(cl.ctx, key, field)
+func (cl *HashOperation) Get(ctx context.Context, key, field string) *redis.StringCmd {
+	return cl.db.HGet(ctx, key, field)
 }

redis_list_operation.go

@@ -2,17 +2,18 @@ package dorm
 
 import (
 	"context"
-	"github.com/go-redis/redis/v8"
+	"github.com/redis/go-redis/v9"
 )
 
+// ListOperation  列表(list)类型数据操作
 type ListOperation struct {
 	db  *redis.Client
 	ctx context.Context
 }
 
 // NewListOperation 列表(list)类型数据操作 https://www.tizi365.com/archives/299.html
-func (c *RedisClient) NewListOperation() *ListOperation {
-	return &ListOperation{db: c.Db, ctx: context.Background()}
+func (r *RedisClient) NewListOperation() *ListOperation {
+	return &ListOperation{db: r.db, ctx: context.Background()}
 }
 
 // LPush 从列表左边插入数据

redis_lock.go

@@ -0,0 +1,73 @@
+package dorm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"github.com/redis/go-redis/v9"
+	"time"
+)
+
+// RedisClientLock https://github.com/go-redis/redis
+type RedisClientLock struct {
+	operation *RedisClient // 操作
+}
+
+// NewLock 实例化锁
+func (r *RedisClient) NewLock() *RedisClientLock {
+	return &RedisClientLock{r}
+}
+
+// Lock 上锁
+// key 锁名
+// val 锁内容
+// ttl 锁过期时间
+func (rl *RedisClientLock) Lock(ctx context.Context, key string, val string, ttl time.Duration) (resp string, err error) {
+	if ttl <= 0 {
+		return resp, errors.New("长期请使用 LockForever 方法")
+	}
+	// 获取
+	get, err := rl.operation.Get(ctx, key).Result()
+	if errors.Is(err, redis.Nil) {
+		// 设置
+		err = rl.operation.Set(ctx, key, val, ttl).Err()
+		if err != nil {
+			return resp, errors.New(fmt.Sprintf("上锁失败：%s", err.Error()))
+		}
+		return val, nil
+	}
+	if get != "" {
+		return resp, errors.New("上锁失败，已存在")
+	}
+	return resp, errors.New(fmt.Sprintf("获取异常：%s", err.Error()))
+}
+
+// Unlock 解锁
+// key 锁名
+func (rl *RedisClientLock) Unlock(ctx context.Context, key string) error {
+	_, err := rl.operation.Del(ctx, key).Result()
+	if err != nil {
+		return errors.New(fmt.Sprintf("解锁失败：%s", err.Error()))
+	}
+	return err
+}
+
+// LockForever 永远上锁
+// key 锁名
+// val 锁内容
+func (rl *RedisClientLock) LockForever(ctx context.Context, key string, val string) (resp string, err error) {
+	// 获取
+	get, err := rl.operation.Get(ctx, key).Result()
+	if errors.Is(err, redis.Nil) {
+		// 设置
+		err = rl.operation.Set(ctx, key, val, 0).Err()
+		if err != nil {
+			return resp, errors.New(fmt.Sprintf("上锁失败：%s", err.Error()))
+		}
+		return val, nil
+	}
+	if get != "" {
+		return resp, errors.New("上锁失败，已存在")
+	}
+	return resp, errors.New(fmt.Sprintf("获取异常：%s", err.Error()))
+}

redis_simple_cache.go

@@ -1,7 +1,8 @@
 package dorm
 
 import (
-	"encoding/json"
+	"context"
+	"go.dtapp.net/gojson"
 	"time"
 )
 
@@ -24,7 +25,7 @@ type SimpleCache struct {
 }
 
 // NewSimpleCache 构造函数
-func (c *RedisClient) NewSimpleCache(operation *StringOperation, expire time.Duration, serializer string) *SimpleCache {
+func (r *RedisClient) NewSimpleCache(operation *StringOperation, expire time.Duration, serializer string) *SimpleCache {
 	return &SimpleCache{
 		Operation:  operation,  // 操作类
 		Expire:     expire,     // 过去时间
@@ -33,29 +34,29 @@ func (c *RedisClient) NewSimpleCache(operation *StringOperation, expire time.Dur
 }
 
 // SetCache 设置缓存
-func (c *SimpleCache) SetCache(key string, value interface{}) {
-	c.Operation.Set(key, value, WithExpire(c.Expire)).Unwrap()
+func (c *SimpleCache) SetCache(ctx context.Context, key string, value interface{}) {
+	c.Operation.Set(ctx, key, value, WithExpire(c.Expire)).Unwrap()
 }
 
 // GetCache 获取缓存
-func (c *SimpleCache) GetCache(key string) (ret interface{}) {
+func (c *SimpleCache) GetCache(ctx context.Context, key string) (ret interface{}) {
 	if c.Serializer == SerializerJson {
 		f := func() string {
 			obj := c.JsonGetter()
-			b, err := json.Marshal(obj)
+			b, err := gojson.Marshal(obj)
 			if err != nil {
 				return ""
 			}
 			return string(b)
 		}
-		ret = c.Operation.Get(key).UnwrapOrElse(f)
-		c.SetCache(key, ret)
+		ret = c.Operation.Get(ctx, key).UnwrapOrElse(f)
+		c.SetCache(ctx, key, ret)
 	} else if c.Serializer == SerializerString {
 		f := func() string {
 			return c.DBGetter()
 		}
-		ret = c.Operation.Get(key).UnwrapOrElse(f)
-		c.SetCache(key, ret)
+		ret = c.Operation.Get(ctx, key).UnwrapOrElse(f)
+		c.SetCache(ctx, key, ret)
 	}
 	return
 }

redis_simple_interface_cache.go

@@ -1,7 +1,7 @@
 package dorm
 
 import (
-	"log"
+	"context"
 	"time"
 )
 
@@ -15,7 +15,7 @@ type SimpleInterfaceCache struct {
 }
 
 // NewSimpleInterfaceCache 构造函数
-func (c *RedisClient) NewSimpleInterfaceCache(operation *SimpleOperation, expire time.Duration) *SimpleInterfaceCache {
+func (r *RedisClient) NewSimpleInterfaceCache(operation *SimpleOperation, expire time.Duration) *SimpleInterfaceCache {
 	return &SimpleInterfaceCache{
 		Operation: operation, // 操作类
 		Expire:    expire,    // 过期时间
@@ -23,17 +23,16 @@ func (c *RedisClient) NewSimpleInterfaceCache(operation *SimpleOperation, expire
 }
 
 // SetCache 设置缓存
-func (c *SimpleInterfaceCache) SetCache(key string, value interface{}) {
-	c.Operation.Set(key, value, WithExpire(c.Expire)).Unwrap()
+func (c *SimpleInterfaceCache) SetCache(ctx context.Context, key string, value interface{}) {
+	c.Operation.Set(ctx, key, value, WithExpire(c.Expire)).Unwrap()
 }
 
 // GetCache 获取缓存
-func (c *SimpleInterfaceCache) GetCache(key string) (ret interface{}) {
+func (c *SimpleInterfaceCache) GetCache(ctx context.Context, key string) (ret interface{}) {
 	f := func() interface{} {
 		return c.DBGetter()
 	}
-	ret = c.Operation.Get(key).UnwrapOrElse(f)
-	c.SetCache(key, ret)
-	log.Println(ret)
+	ret = c.Operation.Get(ctx, key).UnwrapOrElse(f)
+	c.SetCache(ctx, key, ret)
 	return ret
 }

redis_simple_json_cache.go

@@ -1,7 +1,8 @@
 package dorm
 
 import (
-	"encoding/json"
+	"context"
+	"go.dtapp.net/gojson"
 	"time"
 )
 
@@ -15,7 +16,7 @@ type SimpleJsonCache struct {
 }
 
 // NewSimpleJsonCache 构造函数
-func (c *RedisClient) NewSimpleJsonCache(operation *StringOperation, expire time.Duration) *SimpleJsonCache {
+func (r *RedisClient) NewSimpleJsonCache(operation *StringOperation, expire time.Duration) *SimpleJsonCache {
 	return &SimpleJsonCache{
 		Operation: operation, // 操作类
 		Expire:    expire,    // 过期时间
@@ -23,21 +24,21 @@ func (c *RedisClient) NewSimpleJsonCache(operation *StringOperation, expire time
 }
 
 // SetCache 设置缓存
-func (c *SimpleJsonCache) SetCache(key string, value interface{}) {
-	c.Operation.Set(key, value, WithExpire(c.Expire)).Unwrap()
+func (c *SimpleJsonCache) SetCache(ctx context.Context, key string, value interface{}) {
+	c.Operation.Set(ctx, key, value, WithExpire(c.Expire)).Unwrap()
 }
 
 // GetCache 获取缓存
-func (c *SimpleJsonCache) GetCache(key string) (ret interface{}) {
+func (c *SimpleJsonCache) GetCache(ctx context.Context, key string) (ret interface{}) {
 	f := func() string {
 		obj := c.DBGetter()
-		b, err := json.Marshal(obj)
+		b, err := gojson.Marshal(obj)
 		if err != nil {
 			return ""
 		}
 		return string(b)
 	}
-	ret = c.Operation.Get(key).UnwrapOrElse(f)
-	c.SetCache(key, ret)
+	ret = c.Operation.Get(ctx, key).UnwrapOrElse(f)
+	c.SetCache(ctx, key, ret)
 	return
 }

redis_simple_operation.go

@@ -2,37 +2,33 @@ package dorm
 
 import (
 	"context"
-	"github.com/go-redis/redis/v8"
+	"github.com/redis/go-redis/v9"
 	"time"
 )
 
 type SimpleOperation struct {
-	db  *redis.Client
-	ctx context.Context
+	db *redis.Client
 }
 
-func (c *RedisClient) NewSimpleOperation() *SimpleOperation {
-	return &SimpleOperation{
-		db:  c.Db,
-		ctx: context.Background(),
-	}
+func (r *RedisClient) NewSimpleOperation() *SimpleOperation {
+	return &SimpleOperation{db: r.db}
 }
 
 // Set 设置
-func (o *SimpleOperation) Set(key string, value interface{}, attrs ...*OperationAttr) *SimpleResult {
+func (o *SimpleOperation) Set(ctx context.Context, key string, value interface{}, attrs ...*OperationAttr) *SimpleResult {
 	exp := OperationAttrs(attrs).Find(AttrExpr)
 	if exp == nil {
 		exp = time.Second * 0
 	}
-	return NewSimpleResult(o.db.Set(o.ctx, key, value, exp.(time.Duration)).Result())
+	return NewSimpleResult(o.db.Set(ctx, key, value, exp.(time.Duration)).Result())
 }
 
 // Get 获取单个
-func (o *SimpleOperation) Get(key string) *SimpleResult {
-	return NewSimpleResult(o.db.Get(o.ctx, key).Result())
+func (o *SimpleOperation) Get(ctx context.Context, key string) *SimpleResult {
+	return NewSimpleResult(o.db.Get(ctx, key).Result())
 }
 
 // Del 删除key操作，支持批量删除
-func (o *SimpleOperation) Del(keys ...string) *redis.IntCmd {
-	return o.db.Del(o.ctx, keys...)
+func (o *SimpleOperation) Del(ctx context.Context, keys ...string) *redis.IntCmd {
+	return o.db.Del(ctx, keys...)
 }

redis_simple_sring_cache.go

@@ -1,6 +1,7 @@
 package dorm
 
 import (
+	"context"
 	"time"
 )
 
@@ -14,7 +15,7 @@ type SimpleStringCache struct {
 }
 
 // NewSimpleStringCache 构造函数
-func (c *RedisClient) NewSimpleStringCache(operation *StringOperation, expire time.Duration) *SimpleStringCache {
+func (r *RedisClient) NewSimpleStringCache(operation *StringOperation, expire time.Duration) *SimpleStringCache {
 	return &SimpleStringCache{
 		Operation: operation, // 操作类
 		Expire:    expire,    // 过期时间
@@ -22,16 +23,16 @@ func (c *RedisClient) NewSimpleStringCache(operation *StringOperation, expire ti
 }
 
 // SetCache 设置缓存
-func (c *SimpleStringCache) SetCache(key string, value string) {
-	c.Operation.Set(key, value, WithExpire(c.Expire)).Unwrap()
+func (c *SimpleStringCache) SetCache(ctx context.Context, key string, value string) {
+	c.Operation.Set(ctx, key, value, WithExpire(c.Expire)).Unwrap()
 }
 
 // GetCache 获取缓存
-func (c *SimpleStringCache) GetCache(key string) (ret string) {
+func (c *SimpleStringCache) GetCache(ctx context.Context, key string) (ret string) {
 	f := func() string {
 		return c.DBGetter()
 	}
-	ret = c.Operation.Get(key).UnwrapOrElse(f)
-	c.SetCache(key, ret)
+	ret = c.Operation.Get(ctx, key).UnwrapOrElse(f)
+	c.SetCache(ctx, key, ret)
 	return
 }

redis_string_operation.go

@@ -2,42 +2,38 @@ package dorm
 
 import (
 	"context"
-	"github.com/go-redis/redis/v8"
+	"github.com/redis/go-redis/v9"
 	"time"
 )
 
 type StringOperation struct {
-	db  *redis.Client
-	ctx context.Context
+	db *redis.Client
 }
 
-func (c *RedisClient) NewStringOperation() *StringOperation {
-	return &StringOperation{
-		db:  c.Db,
-		ctx: context.Background(),
-	}
+func (r *RedisClient) NewStringOperation() *StringOperation {
+	return &StringOperation{db: r.db}
 }
 
 // Set 设置
-func (o *StringOperation) Set(key string, value interface{}, attrs ...*OperationAttr) *StringResult {
+func (o *StringOperation) Set(ctx context.Context, key string, value interface{}, attrs ...*OperationAttr) *StringResult {
 	exp := OperationAttrs(attrs).Find(AttrExpr)
 	if exp == nil {
 		exp = time.Second * 0
 	}
-	return NewStringResult(o.db.Set(o.ctx, key, value, exp.(time.Duration)).Result())
+	return NewStringResult(o.db.Set(ctx, key, value, exp.(time.Duration)).Result())
 }
 
 // Get 获取单个
-func (o *StringOperation) Get(key string) *StringResult {
-	return NewStringResult(o.db.Get(o.ctx, key).Result())
+func (o *StringOperation) Get(ctx context.Context, key string) *StringResult {
+	return NewStringResult(o.db.Get(ctx, key).Result())
 }
 
 // MGet 获取多个
-func (o *StringOperation) MGet(keys ...string) *SliceResult {
-	return NewSliceResult(o.db.MGet(o.ctx, keys...).Result())
+func (o *StringOperation) MGet(ctx context.Context, keys ...string) *SliceResult {
+	return NewSliceResult(o.db.MGet(ctx, keys...).Result())
 }
 
 // Del 删除key操作，支持批量删除
-func (o *StringOperation) Del(keys ...string) *redis.IntCmd {
-	return o.db.Del(o.ctx, keys...)
+func (o *StringOperation) Del(ctx context.Context, keys ...string) *redis.IntCmd {
+	return o.db.Del(ctx, keys...)
 }

type.go

@@ -0,0 +1,76 @@
+package dorm
+
+// Bool 复制 bool 对象，并返回复制体
+func Bool(b bool) bool {
+	return b
+}
+
+// Uint8 复制 int8 对象，并返回复制体
+func Uint8(ui uint8) uint8 {
+	return ui
+}
+
+// Uint16 复制 uint16 对象，并返回复制体
+func Uint16(ui uint16) uint16 {
+	return ui
+}
+
+// Uint32 复制 uint32 对象，并返回复制体
+func Uint32(ui uint32) uint32 {
+	return ui
+}
+
+// Uint64 复制 uint64 对象，并返回复制体
+func Uint64(ui uint64) uint64 {
+	return ui
+}
+
+// Int8 复制 int8 对象，并返回复制体
+func Int8(i int8) int8 {
+	return i
+}
+
+// Int16 复制 int16 对象，并返回复制体
+func Int16(i int16) int16 {
+	return i
+}
+
+// Int32 复制 int64 对象，并返回复制体
+func Int32(i int32) int32 {
+	return i
+}
+
+// Int64 复制 int64 对象，并返回复制体
+func Int64(i int64) int64 {
+	return i
+}
+
+// Float32 复制 float32 对象，并返回复制体
+func Float32(f float32) float32 {
+	return f
+}
+
+// Float64 复制 float64 对象，并返回复制体
+func Float64(f float64) float64 {
+	return f
+}
+
+// String 复制 string 对象，并返回复制体
+func String(s string) string {
+	return s
+}
+
+// Int 复制 int 对象，并返回复制体
+func Int(i int) int {
+	return i
+}
+
+// Uint 复制 uint 对象，并返回复制体
+func Uint(ui uint) uint {
+	return ui
+}
+
+// Any 复制 any 对象，并返回复制体
+func Any(a any) any {
+	return a
+}

vendor/github.com/cespare/xxhash/v2/LICENSE.txt

@@ -1,22 +0,0 @@
-Copyright (c) 2016 Caleb Spare
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/cespare/xxhash/v2/README.md

@@ -1,69 +0,0 @@
-# xxhash
-
-[![Go Reference](https://pkg.go.dev/badge/github.com/cespare/xxhash/v2.svg)](https://pkg.go.dev/github.com/cespare/xxhash/v2)
-[![Test](https://github.com/cespare/xxhash/actions/workflows/test.yml/badge.svg)](https://github.com/cespare/xxhash/actions/workflows/test.yml)
-
-xxhash is a Go implementation of the 64-bit
-[xxHash](http://cyan4973.github.io/xxHash/) algorithm, XXH64. This is a
-high-quality hashing algorithm that is much faster than anything in the Go
-standard library.
-
-This package provides a straightforward API:
-
-```
-func Sum64(b []byte) uint64
-func Sum64String(s string) uint64
-type Digest struct{ ... }
-    func New() *Digest
-```
-
-The `Digest` type implements hash.Hash64. Its key methods are:
-
-```
-func (*Digest) Write([]byte) (int, error)
-func (*Digest) WriteString(string) (int, error)
-func (*Digest) Sum64() uint64
-```
-
-This implementation provides a fast pure-Go implementation and an even faster
-assembly implementation for amd64.
-
-## Compatibility
-
-This package is in a module and the latest code is in version 2 of the module.
-You need a version of Go with at least "minimal module compatibility" to use
-github.com/cespare/xxhash/v2:
-
-* 1.9.7+ for Go 1.9
-* 1.10.3+ for Go 1.10
-* Go 1.11 or later
-
-I recommend using the latest release of Go.
-
-## Benchmarks
-
-Here are some quick benchmarks comparing the pure-Go and assembly
-implementations of Sum64.
-
-| input size | purego | asm |
-| --- | --- | --- |
-| 5 B   |  979.66 MB/s |  1291.17 MB/s  |
-| 100 B | 7475.26 MB/s | 7973.40 MB/s  |
-| 4 KB  | 17573.46 MB/s | 17602.65 MB/s |
-| 10 MB | 17131.46 MB/s | 17142.16 MB/s |
-
-These numbers were generated on Ubuntu 18.04 with an Intel i7-8700K CPU using
-the following commands under Go 1.11.2:
-
-```
-$ go test -tags purego -benchtime 10s -bench '/xxhash,direct,bytes'
-$ go test -benchtime 10s -bench '/xxhash,direct,bytes'
-```
-
-## Projects using this package
-
-- [InfluxDB](https://github.com/influxdata/influxdb)
-- [Prometheus](https://github.com/prometheus/prometheus)
-- [VictoriaMetrics](https://github.com/VictoriaMetrics/VictoriaMetrics)
-- [FreeCache](https://github.com/coocood/freecache)
-- [FastCache](https://github.com/VictoriaMetrics/fastcache)

vendor/github.com/cespare/xxhash/v2/xxhash.go

@@ -1,235 +0,0 @@
-// Package xxhash implements the 64-bit variant of xxHash (XXH64) as described
-// at http://cyan4973.github.io/xxHash/.
-package xxhash
-
-import (
-	"encoding/binary"
-	"errors"
-	"math/bits"
-)
-
-const (
-	prime1 uint64 = 11400714785074694791
-	prime2 uint64 = 14029467366897019727
-	prime3 uint64 = 1609587929392839161
-	prime4 uint64 = 9650029242287828579
-	prime5 uint64 = 2870177450012600261
-)
-
-// NOTE(caleb): I'm using both consts and vars of the primes. Using consts where
-// possible in the Go code is worth a small (but measurable) performance boost
-// by avoiding some MOVQs. Vars are needed for the asm and also are useful for
-// convenience in the Go code in a few places where we need to intentionally
-// avoid constant arithmetic (e.g., v1 := prime1 + prime2 fails because the
-// result overflows a uint64).
-var (
-	prime1v = prime1
-	prime2v = prime2
-	prime3v = prime3
-	prime4v = prime4
-	prime5v = prime5
-)
-
-// Digest implements hash.Hash64.
-type Digest struct {
-	v1    uint64
-	v2    uint64
-	v3    uint64
-	v4    uint64
-	total uint64
-	mem   [32]byte
-	n     int // how much of mem is used
-}
-
-// New creates a new Digest that computes the 64-bit xxHash algorithm.
-func New() *Digest {
-	var d Digest
-	d.Reset()
-	return &d
-}
-
-// Reset clears the Digest's state so that it can be reused.
-func (d *Digest) Reset() {
-	d.v1 = prime1v + prime2
-	d.v2 = prime2
-	d.v3 = 0
-	d.v4 = -prime1v
-	d.total = 0
-	d.n = 0
-}
-
-// Size always returns 8 bytes.
-func (d *Digest) Size() int { return 8 }
-
-// BlockSize always returns 32 bytes.
-func (d *Digest) BlockSize() int { return 32 }
-
-// Write adds more data to d. It always returns len(b), nil.
-func (d *Digest) Write(b []byte) (n int, err error) {
-	n = len(b)
-	d.total += uint64(n)
-
-	if d.n+n < 32 {
-		// This new data doesn't even fill the current block.
-		copy(d.mem[d.n:], b)
-		d.n += n
-		return
-	}
-
-	if d.n > 0 {
-		// Finish off the partial block.
-		copy(d.mem[d.n:], b)
-		d.v1 = round(d.v1, u64(d.mem[0:8]))
-		d.v2 = round(d.v2, u64(d.mem[8:16]))
-		d.v3 = round(d.v3, u64(d.mem[16:24]))
-		d.v4 = round(d.v4, u64(d.mem[24:32]))
-		b = b[32-d.n:]
-		d.n = 0
-	}
-
-	if len(b) >= 32 {
-		// One or more full blocks left.
-		nw := writeBlocks(d, b)
-		b = b[nw:]
-	}
-
-	// Store any remaining partial block.
-	copy(d.mem[:], b)
-	d.n = len(b)
-
-	return
-}
-
-// Sum appends the current hash to b and returns the resulting slice.
-func (d *Digest) Sum(b []byte) []byte {
-	s := d.Sum64()
-	return append(
-		b,
-		byte(s>>56),
-		byte(s>>48),
-		byte(s>>40),
-		byte(s>>32),
-		byte(s>>24),
-		byte(s>>16),
-		byte(s>>8),
-		byte(s),
-	)
-}
-
-// Sum64 returns the current hash.
-func (d *Digest) Sum64() uint64 {
-	var h uint64
-
-	if d.total >= 32 {
-		v1, v2, v3, v4 := d.v1, d.v2, d.v3, d.v4
-		h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4)
-		h = mergeRound(h, v1)
-		h = mergeRound(h, v2)
-		h = mergeRound(h, v3)
-		h = mergeRound(h, v4)
-	} else {
-		h = d.v3 + prime5
-	}
-
-	h += d.total
-
-	i, end := 0, d.n
-	for ; i+8 <= end; i += 8 {
-		k1 := round(0, u64(d.mem[i:i+8]))
-		h ^= k1
-		h = rol27(h)*prime1 + prime4
-	}
-	if i+4 <= end {
-		h ^= uint64(u32(d.mem[i:i+4])) * prime1
-		h = rol23(h)*prime2 + prime3
-		i += 4
-	}
-	for i < end {
-		h ^= uint64(d.mem[i]) * prime5
-		h = rol11(h) * prime1
-		i++
-	}
-
-	h ^= h >> 33
-	h *= prime2
-	h ^= h >> 29
-	h *= prime3
-	h ^= h >> 32
-
-	return h
-}
-
-const (
-	magic         = "xxh\x06"
-	marshaledSize = len(magic) + 8*5 + 32
-)
-
-// MarshalBinary implements the encoding.BinaryMarshaler interface.
-func (d *Digest) MarshalBinary() ([]byte, error) {
-	b := make([]byte, 0, marshaledSize)
-	b = append(b, magic...)
-	b = appendUint64(b, d.v1)
-	b = appendUint64(b, d.v2)
-	b = appendUint64(b, d.v3)
-	b = appendUint64(b, d.v4)
-	b = appendUint64(b, d.total)
-	b = append(b, d.mem[:d.n]...)
-	b = b[:len(b)+len(d.mem)-d.n]
-	return b, nil
-}
-
-// UnmarshalBinary implements the encoding.BinaryUnmarshaler interface.
-func (d *Digest) UnmarshalBinary(b []byte) error {
-	if len(b) < len(magic) || string(b[:len(magic)]) != magic {
-		return errors.New("xxhash: invalid hash state identifier")
-	}
-	if len(b) != marshaledSize {
-		return errors.New("xxhash: invalid hash state size")
-	}
-	b = b[len(magic):]
-	b, d.v1 = consumeUint64(b)
-	b, d.v2 = consumeUint64(b)
-	b, d.v3 = consumeUint64(b)
-	b, d.v4 = consumeUint64(b)
-	b, d.total = consumeUint64(b)
-	copy(d.mem[:], b)
-	d.n = int(d.total % uint64(len(d.mem)))
-	return nil
-}
-
-func appendUint64(b []byte, x uint64) []byte {
-	var a [8]byte
-	binary.LittleEndian.PutUint64(a[:], x)
-	return append(b, a[:]...)
-}
-
-func consumeUint64(b []byte) ([]byte, uint64) {
-	x := u64(b)
-	return b[8:], x
-}
-
-func u64(b []byte) uint64 { return binary.LittleEndian.Uint64(b) }
-func u32(b []byte) uint32 { return binary.LittleEndian.Uint32(b) }
-
-func round(acc, input uint64) uint64 {
-	acc += input * prime2
-	acc = rol31(acc)
-	acc *= prime1
-	return acc
-}
-
-func mergeRound(acc, val uint64) uint64 {
-	val = round(0, val)
-	acc ^= val
-	acc = acc*prime1 + prime4
-	return acc
-}
-
-func rol1(x uint64) uint64  { return bits.RotateLeft64(x, 1) }
-func rol7(x uint64) uint64  { return bits.RotateLeft64(x, 7) }
-func rol11(x uint64) uint64 { return bits.RotateLeft64(x, 11) }
-func rol12(x uint64) uint64 { return bits.RotateLeft64(x, 12) }
-func rol18(x uint64) uint64 { return bits.RotateLeft64(x, 18) }
-func rol23(x uint64) uint64 { return bits.RotateLeft64(x, 23) }
-func rol27(x uint64) uint64 { return bits.RotateLeft64(x, 27) }
-func rol31(x uint64) uint64 { return bits.RotateLeft64(x, 31) }

vendor/github.com/cespare/xxhash/v2/xxhash_amd64.go

@@ -1,13 +0,0 @@
-// +build !appengine
-// +build gc
-// +build !purego
-
-package xxhash
-
-// Sum64 computes the 64-bit xxHash digest of b.
-//
-//go:noescape
-func Sum64(b []byte) uint64
-
-//go:noescape
-func writeBlocks(d *Digest, b []byte) int

vendor/github.com/cespare/xxhash/v2/xxhash_amd64.s

@@ -1,215 +0,0 @@
-// +build !appengine
-// +build gc
-// +build !purego
-
-#include "textflag.h"
-
-// Register allocation:
-// AX	h
-// SI	pointer to advance through b
-// DX	n
-// BX	loop end
-// R8	v1, k1
-// R9	v2
-// R10	v3
-// R11	v4
-// R12	tmp
-// R13	prime1v
-// R14	prime2v
-// DI	prime4v
-
-// round reads from and advances the buffer pointer in SI.
-// It assumes that R13 has prime1v and R14 has prime2v.
-#define round(r) \
-	MOVQ  (SI), R12 \
-	ADDQ  $8, SI    \
-	IMULQ R14, R12  \
-	ADDQ  R12, r    \
-	ROLQ  $31, r    \
-	IMULQ R13, r
-
-// mergeRound applies a merge round on the two registers acc and val.
-// It assumes that R13 has prime1v, R14 has prime2v, and DI has prime4v.
-#define mergeRound(acc, val) \
-	IMULQ R14, val \
-	ROLQ  $31, val \
-	IMULQ R13, val \
-	XORQ  val, acc \
-	IMULQ R13, acc \
-	ADDQ  DI, acc
-
-// func Sum64(b []byte) uint64
-TEXT ·Sum64(SB), NOSPLIT, $0-32
-	// Load fixed primes.
-	MOVQ ·prime1v(SB), R13
-	MOVQ ·prime2v(SB), R14
-	MOVQ ·prime4v(SB), DI
-
-	// Load slice.
-	MOVQ b_base+0(FP), SI
-	MOVQ b_len+8(FP), DX
-	LEAQ (SI)(DX*1), BX
-
-	// The first loop limit will be len(b)-32.
-	SUBQ $32, BX
-
-	// Check whether we have at least one block.
-	CMPQ DX, $32
-	JLT  noBlocks
-
-	// Set up initial state (v1, v2, v3, v4).
-	MOVQ R13, R8
-	ADDQ R14, R8
-	MOVQ R14, R9
-	XORQ R10, R10
-	XORQ R11, R11
-	SUBQ R13, R11
-
-	// Loop until SI > BX.
-blockLoop:
-	round(R8)
-	round(R9)
-	round(R10)
-	round(R11)
-
-	CMPQ SI, BX
-	JLE  blockLoop
-
-	MOVQ R8, AX
-	ROLQ $1, AX
-	MOVQ R9, R12
-	ROLQ $7, R12
-	ADDQ R12, AX
-	MOVQ R10, R12
-	ROLQ $12, R12
-	ADDQ R12, AX
-	MOVQ R11, R12
-	ROLQ $18, R12
-	ADDQ R12, AX
-
-	mergeRound(AX, R8)
-	mergeRound(AX, R9)
-	mergeRound(AX, R10)
-	mergeRound(AX, R11)
-
-	JMP afterBlocks
-
-noBlocks:
-	MOVQ ·prime5v(SB), AX
-
-afterBlocks:
-	ADDQ DX, AX
-
-	// Right now BX has len(b)-32, and we want to loop until SI > len(b)-8.
-	ADDQ $24, BX
-
-	CMPQ SI, BX
-	JG   fourByte
-
-wordLoop:
-	// Calculate k1.
-	MOVQ  (SI), R8
-	ADDQ  $8, SI
-	IMULQ R14, R8
-	ROLQ  $31, R8
-	IMULQ R13, R8
-
-	XORQ  R8, AX
-	ROLQ  $27, AX
-	IMULQ R13, AX
-	ADDQ  DI, AX
-
-	CMPQ SI, BX
-	JLE  wordLoop
-
-fourByte:
-	ADDQ $4, BX
-	CMPQ SI, BX
-	JG   singles
-
-	MOVL  (SI), R8
-	ADDQ  $4, SI
-	IMULQ R13, R8
-	XORQ  R8, AX
-
-	ROLQ  $23, AX
-	IMULQ R14, AX
-	ADDQ  ·prime3v(SB), AX
-
-singles:
-	ADDQ $4, BX
-	CMPQ SI, BX
-	JGE  finalize
-
-singlesLoop:
-	MOVBQZX (SI), R12
-	ADDQ    $1, SI
-	IMULQ   ·prime5v(SB), R12
-	XORQ    R12, AX
-
-	ROLQ  $11, AX
-	IMULQ R13, AX
-
-	CMPQ SI, BX
-	JL   singlesLoop
-
-finalize:
-	MOVQ  AX, R12
-	SHRQ  $33, R12
-	XORQ  R12, AX
-	IMULQ R14, AX
-	MOVQ  AX, R12
-	SHRQ  $29, R12
-	XORQ  R12, AX
-	IMULQ ·prime3v(SB), AX
-	MOVQ  AX, R12
-	SHRQ  $32, R12
-	XORQ  R12, AX
-
-	MOVQ AX, ret+24(FP)
-	RET
-
-// writeBlocks uses the same registers as above except that it uses AX to store
-// the d pointer.
-
-// func writeBlocks(d *Digest, b []byte) int
-TEXT ·writeBlocks(SB), NOSPLIT, $0-40
-	// Load fixed primes needed for round.
-	MOVQ ·prime1v(SB), R13
-	MOVQ ·prime2v(SB), R14
-
-	// Load slice.
-	MOVQ b_base+8(FP), SI
-	MOVQ b_len+16(FP), DX
-	LEAQ (SI)(DX*1), BX
-	SUBQ $32, BX
-
-	// Load vN from d.
-	MOVQ d+0(FP), AX
-	MOVQ 0(AX), R8   // v1
-	MOVQ 8(AX), R9   // v2
-	MOVQ 16(AX), R10 // v3
-	MOVQ 24(AX), R11 // v4
-
-	// We don't need to check the loop condition here; this function is
-	// always called with at least one block of data to process.
-blockLoop:
-	round(R8)
-	round(R9)
-	round(R10)
-	round(R11)
-
-	CMPQ SI, BX
-	JLE  blockLoop
-
-	// Copy vN back to d.
-	MOVQ R8, 0(AX)
-	MOVQ R9, 8(AX)
-	MOVQ R10, 16(AX)
-	MOVQ R11, 24(AX)
-
-	// The number of bytes written is SI minus the old base pointer.
-	SUBQ b_base+8(FP), SI
-	MOVQ SI, ret+32(FP)
-
-	RET

vendor/github.com/cespare/xxhash/v2/xxhash_other.go

@@ -1,76 +0,0 @@
-// +build !amd64 appengine !gc purego
-
-package xxhash
-
-// Sum64 computes the 64-bit xxHash digest of b.
-func Sum64(b []byte) uint64 {
-	// A simpler version would be
-	//   d := New()
-	//   d.Write(b)
-	//   return d.Sum64()
-	// but this is faster, particularly for small inputs.
-
-	n := len(b)
-	var h uint64
-
-	if n >= 32 {
-		v1 := prime1v + prime2
-		v2 := prime2
-		v3 := uint64(0)
-		v4 := -prime1v
-		for len(b) >= 32 {
-			v1 = round(v1, u64(b[0:8:len(b)]))
-			v2 = round(v2, u64(b[8:16:len(b)]))
-			v3 = round(v3, u64(b[16:24:len(b)]))
-			v4 = round(v4, u64(b[24:32:len(b)]))
-			b = b[32:len(b):len(b)]
-		}
-		h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4)
-		h = mergeRound(h, v1)
-		h = mergeRound(h, v2)
-		h = mergeRound(h, v3)
-		h = mergeRound(h, v4)
-	} else {
-		h = prime5
-	}
-
-	h += uint64(n)
-
-	i, end := 0, len(b)
-	for ; i+8 <= end; i += 8 {
-		k1 := round(0, u64(b[i:i+8:len(b)]))
-		h ^= k1
-		h = rol27(h)*prime1 + prime4
-	}
-	if i+4 <= end {
-		h ^= uint64(u32(b[i:i+4:len(b)])) * prime1
-		h = rol23(h)*prime2 + prime3
-		i += 4
-	}
-	for ; i < end; i++ {
-		h ^= uint64(b[i]) * prime5
-		h = rol11(h) * prime1
-	}
-
-	h ^= h >> 33
-	h *= prime2
-	h ^= h >> 29
-	h *= prime3
-	h ^= h >> 32
-
-	return h
-}
-
-func writeBlocks(d *Digest, b []byte) int {
-	v1, v2, v3, v4 := d.v1, d.v2, d.v3, d.v4
-	n := len(b)
-	for len(b) >= 32 {
-		v1 = round(v1, u64(b[0:8:len(b)]))
-		v2 = round(v2, u64(b[8:16:len(b)]))
-		v3 = round(v3, u64(b[16:24:len(b)]))
-		v4 = round(v4, u64(b[24:32:len(b)]))
-		b = b[32:len(b):len(b)]
-	}
-	d.v1, d.v2, d.v3, d.v4 = v1, v2, v3, v4
-	return n - len(b)
-}

vendor/github.com/cespare/xxhash/v2/xxhash_safe.go

@@ -1,15 +0,0 @@
-// +build appengine
-
-// This file contains the safe implementations of otherwise unsafe-using code.
-
-package xxhash
-
-// Sum64String computes the 64-bit xxHash digest of s.
-func Sum64String(s string) uint64 {
-	return Sum64([]byte(s))
-}
-
-// WriteString adds more data to d. It always returns len(s), nil.
-func (d *Digest) WriteString(s string) (n int, err error) {
-	return d.Write([]byte(s))
-}

vendor/github.com/cespare/xxhash/v2/xxhash_unsafe.go

@@ -1,57 +0,0 @@
-// +build !appengine
-
-// This file encapsulates usage of unsafe.
-// xxhash_safe.go contains the safe implementations.
-
-package xxhash
-
-import (
-	"unsafe"
-)
-
-// In the future it's possible that compiler optimizations will make these
-// XxxString functions unnecessary by realizing that calls such as
-// Sum64([]byte(s)) don't need to copy s. See https://golang.org/issue/2205.
-// If that happens, even if we keep these functions they can be replaced with
-// the trivial safe code.
-
-// NOTE: The usual way of doing an unsafe string-to-[]byte conversion is:
-//
-//   var b []byte
-//   bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
-//   bh.Data = (*reflect.StringHeader)(unsafe.Pointer(&s)).Data
-//   bh.Len = len(s)
-//   bh.Cap = len(s)
-//
-// Unfortunately, as of Go 1.15.3 the inliner's cost model assigns a high enough
-// weight to this sequence of expressions that any function that uses it will
-// not be inlined. Instead, the functions below use a different unsafe
-// conversion designed to minimize the inliner weight and allow both to be
-// inlined. There is also a test (TestInlining) which verifies that these are
-// inlined.
-//
-// See https://github.com/golang/go/issues/42739 for discussion.
-
-// Sum64String computes the 64-bit xxHash digest of s.
-// It may be faster than Sum64([]byte(s)) by avoiding a copy.
-func Sum64String(s string) uint64 {
-	b := *(*[]byte)(unsafe.Pointer(&sliceHeader{s, len(s)}))
-	return Sum64(b)
-}
-
-// WriteString adds more data to d. It always returns len(s), nil.
-// It may be faster than Write([]byte(s)) by avoiding a copy.
-func (d *Digest) WriteString(s string) (n int, err error) {
-	d.Write(*(*[]byte)(unsafe.Pointer(&sliceHeader{s, len(s)})))
-	// d.Write always returns len(s), nil.
-	// Ignoring the return output and returning these fixed values buys a
-	// savings of 6 in the inliner's cost model.
-	return len(s), nil
-}
-
-// sliceHeader is similar to reflect.SliceHeader, but it assumes that the layout
-// of the first two words is the same as the layout of a string.
-type sliceHeader struct {
-	s   string
-	cap int
-}

vendor/github.com/dgryski/go-rendezvous/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2017-2020 Damian Gryski <damian@gryski.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

vendor/github.com/dgryski/go-rendezvous/rdv.go

@@ -1,79 +0,0 @@
-package rendezvous
-
-type Rendezvous struct {
-	nodes map[string]int
-	nstr  []string
-	nhash []uint64
-	hash  Hasher
-}
-
-type Hasher func(s string) uint64
-
-func New(nodes []string, hash Hasher) *Rendezvous {
-	r := &Rendezvous{
-		nodes: make(map[string]int, len(nodes)),
-		nstr:  make([]string, len(nodes)),
-		nhash: make([]uint64, len(nodes)),
-		hash:  hash,
-	}
-
-	for i, n := range nodes {
-		r.nodes[n] = i
-		r.nstr[i] = n
-		r.nhash[i] = hash(n)
-	}
-
-	return r
-}
-
-func (r *Rendezvous) Lookup(k string) string {
-	// short-circuit if we're empty
-	if len(r.nodes) == 0 {
-		return ""
-	}
-
-	khash := r.hash(k)
-
-	var midx int
-	var mhash = xorshiftMult64(khash ^ r.nhash[0])
-
-	for i, nhash := range r.nhash[1:] {
-		if h := xorshiftMult64(khash ^ nhash); h > mhash {
-			midx = i + 1
-			mhash = h
-		}
-	}
-
-	return r.nstr[midx]
-}
-
-func (r *Rendezvous) Add(node string) {
-	r.nodes[node] = len(r.nstr)
-	r.nstr = append(r.nstr, node)
-	r.nhash = append(r.nhash, r.hash(node))
-}
-
-func (r *Rendezvous) Remove(node string) {
-	// find index of node to remove
-	nidx := r.nodes[node]
-
-	// remove from the slices
-	l := len(r.nstr)
-	r.nstr[nidx] = r.nstr[l]
-	r.nstr = r.nstr[:l]
-
-	r.nhash[nidx] = r.nhash[l]
-	r.nhash = r.nhash[:l]
-
-	// update the map
-	delete(r.nodes, node)
-	moved := r.nstr[nidx]
-	r.nodes[moved] = nidx
-}
-
-func xorshiftMult64(x uint64) uint64 {
-	x ^= x >> 12 // a
-	x ^= x << 25 // b
-	x ^= x >> 27 // c
-	return x * 2685821657736338717
-}

vendor/github.com/go-redis/redis/v8/.gitignore

@@ -1,3 +0,0 @@
-*.rdb
-testdata/*/
-.idea/

vendor/github.com/go-redis/redis/v8/.golangci.yml

@@ -1,4 +0,0 @@
-run:
-  concurrency: 8
-  deadline: 5m
-  tests: false

vendor/github.com/go-redis/redis/v8/.prettierrc.yml

@@ -1,4 +0,0 @@
-semi: false
-singleQuote: true
-proseWrap: always
-printWidth: 100

vendor/github.com/go-redis/redis/v8/CHANGELOG.md

@@ -1,177 +0,0 @@
-## [8.11.5](https://github.com/go-redis/redis/compare/v8.11.4...v8.11.5) (2022-03-17)
-
-
-### Bug Fixes
-
-* add missing Expire methods to Cmdable ([17e3b43](https://github.com/go-redis/redis/commit/17e3b43879d516437ada71cf9c0deac6a382ed9a))
-* add whitespace for avoid unlikely colisions ([7f7c181](https://github.com/go-redis/redis/commit/7f7c1817617cfec909efb13d14ad22ef05a6ad4c))
-* example/otel compile error ([#2028](https://github.com/go-redis/redis/issues/2028)) ([187c07c](https://github.com/go-redis/redis/commit/187c07c41bf68dc3ab280bc3a925e960bbef6475))
-* **extra/redisotel:** set span.kind attribute to client ([065b200](https://github.com/go-redis/redis/commit/065b200070b41e6e949710b4f9e01b50ccc60ab2))
-* format ([96f53a0](https://github.com/go-redis/redis/commit/96f53a0159a28affa94beec1543a62234e7f8b32))
-* invalid type assert in stringArg ([de6c131](https://github.com/go-redis/redis/commit/de6c131865b8263400c8491777b295035f2408e4))
-* rename Golang to Go ([#2030](https://github.com/go-redis/redis/issues/2030)) ([b82a2d9](https://github.com/go-redis/redis/commit/b82a2d9d4d2de7b7cbe8fcd4895be62dbcacacbc))
-* set timeout for WAIT command. Fixes [#1963](https://github.com/go-redis/redis/issues/1963) ([333fee1](https://github.com/go-redis/redis/commit/333fee1a8fd98a2fbff1ab187c1b03246a7eb01f))
-* update some argument counts in pre-allocs ([f6974eb](https://github.com/go-redis/redis/commit/f6974ebb5c40a8adf90d2cacab6dc297f4eba4c2))
-
-
-### Features
-
-* Add redis v7's NX, XX, GT, LT expire variants ([e19bbb2](https://github.com/go-redis/redis/commit/e19bbb26e2e395c6e077b48d80d79e99f729a8b8))
-* add support for acl sentinel auth in universal client ([ab0ccc4](https://github.com/go-redis/redis/commit/ab0ccc47413f9b2a6eabc852fed5005a3ee1af6e))
-* add support for COPY command ([#2016](https://github.com/go-redis/redis/issues/2016)) ([730afbc](https://github.com/go-redis/redis/commit/730afbcffb93760e8a36cc06cfe55ab102b693a7))
-* add support for passing extra attributes added to spans ([39faaa1](https://github.com/go-redis/redis/commit/39faaa171523834ba527c9789710c4fde87f5a2e))
-* add support for time.Duration write and scan ([2f1b74e](https://github.com/go-redis/redis/commit/2f1b74e20cdd7719b2aecf0768d3e3ae7c3e781b))
-* **redisotel:** ability to override TracerProvider ([#1998](https://github.com/go-redis/redis/issues/1998)) ([bf8d4aa](https://github.com/go-redis/redis/commit/bf8d4aa60c00366cda2e98c3ddddc8cf68507417))
-* set net.peer.name and net.peer.port in otel example ([69bf454](https://github.com/go-redis/redis/commit/69bf454f706204211cd34835f76b2e8192d3766d))
-
-
-
-## [8.11.4](https://github.com/go-redis/redis/compare/v8.11.3...v8.11.4) (2021-10-04)
-
-
-### Features
-
-* add acl auth support for sentinels ([f66582f](https://github.com/go-redis/redis/commit/f66582f44f3dc3a4705a5260f982043fde4aa634))
-* add Cmd.{String,Int,Float,Bool}Slice helpers and an example ([5d3d293](https://github.com/go-redis/redis/commit/5d3d293cc9c60b90871e2420602001463708ce24))
-* add SetVal method for each command ([168981d](https://github.com/go-redis/redis/commit/168981da2d84ee9e07d15d3e74d738c162e264c4))
-
-
-
-## v8.11
-
-- Remove OpenTelemetry metrics.
-- Supports more redis commands and options.
-
-## v8.10
-
-- Removed extra OpenTelemetry spans from go-redis core. Now go-redis instrumentation only adds a
-  single span with a Redis command (instead of 4 spans). There are multiple reasons behind this
-  decision:
-
-  - Traces become smaller and less noisy.
-  - It may be costly to process those 3 extra spans for each query.
-  - go-redis no longer depends on OpenTelemetry.
-
-  Eventually we hope to replace the information that we no longer collect with OpenTelemetry
-  Metrics.
-
-## v8.9
-
-- Changed `PubSub.Channel` to only rely on `Ping` result. You can now use `WithChannelSize`,
-  `WithChannelHealthCheckInterval`, and `WithChannelSendTimeout` to override default settings.
-
-## v8.8
-
-- To make updating easier, extra modules now have the same version as go-redis does. That means that
-  you need to update your imports:
-
-```
-github.com/go-redis/redis/extra/redisotel -> github.com/go-redis/redis/extra/redisotel/v8
-github.com/go-redis/redis/extra/rediscensus -> github.com/go-redis/redis/extra/rediscensus/v8
-```
-
-## v8.5
-
-- [knadh](https://github.com/knadh) contributed long-awaited ability to scan Redis Hash into a
-  struct:
-
-```go
-err := rdb.HGetAll(ctx, "hash").Scan(&data)
-
-err := rdb.MGet(ctx, "key1", "key2").Scan(&data)
-```
-
-- Please check [redismock](https://github.com/go-redis/redismock) by
-  [monkey92t](https://github.com/monkey92t) if you are looking for mocking Redis Client.
-
-## v8
-
-- All commands require `context.Context` as a first argument, e.g. `rdb.Ping(ctx)`. If you are not
-  using `context.Context` yet, the simplest option is to define global package variable
-  `var ctx = context.TODO()` and use it when `ctx` is required.
-
-- Full support for `context.Context` canceling.
-
-- Added `redis.NewFailoverClusterClient` that supports routing read-only commands to a slave node.
-
-- Added `redisext.OpenTemetryHook` that adds
-  [Redis OpenTelemetry instrumentation](https://redis.uptrace.dev/tracing/).
-
-- Redis slow log support.
-
-- Ring uses Rendezvous Hashing by default which provides better distribution. You need to move
-  existing keys to a new location or keys will be inaccessible / lost. To use old hashing scheme:
-
-```go
-import "github.com/golang/groupcache/consistenthash"
-
-ring := redis.NewRing(&redis.RingOptions{
-    NewConsistentHash: func() {
-        return consistenthash.New(100, crc32.ChecksumIEEE)
-    },
-})
-```
-
-- `ClusterOptions.MaxRedirects` default value is changed from 8 to 3.
-- `Options.MaxRetries` default value is changed from 0 to 3.
-
-- `Cluster.ForEachNode` is renamed to `ForEachShard` for consistency with `Ring`.
-
-## v7.3
-
-- New option `Options.Username` which causes client to use `AuthACL`. Be aware if your connection
-  URL contains username.
-
-## v7.2
-
-- Existing `HMSet` is renamed to `HSet` and old deprecated `HMSet` is restored for Redis 3 users.
-
-## v7.1
-
-- Existing `Cmd.String` is renamed to `Cmd.Text`. New `Cmd.String` implements `fmt.Stringer`
-  interface.
-
-## v7
-
-- _Important_. Tx.Pipeline now returns a non-transactional pipeline. Use Tx.TxPipeline for a
-  transactional pipeline.
-- WrapProcess is replaced with more convenient AddHook that has access to context.Context.
-- WithContext now can not be used to create a shallow copy of the client.
-- New methods ProcessContext, DoContext, and ExecContext.
-- Client respects Context.Deadline when setting net.Conn deadline.
-- Client listens on Context.Done while waiting for a connection from the pool and returns an error
-  when context context is cancelled.
-- Add PubSub.ChannelWithSubscriptions that sends `*Subscription` in addition to `*Message` to allow
-  detecting reconnections.
-- `time.Time` is now marshalled in RFC3339 format. `rdb.Get("foo").Time()` helper is added to parse
-  the time.
-- `SetLimiter` is removed and added `Options.Limiter` instead.
-- `HMSet` is deprecated as of Redis v4.
-
-## v6.15
-
-- Cluster and Ring pipelines process commands for each node in its own goroutine.
-
-## 6.14
-
-- Added Options.MinIdleConns.
-- Added Options.MaxConnAge.
-- PoolStats.FreeConns is renamed to PoolStats.IdleConns.
-- Add Client.Do to simplify creating custom commands.
-- Add Cmd.String, Cmd.Int, Cmd.Int64, Cmd.Uint64, Cmd.Float64, and Cmd.Bool helpers.
-- Lower memory usage.
-
-## v6.13
-
-- Ring got new options called `HashReplicas` and `Hash`. It is recommended to set
-  `HashReplicas = 1000` for better keys distribution between shards.
-- Cluster client was optimized to use much less memory when reloading cluster state.
-- PubSub.ReceiveMessage is re-worked to not use ReceiveTimeout so it does not lose data when timeout
-  occurres. In most cases it is recommended to use PubSub.Channel instead.
-- Dialer.KeepAlive is set to 5 minutes by default.
-
-## v6.12
-
-- ClusterClient got new option called `ClusterSlots` which allows to build cluster of normal Redis
-  Servers that don't have cluster mode enabled. See
-  https://godoc.org/github.com/go-redis/redis#example-NewClusterClient--ManualSetup

vendor/github.com/go-redis/redis/v8/LICENSE

@@ -1,25 +0,0 @@
-Copyright (c) 2013 The github.com/go-redis/redis Authors.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/go-redis/redis/v8/Makefile

@@ -1,35 +0,0 @@
-PACKAGE_DIRS := $(shell find . -mindepth 2 -type f -name 'go.mod' -exec dirname {} \; | sort)
-
-test: testdeps
-	go test ./...
-	go test ./... -short -race
-	go test ./... -run=NONE -bench=. -benchmem
-	env GOOS=linux GOARCH=386 go test ./...
-	go vet
-
-testdeps: testdata/redis/src/redis-server
-
-bench: testdeps
-	go test ./... -test.run=NONE -test.bench=. -test.benchmem
-
-.PHONY: all test testdeps bench
-
-testdata/redis:
-	mkdir -p $@
-	wget -qO- https://download.redis.io/releases/redis-6.2.5.tar.gz | tar xvz --strip-components=1 -C $@
-
-testdata/redis/src/redis-server: testdata/redis
-	cd $< && make all
-
-fmt:
-	gofmt -w -s ./
-	goimports -w  -local github.com/go-redis/redis ./
-
-go_mod_tidy:
-	go get -u && go mod tidy
-	set -e; for dir in $(PACKAGE_DIRS); do \
-	  echo "go mod tidy in $${dir}"; \
-	  (cd "$${dir}" && \
-	    go get -u && \
-	    go mod tidy); \
-	done

vendor/github.com/go-redis/redis/v8/README.md

@@ -1,175 +0,0 @@
-# Redis client for Go
-
-![build workflow](https://github.com/go-redis/redis/actions/workflows/build.yml/badge.svg)
-[![PkgGoDev](https://pkg.go.dev/badge/github.com/go-redis/redis/v8)](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc)
-[![Documentation](https://img.shields.io/badge/redis-documentation-informational)](https://redis.uptrace.dev/)
-
-go-redis is brought to you by :star: [**uptrace/uptrace**](https://github.com/uptrace/uptrace).
-Uptrace is an open source and blazingly fast **distributed tracing** backend powered by
-OpenTelemetry and ClickHouse. Give it a star as well!
-
-## Resources
-
-- [Discussions](https://github.com/go-redis/redis/discussions)
-- [Documentation](https://redis.uptrace.dev)
-- [Reference](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc)
-- [Examples](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#pkg-examples)
-- [RealWorld example app](https://github.com/uptrace/go-treemux-realworld-example-app)
-
-Other projects you may like:
-
-- [Bun](https://bun.uptrace.dev) - fast and simple SQL client for PostgreSQL, MySQL, and SQLite.
-- [BunRouter](https://bunrouter.uptrace.dev/) - fast and flexible HTTP router for Go.
-
-## Ecosystem
-
-- [Redis Mock](https://github.com/go-redis/redismock)
-- [Distributed Locks](https://github.com/bsm/redislock)
-- [Redis Cache](https://github.com/go-redis/cache)
-- [Rate limiting](https://github.com/go-redis/redis_rate)
-
-## Features
-
-- Redis 3 commands except QUIT, MONITOR, and SYNC.
-- Automatic connection pooling with
-  [circuit breaker](https://en.wikipedia.org/wiki/Circuit_breaker_design_pattern) support.
-- [Pub/Sub](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#PubSub).
-- [Transactions](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#example-Client-TxPipeline).
-- [Pipeline](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#example-Client.Pipeline) and
-  [TxPipeline](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#example-Client.TxPipeline).
-- [Scripting](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#Script).
-- [Timeouts](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#Options).
-- [Redis Sentinel](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#NewFailoverClient).
-- [Redis Cluster](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#NewClusterClient).
-- [Cluster of Redis Servers](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#example-NewClusterClient-ManualSetup)
-  without using cluster mode and Redis Sentinel.
-- [Ring](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#NewRing).
-- [Instrumentation](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#example-package-Instrumentation).
-
-## Installation
-
-go-redis supports 2 last Go versions and requires a Go version with
-[modules](https://github.com/golang/go/wiki/Modules) support. So make sure to initialize a Go
-module:
-
-```shell
-go mod init github.com/my/repo
-```
-
-And then install go-redis/v8 (note _v8_ in the import; omitting it is a popular mistake):
-
-```shell
-go get github.com/go-redis/redis/v8
-```
-
-## Quickstart
-
-```go
-import (
-    "context"
-    "github.com/go-redis/redis/v8"
-    "fmt"
-)
-
-var ctx = context.Background()
-
-func ExampleClient() {
-    rdb := redis.NewClient(&redis.Options{
-        Addr:     "localhost:6379",
-        Password: "", // no password set
-        DB:       0,  // use default DB
-    })
-
-    err := rdb.Set(ctx, "key", "value", 0).Err()
-    if err != nil {
-        panic(err)
-    }
-
-    val, err := rdb.Get(ctx, "key").Result()
-    if err != nil {
-        panic(err)
-    }
-    fmt.Println("key", val)
-
-    val2, err := rdb.Get(ctx, "key2").Result()
-    if err == redis.Nil {
-        fmt.Println("key2 does not exist")
-    } else if err != nil {
-        panic(err)
-    } else {
-        fmt.Println("key2", val2)
-    }
-    // Output: key value
-    // key2 does not exist
-}
-```
-
-## Look and feel
-
-Some corner cases:
-
-```go
-// SET key value EX 10 NX
-set, err := rdb.SetNX(ctx, "key", "value", 10*time.Second).Result()
-
-// SET key value keepttl NX
-set, err := rdb.SetNX(ctx, "key", "value", redis.KeepTTL).Result()
-
-// SORT list LIMIT 0 2 ASC
-vals, err := rdb.Sort(ctx, "list", &redis.Sort{Offset: 0, Count: 2, Order: "ASC"}).Result()
-
-// ZRANGEBYSCORE zset -inf +inf WITHSCORES LIMIT 0 2
-vals, err := rdb.ZRangeByScoreWithScores(ctx, "zset", &redis.ZRangeBy{
-    Min: "-inf",
-    Max: "+inf",
-    Offset: 0,
-    Count: 2,
-}).Result()
-
-// ZINTERSTORE out 2 zset1 zset2 WEIGHTS 2 3 AGGREGATE SUM
-vals, err := rdb.ZInterStore(ctx, "out", &redis.ZStore{
-    Keys: []string{"zset1", "zset2"},
-    Weights: []int64{2, 3}
-}).Result()
-
-// EVAL "return {KEYS[1],ARGV[1]}" 1 "key" "hello"
-vals, err := rdb.Eval(ctx, "return {KEYS[1],ARGV[1]}", []string{"key"}, "hello").Result()
-
-// custom command
-res, err := rdb.Do(ctx, "set", "key", "value").Result()
-```
-
-## Run the test
-
-go-redis will start a redis-server and run the test cases.
-
-The paths of redis-server bin file and redis config file are defined in `main_test.go`:
-
-```
-var (
-	redisServerBin, _  = filepath.Abs(filepath.Join("testdata", "redis", "src", "redis-server"))
-	redisServerConf, _ = filepath.Abs(filepath.Join("testdata", "redis", "redis.conf"))
-)
-```
-
-For local testing, you can change the variables to refer to your local files, or create a soft link
-to the corresponding folder for redis-server and copy the config file to `testdata/redis/`:
-
-```
-ln -s /usr/bin/redis-server ./go-redis/testdata/redis/src
-cp ./go-redis/testdata/redis.conf ./go-redis/testdata/redis/
-```
-
-Lastly, run:
-
-```
-go test
-```
-
-## Contributors
-
-Thanks to all the people who already contributed!
-
-<a href="https://github.com/go-redis/redis/graphs/contributors">
-  <img src="https://contributors-img.web.app/image?repo=go-redis/redis" />
-</a>

vendor/github.com/go-redis/redis/v8/RELEASING.md

@@ -1,15 +0,0 @@
-# Releasing
-
-1. Run `release.sh` script which updates versions in go.mod files and pushes a new branch to GitHub:
-
-```shell
-TAG=v1.0.0 ./scripts/release.sh
-```
-
-2. Open a pull request and wait for the build to finish.
-
-3. Merge the pull request and run `tag.sh` to create tags for packages:
-
-```shell
-TAG=v1.0.0 ./scripts/tag.sh
-```

vendor/github.com/go-redis/redis/v8/cluster_commands.go

@@ -1,109 +0,0 @@
-package redis
-
-import (
-	"context"
-	"sync"
-	"sync/atomic"
-)
-
-func (c *ClusterClient) DBSize(ctx context.Context) *IntCmd {
-	cmd := NewIntCmd(ctx, "dbsize")
-	_ = c.hooks.process(ctx, cmd, func(ctx context.Context, _ Cmder) error {
-		var size int64
-		err := c.ForEachMaster(ctx, func(ctx context.Context, master *Client) error {
-			n, err := master.DBSize(ctx).Result()
-			if err != nil {
-				return err
-			}
-			atomic.AddInt64(&size, n)
-			return nil
-		})
-		if err != nil {
-			cmd.SetErr(err)
-		} else {
-			cmd.val = size
-		}
-		return nil
-	})
-	return cmd
-}
-
-func (c *ClusterClient) ScriptLoad(ctx context.Context, script string) *StringCmd {
-	cmd := NewStringCmd(ctx, "script", "load", script)
-	_ = c.hooks.process(ctx, cmd, func(ctx context.Context, _ Cmder) error {
-		mu := &sync.Mutex{}
-		err := c.ForEachShard(ctx, func(ctx context.Context, shard *Client) error {
-			val, err := shard.ScriptLoad(ctx, script).Result()
-			if err != nil {
-				return err
-			}
-
-			mu.Lock()
-			if cmd.Val() == "" {
-				cmd.val = val
-			}
-			mu.Unlock()
-
-			return nil
-		})
-		if err != nil {
-			cmd.SetErr(err)
-		}
-		return nil
-	})
-	return cmd
-}
-
-func (c *ClusterClient) ScriptFlush(ctx context.Context) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "script", "flush")
-	_ = c.hooks.process(ctx, cmd, func(ctx context.Context, _ Cmder) error {
-		err := c.ForEachShard(ctx, func(ctx context.Context, shard *Client) error {
-			return shard.ScriptFlush(ctx).Err()
-		})
-		if err != nil {
-			cmd.SetErr(err)
-		}
-		return nil
-	})
-	return cmd
-}
-
-func (c *ClusterClient) ScriptExists(ctx context.Context, hashes ...string) *BoolSliceCmd {
-	args := make([]interface{}, 2+len(hashes))
-	args[0] = "script"
-	args[1] = "exists"
-	for i, hash := range hashes {
-		args[2+i] = hash
-	}
-	cmd := NewBoolSliceCmd(ctx, args...)
-
-	result := make([]bool, len(hashes))
-	for i := range result {
-		result[i] = true
-	}
-
-	_ = c.hooks.process(ctx, cmd, func(ctx context.Context, _ Cmder) error {
-		mu := &sync.Mutex{}
-		err := c.ForEachShard(ctx, func(ctx context.Context, shard *Client) error {
-			val, err := shard.ScriptExists(ctx, hashes...).Result()
-			if err != nil {
-				return err
-			}
-
-			mu.Lock()
-			for i, v := range val {
-				result[i] = result[i] && v
-			}
-			mu.Unlock()
-
-			return nil
-		})
-		if err != nil {
-			cmd.SetErr(err)
-		} else {
-			cmd.val = result
-		}
-		return nil
-	})
-	return cmd
-}

vendor/github.com/go-redis/redis/v8/doc.go

@@ -1,4 +0,0 @@
-/*
-Package redis implements a Redis client.
-*/
-package redis

vendor/github.com/go-redis/redis/v8/error.go

@@ -1,144 +0,0 @@
-package redis
-
-import (
-	"context"
-	"io"
-	"net"
-	"strings"
-
-	"github.com/go-redis/redis/v8/internal/pool"
-	"github.com/go-redis/redis/v8/internal/proto"
-)
-
-// ErrClosed performs any operation on the closed client will return this error.
-var ErrClosed = pool.ErrClosed
-
-type Error interface {
-	error
-
-	// RedisError is a no-op function but
-	// serves to distinguish types that are Redis
-	// errors from ordinary errors: a type is a
-	// Redis error if it has a RedisError method.
-	RedisError()
-}
-
-var _ Error = proto.RedisError("")
-
-func shouldRetry(err error, retryTimeout bool) bool {
-	switch err {
-	case io.EOF, io.ErrUnexpectedEOF:
-		return true
-	case nil, context.Canceled, context.DeadlineExceeded:
-		return false
-	}
-
-	if v, ok := err.(timeoutError); ok {
-		if v.Timeout() {
-			return retryTimeout
-		}
-		return true
-	}
-
-	s := err.Error()
-	if s == "ERR max number of clients reached" {
-		return true
-	}
-	if strings.HasPrefix(s, "LOADING ") {
-		return true
-	}
-	if strings.HasPrefix(s, "READONLY ") {
-		return true
-	}
-	if strings.HasPrefix(s, "CLUSTERDOWN ") {
-		return true
-	}
-	if strings.HasPrefix(s, "TRYAGAIN ") {
-		return true
-	}
-
-	return false
-}
-
-func isRedisError(err error) bool {
-	_, ok := err.(proto.RedisError)
-	return ok
-}
-
-func isBadConn(err error, allowTimeout bool, addr string) bool {
-	switch err {
-	case nil:
-		return false
-	case context.Canceled, context.DeadlineExceeded:
-		return true
-	}
-
-	if isRedisError(err) {
-		switch {
-		case isReadOnlyError(err):
-			// Close connections in read only state in case domain addr is used
-			// and domain resolves to a different Redis Server. See #790.
-			return true
-		case isMovedSameConnAddr(err, addr):
-			// Close connections when we are asked to move to the same addr
-			// of the connection. Force a DNS resolution when all connections
-			// of the pool are recycled
-			return true
-		default:
-			return false
-		}
-	}
-
-	if allowTimeout {
-		if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
-			return !netErr.Temporary()
-		}
-	}
-
-	return true
-}
-
-func isMovedError(err error) (moved bool, ask bool, addr string) {
-	if !isRedisError(err) {
-		return
-	}
-
-	s := err.Error()
-	switch {
-	case strings.HasPrefix(s, "MOVED "):
-		moved = true
-	case strings.HasPrefix(s, "ASK "):
-		ask = true
-	default:
-		return
-	}
-
-	ind := strings.LastIndex(s, " ")
-	if ind == -1 {
-		return false, false, ""
-	}
-	addr = s[ind+1:]
-	return
-}
-
-func isLoadingError(err error) bool {
-	return strings.HasPrefix(err.Error(), "LOADING ")
-}
-
-func isReadOnlyError(err error) bool {
-	return strings.HasPrefix(err.Error(), "READONLY ")
-}
-
-func isMovedSameConnAddr(err error, addr string) bool {
-	redisError := err.Error()
-	if !strings.HasPrefix(redisError, "MOVED ") {
-		return false
-	}
-	return strings.HasSuffix(redisError, " "+addr)
-}
-
-//------------------------------------------------------------------------------
-
-type timeoutError interface {
-	Timeout() bool
-}

vendor/github.com/go-redis/redis/v8/internal/arg.go

@@ -1,56 +0,0 @@
-package internal
-
-import (
-	"fmt"
-	"strconv"
-	"time"
-)
-
-func AppendArg(b []byte, v interface{}) []byte {
-	switch v := v.(type) {
-	case nil:
-		return append(b, "<nil>"...)
-	case string:
-		return appendUTF8String(b, Bytes(v))
-	case []byte:
-		return appendUTF8String(b, v)
-	case int:
-		return strconv.AppendInt(b, int64(v), 10)
-	case int8:
-		return strconv.AppendInt(b, int64(v), 10)
-	case int16:
-		return strconv.AppendInt(b, int64(v), 10)
-	case int32:
-		return strconv.AppendInt(b, int64(v), 10)
-	case int64:
-		return strconv.AppendInt(b, v, 10)
-	case uint:
-		return strconv.AppendUint(b, uint64(v), 10)
-	case uint8:
-		return strconv.AppendUint(b, uint64(v), 10)
-	case uint16:
-		return strconv.AppendUint(b, uint64(v), 10)
-	case uint32:
-		return strconv.AppendUint(b, uint64(v), 10)
-	case uint64:
-		return strconv.AppendUint(b, v, 10)
-	case float32:
-		return strconv.AppendFloat(b, float64(v), 'f', -1, 64)
-	case float64:
-		return strconv.AppendFloat(b, v, 'f', -1, 64)
-	case bool:
-		if v {
-			return append(b, "true"...)
-		}
-		return append(b, "false"...)
-	case time.Time:
-		return v.AppendFormat(b, time.RFC3339Nano)
-	default:
-		return append(b, fmt.Sprint(v)...)
-	}
-}
-
-func appendUTF8String(dst []byte, src []byte) []byte {
-	dst = append(dst, src...)
-	return dst
-}

vendor/github.com/go-redis/redis/v8/internal/hashtag/hashtag.go

@@ -1,78 +0,0 @@
-package hashtag
-
-import (
-	"strings"
-
-	"github.com/go-redis/redis/v8/internal/rand"
-)
-
-const slotNumber = 16384
-
-// CRC16 implementation according to CCITT standards.
-// Copyright 2001-2010 Georges Menie (www.menie.org)
-// Copyright 2013 The Go Authors. All rights reserved.
-// http://redis.io/topics/cluster-spec#appendix-a-crc16-reference-implementation-in-ansi-c
-var crc16tab = [256]uint16{
-	0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
-	0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
-	0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
-	0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
-	0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
-	0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
-	0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
-	0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
-	0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
-	0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
-	0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
-	0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
-	0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
-	0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
-	0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
-	0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
-	0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
-	0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
-	0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
-	0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
-	0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
-	0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
-	0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
-	0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
-	0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
-	0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
-	0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
-	0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
-	0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
-	0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
-	0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
-	0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0,
-}
-
-func Key(key string) string {
-	if s := strings.IndexByte(key, '{'); s > -1 {
-		if e := strings.IndexByte(key[s+1:], '}'); e > 0 {
-			return key[s+1 : s+e+1]
-		}
-	}
-	return key
-}
-
-func RandomSlot() int {
-	return rand.Intn(slotNumber)
-}
-
-// Slot returns a consistent slot number between 0 and 16383
-// for any given string key.
-func Slot(key string) int {
-	if key == "" {
-		return RandomSlot()
-	}
-	key = Key(key)
-	return int(crc16sum(key)) % slotNumber
-}
-
-func crc16sum(key string) (crc uint16) {
-	for i := 0; i < len(key); i++ {
-		crc = (crc << 8) ^ crc16tab[(byte(crc>>8)^key[i])&0x00ff]
-	}
-	return
-}

vendor/github.com/go-redis/redis/v8/internal/hscan/hscan.go

@@ -1,201 +0,0 @@
-package hscan
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-	"strconv"
-)
-
-// decoderFunc represents decoding functions for default built-in types.
-type decoderFunc func(reflect.Value, string) error
-
-var (
-	// List of built-in decoders indexed by their numeric constant values (eg: reflect.Bool = 1).
-	decoders = []decoderFunc{
-		reflect.Bool:          decodeBool,
-		reflect.Int:           decodeInt,
-		reflect.Int8:          decodeInt8,
-		reflect.Int16:         decodeInt16,
-		reflect.Int32:         decodeInt32,
-		reflect.Int64:         decodeInt64,
-		reflect.Uint:          decodeUint,
-		reflect.Uint8:         decodeUint8,
-		reflect.Uint16:        decodeUint16,
-		reflect.Uint32:        decodeUint32,
-		reflect.Uint64:        decodeUint64,
-		reflect.Float32:       decodeFloat32,
-		reflect.Float64:       decodeFloat64,
-		reflect.Complex64:     decodeUnsupported,
-		reflect.Complex128:    decodeUnsupported,
-		reflect.Array:         decodeUnsupported,
-		reflect.Chan:          decodeUnsupported,
-		reflect.Func:          decodeUnsupported,
-		reflect.Interface:     decodeUnsupported,
-		reflect.Map:           decodeUnsupported,
-		reflect.Ptr:           decodeUnsupported,
-		reflect.Slice:         decodeSlice,
-		reflect.String:        decodeString,
-		reflect.Struct:        decodeUnsupported,
-		reflect.UnsafePointer: decodeUnsupported,
-	}
-
-	// Global map of struct field specs that is populated once for every new
-	// struct type that is scanned. This caches the field types and the corresponding
-	// decoder functions to avoid iterating through struct fields on subsequent scans.
-	globalStructMap = newStructMap()
-)
-
-func Struct(dst interface{}) (StructValue, error) {
-	v := reflect.ValueOf(dst)
-
-	// The destination to scan into should be a struct pointer.
-	if v.Kind() != reflect.Ptr || v.IsNil() {
-		return StructValue{}, fmt.Errorf("redis.Scan(non-pointer %T)", dst)
-	}
-
-	v = v.Elem()
-	if v.Kind() != reflect.Struct {
-		return StructValue{}, fmt.Errorf("redis.Scan(non-struct %T)", dst)
-	}
-
-	return StructValue{
-		spec:  globalStructMap.get(v.Type()),
-		value: v,
-	}, nil
-}
-
-// Scan scans the results from a key-value Redis map result set to a destination struct.
-// The Redis keys are matched to the struct's field with the `redis` tag.
-func Scan(dst interface{}, keys []interface{}, vals []interface{}) error {
-	if len(keys) != len(vals) {
-		return errors.New("args should have the same number of keys and vals")
-	}
-
-	strct, err := Struct(dst)
-	if err != nil {
-		return err
-	}
-
-	// Iterate through the (key, value) sequence.
-	for i := 0; i < len(vals); i++ {
-		key, ok := keys[i].(string)
-		if !ok {
-			continue
-		}
-
-		val, ok := vals[i].(string)
-		if !ok {
-			continue
-		}
-
-		if err := strct.Scan(key, val); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func decodeBool(f reflect.Value, s string) error {
-	b, err := strconv.ParseBool(s)
-	if err != nil {
-		return err
-	}
-	f.SetBool(b)
-	return nil
-}
-
-func decodeInt8(f reflect.Value, s string) error {
-	return decodeNumber(f, s, 8)
-}
-
-func decodeInt16(f reflect.Value, s string) error {
-	return decodeNumber(f, s, 16)
-}
-
-func decodeInt32(f reflect.Value, s string) error {
-	return decodeNumber(f, s, 32)
-}
-
-func decodeInt64(f reflect.Value, s string) error {
-	return decodeNumber(f, s, 64)
-}
-
-func decodeInt(f reflect.Value, s string) error {
-	return decodeNumber(f, s, 0)
-}
-
-func decodeNumber(f reflect.Value, s string, bitSize int) error {
-	v, err := strconv.ParseInt(s, 10, bitSize)
-	if err != nil {
-		return err
-	}
-	f.SetInt(v)
-	return nil
-}
-
-func decodeUint8(f reflect.Value, s string) error {
-	return decodeUnsignedNumber(f, s, 8)
-}
-
-func decodeUint16(f reflect.Value, s string) error {
-	return decodeUnsignedNumber(f, s, 16)
-}
-
-func decodeUint32(f reflect.Value, s string) error {
-	return decodeUnsignedNumber(f, s, 32)
-}
-
-func decodeUint64(f reflect.Value, s string) error {
-	return decodeUnsignedNumber(f, s, 64)
-}
-
-func decodeUint(f reflect.Value, s string) error {
-	return decodeUnsignedNumber(f, s, 0)
-}
-
-func decodeUnsignedNumber(f reflect.Value, s string, bitSize int) error {
-	v, err := strconv.ParseUint(s, 10, bitSize)
-	if err != nil {
-		return err
-	}
-	f.SetUint(v)
-	return nil
-}
-
-func decodeFloat32(f reflect.Value, s string) error {
-	v, err := strconv.ParseFloat(s, 32)
-	if err != nil {
-		return err
-	}
-	f.SetFloat(v)
-	return nil
-}
-
-// although the default is float64, but we better define it.
-func decodeFloat64(f reflect.Value, s string) error {
-	v, err := strconv.ParseFloat(s, 64)
-	if err != nil {
-		return err
-	}
-	f.SetFloat(v)
-	return nil
-}
-
-func decodeString(f reflect.Value, s string) error {
-	f.SetString(s)
-	return nil
-}
-
-func decodeSlice(f reflect.Value, s string) error {
-	// []byte slice ([]uint8).
-	if f.Type().Elem().Kind() == reflect.Uint8 {
-		f.SetBytes([]byte(s))
-	}
-	return nil
-}
-
-func decodeUnsupported(v reflect.Value, s string) error {
-	return fmt.Errorf("redis.Scan(unsupported %s)", v.Type())
-}

vendor/github.com/go-redis/redis/v8/internal/hscan/structmap.go

@@ -1,93 +0,0 @@
-package hscan
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-	"sync"
-)
-
-// structMap contains the map of struct fields for target structs
-// indexed by the struct type.
-type structMap struct {
-	m sync.Map
-}
-
-func newStructMap() *structMap {
-	return new(structMap)
-}
-
-func (s *structMap) get(t reflect.Type) *structSpec {
-	if v, ok := s.m.Load(t); ok {
-		return v.(*structSpec)
-	}
-
-	spec := newStructSpec(t, "redis")
-	s.m.Store(t, spec)
-	return spec
-}
-
-//------------------------------------------------------------------------------
-
-// structSpec contains the list of all fields in a target struct.
-type structSpec struct {
-	m map[string]*structField
-}
-
-func (s *structSpec) set(tag string, sf *structField) {
-	s.m[tag] = sf
-}
-
-func newStructSpec(t reflect.Type, fieldTag string) *structSpec {
-	numField := t.NumField()
-	out := &structSpec{
-		m: make(map[string]*structField, numField),
-	}
-
-	for i := 0; i < numField; i++ {
-		f := t.Field(i)
-
-		tag := f.Tag.Get(fieldTag)
-		if tag == "" || tag == "-" {
-			continue
-		}
-
-		tag = strings.Split(tag, ",")[0]
-		if tag == "" {
-			continue
-		}
-
-		// Use the built-in decoder.
-		out.set(tag, &structField{index: i, fn: decoders[f.Type.Kind()]})
-	}
-
-	return out
-}
-
-//------------------------------------------------------------------------------
-
-// structField represents a single field in a target struct.
-type structField struct {
-	index int
-	fn    decoderFunc
-}
-
-//------------------------------------------------------------------------------
-
-type StructValue struct {
-	spec  *structSpec
-	value reflect.Value
-}
-
-func (s StructValue) Scan(key string, value string) error {
-	field, ok := s.spec.m[key]
-	if !ok {
-		return nil
-	}
-	if err := field.fn(s.value.Field(field.index), value); err != nil {
-		t := s.value.Type()
-		return fmt.Errorf("cannot scan redis.result %s into struct field %s.%s of type %s, error-%s",
-			value, t.Name(), t.Field(field.index).Name, t.Field(field.index).Type, err.Error())
-	}
-	return nil
-}

vendor/github.com/go-redis/redis/v8/internal/internal.go

@@ -1,29 +0,0 @@
-package internal
-
-import (
-	"time"
-
-	"github.com/go-redis/redis/v8/internal/rand"
-)
-
-func RetryBackoff(retry int, minBackoff, maxBackoff time.Duration) time.Duration {
-	if retry < 0 {
-		panic("not reached")
-	}
-	if minBackoff == 0 {
-		return 0
-	}
-
-	d := minBackoff << uint(retry)
-	if d < minBackoff {
-		return maxBackoff
-	}
-
-	d = minBackoff + time.Duration(rand.Int63n(int64(d)))
-
-	if d > maxBackoff || d < minBackoff {
-		d = maxBackoff
-	}
-
-	return d
-}

vendor/github.com/go-redis/redis/v8/internal/log.go

@@ -1,26 +0,0 @@
-package internal
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"os"
-)
-
-type Logging interface {
-	Printf(ctx context.Context, format string, v ...interface{})
-}
-
-type logger struct {
-	log *log.Logger
-}
-
-func (l *logger) Printf(ctx context.Context, format string, v ...interface{}) {
-	_ = l.log.Output(2, fmt.Sprintf(format, v...))
-}
-
-// Logger calls Output to print to the stderr.
-// Arguments are handled in the manner of fmt.Print.
-var Logger Logging = &logger{
-	log: log.New(os.Stderr, "redis: ", log.LstdFlags|log.Lshortfile),
-}

vendor/github.com/go-redis/redis/v8/internal/once.go

@@ -1,60 +0,0 @@
-/*
-Copyright 2014 The Camlistore Authors
-
-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.
-*/
-
-package internal
-
-import (
-	"sync"
-	"sync/atomic"
-)
-
-// A Once will perform a successful action exactly once.
-//
-// Unlike a sync.Once, this Once's func returns an error
-// and is re-armed on failure.
-type Once struct {
-	m    sync.Mutex
-	done uint32
-}
-
-// Do calls the function f if and only if Do has not been invoked
-// without error for this instance of Once.  In other words, given
-// 	var once Once
-// if once.Do(f) is called multiple times, only the first call will
-// invoke f, even if f has a different value in each invocation unless
-// f returns an error.  A new instance of Once is required for each
-// function to execute.
-//
-// Do is intended for initialization that must be run exactly once.  Since f
-// is niladic, it may be necessary to use a function literal to capture the
-// arguments to a function to be invoked by Do:
-// 	err := config.once.Do(func() error { return config.init(filename) })
-func (o *Once) Do(f func() error) error {
-	if atomic.LoadUint32(&o.done) == 1 {
-		return nil
-	}
-	// Slow-path.
-	o.m.Lock()
-	defer o.m.Unlock()
-	var err error
-	if o.done == 0 {
-		err = f()
-		if err == nil {
-			atomic.StoreUint32(&o.done, 1)
-		}
-	}
-	return err
-}

vendor/github.com/go-redis/redis/v8/internal/pool/conn.go

@@ -1,121 +0,0 @@
-package pool
-
-import (
-	"bufio"
-	"context"
-	"net"
-	"sync/atomic"
-	"time"
-
-	"github.com/go-redis/redis/v8/internal/proto"
-)
-
-var noDeadline = time.Time{}
-
-type Conn struct {
-	usedAt  int64 // atomic
-	netConn net.Conn
-
-	rd *proto.Reader
-	bw *bufio.Writer
-	wr *proto.Writer
-
-	Inited    bool
-	pooled    bool
-	createdAt time.Time
-}
-
-func NewConn(netConn net.Conn) *Conn {
-	cn := &Conn{
-		netConn:   netConn,
-		createdAt: time.Now(),
-	}
-	cn.rd = proto.NewReader(netConn)
-	cn.bw = bufio.NewWriter(netConn)
-	cn.wr = proto.NewWriter(cn.bw)
-	cn.SetUsedAt(time.Now())
-	return cn
-}
-
-func (cn *Conn) UsedAt() time.Time {
-	unix := atomic.LoadInt64(&cn.usedAt)
-	return time.Unix(unix, 0)
-}
-
-func (cn *Conn) SetUsedAt(tm time.Time) {
-	atomic.StoreInt64(&cn.usedAt, tm.Unix())
-}
-
-func (cn *Conn) SetNetConn(netConn net.Conn) {
-	cn.netConn = netConn
-	cn.rd.Reset(netConn)
-	cn.bw.Reset(netConn)
-}
-
-func (cn *Conn) Write(b []byte) (int, error) {
-	return cn.netConn.Write(b)
-}
-
-func (cn *Conn) RemoteAddr() net.Addr {
-	if cn.netConn != nil {
-		return cn.netConn.RemoteAddr()
-	}
-	return nil
-}
-
-func (cn *Conn) WithReader(ctx context.Context, timeout time.Duration, fn func(rd *proto.Reader) error) error {
-	if err := cn.netConn.SetReadDeadline(cn.deadline(ctx, timeout)); err != nil {
-		return err
-	}
-	return fn(cn.rd)
-}
-
-func (cn *Conn) WithWriter(
-	ctx context.Context, timeout time.Duration, fn func(wr *proto.Writer) error,
-) error {
-	if err := cn.netConn.SetWriteDeadline(cn.deadline(ctx, timeout)); err != nil {
-		return err
-	}
-
-	if cn.bw.Buffered() > 0 {
-		cn.bw.Reset(cn.netConn)
-	}
-
-	if err := fn(cn.wr); err != nil {
-		return err
-	}
-
-	return cn.bw.Flush()
-}
-
-func (cn *Conn) Close() error {
-	return cn.netConn.Close()
-}
-
-func (cn *Conn) deadline(ctx context.Context, timeout time.Duration) time.Time {
-	tm := time.Now()
-	cn.SetUsedAt(tm)
-
-	if timeout > 0 {
-		tm = tm.Add(timeout)
-	}
-
-	if ctx != nil {
-		deadline, ok := ctx.Deadline()
-		if ok {
-			if timeout == 0 {
-				return deadline
-			}
-			if deadline.Before(tm) {
-				return deadline
-			}
-			return tm
-		}
-	}
-
-	if timeout > 0 {
-		return tm
-	}
-
-	return noDeadline
-}

vendor/github.com/go-redis/redis/v8/internal/pool/pool.go

@@ -1,557 +0,0 @@
-package pool
-
-import (
-	"context"
-	"errors"
-	"net"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/go-redis/redis/v8/internal"
-)
-
-var (
-	// ErrClosed performs any operation on the closed client will return this error.
-	ErrClosed = errors.New("redis: client is closed")
-
-	// ErrPoolTimeout timed out waiting to get a connection from the connection pool.
-	ErrPoolTimeout = errors.New("redis: connection pool timeout")
-)
-
-var timers = sync.Pool{
-	New: func() interface{} {
-		t := time.NewTimer(time.Hour)
-		t.Stop()
-		return t
-	},
-}
-
-// Stats contains pool state information and accumulated stats.
-type Stats struct {
-	Hits     uint32 // number of times free connection was found in the pool
-	Misses   uint32 // number of times free connection was NOT found in the pool
-	Timeouts uint32 // number of times a wait timeout occurred
-
-	TotalConns uint32 // number of total connections in the pool
-	IdleConns  uint32 // number of idle connections in the pool
-	StaleConns uint32 // number of stale connections removed from the pool
-}
-
-type Pooler interface {
-	NewConn(context.Context) (*Conn, error)
-	CloseConn(*Conn) error
-
-	Get(context.Context) (*Conn, error)
-	Put(context.Context, *Conn)
-	Remove(context.Context, *Conn, error)
-
-	Len() int
-	IdleLen() int
-	Stats() *Stats
-
-	Close() error
-}
-
-type Options struct {
-	Dialer  func(context.Context) (net.Conn, error)
-	OnClose func(*Conn) error
-
-	PoolFIFO           bool
-	PoolSize           int
-	MinIdleConns       int
-	MaxConnAge         time.Duration
-	PoolTimeout        time.Duration
-	IdleTimeout        time.Duration
-	IdleCheckFrequency time.Duration
-}
-
-type lastDialErrorWrap struct {
-	err error
-}
-
-type ConnPool struct {
-	opt *Options
-
-	dialErrorsNum uint32 // atomic
-
-	lastDialError atomic.Value
-
-	queue chan struct{}
-
-	connsMu      sync.Mutex
-	conns        []*Conn
-	idleConns    []*Conn
-	poolSize     int
-	idleConnsLen int
-
-	stats Stats
-
-	_closed  uint32 // atomic
-	closedCh chan struct{}
-}
-
-var _ Pooler = (*ConnPool)(nil)
-
-func NewConnPool(opt *Options) *ConnPool {
-	p := &ConnPool{
-		opt: opt,
-
-		queue:     make(chan struct{}, opt.PoolSize),
-		conns:     make([]*Conn, 0, opt.PoolSize),
-		idleConns: make([]*Conn, 0, opt.PoolSize),
-		closedCh:  make(chan struct{}),
-	}
-
-	p.connsMu.Lock()
-	p.checkMinIdleConns()
-	p.connsMu.Unlock()
-
-	if opt.IdleTimeout > 0 && opt.IdleCheckFrequency > 0 {
-		go p.reaper(opt.IdleCheckFrequency)
-	}
-
-	return p
-}
-
-func (p *ConnPool) checkMinIdleConns() {
-	if p.opt.MinIdleConns == 0 {
-		return
-	}
-	for p.poolSize < p.opt.PoolSize && p.idleConnsLen < p.opt.MinIdleConns {
-		p.poolSize++
-		p.idleConnsLen++
-
-		go func() {
-			err := p.addIdleConn()
-			if err != nil && err != ErrClosed {
-				p.connsMu.Lock()
-				p.poolSize--
-				p.idleConnsLen--
-				p.connsMu.Unlock()
-			}
-		}()
-	}
-}
-
-func (p *ConnPool) addIdleConn() error {
-	cn, err := p.dialConn(context.TODO(), true)
-	if err != nil {
-		return err
-	}
-
-	p.connsMu.Lock()
-	defer p.connsMu.Unlock()
-
-	// It is not allowed to add new connections to the closed connection pool.
-	if p.closed() {
-		_ = cn.Close()
-		return ErrClosed
-	}
-
-	p.conns = append(p.conns, cn)
-	p.idleConns = append(p.idleConns, cn)
-	return nil
-}
-
-func (p *ConnPool) NewConn(ctx context.Context) (*Conn, error) {
-	return p.newConn(ctx, false)
-}
-
-func (p *ConnPool) newConn(ctx context.Context, pooled bool) (*Conn, error) {
-	cn, err := p.dialConn(ctx, pooled)
-	if err != nil {
-		return nil, err
-	}
-
-	p.connsMu.Lock()
-	defer p.connsMu.Unlock()
-
-	// It is not allowed to add new connections to the closed connection pool.
-	if p.closed() {
-		_ = cn.Close()
-		return nil, ErrClosed
-	}
-
-	p.conns = append(p.conns, cn)
-	if pooled {
-		// If pool is full remove the cn on next Put.
-		if p.poolSize >= p.opt.PoolSize {
-			cn.pooled = false
-		} else {
-			p.poolSize++
-		}
-	}
-
-	return cn, nil
-}
-
-func (p *ConnPool) dialConn(ctx context.Context, pooled bool) (*Conn, error) {
-	if p.closed() {
-		return nil, ErrClosed
-	}
-
-	if atomic.LoadUint32(&p.dialErrorsNum) >= uint32(p.opt.PoolSize) {
-		return nil, p.getLastDialError()
-	}
-
-	netConn, err := p.opt.Dialer(ctx)
-	if err != nil {
-		p.setLastDialError(err)
-		if atomic.AddUint32(&p.dialErrorsNum, 1) == uint32(p.opt.PoolSize) {
-			go p.tryDial()
-		}
-		return nil, err
-	}
-
-	cn := NewConn(netConn)
-	cn.pooled = pooled
-	return cn, nil
-}
-
-func (p *ConnPool) tryDial() {
-	for {
-		if p.closed() {
-			return
-		}
-
-		conn, err := p.opt.Dialer(context.Background())
-		if err != nil {
-			p.setLastDialError(err)
-			time.Sleep(time.Second)
-			continue
-		}
-
-		atomic.StoreUint32(&p.dialErrorsNum, 0)
-		_ = conn.Close()
-		return
-	}
-}
-
-func (p *ConnPool) setLastDialError(err error) {
-	p.lastDialError.Store(&lastDialErrorWrap{err: err})
-}
-
-func (p *ConnPool) getLastDialError() error {
-	err, _ := p.lastDialError.Load().(*lastDialErrorWrap)
-	if err != nil {
-		return err.err
-	}
-	return nil
-}
-
-// Get returns existed connection from the pool or creates a new one.
-func (p *ConnPool) Get(ctx context.Context) (*Conn, error) {
-	if p.closed() {
-		return nil, ErrClosed
-	}
-
-	if err := p.waitTurn(ctx); err != nil {
-		return nil, err
-	}
-
-	for {
-		p.connsMu.Lock()
-		cn, err := p.popIdle()
-		p.connsMu.Unlock()
-
-		if err != nil {
-			return nil, err
-		}
-
-		if cn == nil {
-			break
-		}
-
-		if p.isStaleConn(cn) {
-			_ = p.CloseConn(cn)
-			continue
-		}
-
-		atomic.AddUint32(&p.stats.Hits, 1)
-		return cn, nil
-	}
-
-	atomic.AddUint32(&p.stats.Misses, 1)
-
-	newcn, err := p.newConn(ctx, true)
-	if err != nil {
-		p.freeTurn()
-		return nil, err
-	}
-
-	return newcn, nil
-}
-
-func (p *ConnPool) getTurn() {
-	p.queue <- struct{}{}
-}
-
-func (p *ConnPool) waitTurn(ctx context.Context) error {
-	select {
-	case <-ctx.Done():
-		return ctx.Err()
-	default:
-	}
-
-	select {
-	case p.queue <- struct{}{}:
-		return nil
-	default:
-	}
-
-	timer := timers.Get().(*time.Timer)
-	timer.Reset(p.opt.PoolTimeout)
-
-	select {
-	case <-ctx.Done():
-		if !timer.Stop() {
-			<-timer.C
-		}
-		timers.Put(timer)
-		return ctx.Err()
-	case p.queue <- struct{}{}:
-		if !timer.Stop() {
-			<-timer.C
-		}
-		timers.Put(timer)
-		return nil
-	case <-timer.C:
-		timers.Put(timer)
-		atomic.AddUint32(&p.stats.Timeouts, 1)
-		return ErrPoolTimeout
-	}
-}
-
-func (p *ConnPool) freeTurn() {
-	<-p.queue
-}
-
-func (p *ConnPool) popIdle() (*Conn, error) {
-	if p.closed() {
-		return nil, ErrClosed
-	}
-	n := len(p.idleConns)
-	if n == 0 {
-		return nil, nil
-	}
-
-	var cn *Conn
-	if p.opt.PoolFIFO {
-		cn = p.idleConns[0]
-		copy(p.idleConns, p.idleConns[1:])
-		p.idleConns = p.idleConns[:n-1]
-	} else {
-		idx := n - 1
-		cn = p.idleConns[idx]
-		p.idleConns = p.idleConns[:idx]
-	}
-	p.idleConnsLen--
-	p.checkMinIdleConns()
-	return cn, nil
-}
-
-func (p *ConnPool) Put(ctx context.Context, cn *Conn) {
-	if cn.rd.Buffered() > 0 {
-		internal.Logger.Printf(ctx, "Conn has unread data")
-		p.Remove(ctx, cn, BadConnError{})
-		return
-	}
-
-	if !cn.pooled {
-		p.Remove(ctx, cn, nil)
-		return
-	}
-
-	p.connsMu.Lock()
-	p.idleConns = append(p.idleConns, cn)
-	p.idleConnsLen++
-	p.connsMu.Unlock()
-	p.freeTurn()
-}
-
-func (p *ConnPool) Remove(ctx context.Context, cn *Conn, reason error) {
-	p.removeConnWithLock(cn)
-	p.freeTurn()
-	_ = p.closeConn(cn)
-}
-
-func (p *ConnPool) CloseConn(cn *Conn) error {
-	p.removeConnWithLock(cn)
-	return p.closeConn(cn)
-}
-
-func (p *ConnPool) removeConnWithLock(cn *Conn) {
-	p.connsMu.Lock()
-	p.removeConn(cn)
-	p.connsMu.Unlock()
-}
-
-func (p *ConnPool) removeConn(cn *Conn) {
-	for i, c := range p.conns {
-		if c == cn {
-			p.conns = append(p.conns[:i], p.conns[i+1:]...)
-			if cn.pooled {
-				p.poolSize--
-				p.checkMinIdleConns()
-			}
-			return
-		}
-	}
-}
-
-func (p *ConnPool) closeConn(cn *Conn) error {
-	if p.opt.OnClose != nil {
-		_ = p.opt.OnClose(cn)
-	}
-	return cn.Close()
-}
-
-// Len returns total number of connections.
-func (p *ConnPool) Len() int {
-	p.connsMu.Lock()
-	n := len(p.conns)
-	p.connsMu.Unlock()
-	return n
-}
-
-// IdleLen returns number of idle connections.
-func (p *ConnPool) IdleLen() int {
-	p.connsMu.Lock()
-	n := p.idleConnsLen
-	p.connsMu.Unlock()
-	return n
-}
-
-func (p *ConnPool) Stats() *Stats {
-	idleLen := p.IdleLen()
-	return &Stats{
-		Hits:     atomic.LoadUint32(&p.stats.Hits),
-		Misses:   atomic.LoadUint32(&p.stats.Misses),
-		Timeouts: atomic.LoadUint32(&p.stats.Timeouts),
-
-		TotalConns: uint32(p.Len()),
-		IdleConns:  uint32(idleLen),
-		StaleConns: atomic.LoadUint32(&p.stats.StaleConns),
-	}
-}
-
-func (p *ConnPool) closed() bool {
-	return atomic.LoadUint32(&p._closed) == 1
-}
-
-func (p *ConnPool) Filter(fn func(*Conn) bool) error {
-	p.connsMu.Lock()
-	defer p.connsMu.Unlock()
-
-	var firstErr error
-	for _, cn := range p.conns {
-		if fn(cn) {
-			if err := p.closeConn(cn); err != nil && firstErr == nil {
-				firstErr = err
-			}
-		}
-	}
-	return firstErr
-}
-
-func (p *ConnPool) Close() error {
-	if !atomic.CompareAndSwapUint32(&p._closed, 0, 1) {
-		return ErrClosed
-	}
-	close(p.closedCh)
-
-	var firstErr error
-	p.connsMu.Lock()
-	for _, cn := range p.conns {
-		if err := p.closeConn(cn); err != nil && firstErr == nil {
-			firstErr = err
-		}
-	}
-	p.conns = nil
-	p.poolSize = 0
-	p.idleConns = nil
-	p.idleConnsLen = 0
-	p.connsMu.Unlock()
-
-	return firstErr
-}
-
-func (p *ConnPool) reaper(frequency time.Duration) {
-	ticker := time.NewTicker(frequency)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-ticker.C:
-			// It is possible that ticker and closedCh arrive together,
-			// and select pseudo-randomly pick ticker case, we double
-			// check here to prevent being executed after closed.
-			if p.closed() {
-				return
-			}
-			_, err := p.ReapStaleConns()
-			if err != nil {
-				internal.Logger.Printf(context.Background(), "ReapStaleConns failed: %s", err)
-				continue
-			}
-		case <-p.closedCh:
-			return
-		}
-	}
-}
-
-func (p *ConnPool) ReapStaleConns() (int, error) {
-	var n int
-	for {
-		p.getTurn()
-
-		p.connsMu.Lock()
-		cn := p.reapStaleConn()
-		p.connsMu.Unlock()
-
-		p.freeTurn()
-
-		if cn != nil {
-			_ = p.closeConn(cn)
-			n++
-		} else {
-			break
-		}
-	}
-	atomic.AddUint32(&p.stats.StaleConns, uint32(n))
-	return n, nil
-}
-
-func (p *ConnPool) reapStaleConn() *Conn {
-	if len(p.idleConns) == 0 {
-		return nil
-	}
-
-	cn := p.idleConns[0]
-	if !p.isStaleConn(cn) {
-		return nil
-	}
-
-	p.idleConns = append(p.idleConns[:0], p.idleConns[1:]...)
-	p.idleConnsLen--
-	p.removeConn(cn)
-
-	return cn
-}
-
-func (p *ConnPool) isStaleConn(cn *Conn) bool {
-	if p.opt.IdleTimeout == 0 && p.opt.MaxConnAge == 0 {
-		return false
-	}
-
-	now := time.Now()
-	if p.opt.IdleTimeout > 0 && now.Sub(cn.UsedAt()) >= p.opt.IdleTimeout {
-		return true
-	}
-	if p.opt.MaxConnAge > 0 && now.Sub(cn.createdAt) >= p.opt.MaxConnAge {
-		return true
-	}
-
-	return false
-}

vendor/github.com/go-redis/redis/v8/internal/pool/pool_single.go

@@ -1,58 +0,0 @@
-package pool
-
-import "context"
-
-type SingleConnPool struct {
-	pool      Pooler
-	cn        *Conn
-	stickyErr error
-}
-
-var _ Pooler = (*SingleConnPool)(nil)
-
-func NewSingleConnPool(pool Pooler, cn *Conn) *SingleConnPool {
-	return &SingleConnPool{
-		pool: pool,
-		cn:   cn,
-	}
-}
-
-func (p *SingleConnPool) NewConn(ctx context.Context) (*Conn, error) {
-	return p.pool.NewConn(ctx)
-}
-
-func (p *SingleConnPool) CloseConn(cn *Conn) error {
-	return p.pool.CloseConn(cn)
-}
-
-func (p *SingleConnPool) Get(ctx context.Context) (*Conn, error) {
-	if p.stickyErr != nil {
-		return nil, p.stickyErr
-	}
-	return p.cn, nil
-}
-
-func (p *SingleConnPool) Put(ctx context.Context, cn *Conn) {}
-
-func (p *SingleConnPool) Remove(ctx context.Context, cn *Conn, reason error) {
-	p.cn = nil
-	p.stickyErr = reason
-}
-
-func (p *SingleConnPool) Close() error {
-	p.cn = nil
-	p.stickyErr = ErrClosed
-	return nil
-}
-
-func (p *SingleConnPool) Len() int {
-	return 0
-}
-
-func (p *SingleConnPool) IdleLen() int {
-	return 0
-}
-
-func (p *SingleConnPool) Stats() *Stats {
-	return &Stats{}
-}

vendor/github.com/go-redis/redis/v8/internal/pool/pool_sticky.go

@@ -1,201 +0,0 @@
-package pool
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"sync/atomic"
-)
-
-const (
-	stateDefault = 0
-	stateInited  = 1
-	stateClosed  = 2
-)
-
-type BadConnError struct {
-	wrapped error
-}
-
-var _ error = (*BadConnError)(nil)
-
-func (e BadConnError) Error() string {
-	s := "redis: Conn is in a bad state"
-	if e.wrapped != nil {
-		s += ": " + e.wrapped.Error()
-	}
-	return s
-}
-
-func (e BadConnError) Unwrap() error {
-	return e.wrapped
-}
-
-//------------------------------------------------------------------------------
-
-type StickyConnPool struct {
-	pool   Pooler
-	shared int32 // atomic
-
-	state uint32 // atomic
-	ch    chan *Conn
-
-	_badConnError atomic.Value
-}
-
-var _ Pooler = (*StickyConnPool)(nil)
-
-func NewStickyConnPool(pool Pooler) *StickyConnPool {
-	p, ok := pool.(*StickyConnPool)
-	if !ok {
-		p = &StickyConnPool{
-			pool: pool,
-			ch:   make(chan *Conn, 1),
-		}
-	}
-	atomic.AddInt32(&p.shared, 1)
-	return p
-}
-
-func (p *StickyConnPool) NewConn(ctx context.Context) (*Conn, error) {
-	return p.pool.NewConn(ctx)
-}
-
-func (p *StickyConnPool) CloseConn(cn *Conn) error {
-	return p.pool.CloseConn(cn)
-}
-
-func (p *StickyConnPool) Get(ctx context.Context) (*Conn, error) {
-	// In worst case this races with Close which is not a very common operation.
-	for i := 0; i < 1000; i++ {
-		switch atomic.LoadUint32(&p.state) {
-		case stateDefault:
-			cn, err := p.pool.Get(ctx)
-			if err != nil {
-				return nil, err
-			}
-			if atomic.CompareAndSwapUint32(&p.state, stateDefault, stateInited) {
-				return cn, nil
-			}
-			p.pool.Remove(ctx, cn, ErrClosed)
-		case stateInited:
-			if err := p.badConnError(); err != nil {
-				return nil, err
-			}
-			cn, ok := <-p.ch
-			if !ok {
-				return nil, ErrClosed
-			}
-			return cn, nil
-		case stateClosed:
-			return nil, ErrClosed
-		default:
-			panic("not reached")
-		}
-	}
-	return nil, fmt.Errorf("redis: StickyConnPool.Get: infinite loop")
-}
-
-func (p *StickyConnPool) Put(ctx context.Context, cn *Conn) {
-	defer func() {
-		if recover() != nil {
-			p.freeConn(ctx, cn)
-		}
-	}()
-	p.ch <- cn
-}
-
-func (p *StickyConnPool) freeConn(ctx context.Context, cn *Conn) {
-	if err := p.badConnError(); err != nil {
-		p.pool.Remove(ctx, cn, err)
-	} else {
-		p.pool.Put(ctx, cn)
-	}
-}
-
-func (p *StickyConnPool) Remove(ctx context.Context, cn *Conn, reason error) {
-	defer func() {
-		if recover() != nil {
-			p.pool.Remove(ctx, cn, ErrClosed)
-		}
-	}()
-	p._badConnError.Store(BadConnError{wrapped: reason})
-	p.ch <- cn
-}
-
-func (p *StickyConnPool) Close() error {
-	if shared := atomic.AddInt32(&p.shared, -1); shared > 0 {
-		return nil
-	}
-
-	for i := 0; i < 1000; i++ {
-		state := atomic.LoadUint32(&p.state)
-		if state == stateClosed {
-			return ErrClosed
-		}
-		if atomic.CompareAndSwapUint32(&p.state, state, stateClosed) {
-			close(p.ch)
-			cn, ok := <-p.ch
-			if ok {
-				p.freeConn(context.TODO(), cn)
-			}
-			return nil
-		}
-	}
-
-	return errors.New("redis: StickyConnPool.Close: infinite loop")
-}
-
-func (p *StickyConnPool) Reset(ctx context.Context) error {
-	if p.badConnError() == nil {
-		return nil
-	}
-
-	select {
-	case cn, ok := <-p.ch:
-		if !ok {
-			return ErrClosed
-		}
-		p.pool.Remove(ctx, cn, ErrClosed)
-		p._badConnError.Store(BadConnError{wrapped: nil})
-	default:
-		return errors.New("redis: StickyConnPool does not have a Conn")
-	}
-
-	if !atomic.CompareAndSwapUint32(&p.state, stateInited, stateDefault) {
-		state := atomic.LoadUint32(&p.state)
-		return fmt.Errorf("redis: invalid StickyConnPool state: %d", state)
-	}
-
-	return nil
-}
-
-func (p *StickyConnPool) badConnError() error {
-	if v := p._badConnError.Load(); v != nil {
-		if err := v.(BadConnError); err.wrapped != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (p *StickyConnPool) Len() int {
-	switch atomic.LoadUint32(&p.state) {
-	case stateDefault:
-		return 0
-	case stateInited:
-		return 1
-	case stateClosed:
-		return 0
-	default:
-		panic("not reached")
-	}
-}
-
-func (p *StickyConnPool) IdleLen() int {
-	return len(p.ch)
-}
-
-func (p *StickyConnPool) Stats() *Stats {
-	return &Stats{}
-}

vendor/github.com/go-redis/redis/v8/internal/proto/reader.go

@@ -1,332 +0,0 @@
-package proto
-
-import (
-	"bufio"
-	"fmt"
-	"io"
-
-	"github.com/go-redis/redis/v8/internal/util"
-)
-
-// redis resp protocol data type.
-const (
-	ErrorReply  = '-'
-	StatusReply = '+'
-	IntReply    = ':'
-	StringReply = '$'
-	ArrayReply  = '*'
-)
-
-//------------------------------------------------------------------------------
-
-const Nil = RedisError("redis: nil") // nolint:errname
-
-type RedisError string
-
-func (e RedisError) Error() string { return string(e) }
-
-func (RedisError) RedisError() {}
-
-//------------------------------------------------------------------------------
-
-type MultiBulkParse func(*Reader, int64) (interface{}, error)
-
-type Reader struct {
-	rd   *bufio.Reader
-	_buf []byte
-}
-
-func NewReader(rd io.Reader) *Reader {
-	return &Reader{
-		rd:   bufio.NewReader(rd),
-		_buf: make([]byte, 64),
-	}
-}
-
-func (r *Reader) Buffered() int {
-	return r.rd.Buffered()
-}
-
-func (r *Reader) Peek(n int) ([]byte, error) {
-	return r.rd.Peek(n)
-}
-
-func (r *Reader) Reset(rd io.Reader) {
-	r.rd.Reset(rd)
-}
-
-func (r *Reader) ReadLine() ([]byte, error) {
-	line, err := r.readLine()
-	if err != nil {
-		return nil, err
-	}
-	if isNilReply(line) {
-		return nil, Nil
-	}
-	return line, nil
-}
-
-// readLine that returns an error if:
-//   - there is a pending read error;
-//   - or line does not end with \r\n.
-func (r *Reader) readLine() ([]byte, error) {
-	b, err := r.rd.ReadSlice('\n')
-	if err != nil {
-		if err != bufio.ErrBufferFull {
-			return nil, err
-		}
-
-		full := make([]byte, len(b))
-		copy(full, b)
-
-		b, err = r.rd.ReadBytes('\n')
-		if err != nil {
-			return nil, err
-		}
-
-		full = append(full, b...) //nolint:makezero
-		b = full
-	}
-	if len(b) <= 2 || b[len(b)-1] != '\n' || b[len(b)-2] != '\r' {
-		return nil, fmt.Errorf("redis: invalid reply: %q", b)
-	}
-	return b[:len(b)-2], nil
-}
-
-func (r *Reader) ReadReply(m MultiBulkParse) (interface{}, error) {
-	line, err := r.ReadLine()
-	if err != nil {
-		return nil, err
-	}
-
-	switch line[0] {
-	case ErrorReply:
-		return nil, ParseErrorReply(line)
-	case StatusReply:
-		return string(line[1:]), nil
-	case IntReply:
-		return util.ParseInt(line[1:], 10, 64)
-	case StringReply:
-		return r.readStringReply(line)
-	case ArrayReply:
-		n, err := parseArrayLen(line)
-		if err != nil {
-			return nil, err
-		}
-		if m == nil {
-			err := fmt.Errorf("redis: got %.100q, but multi bulk parser is nil", line)
-			return nil, err
-		}
-		return m(r, n)
-	}
-	return nil, fmt.Errorf("redis: can't parse %.100q", line)
-}
-
-func (r *Reader) ReadIntReply() (int64, error) {
-	line, err := r.ReadLine()
-	if err != nil {
-		return 0, err
-	}
-	switch line[0] {
-	case ErrorReply:
-		return 0, ParseErrorReply(line)
-	case IntReply:
-		return util.ParseInt(line[1:], 10, 64)
-	default:
-		return 0, fmt.Errorf("redis: can't parse int reply: %.100q", line)
-	}
-}
-
-func (r *Reader) ReadString() (string, error) {
-	line, err := r.ReadLine()
-	if err != nil {
-		return "", err
-	}
-	switch line[0] {
-	case ErrorReply:
-		return "", ParseErrorReply(line)
-	case StringReply:
-		return r.readStringReply(line)
-	case StatusReply:
-		return string(line[1:]), nil
-	case IntReply:
-		return string(line[1:]), nil
-	default:
-		return "", fmt.Errorf("redis: can't parse reply=%.100q reading string", line)
-	}
-}
-
-func (r *Reader) readStringReply(line []byte) (string, error) {
-	if isNilReply(line) {
-		return "", Nil
-	}
-
-	replyLen, err := util.Atoi(line[1:])
-	if err != nil {
-		return "", err
-	}
-
-	b := make([]byte, replyLen+2)
-	_, err = io.ReadFull(r.rd, b)
-	if err != nil {
-		return "", err
-	}
-
-	return util.BytesToString(b[:replyLen]), nil
-}
-
-func (r *Reader) ReadArrayReply(m MultiBulkParse) (interface{}, error) {
-	line, err := r.ReadLine()
-	if err != nil {
-		return nil, err
-	}
-	switch line[0] {
-	case ErrorReply:
-		return nil, ParseErrorReply(line)
-	case ArrayReply:
-		n, err := parseArrayLen(line)
-		if err != nil {
-			return nil, err
-		}
-		return m(r, n)
-	default:
-		return nil, fmt.Errorf("redis: can't parse array reply: %.100q", line)
-	}
-}
-
-func (r *Reader) ReadArrayLen() (int, error) {
-	line, err := r.ReadLine()
-	if err != nil {
-		return 0, err
-	}
-	switch line[0] {
-	case ErrorReply:
-		return 0, ParseErrorReply(line)
-	case ArrayReply:
-		n, err := parseArrayLen(line)
-		if err != nil {
-			return 0, err
-		}
-		return int(n), nil
-	default:
-		return 0, fmt.Errorf("redis: can't parse array reply: %.100q", line)
-	}
-}
-
-func (r *Reader) ReadScanReply() ([]string, uint64, error) {
-	n, err := r.ReadArrayLen()
-	if err != nil {
-		return nil, 0, err
-	}
-	if n != 2 {
-		return nil, 0, fmt.Errorf("redis: got %d elements in scan reply, expected 2", n)
-	}
-
-	cursor, err := r.ReadUint()
-	if err != nil {
-		return nil, 0, err
-	}
-
-	n, err = r.ReadArrayLen()
-	if err != nil {
-		return nil, 0, err
-	}
-
-	keys := make([]string, n)
-
-	for i := 0; i < n; i++ {
-		key, err := r.ReadString()
-		if err != nil {
-			return nil, 0, err
-		}
-		keys[i] = key
-	}
-
-	return keys, cursor, err
-}
-
-func (r *Reader) ReadInt() (int64, error) {
-	b, err := r.readTmpBytesReply()
-	if err != nil {
-		return 0, err
-	}
-	return util.ParseInt(b, 10, 64)
-}
-
-func (r *Reader) ReadUint() (uint64, error) {
-	b, err := r.readTmpBytesReply()
-	if err != nil {
-		return 0, err
-	}
-	return util.ParseUint(b, 10, 64)
-}
-
-func (r *Reader) ReadFloatReply() (float64, error) {
-	b, err := r.readTmpBytesReply()
-	if err != nil {
-		return 0, err
-	}
-	return util.ParseFloat(b, 64)
-}
-
-func (r *Reader) readTmpBytesReply() ([]byte, error) {
-	line, err := r.ReadLine()
-	if err != nil {
-		return nil, err
-	}
-	switch line[0] {
-	case ErrorReply:
-		return nil, ParseErrorReply(line)
-	case StringReply:
-		return r._readTmpBytesReply(line)
-	case StatusReply:
-		return line[1:], nil
-	default:
-		return nil, fmt.Errorf("redis: can't parse string reply: %.100q", line)
-	}
-}
-
-func (r *Reader) _readTmpBytesReply(line []byte) ([]byte, error) {
-	if isNilReply(line) {
-		return nil, Nil
-	}
-
-	replyLen, err := util.Atoi(line[1:])
-	if err != nil {
-		return nil, err
-	}
-
-	buf := r.buf(replyLen + 2)
-	_, err = io.ReadFull(r.rd, buf)
-	if err != nil {
-		return nil, err
-	}
-
-	return buf[:replyLen], nil
-}
-
-func (r *Reader) buf(n int) []byte {
-	if n <= cap(r._buf) {
-		return r._buf[:n]
-	}
-	d := n - cap(r._buf)
-	r._buf = append(r._buf, make([]byte, d)...)
-	return r._buf
-}
-
-func isNilReply(b []byte) bool {
-	return len(b) == 3 &&
-		(b[0] == StringReply || b[0] == ArrayReply) &&
-		b[1] == '-' && b[2] == '1'
-}
-
-func ParseErrorReply(line []byte) error {
-	return RedisError(string(line[1:]))
-}
-
-func parseArrayLen(line []byte) (int64, error) {
-	if isNilReply(line) {
-		return 0, Nil
-	}
-	return util.ParseInt(line[1:], 10, 64)
-}

vendor/github.com/go-redis/redis/v8/internal/proto/scan.go

@@ -1,180 +0,0 @@
-package proto
-
-import (
-	"encoding"
-	"fmt"
-	"reflect"
-	"time"
-
-	"github.com/go-redis/redis/v8/internal/util"
-)
-
-// Scan parses bytes `b` to `v` with appropriate type.
-//nolint:gocyclo
-func Scan(b []byte, v interface{}) error {
-	switch v := v.(type) {
-	case nil:
-		return fmt.Errorf("redis: Scan(nil)")
-	case *string:
-		*v = util.BytesToString(b)
-		return nil
-	case *[]byte:
-		*v = b
-		return nil
-	case *int:
-		var err error
-		*v, err = util.Atoi(b)
-		return err
-	case *int8:
-		n, err := util.ParseInt(b, 10, 8)
-		if err != nil {
-			return err
-		}
-		*v = int8(n)
-		return nil
-	case *int16:
-		n, err := util.ParseInt(b, 10, 16)
-		if err != nil {
-			return err
-		}
-		*v = int16(n)
-		return nil
-	case *int32:
-		n, err := util.ParseInt(b, 10, 32)
-		if err != nil {
-			return err
-		}
-		*v = int32(n)
-		return nil
-	case *int64:
-		n, err := util.ParseInt(b, 10, 64)
-		if err != nil {
-			return err
-		}
-		*v = n
-		return nil
-	case *uint:
-		n, err := util.ParseUint(b, 10, 64)
-		if err != nil {
-			return err
-		}
-		*v = uint(n)
-		return nil
-	case *uint8:
-		n, err := util.ParseUint(b, 10, 8)
-		if err != nil {
-			return err
-		}
-		*v = uint8(n)
-		return nil
-	case *uint16:
-		n, err := util.ParseUint(b, 10, 16)
-		if err != nil {
-			return err
-		}
-		*v = uint16(n)
-		return nil
-	case *uint32:
-		n, err := util.ParseUint(b, 10, 32)
-		if err != nil {
-			return err
-		}
-		*v = uint32(n)
-		return nil
-	case *uint64:
-		n, err := util.ParseUint(b, 10, 64)
-		if err != nil {
-			return err
-		}
-		*v = n
-		return nil
-	case *float32:
-		n, err := util.ParseFloat(b, 32)
-		if err != nil {
-			return err
-		}
-		*v = float32(n)
-		return err
-	case *float64:
-		var err error
-		*v, err = util.ParseFloat(b, 64)
-		return err
-	case *bool:
-		*v = len(b) == 1 && b[0] == '1'
-		return nil
-	case *time.Time:
-		var err error
-		*v, err = time.Parse(time.RFC3339Nano, util.BytesToString(b))
-		return err
-	case *time.Duration:
-		n, err := util.ParseInt(b, 10, 64)
-		if err != nil {
-			return err
-		}
-		*v = time.Duration(n)
-		return nil
-	case encoding.BinaryUnmarshaler:
-		return v.UnmarshalBinary(b)
-	default:
-		return fmt.Errorf(
-			"redis: can't unmarshal %T (consider implementing BinaryUnmarshaler)", v)
-	}
-}
-
-func ScanSlice(data []string, slice interface{}) error {
-	v := reflect.ValueOf(slice)
-	if !v.IsValid() {
-		return fmt.Errorf("redis: ScanSlice(nil)")
-	}
-	if v.Kind() != reflect.Ptr {
-		return fmt.Errorf("redis: ScanSlice(non-pointer %T)", slice)
-	}
-	v = v.Elem()
-	if v.Kind() != reflect.Slice {
-		return fmt.Errorf("redis: ScanSlice(non-slice %T)", slice)
-	}
-
-	next := makeSliceNextElemFunc(v)
-	for i, s := range data {
-		elem := next()
-		if err := Scan([]byte(s), elem.Addr().Interface()); err != nil {
-			err = fmt.Errorf("redis: ScanSlice index=%d value=%q failed: %w", i, s, err)
-			return err
-		}
-	}
-
-	return nil
-}
-
-func makeSliceNextElemFunc(v reflect.Value) func() reflect.Value {
-	elemType := v.Type().Elem()
-
-	if elemType.Kind() == reflect.Ptr {
-		elemType = elemType.Elem()
-		return func() reflect.Value {
-			if v.Len() < v.Cap() {
-				v.Set(v.Slice(0, v.Len()+1))
-				elem := v.Index(v.Len() - 1)
-				if elem.IsNil() {
-					elem.Set(reflect.New(elemType))
-				}
-				return elem.Elem()
-			}
-
-			elem := reflect.New(elemType)
-			v.Set(reflect.Append(v, elem))
-			return elem.Elem()
-		}
-	}
-
-	zero := reflect.Zero(elemType)
-	return func() reflect.Value {
-		if v.Len() < v.Cap() {
-			v.Set(v.Slice(0, v.Len()+1))
-			return v.Index(v.Len() - 1)
-		}
-
-		v.Set(reflect.Append(v, zero))
-		return v.Index(v.Len() - 1)
-	}
-}

vendor/github.com/go-redis/redis/v8/internal/proto/writer.go

@@ -1,155 +0,0 @@
-package proto
-
-import (
-	"encoding"
-	"fmt"
-	"io"
-	"strconv"
-	"time"
-
-	"github.com/go-redis/redis/v8/internal/util"
-)
-
-type writer interface {
-	io.Writer
-	io.ByteWriter
-	// io.StringWriter
-	WriteString(s string) (n int, err error)
-}
-
-type Writer struct {
-	writer
-
-	lenBuf []byte
-	numBuf []byte
-}
-
-func NewWriter(wr writer) *Writer {
-	return &Writer{
-		writer: wr,
-
-		lenBuf: make([]byte, 64),
-		numBuf: make([]byte, 64),
-	}
-}
-
-func (w *Writer) WriteArgs(args []interface{}) error {
-	if err := w.WriteByte(ArrayReply); err != nil {
-		return err
-	}
-
-	if err := w.writeLen(len(args)); err != nil {
-		return err
-	}
-
-	for _, arg := range args {
-		if err := w.WriteArg(arg); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (w *Writer) writeLen(n int) error {
-	w.lenBuf = strconv.AppendUint(w.lenBuf[:0], uint64(n), 10)
-	w.lenBuf = append(w.lenBuf, '\r', '\n')
-	_, err := w.Write(w.lenBuf)
-	return err
-}
-
-func (w *Writer) WriteArg(v interface{}) error {
-	switch v := v.(type) {
-	case nil:
-		return w.string("")
-	case string:
-		return w.string(v)
-	case []byte:
-		return w.bytes(v)
-	case int:
-		return w.int(int64(v))
-	case int8:
-		return w.int(int64(v))
-	case int16:
-		return w.int(int64(v))
-	case int32:
-		return w.int(int64(v))
-	case int64:
-		return w.int(v)
-	case uint:
-		return w.uint(uint64(v))
-	case uint8:
-		return w.uint(uint64(v))
-	case uint16:
-		return w.uint(uint64(v))
-	case uint32:
-		return w.uint(uint64(v))
-	case uint64:
-		return w.uint(v)
-	case float32:
-		return w.float(float64(v))
-	case float64:
-		return w.float(v)
-	case bool:
-		if v {
-			return w.int(1)
-		}
-		return w.int(0)
-	case time.Time:
-		w.numBuf = v.AppendFormat(w.numBuf[:0], time.RFC3339Nano)
-		return w.bytes(w.numBuf)
-	case time.Duration:
-		return w.int(v.Nanoseconds())
-	case encoding.BinaryMarshaler:
-		b, err := v.MarshalBinary()
-		if err != nil {
-			return err
-		}
-		return w.bytes(b)
-	default:
-		return fmt.Errorf(
-			"redis: can't marshal %T (implement encoding.BinaryMarshaler)", v)
-	}
-}
-
-func (w *Writer) bytes(b []byte) error {
-	if err := w.WriteByte(StringReply); err != nil {
-		return err
-	}
-
-	if err := w.writeLen(len(b)); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(b); err != nil {
-		return err
-	}
-
-	return w.crlf()
-}
-
-func (w *Writer) string(s string) error {
-	return w.bytes(util.StringToBytes(s))
-}
-
-func (w *Writer) uint(n uint64) error {
-	w.numBuf = strconv.AppendUint(w.numBuf[:0], n, 10)
-	return w.bytes(w.numBuf)
-}
-
-func (w *Writer) int(n int64) error {
-	w.numBuf = strconv.AppendInt(w.numBuf[:0], n, 10)
-	return w.bytes(w.numBuf)
-}
-
-func (w *Writer) float(f float64) error {
-	w.numBuf = strconv.AppendFloat(w.numBuf[:0], f, 'f', -1, 64)
-	return w.bytes(w.numBuf)
-}
-
-func (w *Writer) crlf() error {
-	if err := w.WriteByte('\r'); err != nil {
-		return err
-	}
-	return w.WriteByte('\n')
-}

vendor/github.com/go-redis/redis/v8/internal/rand/rand.go

@@ -1,50 +0,0 @@
-package rand
-
-import (
-	"math/rand"
-	"sync"
-)
-
-// Int returns a non-negative pseudo-random int.
-func Int() int { return pseudo.Int() }
-
-// Intn returns, as an int, a non-negative pseudo-random number in [0,n).
-// It panics if n <= 0.
-func Intn(n int) int { return pseudo.Intn(n) }
-
-// Int63n returns, as an int64, a non-negative pseudo-random number in [0,n).
-// It panics if n <= 0.
-func Int63n(n int64) int64 { return pseudo.Int63n(n) }
-
-// Perm returns, as a slice of n ints, a pseudo-random permutation of the integers [0,n).
-func Perm(n int) []int { return pseudo.Perm(n) }
-
-// Seed uses the provided seed value to initialize the default Source to a
-// deterministic state. If Seed is not called, the generator behaves as if
-// seeded by Seed(1).
-func Seed(n int64) { pseudo.Seed(n) }
-
-var pseudo = rand.New(&source{src: rand.NewSource(1)})
-
-type source struct {
-	src rand.Source
-	mu  sync.Mutex
-}
-
-func (s *source) Int63() int64 {
-	s.mu.Lock()
-	n := s.src.Int63()
-	s.mu.Unlock()
-	return n
-}
-
-func (s *source) Seed(seed int64) {
-	s.mu.Lock()
-	s.src.Seed(seed)
-	s.mu.Unlock()
-}
-
-// Shuffle pseudo-randomizes the order of elements.
-// n is the number of elements.
-// swap swaps the elements with indexes i and j.
-func Shuffle(n int, swap func(i, j int)) { pseudo.Shuffle(n, swap) }

vendor/github.com/go-redis/redis/v8/internal/safe.go

@@ -1,12 +0,0 @@
-//go:build appengine
-// +build appengine
-
-package internal
-
-func String(b []byte) string {
-	return string(b)
-}
-
-func Bytes(s string) []byte {
-	return []byte(s)
-}

vendor/github.com/go-redis/redis/v8/internal/unsafe.go

@@ -1,21 +0,0 @@
-//go:build !appengine
-// +build !appengine
-
-package internal
-
-import "unsafe"
-
-// String converts byte slice to string.
-func String(b []byte) string {
-	return *(*string)(unsafe.Pointer(&b))
-}
-
-// Bytes converts string to byte slice.
-func Bytes(s string) []byte {
-	return *(*[]byte)(unsafe.Pointer(
-		&struct {
-			string
-			Cap int
-		}{s, len(s)},
-	))
-}

vendor/github.com/go-redis/redis/v8/internal/util.go

@@ -1,46 +0,0 @@
-package internal
-
-import (
-	"context"
-	"time"
-
-	"github.com/go-redis/redis/v8/internal/util"
-)
-
-func Sleep(ctx context.Context, dur time.Duration) error {
-	t := time.NewTimer(dur)
-	defer t.Stop()
-
-	select {
-	case <-t.C:
-		return nil
-	case <-ctx.Done():
-		return ctx.Err()
-	}
-}
-
-func ToLower(s string) string {
-	if isLower(s) {
-		return s
-	}
-
-	b := make([]byte, len(s))
-	for i := range b {
-		c := s[i]
-		if c >= 'A' && c <= 'Z' {
-			c += 'a' - 'A'
-		}
-		b[i] = c
-	}
-	return util.BytesToString(b)
-}
-
-func isLower(s string) bool {
-	for i := 0; i < len(s); i++ {
-		c := s[i]
-		if c >= 'A' && c <= 'Z' {
-			return false
-		}
-	}
-	return true
-}

vendor/github.com/go-redis/redis/v8/internal/util/safe.go

@@ -1,12 +0,0 @@
-//go:build appengine
-// +build appengine
-
-package util
-
-func BytesToString(b []byte) string {
-	return string(b)
-}
-
-func StringToBytes(s string) []byte {
-	return []byte(s)
-}

vendor/github.com/go-redis/redis/v8/internal/util/strconv.go

@@ -1,19 +0,0 @@
-package util
-
-import "strconv"
-
-func Atoi(b []byte) (int, error) {
-	return strconv.Atoi(BytesToString(b))
-}
-
-func ParseInt(b []byte, base int, bitSize int) (int64, error) {
-	return strconv.ParseInt(BytesToString(b), base, bitSize)
-}
-
-func ParseUint(b []byte, base int, bitSize int) (uint64, error) {
-	return strconv.ParseUint(BytesToString(b), base, bitSize)
-}
-
-func ParseFloat(b []byte, bitSize int) (float64, error) {
-	return strconv.ParseFloat(BytesToString(b), bitSize)
-}

vendor/github.com/go-redis/redis/v8/internal/util/unsafe.go

@@ -1,23 +0,0 @@
-//go:build !appengine
-// +build !appengine
-
-package util
-
-import (
-	"unsafe"
-)
-
-// BytesToString converts byte slice to string.
-func BytesToString(b []byte) string {
-	return *(*string)(unsafe.Pointer(&b))
-}
-
-// StringToBytes converts string to byte slice.
-func StringToBytes(s string) []byte {
-	return *(*[]byte)(unsafe.Pointer(
-		&struct {
-			string
-			Cap int
-		}{s, len(s)},
-	))
-}

vendor/github.com/go-redis/redis/v8/iterator.go

@@ -1,77 +0,0 @@
-package redis
-
-import (
-	"context"
-	"sync"
-)
-
-// ScanIterator is used to incrementally iterate over a collection of elements.
-// It's safe for concurrent use by multiple goroutines.
-type ScanIterator struct {
-	mu  sync.Mutex // protects Scanner and pos
-	cmd *ScanCmd
-	pos int
-}
-
-// Err returns the last iterator error, if any.
-func (it *ScanIterator) Err() error {
-	it.mu.Lock()
-	err := it.cmd.Err()
-	it.mu.Unlock()
-	return err
-}
-
-// Next advances the cursor and returns true if more values can be read.
-func (it *ScanIterator) Next(ctx context.Context) bool {
-	it.mu.Lock()
-	defer it.mu.Unlock()
-
-	// Instantly return on errors.
-	if it.cmd.Err() != nil {
-		return false
-	}
-
-	// Advance cursor, check if we are still within range.
-	if it.pos < len(it.cmd.page) {
-		it.pos++
-		return true
-	}
-
-	for {
-		// Return if there is no more data to fetch.
-		if it.cmd.cursor == 0 {
-			return false
-		}
-
-		// Fetch next page.
-		switch it.cmd.args[0] {
-		case "scan", "qscan":
-			it.cmd.args[1] = it.cmd.cursor
-		default:
-			it.cmd.args[2] = it.cmd.cursor
-		}
-
-		err := it.cmd.process(ctx, it.cmd)
-		if err != nil {
-			return false
-		}
-
-		it.pos = 1
-
-		// Redis can occasionally return empty page.
-		if len(it.cmd.page) > 0 {
-			return true
-		}
-	}
-}
-
-// Val returns the key/field at the current cursor position.
-func (it *ScanIterator) Val() string {
-	var v string
-	it.mu.Lock()
-	if it.cmd.Err() == nil && it.pos > 0 && it.pos <= len(it.cmd.page) {
-		v = it.cmd.page[it.pos-1]
-	}
-	it.mu.Unlock()
-	return v
-}

vendor/github.com/go-redis/redis/v8/options.go

@@ -1,429 +0,0 @@
-package redis
-
-import (
-	"context"
-	"crypto/tls"
-	"errors"
-	"fmt"
-	"net"
-	"net/url"
-	"runtime"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/go-redis/redis/v8/internal/pool"
-)
-
-// Limiter is the interface of a rate limiter or a circuit breaker.
-type Limiter interface {
-	// Allow returns nil if operation is allowed or an error otherwise.
-	// If operation is allowed client must ReportResult of the operation
-	// whether it is a success or a failure.
-	Allow() error
-	// ReportResult reports the result of the previously allowed operation.
-	// nil indicates a success, non-nil error usually indicates a failure.
-	ReportResult(result error)
-}
-
-// Options keeps the settings to setup redis connection.
-type Options struct {
-	// The network type, either tcp or unix.
-	// Default is tcp.
-	Network string
-	// host:port address.
-	Addr string
-
-	// Dialer creates new network connection and has priority over
-	// Network and Addr options.
-	Dialer func(ctx context.Context, network, addr string) (net.Conn, error)
-
-	// Hook that is called when new connection is established.
-	OnConnect func(ctx context.Context, cn *Conn) error
-
-	// Use the specified Username to authenticate the current connection
-	// with one of the connections defined in the ACL list when connecting
-	// to a Redis 6.0 instance, or greater, that is using the Redis ACL system.
-	Username string
-	// Optional password. Must match the password specified in the
-	// requirepass server configuration option (if connecting to a Redis 5.0 instance, or lower),
-	// or the User Password when connecting to a Redis 6.0 instance, or greater,
-	// that is using the Redis ACL system.
-	Password string
-
-	// Database to be selected after connecting to the server.
-	DB int
-
-	// Maximum number of retries before giving up.
-	// Default is 3 retries; -1 (not 0) disables retries.
-	MaxRetries int
-	// Minimum backoff between each retry.
-	// Default is 8 milliseconds; -1 disables backoff.
-	MinRetryBackoff time.Duration
-	// Maximum backoff between each retry.
-	// Default is 512 milliseconds; -1 disables backoff.
-	MaxRetryBackoff time.Duration
-
-	// Dial timeout for establishing new connections.
-	// Default is 5 seconds.
-	DialTimeout time.Duration
-	// Timeout for socket reads. If reached, commands will fail
-	// with a timeout instead of blocking. Use value -1 for no timeout and 0 for default.
-	// Default is 3 seconds.
-	ReadTimeout time.Duration
-	// Timeout for socket writes. If reached, commands will fail
-	// with a timeout instead of blocking.
-	// Default is ReadTimeout.
-	WriteTimeout time.Duration
-
-	// Type of connection pool.
-	// true for FIFO pool, false for LIFO pool.
-	// Note that fifo has higher overhead compared to lifo.
-	PoolFIFO bool
-	// Maximum number of socket connections.
-	// Default is 10 connections per every available CPU as reported by runtime.GOMAXPROCS.
-	PoolSize int
-	// Minimum number of idle connections which is useful when establishing
-	// new connection is slow.
-	MinIdleConns int
-	// Connection age at which client retires (closes) the connection.
-	// Default is to not close aged connections.
-	MaxConnAge time.Duration
-	// Amount of time client waits for connection if all connections
-	// are busy before returning an error.
-	// Default is ReadTimeout + 1 second.
-	PoolTimeout time.Duration
-	// Amount of time after which client closes idle connections.
-	// Should be less than server's timeout.
-	// Default is 5 minutes. -1 disables idle timeout check.
-	IdleTimeout time.Duration
-	// Frequency of idle checks made by idle connections reaper.
-	// Default is 1 minute. -1 disables idle connections reaper,
-	// but idle connections are still discarded by the client
-	// if IdleTimeout is set.
-	IdleCheckFrequency time.Duration
-
-	// Enables read only queries on slave nodes.
-	readOnly bool
-
-	// TLS Config to use. When set TLS will be negotiated.
-	TLSConfig *tls.Config
-
-	// Limiter interface used to implemented circuit breaker or rate limiter.
-	Limiter Limiter
-}
-
-func (opt *Options) init() {
-	if opt.Addr == "" {
-		opt.Addr = "localhost:6379"
-	}
-	if opt.Network == "" {
-		if strings.HasPrefix(opt.Addr, "/") {
-			opt.Network = "unix"
-		} else {
-			opt.Network = "tcp"
-		}
-	}
-	if opt.DialTimeout == 0 {
-		opt.DialTimeout = 5 * time.Second
-	}
-	if opt.Dialer == nil {
-		opt.Dialer = func(ctx context.Context, network, addr string) (net.Conn, error) {
-			netDialer := &net.Dialer{
-				Timeout:   opt.DialTimeout,
-				KeepAlive: 5 * time.Minute,
-			}
-			if opt.TLSConfig == nil {
-				return netDialer.DialContext(ctx, network, addr)
-			}
-			return tls.DialWithDialer(netDialer, network, addr, opt.TLSConfig)
-		}
-	}
-	if opt.PoolSize == 0 {
-		opt.PoolSize = 10 * runtime.GOMAXPROCS(0)
-	}
-	switch opt.ReadTimeout {
-	case -1:
-		opt.ReadTimeout = 0
-	case 0:
-		opt.ReadTimeout = 3 * time.Second
-	}
-	switch opt.WriteTimeout {
-	case -1:
-		opt.WriteTimeout = 0
-	case 0:
-		opt.WriteTimeout = opt.ReadTimeout
-	}
-	if opt.PoolTimeout == 0 {
-		opt.PoolTimeout = opt.ReadTimeout + time.Second
-	}
-	if opt.IdleTimeout == 0 {
-		opt.IdleTimeout = 5 * time.Minute
-	}
-	if opt.IdleCheckFrequency == 0 {
-		opt.IdleCheckFrequency = time.Minute
-	}
-
-	if opt.MaxRetries == -1 {
-		opt.MaxRetries = 0
-	} else if opt.MaxRetries == 0 {
-		opt.MaxRetries = 3
-	}
-	switch opt.MinRetryBackoff {
-	case -1:
-		opt.MinRetryBackoff = 0
-	case 0:
-		opt.MinRetryBackoff = 8 * time.Millisecond
-	}
-	switch opt.MaxRetryBackoff {
-	case -1:
-		opt.MaxRetryBackoff = 0
-	case 0:
-		opt.MaxRetryBackoff = 512 * time.Millisecond
-	}
-}
-
-func (opt *Options) clone() *Options {
-	clone := *opt
-	return &clone
-}
-
-// ParseURL parses an URL into Options that can be used to connect to Redis.
-// Scheme is required.
-// There are two connection types: by tcp socket and by unix socket.
-// Tcp connection:
-//		redis://<user>:<password>@<host>:<port>/<db_number>
-// Unix connection:
-//		unix://<user>:<password>@</path/to/redis.sock>?db=<db_number>
-// Most Option fields can be set using query parameters, with the following restrictions:
-//	- field names are mapped using snake-case conversion: to set MaxRetries, use max_retries
-//	- only scalar type fields are supported (bool, int, time.Duration)
-//	- for time.Duration fields, values must be a valid input for time.ParseDuration();
-//	  additionally a plain integer as value (i.e. without unit) is intepreted as seconds
-//	- to disable a duration field, use value less than or equal to 0; to use the default
-//	  value, leave the value blank or remove the parameter
-//	- only the last value is interpreted if a parameter is given multiple times
-//	- fields "network", "addr", "username" and "password" can only be set using other
-//	  URL attributes (scheme, host, userinfo, resp.), query paremeters using these
-//	  names will be treated as unknown parameters
-//	- unknown parameter names will result in an error
-// Examples:
-//		redis://user:password@localhost:6789/3?dial_timeout=3&db=1&read_timeout=6s&max_retries=2
-//		is equivalent to:
-//		&Options{
-//			Network:     "tcp",
-//			Addr:        "localhost:6789",
-//			DB:          1,               // path "/3" was overridden by "&db=1"
-//			DialTimeout: 3 * time.Second, // no time unit = seconds
-//			ReadTimeout: 6 * time.Second,
-//			MaxRetries:  2,
-//		}
-func ParseURL(redisURL string) (*Options, error) {
-	u, err := url.Parse(redisURL)
-	if err != nil {
-		return nil, err
-	}
-
-	switch u.Scheme {
-	case "redis", "rediss":
-		return setupTCPConn(u)
-	case "unix":
-		return setupUnixConn(u)
-	default:
-		return nil, fmt.Errorf("redis: invalid URL scheme: %s", u.Scheme)
-	}
-}
-
-func setupTCPConn(u *url.URL) (*Options, error) {
-	o := &Options{Network: "tcp"}
-
-	o.Username, o.Password = getUserPassword(u)
-
-	h, p, err := net.SplitHostPort(u.Host)
-	if err != nil {
-		h = u.Host
-	}
-	if h == "" {
-		h = "localhost"
-	}
-	if p == "" {
-		p = "6379"
-	}
-	o.Addr = net.JoinHostPort(h, p)
-
-	f := strings.FieldsFunc(u.Path, func(r rune) bool {
-		return r == '/'
-	})
-	switch len(f) {
-	case 0:
-		o.DB = 0
-	case 1:
-		if o.DB, err = strconv.Atoi(f[0]); err != nil {
-			return nil, fmt.Errorf("redis: invalid database number: %q", f[0])
-		}
-	default:
-		return nil, fmt.Errorf("redis: invalid URL path: %s", u.Path)
-	}
-
-	if u.Scheme == "rediss" {
-		o.TLSConfig = &tls.Config{ServerName: h}
-	}
-
-	return setupConnParams(u, o)
-}
-
-func setupUnixConn(u *url.URL) (*Options, error) {
-	o := &Options{
-		Network: "unix",
-	}
-
-	if strings.TrimSpace(u.Path) == "" { // path is required with unix connection
-		return nil, errors.New("redis: empty unix socket path")
-	}
-	o.Addr = u.Path
-	o.Username, o.Password = getUserPassword(u)
-	return setupConnParams(u, o)
-}
-
-type queryOptions struct {
-	q   url.Values
-	err error
-}
-
-func (o *queryOptions) string(name string) string {
-	vs := o.q[name]
-	if len(vs) == 0 {
-		return ""
-	}
-	delete(o.q, name) // enable detection of unknown parameters
-	return vs[len(vs)-1]
-}
-
-func (o *queryOptions) int(name string) int {
-	s := o.string(name)
-	if s == "" {
-		return 0
-	}
-	i, err := strconv.Atoi(s)
-	if err == nil {
-		return i
-	}
-	if o.err == nil {
-		o.err = fmt.Errorf("redis: invalid %s number: %s", name, err)
-	}
-	return 0
-}
-
-func (o *queryOptions) duration(name string) time.Duration {
-	s := o.string(name)
-	if s == "" {
-		return 0
-	}
-	// try plain number first
-	if i, err := strconv.Atoi(s); err == nil {
-		if i <= 0 {
-			// disable timeouts
-			return -1
-		}
-		return time.Duration(i) * time.Second
-	}
-	dur, err := time.ParseDuration(s)
-	if err == nil {
-		return dur
-	}
-	if o.err == nil {
-		o.err = fmt.Errorf("redis: invalid %s duration: %w", name, err)
-	}
-	return 0
-}
-
-func (o *queryOptions) bool(name string) bool {
-	switch s := o.string(name); s {
-	case "true", "1":
-		return true
-	case "false", "0", "":
-		return false
-	default:
-		if o.err == nil {
-			o.err = fmt.Errorf("redis: invalid %s boolean: expected true/false/1/0 or an empty string, got %q", name, s)
-		}
-		return false
-	}
-}
-
-func (o *queryOptions) remaining() []string {
-	if len(o.q) == 0 {
-		return nil
-	}
-	keys := make([]string, 0, len(o.q))
-	for k := range o.q {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-	return keys
-}
-
-// setupConnParams converts query parameters in u to option value in o.
-func setupConnParams(u *url.URL, o *Options) (*Options, error) {
-	q := queryOptions{q: u.Query()}
-
-	// compat: a future major release may use q.int("db")
-	if tmp := q.string("db"); tmp != "" {
-		db, err := strconv.Atoi(tmp)
-		if err != nil {
-			return nil, fmt.Errorf("redis: invalid database number: %w", err)
-		}
-		o.DB = db
-	}
-
-	o.MaxRetries = q.int("max_retries")
-	o.MinRetryBackoff = q.duration("min_retry_backoff")
-	o.MaxRetryBackoff = q.duration("max_retry_backoff")
-	o.DialTimeout = q.duration("dial_timeout")
-	o.ReadTimeout = q.duration("read_timeout")
-	o.WriteTimeout = q.duration("write_timeout")
-	o.PoolFIFO = q.bool("pool_fifo")
-	o.PoolSize = q.int("pool_size")
-	o.MinIdleConns = q.int("min_idle_conns")
-	o.MaxConnAge = q.duration("max_conn_age")
-	o.PoolTimeout = q.duration("pool_timeout")
-	o.IdleTimeout = q.duration("idle_timeout")
-	o.IdleCheckFrequency = q.duration("idle_check_frequency")
-	if q.err != nil {
-		return nil, q.err
-	}
-
-	// any parameters left?
-	if r := q.remaining(); len(r) > 0 {
-		return nil, fmt.Errorf("redis: unexpected option: %s", strings.Join(r, ", "))
-	}
-
-	return o, nil
-}
-
-func getUserPassword(u *url.URL) (string, string) {
-	var user, password string
-	if u.User != nil {
-		user = u.User.Username()
-		if p, ok := u.User.Password(); ok {
-			password = p
-		}
-	}
-	return user, password
-}
-
-func newConnPool(opt *Options) *pool.ConnPool {
-	return pool.NewConnPool(&pool.Options{
-		Dialer: func(ctx context.Context) (net.Conn, error) {
-			return opt.Dialer(ctx, opt.Network, opt.Addr)
-		},
-		PoolFIFO:           opt.PoolFIFO,
-		PoolSize:           opt.PoolSize,
-		MinIdleConns:       opt.MinIdleConns,
-		MaxConnAge:         opt.MaxConnAge,
-		PoolTimeout:        opt.PoolTimeout,
-		IdleTimeout:        opt.IdleTimeout,
-		IdleCheckFrequency: opt.IdleCheckFrequency,
-	})
-}

vendor/github.com/go-redis/redis/v8/package.json

@@ -1,8 +0,0 @@
-{
-  "name": "redis",
-  "version": "8.11.5",
-  "main": "index.js",
-  "repository": "git@github.com:go-redis/redis.git",
-  "author": "Vladimir Mihailenco <vladimir.webdev@gmail.com>",
-  "license": "BSD-2-clause"
-}

vendor/github.com/go-redis/redis/v8/pipeline.go

@@ -1,147 +0,0 @@
-package redis
-
-import (
-	"context"
-	"sync"
-
-	"github.com/go-redis/redis/v8/internal/pool"
-)
-
-type pipelineExecer func(context.Context, []Cmder) error
-
-// Pipeliner is an mechanism to realise Redis Pipeline technique.
-//
-// Pipelining is a technique to extremely speed up processing by packing
-// operations to batches, send them at once to Redis and read a replies in a
-// singe step.
-// See https://redis.io/topics/pipelining
-//
-// Pay attention, that Pipeline is not a transaction, so you can get unexpected
-// results in case of big pipelines and small read/write timeouts.
-// Redis client has retransmission logic in case of timeouts, pipeline
-// can be retransmitted and commands can be executed more then once.
-// To avoid this: it is good idea to use reasonable bigger read/write timeouts
-// depends of your batch size and/or use TxPipeline.
-type Pipeliner interface {
-	StatefulCmdable
-	Len() int
-	Do(ctx context.Context, args ...interface{}) *Cmd
-	Process(ctx context.Context, cmd Cmder) error
-	Close() error
-	Discard() error
-	Exec(ctx context.Context) ([]Cmder, error)
-}
-
-var _ Pipeliner = (*Pipeline)(nil)
-
-// Pipeline implements pipelining as described in
-// http://redis.io/topics/pipelining. It's safe for concurrent use
-// by multiple goroutines.
-type Pipeline struct {
-	cmdable
-	statefulCmdable
-
-	ctx  context.Context
-	exec pipelineExecer
-
-	mu     sync.Mutex
-	cmds   []Cmder
-	closed bool
-}
-
-func (c *Pipeline) init() {
-	c.cmdable = c.Process
-	c.statefulCmdable = c.Process
-}
-
-// Len returns the number of queued commands.
-func (c *Pipeline) Len() int {
-	c.mu.Lock()
-	ln := len(c.cmds)
-	c.mu.Unlock()
-	return ln
-}
-
-// Do queues the custom command for later execution.
-func (c *Pipeline) Do(ctx context.Context, args ...interface{}) *Cmd {
-	cmd := NewCmd(ctx, args...)
-	_ = c.Process(ctx, cmd)
-	return cmd
-}
-
-// Process queues the cmd for later execution.
-func (c *Pipeline) Process(ctx context.Context, cmd Cmder) error {
-	c.mu.Lock()
-	c.cmds = append(c.cmds, cmd)
-	c.mu.Unlock()
-	return nil
-}
-
-// Close closes the pipeline, releasing any open resources.
-func (c *Pipeline) Close() error {
-	c.mu.Lock()
-	_ = c.discard()
-	c.closed = true
-	c.mu.Unlock()
-	return nil
-}
-
-// Discard resets the pipeline and discards queued commands.
-func (c *Pipeline) Discard() error {
-	c.mu.Lock()
-	err := c.discard()
-	c.mu.Unlock()
-	return err
-}
-
-func (c *Pipeline) discard() error {
-	if c.closed {
-		return pool.ErrClosed
-	}
-	c.cmds = c.cmds[:0]
-	return nil
-}
-
-// Exec executes all previously queued commands using one
-// client-server roundtrip.
-//
-// Exec always returns list of commands and error of the first failed
-// command if any.
-func (c *Pipeline) Exec(ctx context.Context) ([]Cmder, error) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	if c.closed {
-		return nil, pool.ErrClosed
-	}
-
-	if len(c.cmds) == 0 {
-		return nil, nil
-	}
-
-	cmds := c.cmds
-	c.cmds = nil
-
-	return cmds, c.exec(ctx, cmds)
-}
-
-func (c *Pipeline) Pipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
-	if err := fn(c); err != nil {
-		return nil, err
-	}
-	cmds, err := c.Exec(ctx)
-	_ = c.Close()
-	return cmds, err
-}
-
-func (c *Pipeline) Pipeline() Pipeliner {
-	return c
-}
-
-func (c *Pipeline) TxPipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
-	return c.Pipelined(ctx, fn)
-}
-
-func (c *Pipeline) TxPipeline() Pipeliner {
-	return c
-}

vendor/github.com/go-redis/redis/v8/pubsub.go

@@ -1,668 +0,0 @@
-package redis
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/go-redis/redis/v8/internal"
-	"github.com/go-redis/redis/v8/internal/pool"
-	"github.com/go-redis/redis/v8/internal/proto"
-)
-
-// PubSub implements Pub/Sub commands as described in
-// http://redis.io/topics/pubsub. Message receiving is NOT safe
-// for concurrent use by multiple goroutines.
-//
-// PubSub automatically reconnects to Redis Server and resubscribes
-// to the channels in case of network errors.
-type PubSub struct {
-	opt *Options
-
-	newConn   func(ctx context.Context, channels []string) (*pool.Conn, error)
-	closeConn func(*pool.Conn) error
-
-	mu       sync.Mutex
-	cn       *pool.Conn
-	channels map[string]struct{}
-	patterns map[string]struct{}
-
-	closed bool
-	exit   chan struct{}
-
-	cmd *Cmd
-
-	chOnce sync.Once
-	msgCh  *channel
-	allCh  *channel
-}
-
-func (c *PubSub) init() {
-	c.exit = make(chan struct{})
-}
-
-func (c *PubSub) String() string {
-	channels := mapKeys(c.channels)
-	channels = append(channels, mapKeys(c.patterns)...)
-	return fmt.Sprintf("PubSub(%s)", strings.Join(channels, ", "))
-}
-
-func (c *PubSub) connWithLock(ctx context.Context) (*pool.Conn, error) {
-	c.mu.Lock()
-	cn, err := c.conn(ctx, nil)
-	c.mu.Unlock()
-	return cn, err
-}
-
-func (c *PubSub) conn(ctx context.Context, newChannels []string) (*pool.Conn, error) {
-	if c.closed {
-		return nil, pool.ErrClosed
-	}
-	if c.cn != nil {
-		return c.cn, nil
-	}
-
-	channels := mapKeys(c.channels)
-	channels = append(channels, newChannels...)
-
-	cn, err := c.newConn(ctx, channels)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := c.resubscribe(ctx, cn); err != nil {
-		_ = c.closeConn(cn)
-		return nil, err
-	}
-
-	c.cn = cn
-	return cn, nil
-}
-
-func (c *PubSub) writeCmd(ctx context.Context, cn *pool.Conn, cmd Cmder) error {
-	return cn.WithWriter(ctx, c.opt.WriteTimeout, func(wr *proto.Writer) error {
-		return writeCmd(wr, cmd)
-	})
-}
-
-func (c *PubSub) resubscribe(ctx context.Context, cn *pool.Conn) error {
-	var firstErr error
-
-	if len(c.channels) > 0 {
-		firstErr = c._subscribe(ctx, cn, "subscribe", mapKeys(c.channels))
-	}
-
-	if len(c.patterns) > 0 {
-		err := c._subscribe(ctx, cn, "psubscribe", mapKeys(c.patterns))
-		if err != nil && firstErr == nil {
-			firstErr = err
-		}
-	}
-
-	return firstErr
-}
-
-func mapKeys(m map[string]struct{}) []string {
-	s := make([]string, len(m))
-	i := 0
-	for k := range m {
-		s[i] = k
-		i++
-	}
-	return s
-}
-
-func (c *PubSub) _subscribe(
-	ctx context.Context, cn *pool.Conn, redisCmd string, channels []string,
-) error {
-	args := make([]interface{}, 0, 1+len(channels))
-	args = append(args, redisCmd)
-	for _, channel := range channels {
-		args = append(args, channel)
-	}
-	cmd := NewSliceCmd(ctx, args...)
-	return c.writeCmd(ctx, cn, cmd)
-}
-
-func (c *PubSub) releaseConnWithLock(
-	ctx context.Context,
-	cn *pool.Conn,
-	err error,
-	allowTimeout bool,
-) {
-	c.mu.Lock()
-	c.releaseConn(ctx, cn, err, allowTimeout)
-	c.mu.Unlock()
-}
-
-func (c *PubSub) releaseConn(ctx context.Context, cn *pool.Conn, err error, allowTimeout bool) {
-	if c.cn != cn {
-		return
-	}
-	if isBadConn(err, allowTimeout, c.opt.Addr) {
-		c.reconnect(ctx, err)
-	}
-}
-
-func (c *PubSub) reconnect(ctx context.Context, reason error) {
-	_ = c.closeTheCn(reason)
-	_, _ = c.conn(ctx, nil)
-}
-
-func (c *PubSub) closeTheCn(reason error) error {
-	if c.cn == nil {
-		return nil
-	}
-	if !c.closed {
-		internal.Logger.Printf(c.getContext(), "redis: discarding bad PubSub connection: %s", reason)
-	}
-	err := c.closeConn(c.cn)
-	c.cn = nil
-	return err
-}
-
-func (c *PubSub) Close() error {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	if c.closed {
-		return pool.ErrClosed
-	}
-	c.closed = true
-	close(c.exit)
-
-	return c.closeTheCn(pool.ErrClosed)
-}
-
-// Subscribe the client to the specified channels. It returns
-// empty subscription if there are no channels.
-func (c *PubSub) Subscribe(ctx context.Context, channels ...string) error {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	err := c.subscribe(ctx, "subscribe", channels...)
-	if c.channels == nil {
-		c.channels = make(map[string]struct{})
-	}
-	for _, s := range channels {
-		c.channels[s] = struct{}{}
-	}
-	return err
-}
-
-// PSubscribe the client to the given patterns. It returns
-// empty subscription if there are no patterns.
-func (c *PubSub) PSubscribe(ctx context.Context, patterns ...string) error {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	err := c.subscribe(ctx, "psubscribe", patterns...)
-	if c.patterns == nil {
-		c.patterns = make(map[string]struct{})
-	}
-	for _, s := range patterns {
-		c.patterns[s] = struct{}{}
-	}
-	return err
-}
-
-// Unsubscribe the client from the given channels, or from all of
-// them if none is given.
-func (c *PubSub) Unsubscribe(ctx context.Context, channels ...string) error {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	for _, channel := range channels {
-		delete(c.channels, channel)
-	}
-	err := c.subscribe(ctx, "unsubscribe", channels...)
-	return err
-}
-
-// PUnsubscribe the client from the given patterns, or from all of
-// them if none is given.
-func (c *PubSub) PUnsubscribe(ctx context.Context, patterns ...string) error {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	for _, pattern := range patterns {
-		delete(c.patterns, pattern)
-	}
-	err := c.subscribe(ctx, "punsubscribe", patterns...)
-	return err
-}
-
-func (c *PubSub) subscribe(ctx context.Context, redisCmd string, channels ...string) error {
-	cn, err := c.conn(ctx, channels)
-	if err != nil {
-		return err
-	}
-
-	err = c._subscribe(ctx, cn, redisCmd, channels)
-	c.releaseConn(ctx, cn, err, false)
-	return err
-}
-
-func (c *PubSub) Ping(ctx context.Context, payload ...string) error {
-	args := []interface{}{"ping"}
-	if len(payload) == 1 {
-		args = append(args, payload[0])
-	}
-	cmd := NewCmd(ctx, args...)
-
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	cn, err := c.conn(ctx, nil)
-	if err != nil {
-		return err
-	}
-
-	err = c.writeCmd(ctx, cn, cmd)
-	c.releaseConn(ctx, cn, err, false)
-	return err
-}
-
-// Subscription received after a successful subscription to channel.
-type Subscription struct {
-	// Can be "subscribe", "unsubscribe", "psubscribe" or "punsubscribe".
-	Kind string
-	// Channel name we have subscribed to.
-	Channel string
-	// Number of channels we are currently subscribed to.
-	Count int
-}
-
-func (m *Subscription) String() string {
-	return fmt.Sprintf("%s: %s", m.Kind, m.Channel)
-}
-
-// Message received as result of a PUBLISH command issued by another client.
-type Message struct {
-	Channel      string
-	Pattern      string
-	Payload      string
-	PayloadSlice []string
-}
-
-func (m *Message) String() string {
-	return fmt.Sprintf("Message<%s: %s>", m.Channel, m.Payload)
-}
-
-// Pong received as result of a PING command issued by another client.
-type Pong struct {
-	Payload string
-}
-
-func (p *Pong) String() string {
-	if p.Payload != "" {
-		return fmt.Sprintf("Pong<%s>", p.Payload)
-	}
-	return "Pong"
-}
-
-func (c *PubSub) newMessage(reply interface{}) (interface{}, error) {
-	switch reply := reply.(type) {
-	case string:
-		return &Pong{
-			Payload: reply,
-		}, nil
-	case []interface{}:
-		switch kind := reply[0].(string); kind {
-		case "subscribe", "unsubscribe", "psubscribe", "punsubscribe":
-			// Can be nil in case of "unsubscribe".
-			channel, _ := reply[1].(string)
-			return &Subscription{
-				Kind:    kind,
-				Channel: channel,
-				Count:   int(reply[2].(int64)),
-			}, nil
-		case "message":
-			switch payload := reply[2].(type) {
-			case string:
-				return &Message{
-					Channel: reply[1].(string),
-					Payload: payload,
-				}, nil
-			case []interface{}:
-				ss := make([]string, len(payload))
-				for i, s := range payload {
-					ss[i] = s.(string)
-				}
-				return &Message{
-					Channel:      reply[1].(string),
-					PayloadSlice: ss,
-				}, nil
-			default:
-				return nil, fmt.Errorf("redis: unsupported pubsub message payload: %T", payload)
-			}
-		case "pmessage":
-			return &Message{
-				Pattern: reply[1].(string),
-				Channel: reply[2].(string),
-				Payload: reply[3].(string),
-			}, nil
-		case "pong":
-			return &Pong{
-				Payload: reply[1].(string),
-			}, nil
-		default:
-			return nil, fmt.Errorf("redis: unsupported pubsub message: %q", kind)
-		}
-	default:
-		return nil, fmt.Errorf("redis: unsupported pubsub message: %#v", reply)
-	}
-}
-
-// ReceiveTimeout acts like Receive but returns an error if message
-// is not received in time. This is low-level API and in most cases
-// Channel should be used instead.
-func (c *PubSub) ReceiveTimeout(ctx context.Context, timeout time.Duration) (interface{}, error) {
-	if c.cmd == nil {
-		c.cmd = NewCmd(ctx)
-	}
-
-	// Don't hold the lock to allow subscriptions and pings.
-
-	cn, err := c.connWithLock(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	err = cn.WithReader(ctx, timeout, func(rd *proto.Reader) error {
-		return c.cmd.readReply(rd)
-	})
-
-	c.releaseConnWithLock(ctx, cn, err, timeout > 0)
-
-	if err != nil {
-		return nil, err
-	}
-
-	return c.newMessage(c.cmd.Val())
-}
-
-// Receive returns a message as a Subscription, Message, Pong or error.
-// See PubSub example for details. This is low-level API and in most cases
-// Channel should be used instead.
-func (c *PubSub) Receive(ctx context.Context) (interface{}, error) {
-	return c.ReceiveTimeout(ctx, 0)
-}
-
-// ReceiveMessage returns a Message or error ignoring Subscription and Pong
-// messages. This is low-level API and in most cases Channel should be used
-// instead.
-func (c *PubSub) ReceiveMessage(ctx context.Context) (*Message, error) {
-	for {
-		msg, err := c.Receive(ctx)
-		if err != nil {
-			return nil, err
-		}
-
-		switch msg := msg.(type) {
-		case *Subscription:
-			// Ignore.
-		case *Pong:
-			// Ignore.
-		case *Message:
-			return msg, nil
-		default:
-			err := fmt.Errorf("redis: unknown message: %T", msg)
-			return nil, err
-		}
-	}
-}
-
-func (c *PubSub) getContext() context.Context {
-	if c.cmd != nil {
-		return c.cmd.ctx
-	}
-	return context.Background()
-}
-
-//------------------------------------------------------------------------------
-
-// Channel returns a Go channel for concurrently receiving messages.
-// The channel is closed together with the PubSub. If the Go channel
-// is blocked full for 30 seconds the message is dropped.
-// Receive* APIs can not be used after channel is created.
-//
-// go-redis periodically sends ping messages to test connection health
-// and re-subscribes if ping can not not received for 30 seconds.
-func (c *PubSub) Channel(opts ...ChannelOption) <-chan *Message {
-	c.chOnce.Do(func() {
-		c.msgCh = newChannel(c, opts...)
-		c.msgCh.initMsgChan()
-	})
-	if c.msgCh == nil {
-		err := fmt.Errorf("redis: Channel can't be called after ChannelWithSubscriptions")
-		panic(err)
-	}
-	return c.msgCh.msgCh
-}
-
-// ChannelSize is like Channel, but creates a Go channel
-// with specified buffer size.
-//
-// Deprecated: use Channel(WithChannelSize(size)), remove in v9.
-func (c *PubSub) ChannelSize(size int) <-chan *Message {
-	return c.Channel(WithChannelSize(size))
-}
-
-// ChannelWithSubscriptions is like Channel, but message type can be either
-// *Subscription or *Message. Subscription messages can be used to detect
-// reconnections.
-//
-// ChannelWithSubscriptions can not be used together with Channel or ChannelSize.
-func (c *PubSub) ChannelWithSubscriptions(_ context.Context, size int) <-chan interface{} {
-	c.chOnce.Do(func() {
-		c.allCh = newChannel(c, WithChannelSize(size))
-		c.allCh.initAllChan()
-	})
-	if c.allCh == nil {
-		err := fmt.Errorf("redis: ChannelWithSubscriptions can't be called after Channel")
-		panic(err)
-	}
-	return c.allCh.allCh
-}
-
-type ChannelOption func(c *channel)
-
-// WithChannelSize specifies the Go chan size that is used to buffer incoming messages.
-//
-// The default is 100 messages.
-func WithChannelSize(size int) ChannelOption {
-	return func(c *channel) {
-		c.chanSize = size
-	}
-}
-
-// WithChannelHealthCheckInterval specifies the health check interval.
-// PubSub will ping Redis Server if it does not receive any messages within the interval.
-// To disable health check, use zero interval.
-//
-// The default is 3 seconds.
-func WithChannelHealthCheckInterval(d time.Duration) ChannelOption {
-	return func(c *channel) {
-		c.checkInterval = d
-	}
-}
-
-// WithChannelSendTimeout specifies the channel send timeout after which
-// the message is dropped.
-//
-// The default is 60 seconds.
-func WithChannelSendTimeout(d time.Duration) ChannelOption {
-	return func(c *channel) {
-		c.chanSendTimeout = d
-	}
-}
-
-type channel struct {
-	pubSub *PubSub
-
-	msgCh chan *Message
-	allCh chan interface{}
-	ping  chan struct{}
-
-	chanSize        int
-	chanSendTimeout time.Duration
-	checkInterval   time.Duration
-}
-
-func newChannel(pubSub *PubSub, opts ...ChannelOption) *channel {
-	c := &channel{
-		pubSub: pubSub,
-
-		chanSize:        100,
-		chanSendTimeout: time.Minute,
-		checkInterval:   3 * time.Second,
-	}
-	for _, opt := range opts {
-		opt(c)
-	}
-	if c.checkInterval > 0 {
-		c.initHealthCheck()
-	}
-	return c
-}
-
-func (c *channel) initHealthCheck() {
-	ctx := context.TODO()
-	c.ping = make(chan struct{}, 1)
-
-	go func() {
-		timer := time.NewTimer(time.Minute)
-		timer.Stop()
-
-		for {
-			timer.Reset(c.checkInterval)
-			select {
-			case <-c.ping:
-				if !timer.Stop() {
-					<-timer.C
-				}
-			case <-timer.C:
-				if pingErr := c.pubSub.Ping(ctx); pingErr != nil {
-					c.pubSub.mu.Lock()
-					c.pubSub.reconnect(ctx, pingErr)
-					c.pubSub.mu.Unlock()
-				}
-			case <-c.pubSub.exit:
-				return
-			}
-		}
-	}()
-}
-
-// initMsgChan must be in sync with initAllChan.
-func (c *channel) initMsgChan() {
-	ctx := context.TODO()
-	c.msgCh = make(chan *Message, c.chanSize)
-
-	go func() {
-		timer := time.NewTimer(time.Minute)
-		timer.Stop()
-
-		var errCount int
-		for {
-			msg, err := c.pubSub.Receive(ctx)
-			if err != nil {
-				if err == pool.ErrClosed {
-					close(c.msgCh)
-					return
-				}
-				if errCount > 0 {
-					time.Sleep(100 * time.Millisecond)
-				}
-				errCount++
-				continue
-			}
-
-			errCount = 0
-
-			// Any message is as good as a ping.
-			select {
-			case c.ping <- struct{}{}:
-			default:
-			}
-
-			switch msg := msg.(type) {
-			case *Subscription:
-				// Ignore.
-			case *Pong:
-				// Ignore.
-			case *Message:
-				timer.Reset(c.chanSendTimeout)
-				select {
-				case c.msgCh <- msg:
-					if !timer.Stop() {
-						<-timer.C
-					}
-				case <-timer.C:
-					internal.Logger.Printf(
-						ctx, "redis: %s channel is full for %s (message is dropped)",
-						c, c.chanSendTimeout)
-				}
-			default:
-				internal.Logger.Printf(ctx, "redis: unknown message type: %T", msg)
-			}
-		}
-	}()
-}
-
-// initAllChan must be in sync with initMsgChan.
-func (c *channel) initAllChan() {
-	ctx := context.TODO()
-	c.allCh = make(chan interface{}, c.chanSize)
-
-	go func() {
-		timer := time.NewTimer(time.Minute)
-		timer.Stop()
-
-		var errCount int
-		for {
-			msg, err := c.pubSub.Receive(ctx)
-			if err != nil {
-				if err == pool.ErrClosed {
-					close(c.allCh)
-					return
-				}
-				if errCount > 0 {
-					time.Sleep(100 * time.Millisecond)
-				}
-				errCount++
-				continue
-			}
-
-			errCount = 0
-
-			// Any message is as good as a ping.
-			select {
-			case c.ping <- struct{}{}:
-			default:
-			}
-
-			switch msg := msg.(type) {
-			case *Pong:
-				// Ignore.
-			case *Subscription, *Message:
-				timer.Reset(c.chanSendTimeout)
-				select {
-				case c.allCh <- msg:
-					if !timer.Stop() {
-						<-timer.C
-					}
-				case <-timer.C:
-					internal.Logger.Printf(
-						ctx, "redis: %s channel is full for %s (message is dropped)",
-						c, c.chanSendTimeout)
-				}
-			default:
-				internal.Logger.Printf(ctx, "redis: unknown message type: %T", msg)
-			}
-		}
-	}()
-}

vendor/github.com/go-redis/redis/v8/redis.go

@@ -1,773 +0,0 @@
-package redis
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"sync/atomic"
-	"time"
-
-	"github.com/go-redis/redis/v8/internal"
-	"github.com/go-redis/redis/v8/internal/pool"
-	"github.com/go-redis/redis/v8/internal/proto"
-)
-
-// Nil reply returned by Redis when key does not exist.
-const Nil = proto.Nil
-
-func SetLogger(logger internal.Logging) {
-	internal.Logger = logger
-}
-
-//------------------------------------------------------------------------------
-
-type Hook interface {
-	BeforeProcess(ctx context.Context, cmd Cmder) (context.Context, error)
-	AfterProcess(ctx context.Context, cmd Cmder) error
-
-	BeforeProcessPipeline(ctx context.Context, cmds []Cmder) (context.Context, error)
-	AfterProcessPipeline(ctx context.Context, cmds []Cmder) error
-}
-
-type hooks struct {
-	hooks []Hook
-}
-
-func (hs *hooks) lock() {
-	hs.hooks = hs.hooks[:len(hs.hooks):len(hs.hooks)]
-}
-
-func (hs hooks) clone() hooks {
-	clone := hs
-	clone.lock()
-	return clone
-}
-
-func (hs *hooks) AddHook(hook Hook) {
-	hs.hooks = append(hs.hooks, hook)
-}
-
-func (hs hooks) process(
-	ctx context.Context, cmd Cmder, fn func(context.Context, Cmder) error,
-) error {
-	if len(hs.hooks) == 0 {
-		err := fn(ctx, cmd)
-		cmd.SetErr(err)
-		return err
-	}
-
-	var hookIndex int
-	var retErr error
-
-	for ; hookIndex < len(hs.hooks) && retErr == nil; hookIndex++ {
-		ctx, retErr = hs.hooks[hookIndex].BeforeProcess(ctx, cmd)
-		if retErr != nil {
-			cmd.SetErr(retErr)
-		}
-	}
-
-	if retErr == nil {
-		retErr = fn(ctx, cmd)
-		cmd.SetErr(retErr)
-	}
-
-	for hookIndex--; hookIndex >= 0; hookIndex-- {
-		if err := hs.hooks[hookIndex].AfterProcess(ctx, cmd); err != nil {
-			retErr = err
-			cmd.SetErr(retErr)
-		}
-	}
-
-	return retErr
-}
-
-func (hs hooks) processPipeline(
-	ctx context.Context, cmds []Cmder, fn func(context.Context, []Cmder) error,
-) error {
-	if len(hs.hooks) == 0 {
-		err := fn(ctx, cmds)
-		return err
-	}
-
-	var hookIndex int
-	var retErr error
-
-	for ; hookIndex < len(hs.hooks) && retErr == nil; hookIndex++ {
-		ctx, retErr = hs.hooks[hookIndex].BeforeProcessPipeline(ctx, cmds)
-		if retErr != nil {
-			setCmdsErr(cmds, retErr)
-		}
-	}
-
-	if retErr == nil {
-		retErr = fn(ctx, cmds)
-	}
-
-	for hookIndex--; hookIndex >= 0; hookIndex-- {
-		if err := hs.hooks[hookIndex].AfterProcessPipeline(ctx, cmds); err != nil {
-			retErr = err
-			setCmdsErr(cmds, retErr)
-		}
-	}
-
-	return retErr
-}
-
-func (hs hooks) processTxPipeline(
-	ctx context.Context, cmds []Cmder, fn func(context.Context, []Cmder) error,
-) error {
-	cmds = wrapMultiExec(ctx, cmds)
-	return hs.processPipeline(ctx, cmds, fn)
-}
-
-//------------------------------------------------------------------------------
-
-type baseClient struct {
-	opt      *Options
-	connPool pool.Pooler
-
-	onClose func() error // hook called when client is closed
-}
-
-func newBaseClient(opt *Options, connPool pool.Pooler) *baseClient {
-	return &baseClient{
-		opt:      opt,
-		connPool: connPool,
-	}
-}
-
-func (c *baseClient) clone() *baseClient {
-	clone := *c
-	return &clone
-}
-
-func (c *baseClient) withTimeout(timeout time.Duration) *baseClient {
-	opt := c.opt.clone()
-	opt.ReadTimeout = timeout
-	opt.WriteTimeout = timeout
-
-	clone := c.clone()
-	clone.opt = opt
-
-	return clone
-}
-
-func (c *baseClient) String() string {
-	return fmt.Sprintf("Redis<%s db:%d>", c.getAddr(), c.opt.DB)
-}
-
-func (c *baseClient) newConn(ctx context.Context) (*pool.Conn, error) {
-	cn, err := c.connPool.NewConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	err = c.initConn(ctx, cn)
-	if err != nil {
-		_ = c.connPool.CloseConn(cn)
-		return nil, err
-	}
-
-	return cn, nil
-}
-
-func (c *baseClient) getConn(ctx context.Context) (*pool.Conn, error) {
-	if c.opt.Limiter != nil {
-		err := c.opt.Limiter.Allow()
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	cn, err := c._getConn(ctx)
-	if err != nil {
-		if c.opt.Limiter != nil {
-			c.opt.Limiter.ReportResult(err)
-		}
-		return nil, err
-	}
-
-	return cn, nil
-}
-
-func (c *baseClient) _getConn(ctx context.Context) (*pool.Conn, error) {
-	cn, err := c.connPool.Get(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	if cn.Inited {
-		return cn, nil
-	}
-
-	if err := c.initConn(ctx, cn); err != nil {
-		c.connPool.Remove(ctx, cn, err)
-		if err := errors.Unwrap(err); err != nil {
-			return nil, err
-		}
-		return nil, err
-	}
-
-	return cn, nil
-}
-
-func (c *baseClient) initConn(ctx context.Context, cn *pool.Conn) error {
-	if cn.Inited {
-		return nil
-	}
-	cn.Inited = true
-
-	if c.opt.Password == "" &&
-		c.opt.DB == 0 &&
-		!c.opt.readOnly &&
-		c.opt.OnConnect == nil {
-		return nil
-	}
-
-	connPool := pool.NewSingleConnPool(c.connPool, cn)
-	conn := newConn(ctx, c.opt, connPool)
-
-	_, err := conn.Pipelined(ctx, func(pipe Pipeliner) error {
-		if c.opt.Password != "" {
-			if c.opt.Username != "" {
-				pipe.AuthACL(ctx, c.opt.Username, c.opt.Password)
-			} else {
-				pipe.Auth(ctx, c.opt.Password)
-			}
-		}
-
-		if c.opt.DB > 0 {
-			pipe.Select(ctx, c.opt.DB)
-		}
-
-		if c.opt.readOnly {
-			pipe.ReadOnly(ctx)
-		}
-
-		return nil
-	})
-	if err != nil {
-		return err
-	}
-
-	if c.opt.OnConnect != nil {
-		return c.opt.OnConnect(ctx, conn)
-	}
-	return nil
-}
-
-func (c *baseClient) releaseConn(ctx context.Context, cn *pool.Conn, err error) {
-	if c.opt.Limiter != nil {
-		c.opt.Limiter.ReportResult(err)
-	}
-
-	if isBadConn(err, false, c.opt.Addr) {
-		c.connPool.Remove(ctx, cn, err)
-	} else {
-		c.connPool.Put(ctx, cn)
-	}
-}
-
-func (c *baseClient) withConn(
-	ctx context.Context, fn func(context.Context, *pool.Conn) error,
-) error {
-	cn, err := c.getConn(ctx)
-	if err != nil {
-		return err
-	}
-
-	defer func() {
-		c.releaseConn(ctx, cn, err)
-	}()
-
-	done := ctx.Done() //nolint:ifshort
-
-	if done == nil {
-		err = fn(ctx, cn)
-		return err
-	}
-
-	errc := make(chan error, 1)
-	go func() { errc <- fn(ctx, cn) }()
-
-	select {
-	case <-done:
-		_ = cn.Close()
-		// Wait for the goroutine to finish and send something.
-		<-errc
-
-		err = ctx.Err()
-		return err
-	case err = <-errc:
-		return err
-	}
-}
-
-func (c *baseClient) process(ctx context.Context, cmd Cmder) error {
-	var lastErr error
-	for attempt := 0; attempt <= c.opt.MaxRetries; attempt++ {
-		attempt := attempt
-
-		retry, err := c._process(ctx, cmd, attempt)
-		if err == nil || !retry {
-			return err
-		}
-
-		lastErr = err
-	}
-	return lastErr
-}
-
-func (c *baseClient) _process(ctx context.Context, cmd Cmder, attempt int) (bool, error) {
-	if attempt > 0 {
-		if err := internal.Sleep(ctx, c.retryBackoff(attempt)); err != nil {
-			return false, err
-		}
-	}
-
-	retryTimeout := uint32(1)
-	err := c.withConn(ctx, func(ctx context.Context, cn *pool.Conn) error {
-		err := cn.WithWriter(ctx, c.opt.WriteTimeout, func(wr *proto.Writer) error {
-			return writeCmd(wr, cmd)
-		})
-		if err != nil {
-			return err
-		}
-
-		err = cn.WithReader(ctx, c.cmdTimeout(cmd), cmd.readReply)
-		if err != nil {
-			if cmd.readTimeout() == nil {
-				atomic.StoreUint32(&retryTimeout, 1)
-			}
-			return err
-		}
-
-		return nil
-	})
-	if err == nil {
-		return false, nil
-	}
-
-	retry := shouldRetry(err, atomic.LoadUint32(&retryTimeout) == 1)
-	return retry, err
-}
-
-func (c *baseClient) retryBackoff(attempt int) time.Duration {
-	return internal.RetryBackoff(attempt, c.opt.MinRetryBackoff, c.opt.MaxRetryBackoff)
-}
-
-func (c *baseClient) cmdTimeout(cmd Cmder) time.Duration {
-	if timeout := cmd.readTimeout(); timeout != nil {
-		t := *timeout
-		if t == 0 {
-			return 0
-		}
-		return t + 10*time.Second
-	}
-	return c.opt.ReadTimeout
-}
-
-// Close closes the client, releasing any open resources.
-//
-// It is rare to Close a Client, as the Client is meant to be
-// long-lived and shared between many goroutines.
-func (c *baseClient) Close() error {
-	var firstErr error
-	if c.onClose != nil {
-		if err := c.onClose(); err != nil {
-			firstErr = err
-		}
-	}
-	if err := c.connPool.Close(); err != nil && firstErr == nil {
-		firstErr = err
-	}
-	return firstErr
-}
-
-func (c *baseClient) getAddr() string {
-	return c.opt.Addr
-}
-
-func (c *baseClient) processPipeline(ctx context.Context, cmds []Cmder) error {
-	return c.generalProcessPipeline(ctx, cmds, c.pipelineProcessCmds)
-}
-
-func (c *baseClient) processTxPipeline(ctx context.Context, cmds []Cmder) error {
-	return c.generalProcessPipeline(ctx, cmds, c.txPipelineProcessCmds)
-}
-
-type pipelineProcessor func(context.Context, *pool.Conn, []Cmder) (bool, error)
-
-func (c *baseClient) generalProcessPipeline(
-	ctx context.Context, cmds []Cmder, p pipelineProcessor,
-) error {
-	err := c._generalProcessPipeline(ctx, cmds, p)
-	if err != nil {
-		setCmdsErr(cmds, err)
-		return err
-	}
-	return cmdsFirstErr(cmds)
-}
-
-func (c *baseClient) _generalProcessPipeline(
-	ctx context.Context, cmds []Cmder, p pipelineProcessor,
-) error {
-	var lastErr error
-	for attempt := 0; attempt <= c.opt.MaxRetries; attempt++ {
-		if attempt > 0 {
-			if err := internal.Sleep(ctx, c.retryBackoff(attempt)); err != nil {
-				return err
-			}
-		}
-
-		var canRetry bool
-		lastErr = c.withConn(ctx, func(ctx context.Context, cn *pool.Conn) error {
-			var err error
-			canRetry, err = p(ctx, cn, cmds)
-			return err
-		})
-		if lastErr == nil || !canRetry || !shouldRetry(lastErr, true) {
-			return lastErr
-		}
-	}
-	return lastErr
-}
-
-func (c *baseClient) pipelineProcessCmds(
-	ctx context.Context, cn *pool.Conn, cmds []Cmder,
-) (bool, error) {
-	err := cn.WithWriter(ctx, c.opt.WriteTimeout, func(wr *proto.Writer) error {
-		return writeCmds(wr, cmds)
-	})
-	if err != nil {
-		return true, err
-	}
-
-	err = cn.WithReader(ctx, c.opt.ReadTimeout, func(rd *proto.Reader) error {
-		return pipelineReadCmds(rd, cmds)
-	})
-	return true, err
-}
-
-func pipelineReadCmds(rd *proto.Reader, cmds []Cmder) error {
-	for _, cmd := range cmds {
-		err := cmd.readReply(rd)
-		cmd.SetErr(err)
-		if err != nil && !isRedisError(err) {
-			return err
-		}
-	}
-	return nil
-}
-
-func (c *baseClient) txPipelineProcessCmds(
-	ctx context.Context, cn *pool.Conn, cmds []Cmder,
-) (bool, error) {
-	err := cn.WithWriter(ctx, c.opt.WriteTimeout, func(wr *proto.Writer) error {
-		return writeCmds(wr, cmds)
-	})
-	if err != nil {
-		return true, err
-	}
-
-	err = cn.WithReader(ctx, c.opt.ReadTimeout, func(rd *proto.Reader) error {
-		statusCmd := cmds[0].(*StatusCmd)
-		// Trim multi and exec.
-		cmds = cmds[1 : len(cmds)-1]
-
-		err := txPipelineReadQueued(rd, statusCmd, cmds)
-		if err != nil {
-			return err
-		}
-
-		return pipelineReadCmds(rd, cmds)
-	})
-	return false, err
-}
-
-func wrapMultiExec(ctx context.Context, cmds []Cmder) []Cmder {
-	if len(cmds) == 0 {
-		panic("not reached")
-	}
-	cmdCopy := make([]Cmder, len(cmds)+2)
-	cmdCopy[0] = NewStatusCmd(ctx, "multi")
-	copy(cmdCopy[1:], cmds)
-	cmdCopy[len(cmdCopy)-1] = NewSliceCmd(ctx, "exec")
-	return cmdCopy
-}
-
-func txPipelineReadQueued(rd *proto.Reader, statusCmd *StatusCmd, cmds []Cmder) error {
-	// Parse queued replies.
-	if err := statusCmd.readReply(rd); err != nil {
-		return err
-	}
-
-	for range cmds {
-		if err := statusCmd.readReply(rd); err != nil && !isRedisError(err) {
-			return err
-		}
-	}
-
-	// Parse number of replies.
-	line, err := rd.ReadLine()
-	if err != nil {
-		if err == Nil {
-			err = TxFailedErr
-		}
-		return err
-	}
-
-	switch line[0] {
-	case proto.ErrorReply:
-		return proto.ParseErrorReply(line)
-	case proto.ArrayReply:
-		// ok
-	default:
-		err := fmt.Errorf("redis: expected '*', but got line %q", line)
-		return err
-	}
-
-	return nil
-}
-
-//------------------------------------------------------------------------------
-
-// Client is a Redis client representing a pool of zero or more
-// underlying connections. It's safe for concurrent use by multiple
-// goroutines.
-type Client struct {
-	*baseClient
-	cmdable
-	hooks
-	ctx context.Context
-}
-
-// NewClient returns a client to the Redis Server specified by Options.
-func NewClient(opt *Options) *Client {
-	opt.init()
-
-	c := Client{
-		baseClient: newBaseClient(opt, newConnPool(opt)),
-		ctx:        context.Background(),
-	}
-	c.cmdable = c.Process
-
-	return &c
-}
-
-func (c *Client) clone() *Client {
-	clone := *c
-	clone.cmdable = clone.Process
-	clone.hooks.lock()
-	return &clone
-}
-
-func (c *Client) WithTimeout(timeout time.Duration) *Client {
-	clone := c.clone()
-	clone.baseClient = c.baseClient.withTimeout(timeout)
-	return clone
-}
-
-func (c *Client) Context() context.Context {
-	return c.ctx
-}
-
-func (c *Client) WithContext(ctx context.Context) *Client {
-	if ctx == nil {
-		panic("nil context")
-	}
-	clone := c.clone()
-	clone.ctx = ctx
-	return clone
-}
-
-func (c *Client) Conn(ctx context.Context) *Conn {
-	return newConn(ctx, c.opt, pool.NewStickyConnPool(c.connPool))
-}
-
-// Do creates a Cmd from the args and processes the cmd.
-func (c *Client) Do(ctx context.Context, args ...interface{}) *Cmd {
-	cmd := NewCmd(ctx, args...)
-	_ = c.Process(ctx, cmd)
-	return cmd
-}
-
-func (c *Client) Process(ctx context.Context, cmd Cmder) error {
-	return c.hooks.process(ctx, cmd, c.baseClient.process)
-}
-
-func (c *Client) processPipeline(ctx context.Context, cmds []Cmder) error {
-	return c.hooks.processPipeline(ctx, cmds, c.baseClient.processPipeline)
-}
-
-func (c *Client) processTxPipeline(ctx context.Context, cmds []Cmder) error {
-	return c.hooks.processTxPipeline(ctx, cmds, c.baseClient.processTxPipeline)
-}
-
-// Options returns read-only Options that were used to create the client.
-func (c *Client) Options() *Options {
-	return c.opt
-}
-
-type PoolStats pool.Stats
-
-// PoolStats returns connection pool stats.
-func (c *Client) PoolStats() *PoolStats {
-	stats := c.connPool.Stats()
-	return (*PoolStats)(stats)
-}
-
-func (c *Client) Pipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
-	return c.Pipeline().Pipelined(ctx, fn)
-}
-
-func (c *Client) Pipeline() Pipeliner {
-	pipe := Pipeline{
-		ctx:  c.ctx,
-		exec: c.processPipeline,
-	}
-	pipe.init()
-	return &pipe
-}
-
-func (c *Client) TxPipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
-	return c.TxPipeline().Pipelined(ctx, fn)
-}
-
-// TxPipeline acts like Pipeline, but wraps queued commands with MULTI/EXEC.
-func (c *Client) TxPipeline() Pipeliner {
-	pipe := Pipeline{
-		ctx:  c.ctx,
-		exec: c.processTxPipeline,
-	}
-	pipe.init()
-	return &pipe
-}
-
-func (c *Client) pubSub() *PubSub {
-	pubsub := &PubSub{
-		opt: c.opt,
-
-		newConn: func(ctx context.Context, channels []string) (*pool.Conn, error) {
-			return c.newConn(ctx)
-		},
-		closeConn: c.connPool.CloseConn,
-	}
-	pubsub.init()
-	return pubsub
-}
-
-// Subscribe subscribes the client to the specified channels.
-// Channels can be omitted to create empty subscription.
-// Note that this method does not wait on a response from Redis, so the
-// subscription may not be active immediately. To force the connection to wait,
-// you may call the Receive() method on the returned *PubSub like so:
-//
-//    sub := client.Subscribe(queryResp)
-//    iface, err := sub.Receive()
-//    if err != nil {
-//        // handle error
-//    }
-//
-//    // Should be *Subscription, but others are possible if other actions have been
-//    // taken on sub since it was created.
-//    switch iface.(type) {
-//    case *Subscription:
-//        // subscribe succeeded
-//    case *Message:
-//        // received first message
-//    case *Pong:
-//        // pong received
-//    default:
-//        // handle error
-//    }
-//
-//    ch := sub.Channel()
-func (c *Client) Subscribe(ctx context.Context, channels ...string) *PubSub {
-	pubsub := c.pubSub()
-	if len(channels) > 0 {
-		_ = pubsub.Subscribe(ctx, channels...)
-	}
-	return pubsub
-}
-
-// PSubscribe subscribes the client to the given patterns.
-// Patterns can be omitted to create empty subscription.
-func (c *Client) PSubscribe(ctx context.Context, channels ...string) *PubSub {
-	pubsub := c.pubSub()
-	if len(channels) > 0 {
-		_ = pubsub.PSubscribe(ctx, channels...)
-	}
-	return pubsub
-}
-
-//------------------------------------------------------------------------------
-
-type conn struct {
-	baseClient
-	cmdable
-	statefulCmdable
-	hooks // TODO: inherit hooks
-}
-
-// Conn represents a single Redis connection rather than a pool of connections.
-// Prefer running commands from Client unless there is a specific need
-// for a continuous single Redis connection.
-type Conn struct {
-	*conn
-	ctx context.Context
-}
-
-func newConn(ctx context.Context, opt *Options, connPool pool.Pooler) *Conn {
-	c := Conn{
-		conn: &conn{
-			baseClient: baseClient{
-				opt:      opt,
-				connPool: connPool,
-			},
-		},
-		ctx: ctx,
-	}
-	c.cmdable = c.Process
-	c.statefulCmdable = c.Process
-	return &c
-}
-
-func (c *Conn) Process(ctx context.Context, cmd Cmder) error {
-	return c.hooks.process(ctx, cmd, c.baseClient.process)
-}
-
-func (c *Conn) processPipeline(ctx context.Context, cmds []Cmder) error {
-	return c.hooks.processPipeline(ctx, cmds, c.baseClient.processPipeline)
-}
-
-func (c *Conn) processTxPipeline(ctx context.Context, cmds []Cmder) error {
-	return c.hooks.processTxPipeline(ctx, cmds, c.baseClient.processTxPipeline)
-}
-
-func (c *Conn) Pipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
-	return c.Pipeline().Pipelined(ctx, fn)
-}
-
-func (c *Conn) Pipeline() Pipeliner {
-	pipe := Pipeline{
-		ctx:  c.ctx,
-		exec: c.processPipeline,
-	}
-	pipe.init()
-	return &pipe
-}
-
-func (c *Conn) TxPipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
-	return c.TxPipeline().Pipelined(ctx, fn)
-}
-
-// TxPipeline acts like Pipeline, but wraps queued commands with MULTI/EXEC.
-func (c *Conn) TxPipeline() Pipeliner {
-	pipe := Pipeline{
-		ctx:  c.ctx,
-		exec: c.processTxPipeline,
-	}
-	pipe.init()
-	return &pipe
-}

vendor/github.com/go-redis/redis/v8/result.go

@@ -1,180 +0,0 @@
-package redis
-
-import "time"
-
-// NewCmdResult returns a Cmd initialised with val and err for testing.
-func NewCmdResult(val interface{}, err error) *Cmd {
-	var cmd Cmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewSliceResult returns a SliceCmd initialised with val and err for testing.
-func NewSliceResult(val []interface{}, err error) *SliceCmd {
-	var cmd SliceCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewStatusResult returns a StatusCmd initialised with val and err for testing.
-func NewStatusResult(val string, err error) *StatusCmd {
-	var cmd StatusCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewIntResult returns an IntCmd initialised with val and err for testing.
-func NewIntResult(val int64, err error) *IntCmd {
-	var cmd IntCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewDurationResult returns a DurationCmd initialised with val and err for testing.
-func NewDurationResult(val time.Duration, err error) *DurationCmd {
-	var cmd DurationCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewBoolResult returns a BoolCmd initialised with val and err for testing.
-func NewBoolResult(val bool, err error) *BoolCmd {
-	var cmd BoolCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewStringResult returns a StringCmd initialised with val and err for testing.
-func NewStringResult(val string, err error) *StringCmd {
-	var cmd StringCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewFloatResult returns a FloatCmd initialised with val and err for testing.
-func NewFloatResult(val float64, err error) *FloatCmd {
-	var cmd FloatCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewStringSliceResult returns a StringSliceCmd initialised with val and err for testing.
-func NewStringSliceResult(val []string, err error) *StringSliceCmd {
-	var cmd StringSliceCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewBoolSliceResult returns a BoolSliceCmd initialised with val and err for testing.
-func NewBoolSliceResult(val []bool, err error) *BoolSliceCmd {
-	var cmd BoolSliceCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewStringStringMapResult returns a StringStringMapCmd initialised with val and err for testing.
-func NewStringStringMapResult(val map[string]string, err error) *StringStringMapCmd {
-	var cmd StringStringMapCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewStringIntMapCmdResult returns a StringIntMapCmd initialised with val and err for testing.
-func NewStringIntMapCmdResult(val map[string]int64, err error) *StringIntMapCmd {
-	var cmd StringIntMapCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewTimeCmdResult returns a TimeCmd initialised with val and err for testing.
-func NewTimeCmdResult(val time.Time, err error) *TimeCmd {
-	var cmd TimeCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewZSliceCmdResult returns a ZSliceCmd initialised with val and err for testing.
-func NewZSliceCmdResult(val []Z, err error) *ZSliceCmd {
-	var cmd ZSliceCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewZWithKeyCmdResult returns a NewZWithKeyCmd initialised with val and err for testing.
-func NewZWithKeyCmdResult(val *ZWithKey, err error) *ZWithKeyCmd {
-	var cmd ZWithKeyCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewScanCmdResult returns a ScanCmd initialised with val and err for testing.
-func NewScanCmdResult(keys []string, cursor uint64, err error) *ScanCmd {
-	var cmd ScanCmd
-	cmd.page = keys
-	cmd.cursor = cursor
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewClusterSlotsCmdResult returns a ClusterSlotsCmd initialised with val and err for testing.
-func NewClusterSlotsCmdResult(val []ClusterSlot, err error) *ClusterSlotsCmd {
-	var cmd ClusterSlotsCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewGeoLocationCmdResult returns a GeoLocationCmd initialised with val and err for testing.
-func NewGeoLocationCmdResult(val []GeoLocation, err error) *GeoLocationCmd {
-	var cmd GeoLocationCmd
-	cmd.locations = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewGeoPosCmdResult returns a GeoPosCmd initialised with val and err for testing.
-func NewGeoPosCmdResult(val []*GeoPos, err error) *GeoPosCmd {
-	var cmd GeoPosCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewCommandsInfoCmdResult returns a CommandsInfoCmd initialised with val and err for testing.
-func NewCommandsInfoCmdResult(val map[string]*CommandInfo, err error) *CommandsInfoCmd {
-	var cmd CommandsInfoCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewXMessageSliceCmdResult returns a XMessageSliceCmd initialised with val and err for testing.
-func NewXMessageSliceCmdResult(val []XMessage, err error) *XMessageSliceCmd {
-	var cmd XMessageSliceCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewXStreamSliceCmdResult returns a XStreamSliceCmd initialised with val and err for testing.
-func NewXStreamSliceCmdResult(val []XStream, err error) *XStreamSliceCmd {
-	var cmd XStreamSliceCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}

vendor/github.com/go-redis/redis/v8/ring.go

@@ -1,736 +0,0 @@
-package redis
-
-import (
-	"context"
-	"crypto/tls"
-	"errors"
-	"fmt"
-	"net"
-	"strconv"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/cespare/xxhash/v2"
-	rendezvous "github.com/dgryski/go-rendezvous" //nolint
-
-	"github.com/go-redis/redis/v8/internal"
-	"github.com/go-redis/redis/v8/internal/hashtag"
-	"github.com/go-redis/redis/v8/internal/pool"
-	"github.com/go-redis/redis/v8/internal/rand"
-)
-
-var errRingShardsDown = errors.New("redis: all ring shards are down")
-
-//------------------------------------------------------------------------------
-
-type ConsistentHash interface {
-	Get(string) string
-}
-
-type rendezvousWrapper struct {
-	*rendezvous.Rendezvous
-}
-
-func (w rendezvousWrapper) Get(key string) string {
-	return w.Lookup(key)
-}
-
-func newRendezvous(shards []string) ConsistentHash {
-	return rendezvousWrapper{rendezvous.New(shards, xxhash.Sum64String)}
-}
-
-//------------------------------------------------------------------------------
-
-// RingOptions are used to configure a ring client and should be
-// passed to NewRing.
-type RingOptions struct {
-	// Map of name => host:port addresses of ring shards.
-	Addrs map[string]string
-
-	// NewClient creates a shard client with provided name and options.
-	NewClient func(name string, opt *Options) *Client
-
-	// Frequency of PING commands sent to check shards availability.
-	// Shard is considered down after 3 subsequent failed checks.
-	HeartbeatFrequency time.Duration
-
-	// NewConsistentHash returns a consistent hash that is used
-	// to distribute keys across the shards.
-	//
-	// See https://medium.com/@dgryski/consistent-hashing-algorithmic-tradeoffs-ef6b8e2fcae8
-	// for consistent hashing algorithmic tradeoffs.
-	NewConsistentHash func(shards []string) ConsistentHash
-
-	// Following options are copied from Options struct.
-
-	Dialer    func(ctx context.Context, network, addr string) (net.Conn, error)
-	OnConnect func(ctx context.Context, cn *Conn) error
-
-	Username string
-	Password string
-	DB       int
-
-	MaxRetries      int
-	MinRetryBackoff time.Duration
-	MaxRetryBackoff time.Duration
-
-	DialTimeout  time.Duration
-	ReadTimeout  time.Duration
-	WriteTimeout time.Duration
-
-	// PoolFIFO uses FIFO mode for each node connection pool GET/PUT (default LIFO).
-	PoolFIFO bool
-
-	PoolSize           int
-	MinIdleConns       int
-	MaxConnAge         time.Duration
-	PoolTimeout        time.Duration
-	IdleTimeout        time.Duration
-	IdleCheckFrequency time.Duration
-
-	TLSConfig *tls.Config
-	Limiter   Limiter
-}
-
-func (opt *RingOptions) init() {
-	if opt.NewClient == nil {
-		opt.NewClient = func(name string, opt *Options) *Client {
-			return NewClient(opt)
-		}
-	}
-
-	if opt.HeartbeatFrequency == 0 {
-		opt.HeartbeatFrequency = 500 * time.Millisecond
-	}
-
-	if opt.NewConsistentHash == nil {
-		opt.NewConsistentHash = newRendezvous
-	}
-
-	if opt.MaxRetries == -1 {
-		opt.MaxRetries = 0
-	} else if opt.MaxRetries == 0 {
-		opt.MaxRetries = 3
-	}
-	switch opt.MinRetryBackoff {
-	case -1:
-		opt.MinRetryBackoff = 0
-	case 0:
-		opt.MinRetryBackoff = 8 * time.Millisecond
-	}
-	switch opt.MaxRetryBackoff {
-	case -1:
-		opt.MaxRetryBackoff = 0
-	case 0:
-		opt.MaxRetryBackoff = 512 * time.Millisecond
-	}
-}
-
-func (opt *RingOptions) clientOptions() *Options {
-	return &Options{
-		Dialer:    opt.Dialer,
-		OnConnect: opt.OnConnect,
-
-		Username: opt.Username,
-		Password: opt.Password,
-		DB:       opt.DB,
-
-		MaxRetries: -1,
-
-		DialTimeout:  opt.DialTimeout,
-		ReadTimeout:  opt.ReadTimeout,
-		WriteTimeout: opt.WriteTimeout,
-
-		PoolFIFO:           opt.PoolFIFO,
-		PoolSize:           opt.PoolSize,
-		MinIdleConns:       opt.MinIdleConns,
-		MaxConnAge:         opt.MaxConnAge,
-		PoolTimeout:        opt.PoolTimeout,
-		IdleTimeout:        opt.IdleTimeout,
-		IdleCheckFrequency: opt.IdleCheckFrequency,
-
-		TLSConfig: opt.TLSConfig,
-		Limiter:   opt.Limiter,
-	}
-}
-
-//------------------------------------------------------------------------------
-
-type ringShard struct {
-	Client *Client
-	down   int32
-}
-
-func newRingShard(opt *RingOptions, name, addr string) *ringShard {
-	clopt := opt.clientOptions()
-	clopt.Addr = addr
-
-	return &ringShard{
-		Client: opt.NewClient(name, clopt),
-	}
-}
-
-func (shard *ringShard) String() string {
-	var state string
-	if shard.IsUp() {
-		state = "up"
-	} else {
-		state = "down"
-	}
-	return fmt.Sprintf("%s is %s", shard.Client, state)
-}
-
-func (shard *ringShard) IsDown() bool {
-	const threshold = 3
-	return atomic.LoadInt32(&shard.down) >= threshold
-}
-
-func (shard *ringShard) IsUp() bool {
-	return !shard.IsDown()
-}
-
-// Vote votes to set shard state and returns true if state was changed.
-func (shard *ringShard) Vote(up bool) bool {
-	if up {
-		changed := shard.IsDown()
-		atomic.StoreInt32(&shard.down, 0)
-		return changed
-	}
-
-	if shard.IsDown() {
-		return false
-	}
-
-	atomic.AddInt32(&shard.down, 1)
-	return shard.IsDown()
-}
-
-//------------------------------------------------------------------------------
-
-type ringShards struct {
-	opt *RingOptions
-
-	mu       sync.RWMutex
-	hash     ConsistentHash
-	shards   map[string]*ringShard // read only
-	list     []*ringShard          // read only
-	numShard int
-	closed   bool
-}
-
-func newRingShards(opt *RingOptions) *ringShards {
-	shards := make(map[string]*ringShard, len(opt.Addrs))
-	list := make([]*ringShard, 0, len(shards))
-
-	for name, addr := range opt.Addrs {
-		shard := newRingShard(opt, name, addr)
-		shards[name] = shard
-
-		list = append(list, shard)
-	}
-
-	c := &ringShards{
-		opt: opt,
-
-		shards: shards,
-		list:   list,
-	}
-	c.rebalance()
-
-	return c
-}
-
-func (c *ringShards) List() []*ringShard {
-	var list []*ringShard
-
-	c.mu.RLock()
-	if !c.closed {
-		list = c.list
-	}
-	c.mu.RUnlock()
-
-	return list
-}
-
-func (c *ringShards) Hash(key string) string {
-	key = hashtag.Key(key)
-
-	var hash string
-
-	c.mu.RLock()
-	if c.numShard > 0 {
-		hash = c.hash.Get(key)
-	}
-	c.mu.RUnlock()
-
-	return hash
-}
-
-func (c *ringShards) GetByKey(key string) (*ringShard, error) {
-	key = hashtag.Key(key)
-
-	c.mu.RLock()
-
-	if c.closed {
-		c.mu.RUnlock()
-		return nil, pool.ErrClosed
-	}
-
-	if c.numShard == 0 {
-		c.mu.RUnlock()
-		return nil, errRingShardsDown
-	}
-
-	hash := c.hash.Get(key)
-	if hash == "" {
-		c.mu.RUnlock()
-		return nil, errRingShardsDown
-	}
-
-	shard := c.shards[hash]
-	c.mu.RUnlock()
-
-	return shard, nil
-}
-
-func (c *ringShards) GetByName(shardName string) (*ringShard, error) {
-	if shardName == "" {
-		return c.Random()
-	}
-
-	c.mu.RLock()
-	shard := c.shards[shardName]
-	c.mu.RUnlock()
-	return shard, nil
-}
-
-func (c *ringShards) Random() (*ringShard, error) {
-	return c.GetByKey(strconv.Itoa(rand.Int()))
-}
-
-// heartbeat monitors state of each shard in the ring.
-func (c *ringShards) Heartbeat(frequency time.Duration) {
-	ticker := time.NewTicker(frequency)
-	defer ticker.Stop()
-
-	ctx := context.Background()
-	for range ticker.C {
-		var rebalance bool
-
-		for _, shard := range c.List() {
-			err := shard.Client.Ping(ctx).Err()
-			isUp := err == nil || err == pool.ErrPoolTimeout
-			if shard.Vote(isUp) {
-				internal.Logger.Printf(context.Background(), "ring shard state changed: %s", shard)
-				rebalance = true
-			}
-		}
-
-		if rebalance {
-			c.rebalance()
-		}
-	}
-}
-
-// rebalance removes dead shards from the Ring.
-func (c *ringShards) rebalance() {
-	c.mu.RLock()
-	shards := c.shards
-	c.mu.RUnlock()
-
-	liveShards := make([]string, 0, len(shards))
-
-	for name, shard := range shards {
-		if shard.IsUp() {
-			liveShards = append(liveShards, name)
-		}
-	}
-
-	hash := c.opt.NewConsistentHash(liveShards)
-
-	c.mu.Lock()
-	c.hash = hash
-	c.numShard = len(liveShards)
-	c.mu.Unlock()
-}
-
-func (c *ringShards) Len() int {
-	c.mu.RLock()
-	l := c.numShard
-	c.mu.RUnlock()
-	return l
-}
-
-func (c *ringShards) Close() error {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	if c.closed {
-		return nil
-	}
-	c.closed = true
-
-	var firstErr error
-	for _, shard := range c.shards {
-		if err := shard.Client.Close(); err != nil && firstErr == nil {
-			firstErr = err
-		}
-	}
-	c.hash = nil
-	c.shards = nil
-	c.list = nil
-
-	return firstErr
-}
-
-//------------------------------------------------------------------------------
-
-type ring struct {
-	opt           *RingOptions
-	shards        *ringShards
-	cmdsInfoCache *cmdsInfoCache //nolint:structcheck
-}
-
-// Ring is a Redis client that uses consistent hashing to distribute
-// keys across multiple Redis servers (shards). It's safe for
-// concurrent use by multiple goroutines.
-//
-// Ring monitors the state of each shard and removes dead shards from
-// the ring. When a shard comes online it is added back to the ring. This
-// gives you maximum availability and partition tolerance, but no
-// consistency between different shards or even clients. Each client
-// uses shards that are available to the client and does not do any
-// coordination when shard state is changed.
-//
-// Ring should be used when you need multiple Redis servers for caching
-// and can tolerate losing data when one of the servers dies.
-// Otherwise you should use Redis Cluster.
-type Ring struct {
-	*ring
-	cmdable
-	hooks
-	ctx context.Context
-}
-
-func NewRing(opt *RingOptions) *Ring {
-	opt.init()
-
-	ring := Ring{
-		ring: &ring{
-			opt:    opt,
-			shards: newRingShards(opt),
-		},
-		ctx: context.Background(),
-	}
-
-	ring.cmdsInfoCache = newCmdsInfoCache(ring.cmdsInfo)
-	ring.cmdable = ring.Process
-
-	go ring.shards.Heartbeat(opt.HeartbeatFrequency)
-
-	return &ring
-}
-
-func (c *Ring) Context() context.Context {
-	return c.ctx
-}
-
-func (c *Ring) WithContext(ctx context.Context) *Ring {
-	if ctx == nil {
-		panic("nil context")
-	}
-	clone := *c
-	clone.cmdable = clone.Process
-	clone.hooks.lock()
-	clone.ctx = ctx
-	return &clone
-}
-
-// Do creates a Cmd from the args and processes the cmd.
-func (c *Ring) Do(ctx context.Context, args ...interface{}) *Cmd {
-	cmd := NewCmd(ctx, args...)
-	_ = c.Process(ctx, cmd)
-	return cmd
-}
-
-func (c *Ring) Process(ctx context.Context, cmd Cmder) error {
-	return c.hooks.process(ctx, cmd, c.process)
-}
-
-// Options returns read-only Options that were used to create the client.
-func (c *Ring) Options() *RingOptions {
-	return c.opt
-}
-
-func (c *Ring) retryBackoff(attempt int) time.Duration {
-	return internal.RetryBackoff(attempt, c.opt.MinRetryBackoff, c.opt.MaxRetryBackoff)
-}
-
-// PoolStats returns accumulated connection pool stats.
-func (c *Ring) PoolStats() *PoolStats {
-	shards := c.shards.List()
-	var acc PoolStats
-	for _, shard := range shards {
-		s := shard.Client.connPool.Stats()
-		acc.Hits += s.Hits
-		acc.Misses += s.Misses
-		acc.Timeouts += s.Timeouts
-		acc.TotalConns += s.TotalConns
-		acc.IdleConns += s.IdleConns
-	}
-	return &acc
-}
-
-// Len returns the current number of shards in the ring.
-func (c *Ring) Len() int {
-	return c.shards.Len()
-}
-
-// Subscribe subscribes the client to the specified channels.
-func (c *Ring) Subscribe(ctx context.Context, channels ...string) *PubSub {
-	if len(channels) == 0 {
-		panic("at least one channel is required")
-	}
-
-	shard, err := c.shards.GetByKey(channels[0])
-	if err != nil {
-		// TODO: return PubSub with sticky error
-		panic(err)
-	}
-	return shard.Client.Subscribe(ctx, channels...)
-}
-
-// PSubscribe subscribes the client to the given patterns.
-func (c *Ring) PSubscribe(ctx context.Context, channels ...string) *PubSub {
-	if len(channels) == 0 {
-		panic("at least one channel is required")
-	}
-
-	shard, err := c.shards.GetByKey(channels[0])
-	if err != nil {
-		// TODO: return PubSub with sticky error
-		panic(err)
-	}
-	return shard.Client.PSubscribe(ctx, channels...)
-}
-
-// ForEachShard concurrently calls the fn on each live shard in the ring.
-// It returns the first error if any.
-func (c *Ring) ForEachShard(
-	ctx context.Context,
-	fn func(ctx context.Context, client *Client) error,
-) error {
-	shards := c.shards.List()
-	var wg sync.WaitGroup
-	errCh := make(chan error, 1)
-	for _, shard := range shards {
-		if shard.IsDown() {
-			continue
-		}
-
-		wg.Add(1)
-		go func(shard *ringShard) {
-			defer wg.Done()
-			err := fn(ctx, shard.Client)
-			if err != nil {
-				select {
-				case errCh <- err:
-				default:
-				}
-			}
-		}(shard)
-	}
-	wg.Wait()
-
-	select {
-	case err := <-errCh:
-		return err
-	default:
-		return nil
-	}
-}
-
-func (c *Ring) cmdsInfo(ctx context.Context) (map[string]*CommandInfo, error) {
-	shards := c.shards.List()
-	var firstErr error
-	for _, shard := range shards {
-		cmdsInfo, err := shard.Client.Command(ctx).Result()
-		if err == nil {
-			return cmdsInfo, nil
-		}
-		if firstErr == nil {
-			firstErr = err
-		}
-	}
-	if firstErr == nil {
-		return nil, errRingShardsDown
-	}
-	return nil, firstErr
-}
-
-func (c *Ring) cmdInfo(ctx context.Context, name string) *CommandInfo {
-	cmdsInfo, err := c.cmdsInfoCache.Get(ctx)
-	if err != nil {
-		return nil
-	}
-	info := cmdsInfo[name]
-	if info == nil {
-		internal.Logger.Printf(ctx, "info for cmd=%s not found", name)
-	}
-	return info
-}
-
-func (c *Ring) cmdShard(ctx context.Context, cmd Cmder) (*ringShard, error) {
-	cmdInfo := c.cmdInfo(ctx, cmd.Name())
-	pos := cmdFirstKeyPos(cmd, cmdInfo)
-	if pos == 0 {
-		return c.shards.Random()
-	}
-	firstKey := cmd.stringArg(pos)
-	return c.shards.GetByKey(firstKey)
-}
-
-func (c *Ring) process(ctx context.Context, cmd Cmder) error {
-	var lastErr error
-	for attempt := 0; attempt <= c.opt.MaxRetries; attempt++ {
-		if attempt > 0 {
-			if err := internal.Sleep(ctx, c.retryBackoff(attempt)); err != nil {
-				return err
-			}
-		}
-
-		shard, err := c.cmdShard(ctx, cmd)
-		if err != nil {
-			return err
-		}
-
-		lastErr = shard.Client.Process(ctx, cmd)
-		if lastErr == nil || !shouldRetry(lastErr, cmd.readTimeout() == nil) {
-			return lastErr
-		}
-	}
-	return lastErr
-}
-
-func (c *Ring) Pipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
-	return c.Pipeline().Pipelined(ctx, fn)
-}
-
-func (c *Ring) Pipeline() Pipeliner {
-	pipe := Pipeline{
-		ctx:  c.ctx,
-		exec: c.processPipeline,
-	}
-	pipe.init()
-	return &pipe
-}
-
-func (c *Ring) processPipeline(ctx context.Context, cmds []Cmder) error {
-	return c.hooks.processPipeline(ctx, cmds, func(ctx context.Context, cmds []Cmder) error {
-		return c.generalProcessPipeline(ctx, cmds, false)
-	})
-}
-
-func (c *Ring) TxPipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
-	return c.TxPipeline().Pipelined(ctx, fn)
-}
-
-func (c *Ring) TxPipeline() Pipeliner {
-	pipe := Pipeline{
-		ctx:  c.ctx,
-		exec: c.processTxPipeline,
-	}
-	pipe.init()
-	return &pipe
-}
-
-func (c *Ring) processTxPipeline(ctx context.Context, cmds []Cmder) error {
-	return c.hooks.processPipeline(ctx, cmds, func(ctx context.Context, cmds []Cmder) error {
-		return c.generalProcessPipeline(ctx, cmds, true)
-	})
-}
-
-func (c *Ring) generalProcessPipeline(
-	ctx context.Context, cmds []Cmder, tx bool,
-) error {
-	cmdsMap := make(map[string][]Cmder)
-	for _, cmd := range cmds {
-		cmdInfo := c.cmdInfo(ctx, cmd.Name())
-		hash := cmd.stringArg(cmdFirstKeyPos(cmd, cmdInfo))
-		if hash != "" {
-			hash = c.shards.Hash(hash)
-		}
-		cmdsMap[hash] = append(cmdsMap[hash], cmd)
-	}
-
-	var wg sync.WaitGroup
-	for hash, cmds := range cmdsMap {
-		wg.Add(1)
-		go func(hash string, cmds []Cmder) {
-			defer wg.Done()
-
-			_ = c.processShardPipeline(ctx, hash, cmds, tx)
-		}(hash, cmds)
-	}
-
-	wg.Wait()
-	return cmdsFirstErr(cmds)
-}
-
-func (c *Ring) processShardPipeline(
-	ctx context.Context, hash string, cmds []Cmder, tx bool,
-) error {
-	// TODO: retry?
-	shard, err := c.shards.GetByName(hash)
-	if err != nil {
-		setCmdsErr(cmds, err)
-		return err
-	}
-
-	if tx {
-		return shard.Client.processTxPipeline(ctx, cmds)
-	}
-	return shard.Client.processPipeline(ctx, cmds)
-}
-
-func (c *Ring) Watch(ctx context.Context, fn func(*Tx) error, keys ...string) error {
-	if len(keys) == 0 {
-		return fmt.Errorf("redis: Watch requires at least one key")
-	}
-
-	var shards []*ringShard
-	for _, key := range keys {
-		if key != "" {
-			shard, err := c.shards.GetByKey(hashtag.Key(key))
-			if err != nil {
-				return err
-			}
-
-			shards = append(shards, shard)
-		}
-	}
-
-	if len(shards) == 0 {
-		return fmt.Errorf("redis: Watch requires at least one shard")
-	}
-
-	if len(shards) > 1 {
-		for _, shard := range shards[1:] {
-			if shard.Client != shards[0].Client {
-				err := fmt.Errorf("redis: Watch requires all keys to be in the same shard")
-				return err
-			}
-		}
-	}
-
-	return shards[0].Client.Watch(ctx, fn, keys...)
-}
-
-// Close closes the ring client, releasing any open resources.
-//
-// It is rare to Close a Ring, as the Ring is meant to be long-lived
-// and shared between many goroutines.
-func (c *Ring) Close() error {
-	return c.shards.Close()
-}

vendor/github.com/go-redis/redis/v8/script.go

@@ -1,65 +0,0 @@
-package redis
-
-import (
-	"context"
-	"crypto/sha1"
-	"encoding/hex"
-	"io"
-	"strings"
-)
-
-type Scripter interface {
-	Eval(ctx context.Context, script string, keys []string, args ...interface{}) *Cmd
-	EvalSha(ctx context.Context, sha1 string, keys []string, args ...interface{}) *Cmd
-	ScriptExists(ctx context.Context, hashes ...string) *BoolSliceCmd
-	ScriptLoad(ctx context.Context, script string) *StringCmd
-}
-
-var (
-	_ Scripter = (*Client)(nil)
-	_ Scripter = (*Ring)(nil)
-	_ Scripter = (*ClusterClient)(nil)
-)
-
-type Script struct {
-	src, hash string
-}
-
-func NewScript(src string) *Script {
-	h := sha1.New()
-	_, _ = io.WriteString(h, src)
-	return &Script{
-		src:  src,
-		hash: hex.EncodeToString(h.Sum(nil)),
-	}
-}
-
-func (s *Script) Hash() string {
-	return s.hash
-}
-
-func (s *Script) Load(ctx context.Context, c Scripter) *StringCmd {
-	return c.ScriptLoad(ctx, s.src)
-}
-
-func (s *Script) Exists(ctx context.Context, c Scripter) *BoolSliceCmd {
-	return c.ScriptExists(ctx, s.hash)
-}
-
-func (s *Script) Eval(ctx context.Context, c Scripter, keys []string, args ...interface{}) *Cmd {
-	return c.Eval(ctx, s.src, keys, args...)
-}
-
-func (s *Script) EvalSha(ctx context.Context, c Scripter, keys []string, args ...interface{}) *Cmd {
-	return c.EvalSha(ctx, s.hash, keys, args...)
-}
-
-// Run optimistically uses EVALSHA to run the script. If script does not exist
-// it is retried using EVAL.
-func (s *Script) Run(ctx context.Context, c Scripter, keys []string, args ...interface{}) *Cmd {
-	r := s.EvalSha(ctx, c, keys, args...)
-	if err := r.Err(); err != nil && strings.HasPrefix(err.Error(), "NOSCRIPT ") {
-		return s.Eval(ctx, c, keys, args...)
-	}
-	return r
-}