diff options
Diffstat (limited to 'vendor/github.com/uptrace')
112 files changed, 0 insertions, 21887 deletions
diff --git a/vendor/github.com/uptrace/bun/.gitignore b/vendor/github.com/uptrace/bun/.gitignore deleted file mode 100644 index b5b79232b..000000000 --- a/vendor/github.com/uptrace/bun/.gitignore +++ /dev/null @@ -1,4 +0,0 @@ -# Patterns for files created by this project. -# For other files, use global gitignore. -*.s3db -.idea diff --git a/vendor/github.com/uptrace/bun/.prettierrc.yml b/vendor/github.com/uptrace/bun/.prettierrc.yml deleted file mode 100644 index decea5634..000000000 --- a/vendor/github.com/uptrace/bun/.prettierrc.yml +++ /dev/null @@ -1,6 +0,0 @@ -trailingComma: all -tabWidth: 2 -semi: false -singleQuote: true -proseWrap: always -printWidth: 100 diff --git a/vendor/github.com/uptrace/bun/CHANGELOG.md b/vendor/github.com/uptrace/bun/CHANGELOG.md deleted file mode 100644 index 9baa78316..000000000 --- a/vendor/github.com/uptrace/bun/CHANGELOG.md +++ /dev/null @@ -1,960 +0,0 @@ -## [1.2.9](https://github.com/uptrace/bun/compare/v1.2.8...v1.2.9) (2025-01-26) - - -### Bug Fixes - -* apply join condition to select with count ([e77b9e7](https://github.com/uptrace/bun/commit/e77b9e72fa5ae8e173d506a4e154ba64214c4aff)), closes [#597](https://github.com/uptrace/bun/issues/597) -* build ([702e525](https://github.com/uptrace/bun/commit/702e525e30ec93b6d4611359518e1008b67744af)) -* individual replica timeout ([9f5e8b1](https://github.com/uptrace/bun/commit/9f5e8b1c46673bd1779bd4309a28db33dcd695bf)) -* test ([dfc4059](https://github.com/uptrace/bun/commit/dfc405901907419d043bb6ced3ad20c131c1b972)) - - -### Features - -* add feature flag AlterColumnExists ([fc35e12](https://github.com/uptrace/bun/commit/fc35e1222242b3d581f0b7496a9021aadfc50b07)), closes [#704](https://github.com/uptrace/bun/issues/704) -* add Options ([815e11a](https://github.com/uptrace/bun/commit/815e11a023d2babf65d528a20ddffc7628636e7e)) -* allow to specify read-only replica for SELECTs ([cbbe1e9](https://github.com/uptrace/bun/commit/cbbe1e94fd0c72d1870395a663c8053d7e8c6ace)) -* downgrade to use the field in has-many-relation ([91e0d27](https://github.com/uptrace/bun/commit/91e0d2719a5a20b3208cea0232e2dbcb452d6c23)), closes [#1107](https://github.com/uptrace/bun/issues/1107) -* make WithReadOnlyReplica variadic ([4cbb15a](https://github.com/uptrace/bun/commit/4cbb15a53e566e03284253aa46be372338968954)) -* **pgdialect:** allow to convert uint to int ([7d22ddd](https://github.com/uptrace/bun/commit/7d22ddd263b28b9fd6e172e0208c124b7c56f111)) -* **pgdriver:** improve otel instrumentation ([c40e4f3](https://github.com/uptrace/bun/commit/c40e4f3c50c710903236dc89b56a843a0351a21a)) - - - -## [1.2.8](https://github.com/uptrace/bun/compare/v1.2.7...v1.2.8) (2025-01-06) - - -### Bug Fixes - -* comment string zero bytes filtering ([34dfd68](https://github.com/uptrace/bun/commit/34dfd684e371c24b9f59e9b13ef57660931f0bde)) -* get m2m table's structKey with driver.Valuer ([f107314](https://github.com/uptrace/bun/commit/f1073147dc73d01dcf8a6ee9252d354ff06a1062)), closes [#1100](https://github.com/uptrace/bun/issues/1100) -* return error when use dest with has-many/many-to-many ([8296774](https://github.com/uptrace/bun/commit/829677486b502e6d5d2ae37814488ae9f2c7386e)), closes [#606](https://github.com/uptrace/bun/issues/606) -* support scan float32 to float32/float64 ([a52e733](https://github.com/uptrace/bun/commit/a52e7339a93f84468878dcaffc42536faa44efae)), closes [#1087](https://github.com/uptrace/bun/issues/1087) - - -### Features - -* add RelationWithOpts method to SelectQuery ([dd3ef52](https://github.com/uptrace/bun/commit/dd3ef522c8a9c656958b73ee5d546854fb7c6edf)) -* enhance debugging by adding query comments in headers ([1376d18](https://github.com/uptrace/bun/commit/1376d1870bfe3d89e3630203787f1e87c503d5df)) -* sort fields by struct ([5edb672](https://github.com/uptrace/bun/commit/5edb672e320be9b210f06d25c4f4b9e761c1c526)), closes [#1095](https://github.com/uptrace/bun/issues/1095) - - - -## [1.2.7](https://github.com/uptrace/bun/compare/v1.2.6...v1.2.7) (2025-01-01) - - -### Bug Fixes - -* do not create new migrations if nothing to migrate ([5cc961d](https://github.com/uptrace/bun/commit/5cc961d6cc461ad3534728fc4d3cae12bf8b736e)) -* has many relation with driver.Valuer ([cb8c42c](https://github.com/uptrace/bun/commit/cb8c42cd3f65d95865c76a594abad815eea1df3c)) -* improve range type to support driver.Valuer and sql.Scanner ([856e12b](https://github.com/uptrace/bun/commit/856e12b0d37275a6aa247370f6a8231fd89ca3e7)) -* pass correct 'transactional' parameter ([ebdef1b](https://github.com/uptrace/bun/commit/ebdef1b0e9d33a5ca475ab4c2ec2fb44d11d4595)) -* **pgdialect:** remove unsigned integer conversion ([ab3c679](https://github.com/uptrace/bun/commit/ab3c679d529dd20d44e789dc6f1d89f9510bde0b)), closes [uptrace/bun#624](https://github.com/uptrace/bun/issues/624) -* remove unused param on table.go and tables.go: canAddr ([d563e2d](https://github.com/uptrace/bun/commit/d563e2dbe95caeb0e00ad1b3e82283431747fe7b)) -* replace the link to docs repo in CONTRIBUTING.md ([e120096](https://github.com/uptrace/bun/commit/e12009662ae1ddefcc1337cc5e32e73d77c7def0)) -* trim surrounding '' in string literal in DEFAULT clause ([a0dff72](https://github.com/uptrace/bun/commit/a0dff72b6ab0ca24d00c96c923046200dd6112ed)) - - -### Features - -* add an ordered map to remove unnecessary dependencies ([9fea143](https://github.com/uptrace/bun/commit/9fea1437d8344d836670e802fd12d3476e8cad86)) -* support disable dialect's feature ([5343bd7](https://github.com/uptrace/bun/commit/5343bd7fc4ceda866a7d607388ebb7a89f7f5823)) - - - -## [1.2.6](https://github.com/uptrace/bun/compare/v1.2.5...v1.2.6) (2024-11-20) - - -### Bug Fixes - -* append IDENTITY to ADD COLUMN statement if needed ([694f873](https://github.com/uptrace/bun/commit/694f873d61ed8d2f09032ae0c0dbec4b71c3719e)) -* **ci:** prune stale should be executed at 3 AM every day ([0cedcb0](https://github.com/uptrace/bun/commit/0cedcb068229b63041a4f48de12bb767c8454048)) -* cleanup after testUniqueRenamedTable ([b1ae32e](https://github.com/uptrace/bun/commit/b1ae32e9e9f45ff2a66e50bfd13bedcf6653d874)) -* fix go.mod of oracledialect ([89e21ea](https://github.com/uptrace/bun/commit/89e21eab362c60511cca00890ae29551a2ba7c46)) -* has many relationship with multiple columns ([1664b2c](https://github.com/uptrace/bun/commit/1664b2c07a5f6cfd3b6730e5005373686e9830a6)) -* ignore case for type equivalence ([c3253a5](https://github.com/uptrace/bun/commit/c3253a5c59b078607db9e216ddc11afdef546e05)) -* implement DefaultSchema for Oracle dialect ([d08fa40](https://github.com/uptrace/bun/commit/d08fa40cc87d67296a83a77448ea511531fc8cdd)) -* **oracledialect:** add go.mod file so the dialect is released properly ([#1043](https://github.com/uptrace/bun/issues/1043)) ([1bb5597](https://github.com/uptrace/bun/commit/1bb5597f1a32f5d693101ef4a62e25d99f5b9db5)) -* **oracledialect:** update go.mod by go mod tidy to fix tests ([7f90a15](https://github.com/uptrace/bun/commit/7f90a15c51a2482dda94226dd13b913d6b470a29)) -* **pgdialect:** array value quoting ([892c416](https://github.com/uptrace/bun/commit/892c416272a8428c592896d65d3ad51a6f2356d8)) -* remove schema name from t.Name during bun-schema inspection ([31ed582](https://github.com/uptrace/bun/commit/31ed58254ad08143d88684672acd33ce044ea5a9)) -* rename column only if the name does not exist in 'target' ([fed6012](https://github.com/uptrace/bun/commit/fed6012d177e55b8320b31ef37fc02a0cbf0b9f5)) -* support embed with tag Unique ([3acd6dd](https://github.com/uptrace/bun/commit/3acd6dd8546118d7b867ca796a5e56311edad070)) -* update oracledialect/version.go in release.sh ([bcd070f](https://github.com/uptrace/bun/commit/bcd070f48a75d0092a5620261658c9c5994f0bf6)) -* update schema.Field names ([9b810de](https://github.com/uptrace/bun/commit/9b810dee4b1a721efb82c913099f39f52c44eb57)) - - -### Features - -* add and drop columns ([3fdd5b8](https://github.com/uptrace/bun/commit/3fdd5b8f635f849a74e78c665274609f75245b19)) -* add and drop IDENTITY ([dd83779](https://github.com/uptrace/bun/commit/dd837795c31490fd8816eec0e9833e79fafdda32)) -* add support type for net/netip.addr and net/netip.prefix ([#1028](https://github.com/uptrace/bun/issues/1028)) ([95c4a8e](https://github.com/uptrace/bun/commit/95c4a8ebd634e1e99114727a7b157eeeb9297ee9)) -* **automigrate:** detect renamed tables ([c03938f](https://github.com/uptrace/bun/commit/c03938ff5e9fa2f653e4c60668b1368357d2de10)) -* change column type ([3cfd8c6](https://github.com/uptrace/bun/commit/3cfd8c62125786aaf6f493acc5b39f4d3db3d628)) -* **ci:** support release on osx ([435510b](https://github.com/uptrace/bun/commit/435510b0a73b0d9e6d06e3e3c3f0fa4379e9ed8c)) -* create sql migrations and apply them ([1bf7cfd](https://github.com/uptrace/bun/commit/1bf7cfd067e0e26ae212b0f7421e5abc6f67fb4f)) -* create transactional migration files ([c3320f6](https://github.com/uptrace/bun/commit/c3320f624830dc2fe99af2c7cbe492b2a83f9e4a)) -* detect Create/Drop table ([408859f](https://github.com/uptrace/bun/commit/408859f07be38236b39a00909cdce55d49f6f824)) -* detect modified relations ([a918dc4](https://github.com/uptrace/bun/commit/a918dc472a33dd24c5fffd4d048bcf49f2e07a42)) -* detect renamed columns ([886d0a5](https://github.com/uptrace/bun/commit/886d0a5b18aba272f1c86af2a2cf68ce4c8879f2)) -* detect renamed tables ([8857bab](https://github.com/uptrace/bun/commit/8857bab54b94170d218633f3b210d379e4e51a21)) -* enhance Apply method to accept multiple functions ([7823f2f](https://github.com/uptrace/bun/commit/7823f2f24c814e104dc59475156255c7b3b26144)) -* implement fmt.Stringer queries ([5060e47](https://github.com/uptrace/bun/commit/5060e47db13451a982e48d0f14055a58ba60b472)) -* improve FK handling ([a822fc5](https://github.com/uptrace/bun/commit/a822fc5f8ae547b7cd41e1ca35609d519d78598b)) -* include target schema name in migration name ([ac8d221](https://github.com/uptrace/bun/commit/ac8d221e6443b469e794314c5fc189250fa542d5)) -* **mariadb:** support RETURNING clause in DELETE statement ([b8dec9d](https://github.com/uptrace/bun/commit/b8dec9d9a06124696bd5ee2abbf33f19087174b6)) -* migrate FKs ([4c1dfdb](https://github.com/uptrace/bun/commit/4c1dfdbe99c73d0c0f2d7b1f8b11adf30c6a41f7)) -* **mysql:** support ORDER BY and LIMIT clauses in UPDATE and DELETE statements ([de71bed](https://github.com/uptrace/bun/commit/de71bed9252980648269af85b7a51cbc464ce710)) -* support modifying primary keys ([a734629](https://github.com/uptrace/bun/commit/a734629fa285406038cbe4a50798626b5ac08539)) -* support UNIQUE constraints ([3c4d5d2](https://github.com/uptrace/bun/commit/3c4d5d2c47be4652fb9b5cf1c6bd7b6c0a437287)) -* use *bun.DB in MigratorDialect ([a8788bf](https://github.com/uptrace/bun/commit/a8788bf62cbcc954a08532c299c774262de7a81d)) - - - -## [1.2.5](https://github.com/uptrace/bun/compare/v1.2.3...v1.2.5) (2024-10-26) - - -### Bug Fixes - -* allow Limit() without Order() with MSSQL ([#1009](https://github.com/uptrace/bun/issues/1009)) ([1a46ddc](https://github.com/uptrace/bun/commit/1a46ddc0d3ca0bdc60ca8be5ad1886799d14c8b0)) -* copy bytes in mapModel.Scan ([#1030](https://github.com/uptrace/bun/issues/1030)) ([#1032](https://github.com/uptrace/bun/issues/1032)) ([39fda4e](https://github.com/uptrace/bun/commit/39fda4e3d341e59e4955f751cb354a939e57c1b1)) -* fix issue with has-many join and pointer fields ([#950](https://github.com/uptrace/bun/issues/950)) ([#983](https://github.com/uptrace/bun/issues/983)) ([cbc5177](https://github.com/uptrace/bun/commit/cbc517792ba6cdcef1828f3699d3d4dfe3c5e0eb)) -* restore explicit column: name override ([#984](https://github.com/uptrace/bun/issues/984)) ([169f258](https://github.com/uptrace/bun/commit/169f258a9460cad451f3025d2ef8df1bbd42a003)) -* return column option back ([#1036](https://github.com/uptrace/bun/issues/1036)) ([a3ccbea](https://github.com/uptrace/bun/commit/a3ccbeab39151d3eed6cb245fe15cfb5d71ba557)) -* sql.NullString mistaken as custom struct ([#1019](https://github.com/uptrace/bun/issues/1019)) ([87c77b8](https://github.com/uptrace/bun/commit/87c77b8911f2035b0ee8ea96356a2c7600b5b94d)) -* typos ([#1026](https://github.com/uptrace/bun/issues/1026)) ([760de7d](https://github.com/uptrace/bun/commit/760de7d0fad15dc761475670a4dde056aef9210d)) - - -### Features - -* add transaction isolation level support to pgdriver ([#1034](https://github.com/uptrace/bun/issues/1034)) ([3ef44ce](https://github.com/uptrace/bun/commit/3ef44ce1cdd969a21b76d6c803119cf12c375cb0)) - - -### Performance Improvements - -* refactor SelectQuery.ScanAndCount to optimize performance when there is no limit and offset ([#1035](https://github.com/uptrace/bun/issues/1035)) ([8638613](https://github.com/uptrace/bun/commit/86386135897485bbada6c50ec9a2743626111433)) - - - -## [1.2.4](https://github.com/uptrace/bun/compare/v1.2.3...v1.2.4) (2024-10-26) - - -### Bug Fixes - -* allow Limit() without Order() with MSSQL ([#1009](https://github.com/uptrace/bun/issues/1009)) ([1a46ddc](https://github.com/uptrace/bun/commit/1a46ddc0d3ca0bdc60ca8be5ad1886799d14c8b0)) -* copy bytes in mapModel.Scan ([#1030](https://github.com/uptrace/bun/issues/1030)) ([#1032](https://github.com/uptrace/bun/issues/1032)) ([39fda4e](https://github.com/uptrace/bun/commit/39fda4e3d341e59e4955f751cb354a939e57c1b1)) -* return column option back ([#1036](https://github.com/uptrace/bun/issues/1036)) ([a3ccbea](https://github.com/uptrace/bun/commit/a3ccbeab39151d3eed6cb245fe15cfb5d71ba557)) -* sql.NullString mistaken as custom struct ([#1019](https://github.com/uptrace/bun/issues/1019)) ([87c77b8](https://github.com/uptrace/bun/commit/87c77b8911f2035b0ee8ea96356a2c7600b5b94d)) -* typos ([#1026](https://github.com/uptrace/bun/issues/1026)) ([760de7d](https://github.com/uptrace/bun/commit/760de7d0fad15dc761475670a4dde056aef9210d)) - - -### Features - -* add transaction isolation level support to pgdriver ([#1034](https://github.com/uptrace/bun/issues/1034)) ([3ef44ce](https://github.com/uptrace/bun/commit/3ef44ce1cdd969a21b76d6c803119cf12c375cb0)) - - -### Performance Improvements - -* refactor SelectQuery.ScanAndCount to optimize performance when there is no limit and offset ([#1035](https://github.com/uptrace/bun/issues/1035)) ([8638613](https://github.com/uptrace/bun/commit/86386135897485bbada6c50ec9a2743626111433)) - - - -## [1.2.3](https://github.com/uptrace/bun/compare/v1.2.2...v1.2.3) (2024-08-31) - - - -## [1.2.2](https://github.com/uptrace/bun/compare/v1.2.1...v1.2.2) (2024-08-29) - - -### Bug Fixes - -* gracefully handle empty hstore in pgdialect ([#1010](https://github.com/uptrace/bun/issues/1010)) ([2f73d8a](https://github.com/uptrace/bun/commit/2f73d8a8e16c8718ebfc956036d9c9a01a0888bc)) -* number each unit test ([#974](https://github.com/uptrace/bun/issues/974)) ([b005dc2](https://github.com/uptrace/bun/commit/b005dc2a9034715c6f59dcfc8e76aa3b85df38ab)) - - -### Features - -* add ModelTableExpr to TruncateTableQuery ([#969](https://github.com/uptrace/bun/issues/969)) ([7bc330f](https://github.com/uptrace/bun/commit/7bc330f152cf0d9dc30956478e2731ea5816f012)) - - - -## [1.2.1](https://github.com/uptrace/bun/compare/v1.2.0...v1.2.1) (2024-04-02) - - - -# [1.2.0](https://github.com/uptrace/bun/compare/v1.1.17...v1.2.0) (2024-04-02) - - -### Bug Fixes - -* embedding of scanonly fields ([ed6ed74](https://github.com/uptrace/bun/commit/ed6ed74d5379ea6badb09cc37709211a51f5792b)) -* **table:** allow alt annotation ([#956](https://github.com/uptrace/bun/issues/956)) ([8a0397b](https://github.com/uptrace/bun/commit/8a0397b6e2219909d6b00d258eb7934170058edd)) -* transactional migration file extension ([#959](https://github.com/uptrace/bun/issues/959)) ([921b15b](https://github.com/uptrace/bun/commit/921b15b80110d28251a9210c77397d29924ffbc5)) - - -### Features - -* Allow overriding of Warn and Deprecated loggers ([#952](https://github.com/uptrace/bun/issues/952)) ([0e9d737](https://github.com/uptrace/bun/commit/0e9d737e4ca2deb86930237ee32a39cf3f7e8157)) -* enable SNI ([#953](https://github.com/uptrace/bun/issues/953)) ([4071ffb](https://github.com/uptrace/bun/commit/4071ffb5bcb1b233cda239c92504d8139dcf1d2f)) -* **idb:** add NewMerge method to IDB ([#966](https://github.com/uptrace/bun/issues/966)) ([664e2f1](https://github.com/uptrace/bun/commit/664e2f154f1153d2a80cd062a5074f1692edaee7)) - - - -## [1.1.17](https://github.com/uptrace/bun/compare/v1.1.16...v1.1.17) (2024-01-11) - - -### Features - -* add CreateTxSQLMigrations function ([#916](https://github.com/uptrace/bun/issues/916)) ([c68ec7c](https://github.com/uptrace/bun/commit/c68ec7cfc418959eb7c79028be7ac91f97d462ef)) -* add Join to UpdateQuery ([#908](https://github.com/uptrace/bun/issues/908)) ([8c4d8be](https://github.com/uptrace/bun/commit/8c4d8be3aa4e64582698b37fd21434b8960dddc0)) -* bunslog.QueryHook for Bun logging using `log/slog` ([#904](https://github.com/uptrace/bun/issues/904)) ([4953367](https://github.com/uptrace/bun/commit/495336731da0a995aa28c7bc84345c7825408e48)) -* dbfixture.New to accept IDB interface ([#900](https://github.com/uptrace/bun/issues/900)) ([2dee174](https://github.com/uptrace/bun/commit/2dee174bc4d09a45caeeede2885306e5fd10002d)) - - - -## [1.1.16](https://github.com/uptrace/bun/compare/v1.1.15...v1.1.16) (2023-09-16) - - -### Reverts - -* Revert "fix: "model does not have column" error (#850)" ([387228e](https://github.com/uptrace/bun/commit/387228e85d22dfcf3659f4631dfa87106d7ef45f)), closes [#850](https://github.com/uptrace/bun/issues/850) - - - -## [1.1.15](https://github.com/uptrace/bun/compare/v1.1.14...v1.1.15) (2023-09-10) - - -### Bug Fixes - -* "model does not have column" error ([#850](https://github.com/uptrace/bun/issues/850)) ([16367aa](https://github.com/uptrace/bun/commit/16367aabb34b98766d28e0678f9d47710f451fae)) -* alloc when mounting ([#891](https://github.com/uptrace/bun/issues/891)) ([f2256f1](https://github.com/uptrace/bun/commit/f2256f10a1d328fb924ca79cde76e77641398573)) -* index hints have to be specified following a table name ([4a2ae85](https://github.com/uptrace/bun/commit/4a2ae853a1509bb300bc2d96471505caee799e43)) -* make Rows.Close to drain messages ([5ceba07](https://github.com/uptrace/bun/commit/5ceba076668eb7aaddb1d8a56202256d5e6c1ead)) -* run hooks on Rows ([#892](https://github.com/uptrace/bun/issues/892)) ([f652b3d](https://github.com/uptrace/bun/commit/f652b3d399a3dc46c856eb8c0f10140a12ea4310)) -* scan error [#709](https://github.com/uptrace/bun/issues/709) ([#837](https://github.com/uptrace/bun/issues/837)) ([b82afa5](https://github.com/uptrace/bun/commit/b82afa52633b2a1b352db6de4ff0d369d5468a07)) - - -### Features - -* add bun.NullZero ([786bb6b](https://github.com/uptrace/bun/commit/786bb6bfeba3c12f8b28579d61e4794d9fb3e373)) -* **bunotel:** add options for set otel providers ([#836](https://github.com/uptrace/bun/issues/836)) ([806e632](https://github.com/uptrace/bun/commit/806e6323f60b4703b03a71c113c263d0afc95b35)) - - - -## [1.1.14](https://github.com/uptrace/bun/compare/v1.1.13...v1.1.14) (2023-05-24) - - -### Bug Fixes - -* enable CompositeIn for MySQL ([9f377b5](https://github.com/uptrace/bun/commit/9f377b5e744cb38ef4aadd61213855c009e47354)) - - - -## [1.1.13](https://github.com/uptrace/bun/compare/v1.1.12...v1.1.13) (2023-05-06) - - -### Bug Fixes - -* bunbig.Int.Scan typo ([7ddabb8](https://github.com/uptrace/bun/commit/7ddabb8c667f50032bc0bb2523a287efbe0851e7)) -* compare full MySQL version ([096fabe](https://github.com/uptrace/bun/commit/096fabefa114202d3601ad8e456f5e491a4e3787)) -* enable delete table alias for MySQL >= 8.0.16 ([77a600b](https://github.com/uptrace/bun/commit/77a600bc060154fb91aa68e68ba6a8875e5b10fb)) -* incorrect table relationship panic message [#791](https://github.com/uptrace/bun/issues/791) ([ad41888](https://github.com/uptrace/bun/commit/ad4188862eeaab30fc7c48d3224b5a786557aec5)) -* should rollback if migrate using transaction and got an err (thanks [@bayshark](https://github.com/bayshark)) ([e7a119b](https://github.com/uptrace/bun/commit/e7a119b1b8911d8bf059bb271c90ad4a5f5f02be)) - - -### Features - -* add option to customize Go migration template ([f31bf73](https://github.com/uptrace/bun/commit/f31bf739b9c7a0383411b9e67cba96c858795c68)) -* expose Exec(…) method for RawQuery ([11192c8](https://github.com/uptrace/bun/commit/11192c83f932eb7421ef09e06859a7f171de7803)) -* prefix migration files with 1 upto 14 digits ([b74b671](https://github.com/uptrace/bun/commit/b74b6714bb6a83e470e21801c97cc40e20acfb50)) -* rename option ([9353a3f](https://github.com/uptrace/bun/commit/9353a3f921c038fdf4a90665f1b0a9d0d03dc182)) - - - -## [1.1.12](https://github.com/uptrace/bun/compare/v1.1.11...v1.1.12) (2023-02-20) - - - -## [1.1.11](https://github.com/uptrace/bun/compare/v1.1.10...v1.1.11) (2023-02-01) - - -### Bug Fixes - -* add support for inserting values with Unicode encoding for mssql dialect ([e98c6c0](https://github.com/uptrace/bun/commit/e98c6c0f033b553bea3bbc783aa56c2eaa17718f)) -* fix relation tag ([a3eedff](https://github.com/uptrace/bun/commit/a3eedff49700490d4998dcdcdc04f554d8f17166)) - - - -## [1.1.10](https://github.com/uptrace/bun/compare/v1.1.9...v1.1.10) (2023-01-16) - - -### Bug Fixes - -* allow QueryEvent to better detect operations in raw queries ([8e44735](https://github.com/uptrace/bun/commit/8e4473538364bae6562055d35e94c3e9c0b77691)) -* append default VARCHAR length instead of hardcoding it in the type definition ([e5079c7](https://github.com/uptrace/bun/commit/e5079c70343ba8c8b410aed23ac1d1ae5a2c9ff6)) -* prevent panic when use pg array with custom database type ([67e4412](https://github.com/uptrace/bun/commit/67e4412a972a9ed5f3a1d07c66957beedbc8a8a3)) -* properly return sql.ErrNoRows when scanning []byte ([996fead](https://github.com/uptrace/bun/commit/996fead2595fbcaff4878b77befe6709a54b3a4d)) - - -### Features - -* mssql output support for update or delete query ([#718](https://github.com/uptrace/bun/issues/718)) ([08876b4](https://github.com/uptrace/bun/commit/08876b4d420e761cbfa658aa6bb89b3f7c62c240)) -* add Err method to query builder ([c722c90](https://github.com/uptrace/bun/commit/c722c90f3dce2642ca4f4c2ab3f9a35cd496b557)) -* add support for time.Time array in Postgres ([3dd6f3b](https://github.com/uptrace/bun/commit/3dd6f3b2ac1bfbcda08240dc1676647b61715a9c)) -* mssql and pg merge query ([#723](https://github.com/uptrace/bun/issues/723)) ([deea764](https://github.com/uptrace/bun/commit/deea764d9380b16aad34228aa32717d10f2a4bab)) -* setError on attempt to set non-positive .Varchar() ([3335e0b](https://github.com/uptrace/bun/commit/3335e0b9d6d3f424145e1f715223a0fffe773d9a)) - - -### Reverts - -* go 1.18 ([67a4488](https://github.com/uptrace/bun/commit/67a448897eaaf1ebc54d629dfd3b2509b35da352)) - - - -## [1.1.9](https://github.com/uptrace/bun/compare/v1.1.8...v1.1.9) (2022-11-23) - - -### Bug Fixes - -* adding dialect override for append-bool ([#695](https://github.com/uptrace/bun/issues/695)) ([338f2f0](https://github.com/uptrace/bun/commit/338f2f04105ad89e64530db86aeb387e2ad4789e)) -* don't call hooks twice for whereExists ([9057857](https://github.com/uptrace/bun/commit/90578578e717f248e4b6eb114c5b495fd8d4ed41)) -* don't lock migrations when running Migrate and Rollback ([69a7354](https://github.com/uptrace/bun/commit/69a7354d987ff2ed5338c9ef5f4ce320724299ab)) -* **query:** make WhereDeleted compatible with ForceDelete ([299c3fd](https://github.com/uptrace/bun/commit/299c3fd57866aaecd127a8f219c95332898475db)), closes [#673](https://github.com/uptrace/bun/issues/673) -* relation join soft delete SQL generate ([a98f4e9](https://github.com/uptrace/bun/commit/a98f4e9f2bbdbc2b81cd13aa228a1a91eb905ba2)) - - -### Features - -* add migrate.Exec ([d368bbe](https://github.com/uptrace/bun/commit/d368bbe52bb1ee3dabf0aada190bf967eec10255)) -* **update:** "skipupdate" while bulk ([1a32b2f](https://github.com/uptrace/bun/commit/1a32b2ffbd5bc9a8d8b5978dd0f16c9fb79242ee)) -* **zerolog:** added zerolog hook ([9d2267d](https://github.com/uptrace/bun/commit/9d2267d414b47164ab6ceada55bf311ad548a6b0)) - - - -## [1.1.8](https://github.com/uptrace/bun/compare/v1.1.7...v1.1.8) (2022-08-29) - - -### Bug Fixes - -* **bunotel:** handle option attributes ([#656](https://github.com/uptrace/bun/issues/656)) ([9f1e0bd](https://github.com/uptrace/bun/commit/9f1e0bd19fc0300f12996b3e6595f093024e06b6)) -* driver.Valuer returns itself causes stackoverflow ([c9f51d3](https://github.com/uptrace/bun/commit/c9f51d3e2dabed0c29c26a4221abbc426a7206f3)), closes [#657](https://github.com/uptrace/bun/issues/657) -* **pgdriver:** return FATAL and PANIC errors immediately ([4595e38](https://github.com/uptrace/bun/commit/4595e385d3706116e47bf9dc295186ec7a2ab0f9)) -* quote m2m table name fixes [#649](https://github.com/uptrace/bun/issues/649) ([61a634e](https://github.com/uptrace/bun/commit/61a634e4cd5c18df4b75f756d4b0f06ea94bc3c8)) -* support multi-level embed column ([177ec4c](https://github.com/uptrace/bun/commit/177ec4c6e04f92957614ad4724bc82c422649a4b)), closes [#643](https://github.com/uptrace/bun/issues/643) - - -### Features - -* conditions not supporting composite in ([e5d78d4](https://github.com/uptrace/bun/commit/e5d78d464b94b78438cf275b4c35f713d129961d)) -* **idb:** support raw query ([be4e688](https://github.com/uptrace/bun/commit/be4e6886ad94b4b6ca42f24f73d79a15b1ac3188)) -* **migrate:** add MissingMigrations ([42567d0](https://github.com/uptrace/bun/commit/42567d052280f2c412d4796df7178915e537e6d9)) -* **pgdriver:** implement database/sql/driver.SessionResetter ([bda298a](https://github.com/uptrace/bun/commit/bda298ac66305e5b00ba67d72d3973625930c6b9)) -* **pgdriver:** provide access to the underlying net.Conn ([d07ea0e](https://github.com/uptrace/bun/commit/d07ea0ed1541225b5f08e59a4c87383811f7f051)) - - - -## [1.1.7](https://github.com/uptrace/bun/compare/v1.1.6...v1.1.7) (2022-07-29) - - -### Bug Fixes - -* change ScanAndCount without a limit to select all rows ([de5c570](https://github.com/uptrace/bun/commit/de5c5704166563aea41a82f7863f2db88ff108e2)) - - - -## [1.1.6](https://github.com/uptrace/bun/compare/v1.1.5...v1.1.6) (2022-07-10) - - -### Bug Fixes - -* bunotel add set attributes to query metrics ([dae82cc](https://github.com/uptrace/bun/commit/dae82cc0e3af49be1e474027b55c34364676985d)) -* **db.ScanRows:** ensure rows.Close is called ([9ffbc6a](https://github.com/uptrace/bun/commit/9ffbc6a46e24b908742b6973f33ef8e5b17cc12b)) -* merge apply ([3081849](https://github.com/uptrace/bun/commit/30818499eacddd3b1a3e749091ba6a1468125641)) -* **migrate:** close conn/tx on error ([7b168ea](https://github.com/uptrace/bun/commit/7b168eabfe0f844bcbf8dc89629d04c385b9f58c)) -* **migrate:** type Migration should be used as a value rather than a pointer ([fb43935](https://github.com/uptrace/bun/commit/fb4393582b49fe528800a66aac5fb1c9a6033048)) -* **migrate:** type MigrationGroup should be used as a value rather than a pointer ([649da1b](https://github.com/uptrace/bun/commit/649da1b3c158060add9b61b32c289260daafa65a)) -* mssql cursor pagination ([#589](https://github.com/uptrace/bun/issues/589)) ([b34ec97](https://github.com/uptrace/bun/commit/b34ec97ddda95629f73762721d60fd3e00e7e99f)) - - -### Features - -* "skipupdate" model field tag ([#565](https://github.com/uptrace/bun/issues/565)) ([9288294](https://github.com/uptrace/bun/commit/928829482c718a0c215aa4f4adfa6f3fb3ed4302)) -* add pgdriver write error to log ([5ddda3d](https://github.com/uptrace/bun/commit/5ddda3de31cd08ceee4bdea64ceae8d15eace07b)) -* add query string representation ([520da7e](https://github.com/uptrace/bun/commit/520da7e1d6dbf7b06846f6b39a7f99e8753c1466)) -* add relation condition with tag ([fe5bbf6](https://github.com/uptrace/bun/commit/fe5bbf64f33d25b310e5510ece7d705b9eb3bfea)) -* add support for ON UPDATE and ON DELETE rules on belongs-to relationships from struct tags ([#533](https://github.com/uptrace/bun/issues/533)) ([a327b2a](https://github.com/uptrace/bun/commit/a327b2ae216abb55a705626296c0cdbf8d648697)) -* add tx methods to IDB ([#587](https://github.com/uptrace/bun/issues/587)) ([feab313](https://github.com/uptrace/bun/commit/feab313c0358200b6e270ac70f4551b011ab5276)) -* added raw query calls ([#596](https://github.com/uptrace/bun/issues/596)) ([127644d](https://github.com/uptrace/bun/commit/127644d2eea443736fbd6bed3417595d439e4639)) -* **bunotel:** add option to enable formatting of queries ([#547](https://github.com/uptrace/bun/issues/547)) ([b9c768c](https://github.com/uptrace/bun/commit/b9c768cec3b5dea36c3c9c344d1e76e0ffad1369)) -* **config.go:** add sslrootcert support to DSN parameters ([3bd5d69](https://github.com/uptrace/bun/commit/3bd5d692d7df4f30d07b835d6a46fc7af382489a)) -* create an extra module for newrelic ([#599](https://github.com/uptrace/bun/issues/599)) ([6c676ce](https://github.com/uptrace/bun/commit/6c676ce13f05fe763471fbec2d5a2db48bc88650)) -* **migrate:** add WithMarkAppliedOnSuccess ([31b2cc4](https://github.com/uptrace/bun/commit/31b2cc4f5ccd794a436d081073d4974835d3780d)) -* **pgdialect:** add hstore support ([66b44f7](https://github.com/uptrace/bun/commit/66b44f7c0edc205927fb8be96aaf263b31828fa1)) -* **pgdialect:** add identity support ([646251e](https://github.com/uptrace/bun/commit/646251ec02a1e2ec717e907e6f128d8b51f17c6d)) -* **pgdriver:** expose pgdriver.ParseTime ([405a7d7](https://github.com/uptrace/bun/commit/405a7d78d8f60cf27e8f175deaf95db5877d84be)) - - - -## [1.1.5](https://github.com/uptrace/bun/compare/v1.1.4...v1.1.5) (2022-05-12) - - -### Bug Fixes - -* **driver/sqliteshim:** make it work with recent version of modernc sqlite ([2360584](https://github.com/uptrace/bun/commit/23605846c20684e39bf1eaac50a2147a1b68a729)) - - - -## [1.1.4](https://github.com/uptrace/bun/compare/v1.1.3...v1.1.4) (2022-04-20) - - -### Bug Fixes - -* automatically set nullzero when there is default:value option ([72c44ae](https://github.com/uptrace/bun/commit/72c44aebbeec3a83ed97ea25a3262174d744df65)) -* fix ForceDelete on live/undeleted rows ([1a33250](https://github.com/uptrace/bun/commit/1a33250f27f00e752a735ce10311ac95dcb0c968)) -* fix OmitZero and value overriding ([087ea07](https://github.com/uptrace/bun/commit/087ea0730551f1e841bacb6ad2fa3afd512a1df8)) -* rename Query to QueryBuilder ([98d111b](https://github.com/uptrace/bun/commit/98d111b7cc00fa61b6b2cec147f43285f4baadb4)) - - -### Features - -* add ApplyQueryBuilder ([582eca0](https://github.com/uptrace/bun/commit/582eca09cf2b59e67c2e4a2ad24f1a74cb53addd)) -* **config.go:** add connect_timeout to DSN parsable params ([998b04d](https://github.com/uptrace/bun/commit/998b04d51a9a4f182ac3458f90db8dbf9185c4ba)), closes [#505](https://github.com/uptrace/bun/issues/505) - - - -# [1.1.3](https://github.com/uptrace/bun/compare/v1.1.2...v) (2022-03-29) - -### Bug Fixes - -- fix panic message when has-many encounter an error - ([cfd2747](https://github.com/uptrace/bun/commit/cfd27475fac89a1c8cf798bfa64898bd77bbba79)) -- **migrate:** change rollback to match migrate behavior - ([df5af9c](https://github.com/uptrace/bun/commit/df5af9c9cbdf54ce243e037bbb2c7b154f8422b3)) - -### Features - -- added QueryBuilder interface for SelectQuery, UpdateQuery, DeleteQuery - ([#499](https://github.com/uptrace/bun/issues/499)) - ([59fef48](https://github.com/uptrace/bun/commit/59fef48f6b3ec7f32bdda779b6693c333ff1dfdb)) - -# [1.1.2](https://github.com/uptrace/bun/compare/v1.1.2...v) (2022-03-22) - -### Bug Fixes - -- correctly handle bun.In([][]byte{...}) - ([800616e](https://github.com/uptrace/bun/commit/800616ed28ca600ad676319a10adb970b2b4daf6)) - -### Features - -- accept extend option to allow extending existing models - ([48b80e4](https://github.com/uptrace/bun/commit/48b80e4f7e3ed8a28fd305f7853ebe7ab984a497)) - -# [1.1.0](https://github.com/uptrace/bun/compare/v1.1.0-beta.1...v1.1.0) (2022-02-28) - -### Features - -- Added [MSSQL](https://bun.uptrace.dev/guide/drivers.html#mssql) support as a 4th fully supported - DBMS. -- Added `SetColumn("col_name", "upper(?)", "hello")` in addition to - `Set("col_name = upper(?)", "hello")` which works for all 4 supported DBMS. - -* improve nil ptr values handling - ([b398e6b](https://github.com/uptrace/bun/commit/b398e6bea840ea2fd3e001b7879c0b00b6dcd6f7)) - -### Breaking changes - -- Bun no longer automatically marks some fields like `ID int64` as `pk` and `autoincrement`. You - need to manually add those options: - -```diff -type Model struct { -- ID int64 -+ ID int64 `bun:",pk,autoincrement"` -} -``` - -Bun [v1.0.25](#1024-2022-02-22) prints warnings for models with missing options so you are -recommended to upgrade to v1.0.24 before upgrading to v1.1.x. - -- Also, Bun no longer adds `nullzero` option to `soft_delete` fields. - -- Removed `nopk` and `allowzero` options. - -### Bug Fixes - -- append slice values - ([4a65129](https://github.com/uptrace/bun/commit/4a651294fb0f1e73079553024810c3ead9777311)) -- check for nils when appending driver.Value - ([7bb1640](https://github.com/uptrace/bun/commit/7bb1640a00fceca1e1075fe6544b9a4842ab2b26)) -- cleanup soft deletes for mssql - ([e72e2c5](https://github.com/uptrace/bun/commit/e72e2c5d0a85f3d26c3fa22c7284c2de1dcfda8e)) -- **dbfixture:** apply cascade option. Fixes [#447](https://github.com/uptrace/bun/issues/447) - ([d32d988](https://github.com/uptrace/bun/commit/d32d98840bc23e74c836f8192cb4bc9529aa9233)) -- create table WithForeignKey() and has-many relation - ([3cf5649](https://github.com/uptrace/bun/commit/3cf56491706b5652c383dbe007ff2389ad64922e)) -- do not emit m2m relations in WithForeignKeys() - ([56c8c5e](https://github.com/uptrace/bun/commit/56c8c5ed44c0d6d734c3d3161c642ce8437e2248)) -- accept dest in select queries - ([33b5b6f](https://github.com/uptrace/bun/commit/33b5b6ff660b77238a737a543ca12675c7f0c284)) - -## [1.0.25](https://github.com/uptrace/bun/compare/v1.0.23...v1.0.25) (2022-02-22) - -### Bug Fixes - -### Deprecated - -In the coming v1.1.x release, Bun will stop automatically adding `,pk,autoincrement` options on -`ID int64/int32` fields. This version (v1.0.23) only prints a warning when it encounters such -fields, but the code will continue working as before. - -To fix warnings, add missing options: - -```diff -type Model struct { -- ID int64 -+ ID int64 `bun:",pk,autoincrement"` -} -``` - -To silence warnings: - -```go -bun.SetWarnLogger(log.New(ioutil.Discard, "", log.LstdFlags)) -``` - -Bun will also print a warning on [soft delete](https://bun.uptrace.dev/guide/soft-deletes.html) -fields without a `,nullzero` option. You can fix the warning by adding missing `,nullzero` or -`,allowzero` options. - -In v1.1.x, such options as `,nopk` and `,allowzero` will not be necessary and will be removed. - -### Bug Fixes - -- fix missing autoincrement warning - ([3bc9c72](https://github.com/uptrace/bun/commit/3bc9c721e1c1c5104c256a0c01c4525df6ecefc2)) - -* append slice values - ([4a65129](https://github.com/uptrace/bun/commit/4a651294fb0f1e73079553024810c3ead9777311)) -* don't automatically set pk, nullzero, and autoincrement options - ([519a0df](https://github.com/uptrace/bun/commit/519a0df9707de01a418aba0d6b7482cfe4c9a532)) - -### Features - -- add CreateTableQuery.DetectForeignKeys - ([a958fcb](https://github.com/uptrace/bun/commit/a958fcbab680b0c5ad7980f369c7b73f7673db87)) - -## [1.0.22](https://github.com/uptrace/bun/compare/v1.0.21...v1.0.22) (2022-01-28) - -### Bug Fixes - -- improve scan error message - ([54048b2](https://github.com/uptrace/bun/commit/54048b296b9648fd62107ce6fa6fd7e6e2a648c7)) -- properly discover json.Marshaler on ptr field - ([3b321b0](https://github.com/uptrace/bun/commit/3b321b08601c4b8dc6bcaa24adea20875883ac14)) - -### Breaking (MySQL, MariaDB) - -- **insert:** get last insert id only with pk support auto increment - ([79e7c79](https://github.com/uptrace/bun/commit/79e7c797beea54bfc9dc1cb0141a7520ff941b4d)). Make - sure your MySQL models have `bun:",pk,autoincrement"` options if you are using autoincrements. - -### Features - -- refuse to start when version check does not pass - ([ff8d767](https://github.com/uptrace/bun/commit/ff8d76794894eeaebede840e5199720f3f5cf531)) -- support Column in ValuesQuery - ([0707679](https://github.com/uptrace/bun/commit/0707679b075cac57efa8e6fe9019b57b2da4bcc7)) - -## [1.0.21](https://github.com/uptrace/bun/compare/v1.0.20...v1.0.21) (2022-01-06) - -### Bug Fixes - -- append where to index create - ([1de6cea](https://github.com/uptrace/bun/commit/1de6ceaa8bba59b69fbe0cc6916d1b27da5586d8)) -- check if slice is nil when calling BeforeAppendModel - ([938d9da](https://github.com/uptrace/bun/commit/938d9dadb72ceeeb906064d9575278929d20cbbe)) -- **dbfixture:** directly set matching types via reflect - ([780504c](https://github.com/uptrace/bun/commit/780504cf1da687fc51a22d002ea66e2ccc41e1a3)) -- properly handle driver.Valuer and type:json - ([a17454a](https://github.com/uptrace/bun/commit/a17454ac6b95b2a2e927d0c4e4aee96494108389)) -- support scanning string into uint64 - ([73cc117](https://github.com/uptrace/bun/commit/73cc117a9f7a623ced1fdaedb4546e8e7470e4d3)) -- unique module name for opentelemetry example - ([f2054fe](https://github.com/uptrace/bun/commit/f2054fe1d11cea3b21d69dab6f6d6d7d97ba06bb)) - -### Features - -- add anonymous fields with type name - ([508375b](https://github.com/uptrace/bun/commit/508375b8f2396cb088fd4399a9259584353eb7e5)) -- add baseQuery.GetConn() - ([81a9bee](https://github.com/uptrace/bun/commit/81a9beecb74fed7ec3574a1d42acdf10a74e0b00)) -- create new queries from baseQuery - ([ae1dd61](https://github.com/uptrace/bun/commit/ae1dd611a91c2b7c79bc2bc12e9a53e857791e71)) -- support INSERT ... RETURNING for MariaDB >= 10.5.0 - ([b6531c0](https://github.com/uptrace/bun/commit/b6531c00ecbd4c7ec56b4131fab213f9313edc1b)) - -## [1.0.20](https://github.com/uptrace/bun/compare/v1.0.19...v1.0.20) (2021-12-19) - -### Bug Fixes - -- add Event.QueryTemplate and change Event.Query to be always formatted - ([52b1ccd](https://github.com/uptrace/bun/commit/52b1ccdf3578418aa427adef9dcf942d90ae4fdd)) -- change GetTableName to return formatted table name in case ModelTableExpr - ([95144dd](https://github.com/uptrace/bun/commit/95144dde937b4ac88b36b0bd8b01372421069b44)) -- change ScanAndCount to work with transactions - ([5b3f2c0](https://github.com/uptrace/bun/commit/5b3f2c021c424da366caffd33589e8adde821403)) -- **dbfixture:** directly call funcs bypassing template eval - ([a61974b](https://github.com/uptrace/bun/commit/a61974ba2d24361c5357fb9bda1f3eceec5a45cd)) -- don't append CASCADE by default in drop table/column queries - ([26457ea](https://github.com/uptrace/bun/commit/26457ea5cb20862d232e6e5fa4dbdeac5d444bf1)) -- **migrate:** mark migrations as applied on error so the migration can be rolled back - ([8ce33fb](https://github.com/uptrace/bun/commit/8ce33fbbac8e33077c20daf19a14c5ff2291bcae)) -- respect nullzero when appending struct fields. Fixes - [#339](https://github.com/uptrace/bun/issues/339) - ([ffd02f3](https://github.com/uptrace/bun/commit/ffd02f3170b3cccdd670a48d563cfb41094c05d6)) -- reuse tx for relation join ([#366](https://github.com/uptrace/bun/issues/366)) - ([60bdb1a](https://github.com/uptrace/bun/commit/60bdb1ac84c0a699429eead3b7fdfbf14fe69ac6)) - -### Features - -- add `Dialect()` to Transaction and IDB interface - ([693f1e1](https://github.com/uptrace/bun/commit/693f1e135999fc31cf83b99a2530a695b20f4e1b)) -- add model embedding via embed:prefix\_ - ([9a2cedc](https://github.com/uptrace/bun/commit/9a2cedc8b08fa8585d4bfced338bd0a40d736b1d)) -- change the default log output to stderr - ([4bf5773](https://github.com/uptrace/bun/commit/4bf577382f19c64457cbf0d64490401450954654)), - closes [#349](https://github.com/uptrace/bun/issues/349) - -## [1.0.19](https://github.com/uptrace/bun/compare/v1.0.18...v1.0.19) (2021-11-30) - -### Features - -- add support for column:name to specify column name - ([e37b460](https://github.com/uptrace/bun/commit/e37b4602823babc8221970e086cfed90c6ad4cf4)) - -## [1.0.18](https://github.com/uptrace/bun/compare/v1.0.17...v1.0.18) (2021-11-24) - -### Bug Fixes - -- use correct operation for UpdateQuery - ([687a004](https://github.com/uptrace/bun/commit/687a004ef7ec6fe1ef06c394965dd2c2d822fc82)) - -### Features - -- add pgdriver.Notify - ([7ee443d](https://github.com/uptrace/bun/commit/7ee443d1b869d8ddc4746850f7425d0a9ccd012b)) -- CreateTableQuery.PartitionBy and CreateTableQuery.TableSpace - ([cd3ab4d](https://github.com/uptrace/bun/commit/cd3ab4d8f3682f5a30b87c2ebc2d7e551d739078)) -- **pgdriver:** add CopyFrom and CopyTo - ([0b97703](https://github.com/uptrace/bun/commit/0b977030b5c05f509e11d13550b5f99dfd62358d)) -- support InsertQuery.Ignore on PostgreSQL - ([1aa9d14](https://github.com/uptrace/bun/commit/1aa9d149da8e46e63ff79192e394fde4d18d9b60)) - -## [1.0.17](https://github.com/uptrace/bun/compare/v1.0.16...v1.0.17) (2021-11-11) - -### Bug Fixes - -- don't call rollback when tx is already done - ([8246c2a](https://github.com/uptrace/bun/commit/8246c2a63e2e6eba314201c6ba87f094edf098b9)) -- **mysql:** escape backslash char in strings - ([fb32029](https://github.com/uptrace/bun/commit/fb32029ea7604d066800b16df21f239b71bf121d)) - -## [1.0.16](https://github.com/uptrace/bun/compare/v1.0.15...v1.0.16) (2021-11-07) - -### Bug Fixes - -- call query hook when tx is started, committed, or rolled back - ([30e85b5](https://github.com/uptrace/bun/commit/30e85b5366b2e51951ef17a0cf362b58f708dab1)) -- **pgdialect:** auto-enable array support if the sql type is an array - ([62c1012](https://github.com/uptrace/bun/commit/62c1012b2482e83969e5c6f5faf89e655ce78138)) - -### Features - -- support multiple tag options join:left_col1=right_col1,join:left_col2=right_col2 - ([78cd5aa](https://github.com/uptrace/bun/commit/78cd5aa60a5c7d1323bb89081db2b2b811113052)) -- **tag:** log with bad tag name - ([4e82d75](https://github.com/uptrace/bun/commit/4e82d75be2dabdba1a510df4e1fbb86092f92f4c)) - -## [1.0.15](https://github.com/uptrace/bun/compare/v1.0.14...v1.0.15) (2021-10-29) - -### Bug Fixes - -- fixed bug creating table when model has no columns - ([042c50b](https://github.com/uptrace/bun/commit/042c50bfe41caaa6e279e02c887c3a84a3acd84f)) -- init table with dialect once - ([9a1ce1e](https://github.com/uptrace/bun/commit/9a1ce1e492602742bb2f587e9ed24e50d7d07cad)) - -### Features - -- accept columns in WherePK - ([b3e7035](https://github.com/uptrace/bun/commit/b3e70356db1aa4891115a10902316090fccbc8bf)) -- support ADD COLUMN IF NOT EXISTS - ([ca7357c](https://github.com/uptrace/bun/commit/ca7357cdfe283e2f0b94eb638372e18401c486e9)) - -## [1.0.14](https://github.com/uptrace/bun/compare/v1.0.13...v1.0.14) (2021-10-24) - -### Bug Fixes - -- correct binary serialization for mysql ([#259](https://github.com/uptrace/bun/issues/259)) - ([e899f50](https://github.com/uptrace/bun/commit/e899f50b22ef6759ef8c029a6cd3f25f2bde17ef)) -- correctly escape single quotes in pg arrays - ([3010847](https://github.com/uptrace/bun/commit/3010847f5c2c50bce1969689a0b77fd8a6fb7e55)) -- use BLOB sql type to encode []byte in MySQL and SQLite - ([725ec88](https://github.com/uptrace/bun/commit/725ec8843824a7fc8f4058ead75ab0e62a78192a)) - -### Features - -- warn when there are args but no placeholders - ([06dde21](https://github.com/uptrace/bun/commit/06dde215c8d0bde2b2364597190729a160e536a1)) - -## [1.0.13](https://github.com/uptrace/bun/compare/v1.0.12...v1.0.13) (2021-10-17) - -### Breaking Change - -- **pgdriver:** enable TLS by default with InsecureSkipVerify=true - ([15ec635](https://github.com/uptrace/bun/commit/15ec6356a04d5cf62d2efbeb189610532dc5eb31)) - -### Features - -- add BeforeAppendModelHook - ([0b55de7](https://github.com/uptrace/bun/commit/0b55de77aaffc1ed0894ef16f45df77bca7d93c1)) -- **pgdriver:** add support for unix socket DSN - ([f398cec](https://github.com/uptrace/bun/commit/f398cec1c3873efdf61ac0b94ebe06c657f0cf91)) - -## [1.0.12](https://github.com/uptrace/bun/compare/v1.0.11...v1.0.12) (2021-10-14) - -### Bug Fixes - -- add InsertQuery.ColumnExpr to specify columns - ([60ffe29](https://github.com/uptrace/bun/commit/60ffe293b37912d95f28e69734ff51edf4b27da7)) -- **bundebug:** change WithVerbose to accept a bool flag - ([b2f8b91](https://github.com/uptrace/bun/commit/b2f8b912de1dc29f40c79066de1e9d6379db666c)) -- **pgdialect:** fix bytea[] handling - ([a5ca013](https://github.com/uptrace/bun/commit/a5ca013742c5a2e947b43d13f9c2fc0cf6a65d9c)) -- **pgdriver:** rename DriverOption to Option - ([51c1702](https://github.com/uptrace/bun/commit/51c1702431787d7369904b2624e346bf3e59c330)) -- support allowzero on the soft delete field - ([d0abec7](https://github.com/uptrace/bun/commit/d0abec71a9a546472a83bd70ed4e6a7357659a9b)) - -### Features - -- **bundebug:** allow to configure the hook using env var, for example, BUNDEBUG={0,1,2} - ([ce92852](https://github.com/uptrace/bun/commit/ce928524cab9a83395f3772ae9dd5d7732af281d)) -- **bunotel:** report DBStats metrics - ([b9b1575](https://github.com/uptrace/bun/commit/b9b15750f405cdbd345b776f5a56c6f742bc7361)) -- **pgdriver:** add Error.StatementTimeout - ([8a7934d](https://github.com/uptrace/bun/commit/8a7934dd788057828bb2b0983732b4394b74e960)) -- **pgdriver:** allow setting Network in config - ([b24b5d8](https://github.com/uptrace/bun/commit/b24b5d8014195a56ad7a4c634c10681038e6044d)) - -## [1.0.11](https://github.com/uptrace/bun/compare/v1.0.10...v1.0.11) (2021-10-05) - -### Bug Fixes - -- **mysqldialect:** remove duplicate AppendTime - ([8d42090](https://github.com/uptrace/bun/commit/8d42090af34a1760004482c7fc0923b114d79937)) - -## [1.0.10](https://github.com/uptrace/bun/compare/v1.0.9...v1.0.10) (2021-10-05) - -### Bug Fixes - -- add UpdateQuery.OmitZero - ([2294db6](https://github.com/uptrace/bun/commit/2294db61d228711435fff1075409a30086b37555)) -- make ExcludeColumn work with many-to-many queries - ([300e12b](https://github.com/uptrace/bun/commit/300e12b993554ff839ec4fa6bbea97e16aca1b55)) -- **mysqldialect:** append time in local timezone - ([e763cc8](https://github.com/uptrace/bun/commit/e763cc81eac4b11fff4e074ad3ff6cd970a71697)) -- **tagparser:** improve parsing options with brackets - ([0daa61e](https://github.com/uptrace/bun/commit/0daa61edc3c4d927ed260332b99ee09f4bb6b42f)) - -### Features - -- add timetz parsing - ([6e415c4](https://github.com/uptrace/bun/commit/6e415c4c5fa2c8caf4bb4aed4e5897fe5676f5a5)) - -## [1.0.9](https://github.com/uptrace/bun/compare/v1.0.8...v1.0.9) (2021-09-27) - -### Bug Fixes - -- change DBStats to use uint32 instead of uint64 to make it work on i386 - ([caca2a7](https://github.com/uptrace/bun/commit/caca2a7130288dec49fa26b49c8550140ee52f4c)) - -### Features - -- add IQuery and QueryEvent.IQuery - ([b762942](https://github.com/uptrace/bun/commit/b762942fa3b1d8686d0a559f93f2a6847b83d9c1)) -- add QueryEvent.Model - ([7688201](https://github.com/uptrace/bun/commit/7688201b485d14d3e393956f09a3200ea4d4e31d)) -- **bunotel:** add experimental bun.query.timing metric - ([2cdb384](https://github.com/uptrace/bun/commit/2cdb384678631ccadac0fb75f524bd5e91e96ee2)) -- **pgdriver:** add Config.ConnParams to session config params - ([408caf0](https://github.com/uptrace/bun/commit/408caf0bb579e23e26fc6149efd6851814c22517)) -- **pgdriver:** allow specifying timeout in DSN - ([7dbc71b](https://github.com/uptrace/bun/commit/7dbc71b3494caddc2e97d113f00067071b9e19da)) - -## [1.0.8](https://github.com/uptrace/bun/compare/v1.0.7...v1.0.8) (2021-09-18) - -### Bug Fixes - -- don't append soft delete where for insert queries with on conflict clause - ([27c477c](https://github.com/uptrace/bun/commit/27c477ce071d4c49c99a2531d638ed9f20e33461)) -- improve bun.NullTime to accept string - ([73ad6f5](https://github.com/uptrace/bun/commit/73ad6f5640a0a9b09f8df2bc4ab9cb510021c50c)) -- make allowzero work with auto-detected primary keys - ([82ca87c](https://github.com/uptrace/bun/commit/82ca87c7c49797d507b31fdaacf8343716d4feff)) -- support soft deletes on nil model - ([0556e3c](https://github.com/uptrace/bun/commit/0556e3c63692a7f4e48659d52b55ffd9cca0202a)) - -## [1.0.7](https://github.com/uptrace/bun/compare/v1.0.6...v1.0.7) (2021-09-15) - -### Bug Fixes - -- don't append zero time as NULL without nullzero tag - ([3b8d9cb](https://github.com/uptrace/bun/commit/3b8d9cb4e39eb17f79a618396bbbe0adbc66b07b)) -- **pgdriver:** return PostgreSQL DATE as a string - ([40be0e8](https://github.com/uptrace/bun/commit/40be0e8ea85f8932b7a410a6fc2dd3acd2d18ebc)) -- specify table alias for soft delete where - ([5fff1dc](https://github.com/uptrace/bun/commit/5fff1dc1dd74fa48623a24fa79e358a544dfac0b)) - -### Features - -- add SelectQuery.Exists helper - ([c3e59c1](https://github.com/uptrace/bun/commit/c3e59c1bc58b43c4b8e33e7d170ad33a08fbc3c7)) - -## [1.0.6](https://github.com/uptrace/bun/compare/v1.0.5...v1.0.6) (2021-09-11) - -### Bug Fixes - -- change unique tag to create a separate unique constraint - ([8401615](https://github.com/uptrace/bun/commit/84016155a77ca77613cc054277fefadae3098757)) -- improve zero checker for ptr values - ([2b3623d](https://github.com/uptrace/bun/commit/2b3623dd665d873911fd20ca707016929921e862)) - -## v1.0.5 - Sep 09 2021 - -- chore: tweak bundebug colors -- fix: check if table is present when appending columns -- fix: copy []byte when scanning - -## v1.0.4 - Sep 08 2021 - -- Added support for MariaDB. -- Restored default `SET` for `ON CONFLICT DO UPDATE` queries. - -## v1.0.3 - Sep 06 2021 - -- Fixed bulk soft deletes. -- pgdialect: fixed scanning into an array pointer. - -## v1.0.2 - Sep 04 2021 - -- Changed to completely ignore fields marked with `bun:"-"`. If you want to be able to scan into - such columns, use `bun:",scanonly"`. -- pgdriver: fixed SASL authentication handling. - -## v1.0.1 - Sep 02 2021 - -- pgdriver: added erroneous zero writes retry. -- Improved column handling in Relation callback. - -## v1.0.0 - Sep 01 2021 - -- First stable release. - -## v0.4.1 - Aug 18 2021 - -- Fixed migrate package to properly rollback migrations. -- Added `allowzero` tag option that undoes `nullzero` option. - -## v0.4.0 - Aug 11 2021 - -- Changed `WhereGroup` function to accept `*SelectQuery`. -- Fixed query hooks for count queries. - -## v0.3.4 - Jul 19 2021 - -- Renamed `migrate.CreateGo` to `CreateGoMigration`. -- Added `migrate.WithPackageName` to customize the Go package name in generated migrations. -- Renamed `migrate.CreateSQL` to `CreateSQLMigrations` and changed `CreateSQLMigrations` to create - both up and down migration files. - -## v0.3.1 - Jul 12 2021 - -- Renamed `alias` field struct tag to `alt` so it is not confused with column alias. -- Reworked migrate package API. See - [migrate](https://github.com/uptrace/bun/tree/master/example/migrate) example for details. - -## v0.3.0 - Jul 09 2021 - -- Changed migrate package to return structured data instead of logging the progress. See - [migrate](https://github.com/uptrace/bun/tree/master/example/migrate) example for details. - -## v0.2.14 - Jul 01 2021 - -- Added [sqliteshim](https://pkg.go.dev/github.com/uptrace/bun/driver/sqliteshim) by - [Ivan Trubach](https://github.com/tie). -- Added support for MySQL 5.7 in addition to MySQL 8. - -## v0.2.12 - Jun 29 2021 - -- Fixed scanners for net.IP and net.IPNet. - -## v0.2.10 - Jun 29 2021 - -- Fixed pgdriver to format passed query args. - -## v0.2.9 - Jun 27 2021 - -- Added support for prepared statements in pgdriver. - -## v0.2.7 - Jun 26 2021 - -- Added `UpdateQuery.Bulk` helper to generate bulk-update queries. - - Before: - - ```go - models := []Model{ - {42, "hello"}, - {43, "world"}, - } - return db.NewUpdate(). - With("_data", db.NewValues(&models)). - Model(&models). - Table("_data"). - Set("model.str = _data.str"). - Where("model.id = _data.id") - ``` - - Now: - - ```go - db.NewUpdate(). - Model(&models). - Bulk() - ``` - -## v0.2.5 - Jun 25 2021 - -- Changed time.Time to always append zero time as `NULL`. -- Added `db.RunInTx` helper. - -## v0.2.4 - Jun 21 2021 - -- Added SSL support to pgdriver. - -## v0.2.3 - Jun 20 2021 - -- Replaced `ForceDelete(ctx)` with `ForceDelete().Exec(ctx)` for soft deletes. - -## v0.2.1 - Jun 17 2021 - -- Renamed `DBI` to `IConn`. `IConn` is a common interface for `*sql.DB`, `*sql.Conn`, and `*sql.Tx`. -- Added `IDB`. `IDB` is a common interface for `*bun.DB`, `bun.Conn`, and `bun.Tx`. - -## v0.2.0 - Jun 16 2021 - -- Changed [model hooks](https://bun.uptrace.dev/guide/hooks.html#model-hooks). See - [model-hooks](example/model-hooks) example. -- Renamed `has-one` to `belongs-to`. Renamed `belongs-to` to `has-one`. Previously Bun used - incorrect names for these relations. diff --git a/vendor/github.com/uptrace/bun/CONTRIBUTING.md b/vendor/github.com/uptrace/bun/CONTRIBUTING.md deleted file mode 100644 index 9426875be..000000000 --- a/vendor/github.com/uptrace/bun/CONTRIBUTING.md +++ /dev/null @@ -1,34 +0,0 @@ -## Running tests - -To run tests, you need Docker which starts PostgreSQL and MySQL servers: - -```shell -cd internal/dbtest -./test.sh -``` - -To ease debugging, you can run tests and print all executed queries: - -```shell -BUNDEBUG=2 TZ= go test -run=TestName -``` - -## 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 -``` - -## Documentation - -To contribute to the docs visit https://github.com/uptrace/bun-docs diff --git a/vendor/github.com/uptrace/bun/LICENSE b/vendor/github.com/uptrace/bun/LICENSE deleted file mode 100644 index 7ec81810c..000000000 --- a/vendor/github.com/uptrace/bun/LICENSE +++ /dev/null @@ -1,24 +0,0 @@ -Copyright (c) 2021 Vladimir Mihailenco. 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. diff --git a/vendor/github.com/uptrace/bun/Makefile b/vendor/github.com/uptrace/bun/Makefile deleted file mode 100644 index 255d0f7ee..000000000 --- a/vendor/github.com/uptrace/bun/Makefile +++ /dev/null @@ -1,29 +0,0 @@ -ALL_GO_MOD_DIRS := $(shell find . -type f -name 'go.mod' -exec dirname {} \; | sort) -EXAMPLE_GO_MOD_DIRS := $(shell find ./example/ -type f -name 'go.mod' -exec dirname {} \; | sort) - -test: - set -e; for dir in $(ALL_GO_MOD_DIRS); do \ - echo "go test in $${dir}"; \ - (cd "$${dir}" && \ - go test && \ - env GOOS=linux GOARCH=386 TZ= go test && \ - go vet); \ - done - -go_mod_tidy: - set -e; for dir in $(ALL_GO_MOD_DIRS); do \ - echo "go mod tidy in $${dir}"; \ - (cd "$${dir}" && \ - go get -u ./... && \ - go mod tidy); \ - done - -fmt: - gofmt -w -s ./ - goimports -w -local github.com/uptrace/bun ./ - -run-examples: - set -e; for dir in $(EXAMPLE_GO_MOD_DIRS); do \ - echo "go run . in $${dir}"; \ - (cd "$${dir}" && go run .); \ - done diff --git a/vendor/github.com/uptrace/bun/README.md b/vendor/github.com/uptrace/bun/README.md deleted file mode 100644 index eb2d98bc5..000000000 --- a/vendor/github.com/uptrace/bun/README.md +++ /dev/null @@ -1,146 +0,0 @@ -# SQL-first Golang ORM for PostgreSQL, MySQL, MSSQL, SQLite and Oracle - -[](https://github.com/uptrace/bun/actions) -[](https://pkg.go.dev/github.com/uptrace/bun) -[](https://bun.uptrace.dev/) -[](https://discord.gg/rWtp5Aj) -[](https://gurubase.io/g/bun) - -> Bun is brought to you by :star: [**uptrace/uptrace**](https://github.com/uptrace/uptrace). Uptrace -> is an open-source APM tool that supports distributed tracing, metrics, and logs. You can use it to -> monitor applications and set up automatic alerts to receive notifications via email, Slack, -> Telegram, and others. -> -> See [OpenTelemetry](example/opentelemetry) example which demonstrates how you can use Uptrace to -> monitor Bun. - -## Features - -- Works with [PostgreSQL](https://bun.uptrace.dev/guide/drivers.html#postgresql), - [MySQL](https://bun.uptrace.dev/guide/drivers.html#mysql) (including MariaDB), - [MSSQL](https://bun.uptrace.dev/guide/drivers.html#mssql), - [SQLite](https://bun.uptrace.dev/guide/drivers.html#sqlite). - [Oracle](https://bun.uptrace.dev/guide/drivers.html#oracle). -- [ORM-like](/example/basic/) experience using good old SQL. Bun supports structs, map, scalars, and - slices of map/structs/scalars. -- [Bulk inserts](https://bun.uptrace.dev/guide/query-insert.html). -- [Bulk updates](https://bun.uptrace.dev/guide/query-update.html) using common table expressions. -- [Bulk deletes](https://bun.uptrace.dev/guide/query-delete.html). -- [Fixtures](https://bun.uptrace.dev/guide/fixtures.html). -- [Migrations](https://bun.uptrace.dev/guide/migrations.html). -- [Soft deletes](https://bun.uptrace.dev/guide/soft-deletes.html). - -### Resources - -- [**Get started**](https://bun.uptrace.dev/guide/golang-orm.html) -- [Examples](https://github.com/uptrace/bun/tree/master/example) -- [Discussions](https://github.com/uptrace/bun/discussions) -- [Chat](https://discord.gg/rWtp5Aj) -- [Reference](https://pkg.go.dev/github.com/uptrace/bun) -- [Starter kit](https://github.com/go-bun/bun-starter-kit) - -### Tutorials - -Wrote a tutorial for Bun? Create a PR to add here and on [Bun](https://bun.uptrace.dev/) site. - -### Featured projects using Bun - -- [uptrace](https://github.com/uptrace/uptrace) - Distributed tracing and metrics. -- [paralus](https://github.com/paralus/paralus) - All-in-one Kubernetes access manager. -- [inovex/scrumlr.io](https://github.com/inovex/scrumlr.io) - Webapp for collaborative online - retrospectives. -- [gotosocial](https://github.com/superseriousbusiness/gotosocial) - Golang fediverse server. -- [lorawan-stack](https://github.com/TheThingsNetwork/lorawan-stack) - The Things Stack, an Open - Source LoRaWAN Network Server. -- [anti-phishing-bot](https://github.com/Benricheson101/anti-phishing-bot) - Discord bot for - deleting Steam/Discord phishing links. -- [emerald-web3-gateway](https://github.com/oasisprotocol/emerald-web3-gateway) - Web3 Gateway for - the Oasis Emerald paratime. -- [lndhub.go](https://github.com/getAlby/lndhub.go) - accounting wrapper for the Lightning Network. -- [penguin-statistics](https://github.com/penguin-statistics/backend-next) - Penguin Statistics v3 - Backend. -- And - [hundreds more](https://github.com/uptrace/bun/network/dependents?package_id=UGFja2FnZS0yMjkxOTc4OTA4). - -## Why another database client? - -So you can elegantly write complex queries: - -```go -regionalSales := db.NewSelect(). - ColumnExpr("region"). - ColumnExpr("SUM(amount) AS total_sales"). - TableExpr("orders"). - GroupExpr("region") - -topRegions := db.NewSelect(). - ColumnExpr("region"). - TableExpr("regional_sales"). - Where("total_sales > (SELECT SUM(total_sales) / 10 FROM regional_sales)") - -var items []map[string]interface{} -err := db.NewSelect(). - With("regional_sales", regionalSales). - With("top_regions", topRegions). - ColumnExpr("region"). - ColumnExpr("product"). - ColumnExpr("SUM(quantity) AS product_units"). - ColumnExpr("SUM(amount) AS product_sales"). - TableExpr("orders"). - Where("region IN (SELECT region FROM top_regions)"). - GroupExpr("region"). - GroupExpr("product"). - Scan(ctx, &items) -``` - -```sql -WITH regional_sales AS ( - SELECT region, SUM(amount) AS total_sales - FROM orders - GROUP BY region -), top_regions AS ( - SELECT region - FROM regional_sales - WHERE total_sales > (SELECT SUM(total_sales)/10 FROM regional_sales) -) -SELECT region, - product, - SUM(quantity) AS product_units, - SUM(amount) AS product_sales -FROM orders -WHERE region IN (SELECT region FROM top_regions) -GROUP BY region, product -``` - -And scan results into scalars, structs, maps, slices of structs/maps/scalars: - -```go -users := make([]User, 0) -if err := db.NewSelect().Model(&users).OrderExpr("id ASC").Scan(ctx); err != nil { - panic(err) -} - -user1 := new(User) -if err := db.NewSelect().Model(user1).Where("id = ?", 1).Scan(ctx); err != nil { - panic(err) -} -``` - -See [**Getting started**](https://bun.uptrace.dev/guide/golang-orm.html) guide and check -[examples](example). - -## See also - -- [Golang HTTP router](https://github.com/uptrace/bunrouter) -- [Golang ClickHouse ORM](https://github.com/uptrace/go-clickhouse) -- [Golang msgpack](https://github.com/vmihailenco/msgpack) - -## Contributing - -See [CONTRIBUTING.md](CONTRIBUTING.md) for some hints. - -And thanks to all the people who already contributed! - -<a href="https://github.com/uptrace/bun/graphs/contributors"> - <img src="https://contributors-img.web.app/image?repo=uptrace/bun" /> -</a> diff --git a/vendor/github.com/uptrace/bun/bun.go b/vendor/github.com/uptrace/bun/bun.go deleted file mode 100644 index 626f0bf4b..000000000 --- a/vendor/github.com/uptrace/bun/bun.go +++ /dev/null @@ -1,88 +0,0 @@ -package bun - -import ( - "context" - - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type ( - Safe = schema.Safe - Ident = schema.Ident - Name = schema.Name - - NullTime = schema.NullTime - BaseModel = schema.BaseModel - Query = schema.Query - - BeforeAppendModelHook = schema.BeforeAppendModelHook - - BeforeScanRowHook = schema.BeforeScanRowHook - AfterScanRowHook = schema.AfterScanRowHook -) - -func SafeQuery(query string, args ...interface{}) schema.QueryWithArgs { - return schema.SafeQuery(query, args) -} - -type BeforeSelectHook interface { - BeforeSelect(ctx context.Context, query *SelectQuery) error -} - -type AfterSelectHook interface { - AfterSelect(ctx context.Context, query *SelectQuery) error -} - -type BeforeInsertHook interface { - BeforeInsert(ctx context.Context, query *InsertQuery) error -} - -type AfterInsertHook interface { - AfterInsert(ctx context.Context, query *InsertQuery) error -} - -type BeforeUpdateHook interface { - BeforeUpdate(ctx context.Context, query *UpdateQuery) error -} - -type AfterUpdateHook interface { - AfterUpdate(ctx context.Context, query *UpdateQuery) error -} - -type BeforeDeleteHook interface { - BeforeDelete(ctx context.Context, query *DeleteQuery) error -} - -type AfterDeleteHook interface { - AfterDelete(ctx context.Context, query *DeleteQuery) error -} - -type BeforeCreateTableHook interface { - BeforeCreateTable(ctx context.Context, query *CreateTableQuery) error -} - -type AfterCreateTableHook interface { - AfterCreateTable(ctx context.Context, query *CreateTableQuery) error -} - -type BeforeDropTableHook interface { - BeforeDropTable(ctx context.Context, query *DropTableQuery) error -} - -type AfterDropTableHook interface { - AfterDropTable(ctx context.Context, query *DropTableQuery) error -} - -// SetLogger overwrites default Bun logger. -func SetLogger(logger internal.Logging) { - internal.SetLogger(logger) -} - -func In(slice interface{}) schema.QueryAppender { - return schema.In(slice) -} - -func NullZero(value interface{}) schema.QueryAppender { - return schema.NullZero(value) -} diff --git a/vendor/github.com/uptrace/bun/commitlint.config.js b/vendor/github.com/uptrace/bun/commitlint.config.js deleted file mode 100644 index 4fedde6da..000000000 --- a/vendor/github.com/uptrace/bun/commitlint.config.js +++ /dev/null @@ -1 +0,0 @@ -module.exports = { extends: ['@commitlint/config-conventional'] } diff --git a/vendor/github.com/uptrace/bun/db.go b/vendor/github.com/uptrace/bun/db.go deleted file mode 100644 index 067996d1c..000000000 --- a/vendor/github.com/uptrace/bun/db.go +++ /dev/null @@ -1,859 +0,0 @@ -package bun - -import ( - "context" - "crypto/rand" - "database/sql" - "encoding/hex" - "fmt" - "reflect" - "strings" - "sync/atomic" - "time" - - "github.com/uptrace/bun/dialect/feature" - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -const ( - discardUnknownColumns internal.Flag = 1 << iota -) - -type DBStats struct { - Queries uint32 - Errors uint32 -} - -type DBOption func(db *DB) - -func WithOptions(opts ...DBOption) DBOption { - return func(db *DB) { - for _, opt := range opts { - opt(db) - } - } -} - -func WithDiscardUnknownColumns() DBOption { - return func(db *DB) { - db.flags = db.flags.Set(discardUnknownColumns) - } -} - -func WithConnResolver(resolver ConnResolver) DBOption { - return func(db *DB) { - db.resolver = resolver - } -} - -type DB struct { - // Must be a pointer so we copy the whole state, not individual fields. - *noCopyState - - queryHooks []QueryHook - - fmter schema.Formatter - stats DBStats -} - -// noCopyState contains DB fields that must not be copied on clone(), -// for example, it is forbidden to copy atomic.Pointer. -type noCopyState struct { - *sql.DB - dialect schema.Dialect - resolver ConnResolver - - flags internal.Flag - closed atomic.Bool -} - -func NewDB(sqldb *sql.DB, dialect schema.Dialect, opts ...DBOption) *DB { - dialect.Init(sqldb) - - db := &DB{ - noCopyState: &noCopyState{ - DB: sqldb, - dialect: dialect, - }, - fmter: schema.NewFormatter(dialect), - } - - for _, opt := range opts { - opt(db) - } - - return db -} - -func (db *DB) String() string { - var b strings.Builder - b.WriteString("DB<dialect=") - b.WriteString(db.dialect.Name().String()) - b.WriteString(">") - return b.String() -} - -func (db *DB) Close() error { - if db.closed.Swap(true) { - return nil - } - - firstErr := db.DB.Close() - - if db.resolver != nil { - if err := db.resolver.Close(); err != nil && firstErr == nil { - firstErr = err - } - } - - return firstErr -} - -func (db *DB) DBStats() DBStats { - return DBStats{ - Queries: atomic.LoadUint32(&db.stats.Queries), - Errors: atomic.LoadUint32(&db.stats.Errors), - } -} - -func (db *DB) NewValues(model interface{}) *ValuesQuery { - return NewValuesQuery(db, model) -} - -func (db *DB) NewMerge() *MergeQuery { - return NewMergeQuery(db) -} - -func (db *DB) NewSelect() *SelectQuery { - return NewSelectQuery(db) -} - -func (db *DB) NewInsert() *InsertQuery { - return NewInsertQuery(db) -} - -func (db *DB) NewUpdate() *UpdateQuery { - return NewUpdateQuery(db) -} - -func (db *DB) NewDelete() *DeleteQuery { - return NewDeleteQuery(db) -} - -func (db *DB) NewRaw(query string, args ...interface{}) *RawQuery { - return NewRawQuery(db, query, args...) -} - -func (db *DB) NewCreateTable() *CreateTableQuery { - return NewCreateTableQuery(db) -} - -func (db *DB) NewDropTable() *DropTableQuery { - return NewDropTableQuery(db) -} - -func (db *DB) NewCreateIndex() *CreateIndexQuery { - return NewCreateIndexQuery(db) -} - -func (db *DB) NewDropIndex() *DropIndexQuery { - return NewDropIndexQuery(db) -} - -func (db *DB) NewTruncateTable() *TruncateTableQuery { - return NewTruncateTableQuery(db) -} - -func (db *DB) NewAddColumn() *AddColumnQuery { - return NewAddColumnQuery(db) -} - -func (db *DB) NewDropColumn() *DropColumnQuery { - return NewDropColumnQuery(db) -} - -func (db *DB) ResetModel(ctx context.Context, models ...interface{}) error { - for _, model := range models { - if _, err := db.NewDropTable().Model(model).IfExists().Cascade().Exec(ctx); err != nil { - return err - } - if _, err := db.NewCreateTable().Model(model).Exec(ctx); err != nil { - return err - } - } - return nil -} - -func (db *DB) Dialect() schema.Dialect { - return db.dialect -} - -func (db *DB) ScanRows(ctx context.Context, rows *sql.Rows, dest ...interface{}) error { - defer rows.Close() - - model, err := newModel(db, dest) - if err != nil { - return err - } - - _, err = model.ScanRows(ctx, rows) - if err != nil { - return err - } - - return rows.Err() -} - -func (db *DB) ScanRow(ctx context.Context, rows *sql.Rows, dest ...interface{}) error { - model, err := newModel(db, dest) - if err != nil { - return err - } - - rs, ok := model.(rowScanner) - if !ok { - return fmt.Errorf("bun: %T does not support ScanRow", model) - } - - return rs.ScanRow(ctx, rows) -} - -type queryHookIniter interface { - Init(db *DB) -} - -func (db *DB) AddQueryHook(hook QueryHook) { - if initer, ok := hook.(queryHookIniter); ok { - initer.Init(db) - } - db.queryHooks = append(db.queryHooks, hook) -} - -func (db *DB) Table(typ reflect.Type) *schema.Table { - return db.dialect.Tables().Get(typ) -} - -// RegisterModel registers models by name so they can be referenced in table relations -// and fixtures. -func (db *DB) RegisterModel(models ...interface{}) { - db.dialect.Tables().Register(models...) -} - -func (db *DB) clone() *DB { - clone := *db - - l := len(clone.queryHooks) - clone.queryHooks = clone.queryHooks[:l:l] - - return &clone -} - -func (db *DB) WithNamedArg(name string, value interface{}) *DB { - clone := db.clone() - clone.fmter = clone.fmter.WithNamedArg(name, value) - return clone -} - -func (db *DB) Formatter() schema.Formatter { - return db.fmter -} - -// UpdateFQN returns a fully qualified column name. For MySQL, it returns the column name with -// the table alias. For other RDBMS, it returns just the column name. -func (db *DB) UpdateFQN(alias, column string) Ident { - if db.HasFeature(feature.UpdateMultiTable) { - return Ident(alias + "." + column) - } - return Ident(column) -} - -// HasFeature uses feature package to report whether the underlying DBMS supports this feature. -func (db *DB) HasFeature(feat feature.Feature) bool { - return db.dialect.Features().Has(feat) -} - -//------------------------------------------------------------------------------ - -func (db *DB) Exec(query string, args ...interface{}) (sql.Result, error) { - return db.ExecContext(context.Background(), query, args...) -} - -func (db *DB) ExecContext( - ctx context.Context, query string, args ...interface{}, -) (sql.Result, error) { - formattedQuery := db.format(query, args) - ctx, event := db.beforeQuery(ctx, nil, query, args, formattedQuery, nil) - res, err := db.DB.ExecContext(ctx, formattedQuery) - db.afterQuery(ctx, event, res, err) - return res, err -} - -func (db *DB) Query(query string, args ...interface{}) (*sql.Rows, error) { - return db.QueryContext(context.Background(), query, args...) -} - -func (db *DB) QueryContext( - ctx context.Context, query string, args ...interface{}, -) (*sql.Rows, error) { - formattedQuery := db.format(query, args) - ctx, event := db.beforeQuery(ctx, nil, query, args, formattedQuery, nil) - rows, err := db.DB.QueryContext(ctx, formattedQuery) - db.afterQuery(ctx, event, nil, err) - return rows, err -} - -func (db *DB) QueryRow(query string, args ...interface{}) *sql.Row { - return db.QueryRowContext(context.Background(), query, args...) -} - -func (db *DB) QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row { - formattedQuery := db.format(query, args) - ctx, event := db.beforeQuery(ctx, nil, query, args, formattedQuery, nil) - row := db.DB.QueryRowContext(ctx, formattedQuery) - db.afterQuery(ctx, event, nil, row.Err()) - return row -} - -func (db *DB) format(query string, args []interface{}) string { - return db.fmter.FormatQuery(query, args...) -} - -//------------------------------------------------------------------------------ - -type Conn struct { - db *DB - *sql.Conn -} - -func (db *DB) Conn(ctx context.Context) (Conn, error) { - conn, err := db.DB.Conn(ctx) - if err != nil { - return Conn{}, err - } - return Conn{ - db: db, - Conn: conn, - }, nil -} - -func (c Conn) ExecContext( - ctx context.Context, query string, args ...interface{}, -) (sql.Result, error) { - formattedQuery := c.db.format(query, args) - ctx, event := c.db.beforeQuery(ctx, nil, query, args, formattedQuery, nil) - res, err := c.Conn.ExecContext(ctx, formattedQuery) - c.db.afterQuery(ctx, event, res, err) - return res, err -} - -func (c Conn) QueryContext( - ctx context.Context, query string, args ...interface{}, -) (*sql.Rows, error) { - formattedQuery := c.db.format(query, args) - ctx, event := c.db.beforeQuery(ctx, nil, query, args, formattedQuery, nil) - rows, err := c.Conn.QueryContext(ctx, formattedQuery) - c.db.afterQuery(ctx, event, nil, err) - return rows, err -} - -func (c Conn) QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row { - formattedQuery := c.db.format(query, args) - ctx, event := c.db.beforeQuery(ctx, nil, query, args, formattedQuery, nil) - row := c.Conn.QueryRowContext(ctx, formattedQuery) - c.db.afterQuery(ctx, event, nil, row.Err()) - return row -} - -func (c Conn) Dialect() schema.Dialect { - return c.db.Dialect() -} - -func (c Conn) NewValues(model interface{}) *ValuesQuery { - return NewValuesQuery(c.db, model).Conn(c) -} - -func (c Conn) NewMerge() *MergeQuery { - return NewMergeQuery(c.db).Conn(c) -} - -func (c Conn) NewSelect() *SelectQuery { - return NewSelectQuery(c.db).Conn(c) -} - -func (c Conn) NewInsert() *InsertQuery { - return NewInsertQuery(c.db).Conn(c) -} - -func (c Conn) NewUpdate() *UpdateQuery { - return NewUpdateQuery(c.db).Conn(c) -} - -func (c Conn) NewDelete() *DeleteQuery { - return NewDeleteQuery(c.db).Conn(c) -} - -func (c Conn) NewRaw(query string, args ...interface{}) *RawQuery { - return NewRawQuery(c.db, query, args...).Conn(c) -} - -func (c Conn) NewCreateTable() *CreateTableQuery { - return NewCreateTableQuery(c.db).Conn(c) -} - -func (c Conn) NewDropTable() *DropTableQuery { - return NewDropTableQuery(c.db).Conn(c) -} - -func (c Conn) NewCreateIndex() *CreateIndexQuery { - return NewCreateIndexQuery(c.db).Conn(c) -} - -func (c Conn) NewDropIndex() *DropIndexQuery { - return NewDropIndexQuery(c.db).Conn(c) -} - -func (c Conn) NewTruncateTable() *TruncateTableQuery { - return NewTruncateTableQuery(c.db).Conn(c) -} - -func (c Conn) NewAddColumn() *AddColumnQuery { - return NewAddColumnQuery(c.db).Conn(c) -} - -func (c Conn) NewDropColumn() *DropColumnQuery { - return NewDropColumnQuery(c.db).Conn(c) -} - -// RunInTx runs the function in a transaction. If the function returns an error, -// the transaction is rolled back. Otherwise, the transaction is committed. -func (c Conn) RunInTx( - ctx context.Context, opts *sql.TxOptions, fn func(ctx context.Context, tx Tx) error, -) error { - tx, err := c.BeginTx(ctx, opts) - if err != nil { - return err - } - - var done bool - - defer func() { - if !done { - _ = tx.Rollback() - } - }() - - if err := fn(ctx, tx); err != nil { - return err - } - - done = true - return tx.Commit() -} - -func (c Conn) BeginTx(ctx context.Context, opts *sql.TxOptions) (Tx, error) { - ctx, event := c.db.beforeQuery(ctx, nil, "BEGIN", nil, "BEGIN", nil) - tx, err := c.Conn.BeginTx(ctx, opts) - c.db.afterQuery(ctx, event, nil, err) - if err != nil { - return Tx{}, err - } - return Tx{ - ctx: ctx, - db: c.db, - Tx: tx, - }, nil -} - -//------------------------------------------------------------------------------ - -type Stmt struct { - *sql.Stmt -} - -func (db *DB) Prepare(query string) (Stmt, error) { - return db.PrepareContext(context.Background(), query) -} - -func (db *DB) PrepareContext(ctx context.Context, query string) (Stmt, error) { - stmt, err := db.DB.PrepareContext(ctx, query) - if err != nil { - return Stmt{}, err - } - return Stmt{Stmt: stmt}, nil -} - -//------------------------------------------------------------------------------ - -type Tx struct { - ctx context.Context - db *DB - // name is the name of a savepoint - name string - *sql.Tx -} - -// RunInTx runs the function in a transaction. If the function returns an error, -// the transaction is rolled back. Otherwise, the transaction is committed. -func (db *DB) RunInTx( - ctx context.Context, opts *sql.TxOptions, fn func(ctx context.Context, tx Tx) error, -) error { - tx, err := db.BeginTx(ctx, opts) - if err != nil { - return err - } - - var done bool - - defer func() { - if !done { - _ = tx.Rollback() - } - }() - - if err := fn(ctx, tx); err != nil { - return err - } - - done = true - return tx.Commit() -} - -func (db *DB) Begin() (Tx, error) { - return db.BeginTx(context.Background(), nil) -} - -func (db *DB) BeginTx(ctx context.Context, opts *sql.TxOptions) (Tx, error) { - ctx, event := db.beforeQuery(ctx, nil, "BEGIN", nil, "BEGIN", nil) - tx, err := db.DB.BeginTx(ctx, opts) - db.afterQuery(ctx, event, nil, err) - if err != nil { - return Tx{}, err - } - return Tx{ - ctx: ctx, - db: db, - Tx: tx, - }, nil -} - -func (tx Tx) Commit() error { - if tx.name == "" { - return tx.commitTX() - } - return tx.commitSP() -} - -func (tx Tx) commitTX() error { - ctx, event := tx.db.beforeQuery(tx.ctx, nil, "COMMIT", nil, "COMMIT", nil) - err := tx.Tx.Commit() - tx.db.afterQuery(ctx, event, nil, err) - return err -} - -func (tx Tx) commitSP() error { - if tx.db.HasFeature(feature.MSSavepoint) { - return nil - } - query := "RELEASE SAVEPOINT " + tx.name - _, err := tx.ExecContext(tx.ctx, query) - return err -} - -func (tx Tx) Rollback() error { - if tx.name == "" { - return tx.rollbackTX() - } - return tx.rollbackSP() -} - -func (tx Tx) rollbackTX() error { - ctx, event := tx.db.beforeQuery(tx.ctx, nil, "ROLLBACK", nil, "ROLLBACK", nil) - err := tx.Tx.Rollback() - tx.db.afterQuery(ctx, event, nil, err) - return err -} - -func (tx Tx) rollbackSP() error { - query := "ROLLBACK TO SAVEPOINT " + tx.name - if tx.db.HasFeature(feature.MSSavepoint) { - query = "ROLLBACK TRANSACTION " + tx.name - } - _, err := tx.ExecContext(tx.ctx, query) - return err -} - -func (tx Tx) Exec(query string, args ...interface{}) (sql.Result, error) { - return tx.ExecContext(context.TODO(), query, args...) -} - -func (tx Tx) ExecContext( - ctx context.Context, query string, args ...interface{}, -) (sql.Result, error) { - formattedQuery := tx.db.format(query, args) - ctx, event := tx.db.beforeQuery(ctx, nil, query, args, formattedQuery, nil) - res, err := tx.Tx.ExecContext(ctx, formattedQuery) - tx.db.afterQuery(ctx, event, res, err) - return res, err -} - -func (tx Tx) Query(query string, args ...interface{}) (*sql.Rows, error) { - return tx.QueryContext(context.TODO(), query, args...) -} - -func (tx Tx) QueryContext( - ctx context.Context, query string, args ...interface{}, -) (*sql.Rows, error) { - formattedQuery := tx.db.format(query, args) - ctx, event := tx.db.beforeQuery(ctx, nil, query, args, formattedQuery, nil) - rows, err := tx.Tx.QueryContext(ctx, formattedQuery) - tx.db.afterQuery(ctx, event, nil, err) - return rows, err -} - -func (tx Tx) QueryRow(query string, args ...interface{}) *sql.Row { - return tx.QueryRowContext(context.TODO(), query, args...) -} - -func (tx Tx) QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row { - formattedQuery := tx.db.format(query, args) - ctx, event := tx.db.beforeQuery(ctx, nil, query, args, formattedQuery, nil) - row := tx.Tx.QueryRowContext(ctx, formattedQuery) - tx.db.afterQuery(ctx, event, nil, row.Err()) - return row -} - -//------------------------------------------------------------------------------ - -func (tx Tx) Begin() (Tx, error) { - return tx.BeginTx(tx.ctx, nil) -} - -// BeginTx will save a point in the running transaction. -func (tx Tx) BeginTx(ctx context.Context, _ *sql.TxOptions) (Tx, error) { - // mssql savepoint names are limited to 32 characters - sp := make([]byte, 14) - _, err := rand.Read(sp) - if err != nil { - return Tx{}, err - } - - qName := "SP_" + hex.EncodeToString(sp) - query := "SAVEPOINT " + qName - if tx.db.HasFeature(feature.MSSavepoint) { - query = "SAVE TRANSACTION " + qName - } - _, err = tx.ExecContext(ctx, query) - if err != nil { - return Tx{}, err - } - return Tx{ - ctx: ctx, - db: tx.db, - Tx: tx.Tx, - name: qName, - }, nil -} - -func (tx Tx) RunInTx( - ctx context.Context, _ *sql.TxOptions, fn func(ctx context.Context, tx Tx) error, -) error { - sp, err := tx.BeginTx(ctx, nil) - if err != nil { - return err - } - - var done bool - - defer func() { - if !done { - _ = sp.Rollback() - } - }() - - if err := fn(ctx, sp); err != nil { - return err - } - - done = true - return sp.Commit() -} - -func (tx Tx) Dialect() schema.Dialect { - return tx.db.Dialect() -} - -func (tx Tx) NewValues(model interface{}) *ValuesQuery { - return NewValuesQuery(tx.db, model).Conn(tx) -} - -func (tx Tx) NewMerge() *MergeQuery { - return NewMergeQuery(tx.db).Conn(tx) -} - -func (tx Tx) NewSelect() *SelectQuery { - return NewSelectQuery(tx.db).Conn(tx) -} - -func (tx Tx) NewInsert() *InsertQuery { - return NewInsertQuery(tx.db).Conn(tx) -} - -func (tx Tx) NewUpdate() *UpdateQuery { - return NewUpdateQuery(tx.db).Conn(tx) -} - -func (tx Tx) NewDelete() *DeleteQuery { - return NewDeleteQuery(tx.db).Conn(tx) -} - -func (tx Tx) NewRaw(query string, args ...interface{}) *RawQuery { - return NewRawQuery(tx.db, query, args...).Conn(tx) -} - -func (tx Tx) NewCreateTable() *CreateTableQuery { - return NewCreateTableQuery(tx.db).Conn(tx) -} - -func (tx Tx) NewDropTable() *DropTableQuery { - return NewDropTableQuery(tx.db).Conn(tx) -} - -func (tx Tx) NewCreateIndex() *CreateIndexQuery { - return NewCreateIndexQuery(tx.db).Conn(tx) -} - -func (tx Tx) NewDropIndex() *DropIndexQuery { - return NewDropIndexQuery(tx.db).Conn(tx) -} - -func (tx Tx) NewTruncateTable() *TruncateTableQuery { - return NewTruncateTableQuery(tx.db).Conn(tx) -} - -func (tx Tx) NewAddColumn() *AddColumnQuery { - return NewAddColumnQuery(tx.db).Conn(tx) -} - -func (tx Tx) NewDropColumn() *DropColumnQuery { - return NewDropColumnQuery(tx.db).Conn(tx) -} - -//------------------------------------------------------------------------------ - -func (db *DB) makeQueryBytes() []byte { - return internal.MakeQueryBytes() -} - -//------------------------------------------------------------------------------ - -// ConnResolver enables routing queries to multiple databases. -type ConnResolver interface { - ResolveConn(query Query) IConn - Close() error -} - -// TODO: -// - make monitoring interval configurable -// - make ping timeout configutable -// - allow adding read/write replicas for multi-master replication -type ReadWriteConnResolver struct { - replicas []*sql.DB // read-only replicas - healthyReplicas atomic.Pointer[[]*sql.DB] - nextReplica atomic.Int64 - closed atomic.Bool -} - -func NewReadWriteConnResolver(opts ...ReadWriteConnResolverOption) *ReadWriteConnResolver { - r := new(ReadWriteConnResolver) - - for _, opt := range opts { - opt(r) - } - - if len(r.replicas) > 0 { - r.healthyReplicas.Store(&r.replicas) - go r.monitor() - } - - return r -} - -type ReadWriteConnResolverOption func(r *ReadWriteConnResolver) - -func WithReadOnlyReplica(dbs ...*sql.DB) ReadWriteConnResolverOption { - return func(r *ReadWriteConnResolver) { - r.replicas = append(r.replicas, dbs...) - } -} - -func (r *ReadWriteConnResolver) Close() error { - if r.closed.Swap(true) { - return nil - } - - var firstErr error - for _, db := range r.replicas { - if err := db.Close(); err != nil && firstErr == nil { - firstErr = err - } - } - return firstErr -} - -// healthyReplica returns a random healthy replica. -func (r *ReadWriteConnResolver) ResolveConn(query Query) IConn { - if len(r.replicas) == 0 || !isReadOnlyQuery(query) { - return nil - } - - replicas := r.loadHealthyReplicas() - if len(replicas) == 0 { - return nil - } - if len(replicas) == 1 { - return replicas[0] - } - i := r.nextReplica.Add(1) - return replicas[int(i)%len(replicas)] -} - -func isReadOnlyQuery(query Query) bool { - sel, ok := query.(*SelectQuery) - if !ok { - return false - } - for _, el := range sel.with { - if !isReadOnlyQuery(el.query) { - return false - } - } - return true -} - -func (r *ReadWriteConnResolver) loadHealthyReplicas() []*sql.DB { - if ptr := r.healthyReplicas.Load(); ptr != nil { - return *ptr - } - return nil -} - -func (r *ReadWriteConnResolver) monitor() { - const interval = 5 * time.Second - for !r.closed.Load() { - healthy := make([]*sql.DB, 0, len(r.replicas)) - - for _, replica := range r.replicas { - ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) - err := replica.PingContext(ctx) - cancel() - - if err == nil { - healthy = append(healthy, replica) - } - } - - r.healthyReplicas.Store(&healthy) - time.Sleep(interval) - } -} diff --git a/vendor/github.com/uptrace/bun/dialect/append.go b/vendor/github.com/uptrace/bun/dialect/append.go deleted file mode 100644 index 8f5485fe3..000000000 --- a/vendor/github.com/uptrace/bun/dialect/append.go +++ /dev/null @@ -1,105 +0,0 @@ -package dialect - -import ( - "math" - "strconv" - - "github.com/uptrace/bun/internal" -) - -func AppendError(b []byte, err error) []byte { - b = append(b, "?!("...) - b = append(b, err.Error()...) - b = append(b, ')') - return b -} - -func AppendNull(b []byte) []byte { - return append(b, "NULL"...) -} - -func AppendBool(b []byte, v bool) []byte { - if v { - return append(b, "TRUE"...) - } - return append(b, "FALSE"...) -} - -func AppendFloat32(b []byte, num float32) []byte { - return appendFloat(b, float64(num), 32) -} - -func AppendFloat64(b []byte, num float64) []byte { - return appendFloat(b, num, 64) -} - -func appendFloat(b []byte, num float64, bitSize int) []byte { - switch { - case math.IsNaN(num): - return append(b, "'NaN'"...) - case math.IsInf(num, 1): - return append(b, "'Infinity'"...) - case math.IsInf(num, -1): - return append(b, "'-Infinity'"...) - default: - return strconv.AppendFloat(b, num, 'f', -1, bitSize) - } -} - -//------------------------------------------------------------------------------ - -func AppendName(b []byte, ident string, quote byte) []byte { - return appendName(b, internal.Bytes(ident), quote) -} - -func appendName(b, ident []byte, quote byte) []byte { - b = append(b, quote) - for _, c := range ident { - if c == quote { - b = append(b, quote, quote) - } else { - b = append(b, c) - } - } - b = append(b, quote) - return b -} - -func AppendIdent(b []byte, name string, quote byte) []byte { - return appendIdent(b, internal.Bytes(name), quote) -} - -func appendIdent(b, name []byte, quote byte) []byte { - var quoted bool -loop: - for _, c := range name { - switch c { - case '*': - if !quoted { - b = append(b, '*') - continue loop - } - case '.': - if quoted { - b = append(b, quote) - quoted = false - } - b = append(b, '.') - continue loop - } - - if !quoted { - b = append(b, quote) - quoted = true - } - if c == quote { - b = append(b, quote, quote) - } else { - b = append(b, c) - } - } - if quoted { - b = append(b, quote) - } - return b -} diff --git a/vendor/github.com/uptrace/bun/dialect/dialect.go b/vendor/github.com/uptrace/bun/dialect/dialect.go deleted file mode 100644 index 4dde63c92..000000000 --- a/vendor/github.com/uptrace/bun/dialect/dialect.go +++ /dev/null @@ -1,29 +0,0 @@ -package dialect - -type Name int - -func (n Name) String() string { - switch n { - case PG: - return "pg" - case SQLite: - return "sqlite" - case MySQL: - return "mysql" - case MSSQL: - return "mssql" - case Oracle: - return "oracle" - default: - return "invalid" - } -} - -const ( - Invalid Name = iota - PG - SQLite - MySQL - MSSQL - Oracle -) diff --git a/vendor/github.com/uptrace/bun/dialect/feature/feature.go b/vendor/github.com/uptrace/bun/dialect/feature/feature.go deleted file mode 100644 index 89693fc21..000000000 --- a/vendor/github.com/uptrace/bun/dialect/feature/feature.go +++ /dev/null @@ -1,94 +0,0 @@ -package feature - -import ( - "fmt" - "strconv" - - "github.com/uptrace/bun/internal" -) - -type Feature = internal.Flag - -const ( - CTE Feature = 1 << iota - WithValues - Returning - InsertReturning - Output // mssql - DefaultPlaceholder - DoubleColonCast - ValuesRow - UpdateMultiTable - InsertTableAlias - UpdateTableAlias - DeleteTableAlias - AutoIncrement - Identity - TableCascade - TableIdentity - TableTruncate - InsertOnConflict // INSERT ... ON CONFLICT - InsertOnDuplicateKey // INSERT ... ON DUPLICATE KEY - InsertIgnore // INSERT IGNORE ... - TableNotExists - OffsetFetch - SelectExists - UpdateFromTable - MSSavepoint - GeneratedIdentity - CompositeIn // ... WHERE (A,B) IN ((N, NN), (N, NN)...) - UpdateOrderLimit // UPDATE ... ORDER BY ... LIMIT ... - DeleteOrderLimit // DELETE ... ORDER BY ... LIMIT ... - DeleteReturning - AlterColumnExists // ADD/DROP COLUMN IF NOT EXISTS/IF EXISTS -) - -type NotSupportError struct { - Flag Feature -} - -func (err *NotSupportError) Error() string { - name, ok := flag2str[err.Flag] - if !ok { - name = strconv.FormatInt(int64(err.Flag), 10) - } - return fmt.Sprintf("bun: feature %s is not supported by current dialect", name) -} - -func NewNotSupportError(flag Feature) *NotSupportError { - return &NotSupportError{Flag: flag} -} - -var flag2str = map[Feature]string{ - CTE: "CTE", - WithValues: "WithValues", - Returning: "Returning", - InsertReturning: "InsertReturning", - Output: "Output", - DefaultPlaceholder: "DefaultPlaceholder", - DoubleColonCast: "DoubleColonCast", - ValuesRow: "ValuesRow", - UpdateMultiTable: "UpdateMultiTable", - InsertTableAlias: "InsertTableAlias", - UpdateTableAlias: "UpdateTableAlias", - DeleteTableAlias: "DeleteTableAlias", - AutoIncrement: "AutoIncrement", - Identity: "Identity", - TableCascade: "TableCascade", - TableIdentity: "TableIdentity", - TableTruncate: "TableTruncate", - InsertOnConflict: "InsertOnConflict", - InsertOnDuplicateKey: "InsertOnDuplicateKey", - InsertIgnore: "InsertIgnore", - TableNotExists: "TableNotExists", - OffsetFetch: "OffsetFetch", - SelectExists: "SelectExists", - UpdateFromTable: "UpdateFromTable", - MSSavepoint: "MSSavepoint", - GeneratedIdentity: "GeneratedIdentity", - CompositeIn: "CompositeIn", - UpdateOrderLimit: "UpdateOrderLimit", - DeleteOrderLimit: "DeleteOrderLimit", - DeleteReturning: "DeleteReturning", - AlterColumnExists: "AlterColumnExists", -} diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/LICENSE b/vendor/github.com/uptrace/bun/dialect/pgdialect/LICENSE deleted file mode 100644 index 7ec81810c..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/LICENSE +++ /dev/null @@ -1,24 +0,0 @@ -Copyright (c) 2021 Vladimir Mihailenco. 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. diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/alter_table.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/alter_table.go deleted file mode 100644 index d20f8c069..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/alter_table.go +++ /dev/null @@ -1,245 +0,0 @@ -package pgdialect - -import ( - "fmt" - "strings" - - "github.com/uptrace/bun" - "github.com/uptrace/bun/migrate" - "github.com/uptrace/bun/migrate/sqlschema" - "github.com/uptrace/bun/schema" -) - -func (d *Dialect) NewMigrator(db *bun.DB, schemaName string) sqlschema.Migrator { - return &migrator{db: db, schemaName: schemaName, BaseMigrator: sqlschema.NewBaseMigrator(db)} -} - -type migrator struct { - *sqlschema.BaseMigrator - - db *bun.DB - schemaName string -} - -var _ sqlschema.Migrator = (*migrator)(nil) - -func (m *migrator) AppendSQL(b []byte, operation interface{}) (_ []byte, err error) { - fmter := m.db.Formatter() - - // Append ALTER TABLE statement to the enclosed query bytes []byte. - appendAlterTable := func(query []byte, tableName string) []byte { - query = append(query, "ALTER TABLE "...) - query = m.appendFQN(fmter, query, tableName) - return append(query, " "...) - } - - switch change := operation.(type) { - case *migrate.CreateTableOp: - return m.AppendCreateTable(b, change.Model) - case *migrate.DropTableOp: - return m.AppendDropTable(b, m.schemaName, change.TableName) - case *migrate.RenameTableOp: - b, err = m.renameTable(fmter, appendAlterTable(b, change.TableName), change) - case *migrate.RenameColumnOp: - b, err = m.renameColumn(fmter, appendAlterTable(b, change.TableName), change) - case *migrate.AddColumnOp: - b, err = m.addColumn(fmter, appendAlterTable(b, change.TableName), change) - case *migrate.DropColumnOp: - b, err = m.dropColumn(fmter, appendAlterTable(b, change.TableName), change) - case *migrate.AddPrimaryKeyOp: - b, err = m.addPrimaryKey(fmter, appendAlterTable(b, change.TableName), change.PrimaryKey) - case *migrate.ChangePrimaryKeyOp: - b, err = m.changePrimaryKey(fmter, appendAlterTable(b, change.TableName), change) - case *migrate.DropPrimaryKeyOp: - b, err = m.dropConstraint(fmter, appendAlterTable(b, change.TableName), change.PrimaryKey.Name) - case *migrate.AddUniqueConstraintOp: - b, err = m.addUnique(fmter, appendAlterTable(b, change.TableName), change) - case *migrate.DropUniqueConstraintOp: - b, err = m.dropConstraint(fmter, appendAlterTable(b, change.TableName), change.Unique.Name) - case *migrate.ChangeColumnTypeOp: - b, err = m.changeColumnType(fmter, appendAlterTable(b, change.TableName), change) - case *migrate.AddForeignKeyOp: - b, err = m.addForeignKey(fmter, appendAlterTable(b, change.TableName()), change) - case *migrate.DropForeignKeyOp: - b, err = m.dropConstraint(fmter, appendAlterTable(b, change.TableName()), change.ConstraintName) - default: - return nil, fmt.Errorf("append sql: unknown operation %T", change) - } - if err != nil { - return nil, fmt.Errorf("append sql: %w", err) - } - return b, nil -} - -func (m *migrator) appendFQN(fmter schema.Formatter, b []byte, tableName string) []byte { - return fmter.AppendQuery(b, "?.?", bun.Ident(m.schemaName), bun.Ident(tableName)) -} - -func (m *migrator) renameTable(fmter schema.Formatter, b []byte, rename *migrate.RenameTableOp) (_ []byte, err error) { - b = append(b, "RENAME TO "...) - b = fmter.AppendName(b, rename.NewName) - return b, nil -} - -func (m *migrator) renameColumn(fmter schema.Formatter, b []byte, rename *migrate.RenameColumnOp) (_ []byte, err error) { - b = append(b, "RENAME COLUMN "...) - b = fmter.AppendName(b, rename.OldName) - - b = append(b, " TO "...) - b = fmter.AppendName(b, rename.NewName) - - return b, nil -} - -func (m *migrator) addColumn(fmter schema.Formatter, b []byte, add *migrate.AddColumnOp) (_ []byte, err error) { - b = append(b, "ADD COLUMN "...) - b = fmter.AppendName(b, add.ColumnName) - b = append(b, " "...) - - b, err = add.Column.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - - if add.Column.GetDefaultValue() != "" { - b = append(b, " DEFAULT "...) - b = append(b, add.Column.GetDefaultValue()...) - b = append(b, " "...) - } - - if add.Column.GetIsIdentity() { - b = appendGeneratedAsIdentity(b) - } - - return b, nil -} - -func (m *migrator) dropColumn(fmter schema.Formatter, b []byte, drop *migrate.DropColumnOp) (_ []byte, err error) { - b = append(b, "DROP COLUMN "...) - b = fmter.AppendName(b, drop.ColumnName) - - return b, nil -} - -func (m *migrator) addPrimaryKey(fmter schema.Formatter, b []byte, pk sqlschema.PrimaryKey) (_ []byte, err error) { - b = append(b, "ADD PRIMARY KEY ("...) - b, _ = pk.Columns.AppendQuery(fmter, b) - b = append(b, ")"...) - - return b, nil -} - -func (m *migrator) changePrimaryKey(fmter schema.Formatter, b []byte, change *migrate.ChangePrimaryKeyOp) (_ []byte, err error) { - b, _ = m.dropConstraint(fmter, b, change.Old.Name) - b = append(b, ", "...) - b, _ = m.addPrimaryKey(fmter, b, change.New) - return b, nil -} - -func (m *migrator) addUnique(fmter schema.Formatter, b []byte, change *migrate.AddUniqueConstraintOp) (_ []byte, err error) { - b = append(b, "ADD CONSTRAINT "...) - if change.Unique.Name != "" { - b = fmter.AppendName(b, change.Unique.Name) - } else { - // Default naming scheme for unique constraints in Postgres is <table>_<column>_key - b = fmter.AppendName(b, fmt.Sprintf("%s_%s_key", change.TableName, change.Unique.Columns)) - } - b = append(b, " UNIQUE ("...) - b, _ = change.Unique.Columns.AppendQuery(fmter, b) - b = append(b, ")"...) - - return b, nil -} - -func (m *migrator) dropConstraint(fmter schema.Formatter, b []byte, name string) (_ []byte, err error) { - b = append(b, "DROP CONSTRAINT "...) - b = fmter.AppendName(b, name) - - return b, nil -} - -func (m *migrator) addForeignKey(fmter schema.Formatter, b []byte, add *migrate.AddForeignKeyOp) (_ []byte, err error) { - b = append(b, "ADD CONSTRAINT "...) - - name := add.ConstraintName - if name == "" { - colRef := add.ForeignKey.From - columns := strings.Join(colRef.Column.Split(), "_") - name = fmt.Sprintf("%s_%s_fkey", colRef.TableName, columns) - } - b = fmter.AppendName(b, name) - - b = append(b, " FOREIGN KEY ("...) - if b, err = add.ForeignKey.From.Column.AppendQuery(fmter, b); err != nil { - return b, err - } - b = append(b, ")"...) - - b = append(b, " REFERENCES "...) - b = m.appendFQN(fmter, b, add.ForeignKey.To.TableName) - - b = append(b, " ("...) - if b, err = add.ForeignKey.To.Column.AppendQuery(fmter, b); err != nil { - return b, err - } - b = append(b, ")"...) - - return b, nil -} - -func (m *migrator) changeColumnType(fmter schema.Formatter, b []byte, colDef *migrate.ChangeColumnTypeOp) (_ []byte, err error) { - // alterColumn never re-assigns err, so there is no need to check for err != nil after calling it - var i int - appendAlterColumn := func() { - if i > 0 { - b = append(b, ", "...) - } - b = append(b, "ALTER COLUMN "...) - b = fmter.AppendName(b, colDef.Column) - i++ - } - - got, want := colDef.From, colDef.To - - inspector := m.db.Dialect().(sqlschema.InspectorDialect) - if !inspector.CompareType(want, got) { - appendAlterColumn() - b = append(b, " SET DATA TYPE "...) - if b, err = want.AppendQuery(fmter, b); err != nil { - return b, err - } - } - - // Column must be declared NOT NULL before identity can be added. - // Although PG can resolve the order of operations itself, we make this explicit in the query. - if want.GetIsNullable() != got.GetIsNullable() { - appendAlterColumn() - if !want.GetIsNullable() { - b = append(b, " SET NOT NULL"...) - } else { - b = append(b, " DROP NOT NULL"...) - } - } - - if want.GetIsIdentity() != got.GetIsIdentity() { - appendAlterColumn() - if !want.GetIsIdentity() { - b = append(b, " DROP IDENTITY"...) - } else { - b = append(b, " ADD"...) - b = appendGeneratedAsIdentity(b) - } - } - - if want.GetDefaultValue() != got.GetDefaultValue() { - appendAlterColumn() - if want.GetDefaultValue() == "" { - b = append(b, " DROP DEFAULT"...) - } else { - b = append(b, " SET DEFAULT "...) - b = append(b, want.GetDefaultValue()...) - } - } - - return b, nil -} diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/append.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/append.go deleted file mode 100644 index 18a1f9baf..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/append.go +++ /dev/null @@ -1,87 +0,0 @@ -package pgdialect - -import ( - "database/sql/driver" - "fmt" - "reflect" - "time" - - "github.com/uptrace/bun/dialect" - "github.com/uptrace/bun/schema" -) - -var ( - driverValuerType = reflect.TypeFor[driver.Valuer]() - - stringType = reflect.TypeFor[string]() - sliceStringType = reflect.TypeFor[[]string]() - - intType = reflect.TypeFor[int]() - sliceIntType = reflect.TypeFor[[]int]() - - int64Type = reflect.TypeFor[int64]() - sliceInt64Type = reflect.TypeFor[[]int64]() - - float64Type = reflect.TypeFor[float64]() - sliceFloat64Type = reflect.TypeFor[[]float64]() - - timeType = reflect.TypeFor[time.Time]() - sliceTimeType = reflect.TypeFor[[]time.Time]() -) - -func appendTime(buf []byte, tm time.Time) []byte { - return tm.UTC().AppendFormat(buf, "2006-01-02 15:04:05.999999-07:00") -} - -var mapStringStringType = reflect.TypeOf(map[string]string(nil)) - -func (d *Dialect) hstoreAppender(typ reflect.Type) schema.AppenderFunc { - kind := typ.Kind() - - switch kind { - case reflect.Ptr: - if fn := d.hstoreAppender(typ.Elem()); fn != nil { - return schema.PtrAppender(fn) - } - case reflect.Map: - // ok: - default: - return nil - } - - if typ.Key() == stringType && typ.Elem() == stringType { - return appendMapStringStringValue - } - - return func(fmter schema.Formatter, b []byte, v reflect.Value) []byte { - err := fmt.Errorf("bun: Hstore(unsupported %s)", v.Type()) - return dialect.AppendError(b, err) - } -} - -func appendMapStringString(b []byte, m map[string]string) []byte { - if m == nil { - return dialect.AppendNull(b) - } - - b = append(b, '\'') - - for key, value := range m { - b = appendStringElem(b, key) - b = append(b, '=', '>') - b = appendStringElem(b, value) - b = append(b, ',') - } - if len(m) > 0 { - b = b[:len(b)-1] // Strip trailing comma. - } - - b = append(b, '\'') - - return b -} - -func appendMapStringStringValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte { - m := v.Convert(mapStringStringType).Interface().(map[string]string) - return appendMapStringString(b, m) -} diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/array.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/array.go deleted file mode 100644 index 058b9f2fb..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/array.go +++ /dev/null @@ -1,594 +0,0 @@ -package pgdialect - -import ( - "database/sql" - "database/sql/driver" - "fmt" - "math" - "reflect" - "strconv" - "time" - - "github.com/uptrace/bun/dialect" - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type ArrayValue struct { - v reflect.Value - - append schema.AppenderFunc - scan schema.ScannerFunc -} - -// Array accepts a slice and returns a wrapper for working with PostgreSQL -// array data type. -// -// For struct fields you can use array tag: -// -// Emails []string `bun:",array"` -func Array(vi interface{}) *ArrayValue { - v := reflect.ValueOf(vi) - if !v.IsValid() { - panic(fmt.Errorf("bun: Array(nil)")) - } - - return &ArrayValue{ - v: v, - - append: pgDialect.arrayAppender(v.Type()), - scan: arrayScanner(v.Type()), - } -} - -var ( - _ schema.QueryAppender = (*ArrayValue)(nil) - _ sql.Scanner = (*ArrayValue)(nil) -) - -func (a *ArrayValue) AppendQuery(fmter schema.Formatter, b []byte) ([]byte, error) { - if a.append == nil { - panic(fmt.Errorf("bun: Array(unsupported %s)", a.v.Type())) - } - return a.append(fmter, b, a.v), nil -} - -func (a *ArrayValue) Scan(src interface{}) error { - if a.scan == nil { - return fmt.Errorf("bun: Array(unsupported %s)", a.v.Type()) - } - if a.v.Kind() != reflect.Ptr { - return fmt.Errorf("bun: Array(non-pointer %s)", a.v.Type()) - } - return a.scan(a.v, src) -} - -func (a *ArrayValue) Value() interface{} { - if a.v.IsValid() { - return a.v.Interface() - } - return nil -} - -//------------------------------------------------------------------------------ - -func (d *Dialect) arrayAppender(typ reflect.Type) schema.AppenderFunc { - kind := typ.Kind() - - switch kind { - case reflect.Ptr: - if fn := d.arrayAppender(typ.Elem()); fn != nil { - return schema.PtrAppender(fn) - } - case reflect.Slice, reflect.Array: - // continue below - default: - return nil - } - - elemType := typ.Elem() - - if kind == reflect.Slice { - switch elemType { - case stringType: - return appendStringSliceValue - case intType: - return appendIntSliceValue - case int64Type: - return appendInt64SliceValue - case float64Type: - return appendFloat64SliceValue - case timeType: - return appendTimeSliceValue - } - } - - appendElem := d.arrayElemAppender(elemType) - if appendElem == nil { - panic(fmt.Errorf("pgdialect: %s is not supported", typ)) - } - - return func(fmter schema.Formatter, b []byte, v reflect.Value) []byte { - kind := v.Kind() - switch kind { - case reflect.Ptr, reflect.Slice: - if v.IsNil() { - return dialect.AppendNull(b) - } - } - - if kind == reflect.Ptr { - v = v.Elem() - } - - b = append(b, "'{"...) - - ln := v.Len() - for i := 0; i < ln; i++ { - elem := v.Index(i) - if i > 0 { - b = append(b, ',') - } - b = appendElem(fmter, b, elem) - } - - b = append(b, "}'"...) - - return b - } -} - -func (d *Dialect) arrayElemAppender(typ reflect.Type) schema.AppenderFunc { - if typ.Implements(driverValuerType) { - return arrayAppendDriverValue - } - switch typ.Kind() { - case reflect.String: - return appendStringElemValue - case reflect.Slice: - if typ.Elem().Kind() == reflect.Uint8 { - return appendBytesElemValue - } - } - return schema.Appender(d, typ) -} - -func appendStringElemValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte { - return appendStringElem(b, v.String()) -} - -func appendBytesElemValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte { - return appendBytesElem(b, v.Bytes()) -} - -func arrayAppendDriverValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte { - iface, err := v.Interface().(driver.Valuer).Value() - if err != nil { - return dialect.AppendError(b, err) - } - return appendElem(b, iface) -} - -func appendStringSliceValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte { - ss := v.Convert(sliceStringType).Interface().([]string) - return appendStringSlice(b, ss) -} - -func appendStringSlice(b []byte, ss []string) []byte { - if ss == nil { - return dialect.AppendNull(b) - } - - b = append(b, '\'') - - b = append(b, '{') - for _, s := range ss { - b = appendStringElem(b, s) - b = append(b, ',') - } - if len(ss) > 0 { - b[len(b)-1] = '}' // Replace trailing comma. - } else { - b = append(b, '}') - } - - b = append(b, '\'') - - return b -} - -func appendIntSliceValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte { - ints := v.Convert(sliceIntType).Interface().([]int) - return appendIntSlice(b, ints) -} - -func appendIntSlice(b []byte, ints []int) []byte { - if ints == nil { - return dialect.AppendNull(b) - } - - b = append(b, '\'') - - b = append(b, '{') - for _, n := range ints { - b = strconv.AppendInt(b, int64(n), 10) - b = append(b, ',') - } - if len(ints) > 0 { - b[len(b)-1] = '}' // Replace trailing comma. - } else { - b = append(b, '}') - } - - b = append(b, '\'') - - return b -} - -func appendInt64SliceValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte { - ints := v.Convert(sliceInt64Type).Interface().([]int64) - return appendInt64Slice(b, ints) -} - -func appendInt64Slice(b []byte, ints []int64) []byte { - if ints == nil { - return dialect.AppendNull(b) - } - - b = append(b, '\'') - - b = append(b, '{') - for _, n := range ints { - b = strconv.AppendInt(b, n, 10) - b = append(b, ',') - } - if len(ints) > 0 { - b[len(b)-1] = '}' // Replace trailing comma. - } else { - b = append(b, '}') - } - - b = append(b, '\'') - - return b -} - -func appendFloat64SliceValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte { - floats := v.Convert(sliceFloat64Type).Interface().([]float64) - return appendFloat64Slice(b, floats) -} - -func appendFloat64Slice(b []byte, floats []float64) []byte { - if floats == nil { - return dialect.AppendNull(b) - } - - b = append(b, '\'') - - b = append(b, '{') - for _, n := range floats { - b = arrayAppendFloat64(b, n) - b = append(b, ',') - } - if len(floats) > 0 { - b[len(b)-1] = '}' // Replace trailing comma. - } else { - b = append(b, '}') - } - - b = append(b, '\'') - - return b -} - -func arrayAppendFloat64(b []byte, num float64) []byte { - switch { - case math.IsNaN(num): - return append(b, "NaN"...) - case math.IsInf(num, 1): - return append(b, "Infinity"...) - case math.IsInf(num, -1): - return append(b, "-Infinity"...) - default: - return strconv.AppendFloat(b, num, 'f', -1, 64) - } -} - -func appendTimeSliceValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte { - ts := v.Convert(sliceTimeType).Interface().([]time.Time) - return appendTimeSlice(fmter, b, ts) -} - -func appendTimeSlice(fmter schema.Formatter, b []byte, ts []time.Time) []byte { - if ts == nil { - return dialect.AppendNull(b) - } - b = append(b, '\'') - b = append(b, '{') - for _, t := range ts { - b = append(b, '"') - b = appendTime(b, t) - b = append(b, '"') - b = append(b, ',') - } - if len(ts) > 0 { - b[len(b)-1] = '}' // Replace trailing comma. - } else { - b = append(b, '}') - } - b = append(b, '\'') - return b -} - -//------------------------------------------------------------------------------ - -func arrayScanner(typ reflect.Type) schema.ScannerFunc { - kind := typ.Kind() - - switch kind { - case reflect.Ptr: - if fn := arrayScanner(typ.Elem()); fn != nil { - return schema.PtrScanner(fn) - } - case reflect.Slice, reflect.Array: - // ok: - default: - return nil - } - - elemType := typ.Elem() - - if kind == reflect.Slice { - switch elemType { - case stringType: - return scanStringSliceValue - case intType: - return scanIntSliceValue - case int64Type: - return scanInt64SliceValue - case float64Type: - return scanFloat64SliceValue - } - } - - scanElem := schema.Scanner(elemType) - return func(dest reflect.Value, src interface{}) error { - dest = reflect.Indirect(dest) - if !dest.CanSet() { - return fmt.Errorf("bun: Scan(non-settable %s)", dest.Type()) - } - - kind := dest.Kind() - - if src == nil { - if kind != reflect.Slice || !dest.IsNil() { - dest.Set(reflect.Zero(dest.Type())) - } - return nil - } - - if kind == reflect.Slice { - if dest.IsNil() { - dest.Set(reflect.MakeSlice(dest.Type(), 0, 0)) - } else if dest.Len() > 0 { - dest.Set(dest.Slice(0, 0)) - } - } - - if src == nil { - return nil - } - - b, err := toBytes(src) - if err != nil { - return err - } - - p := newArrayParser(b) - nextValue := internal.MakeSliceNextElemFunc(dest) - for p.Next() { - elem := p.Elem() - elemValue := nextValue() - if err := scanElem(elemValue, elem); err != nil { - return fmt.Errorf("scanElem failed: %w", err) - } - } - return p.Err() - } -} - -func scanStringSliceValue(dest reflect.Value, src interface{}) error { - dest = reflect.Indirect(dest) - if !dest.CanSet() { - return fmt.Errorf("bun: Scan(non-settable %s)", dest.Type()) - } - - slice, err := decodeStringSlice(src) - if err != nil { - return err - } - - dest.Set(reflect.ValueOf(slice)) - return nil -} - -func decodeStringSlice(src interface{}) ([]string, error) { - if src == nil { - return nil, nil - } - - b, err := toBytes(src) - if err != nil { - return nil, err - } - - slice := make([]string, 0) - - p := newArrayParser(b) - for p.Next() { - elem := p.Elem() - slice = append(slice, string(elem)) - } - if err := p.Err(); err != nil { - return nil, err - } - return slice, nil -} - -func scanIntSliceValue(dest reflect.Value, src interface{}) error { - dest = reflect.Indirect(dest) - if !dest.CanSet() { - return fmt.Errorf("bun: Scan(non-settable %s)", dest.Type()) - } - - slice, err := decodeIntSlice(src) - if err != nil { - return err - } - - dest.Set(reflect.ValueOf(slice)) - return nil -} - -func decodeIntSlice(src interface{}) ([]int, error) { - if src == nil { - return nil, nil - } - - b, err := toBytes(src) - if err != nil { - return nil, err - } - - slice := make([]int, 0) - - p := newArrayParser(b) - for p.Next() { - elem := p.Elem() - - if elem == nil { - slice = append(slice, 0) - continue - } - - n, err := strconv.Atoi(internal.String(elem)) - if err != nil { - return nil, err - } - - slice = append(slice, n) - } - if err := p.Err(); err != nil { - return nil, err - } - return slice, nil -} - -func scanInt64SliceValue(dest reflect.Value, src interface{}) error { - dest = reflect.Indirect(dest) - if !dest.CanSet() { - return fmt.Errorf("bun: Scan(non-settable %s)", dest.Type()) - } - - slice, err := decodeInt64Slice(src) - if err != nil { - return err - } - - dest.Set(reflect.ValueOf(slice)) - return nil -} - -func decodeInt64Slice(src interface{}) ([]int64, error) { - if src == nil { - return nil, nil - } - - b, err := toBytes(src) - if err != nil { - return nil, err - } - - slice := make([]int64, 0) - - p := newArrayParser(b) - for p.Next() { - elem := p.Elem() - - if elem == nil { - slice = append(slice, 0) - continue - } - - n, err := strconv.ParseInt(internal.String(elem), 10, 64) - if err != nil { - return nil, err - } - - slice = append(slice, n) - } - if err := p.Err(); err != nil { - return nil, err - } - return slice, nil -} - -func scanFloat64SliceValue(dest reflect.Value, src interface{}) error { - dest = reflect.Indirect(dest) - if !dest.CanSet() { - return fmt.Errorf("bun: Scan(non-settable %s)", dest.Type()) - } - - slice, err := scanFloat64Slice(src) - if err != nil { - return err - } - - dest.Set(reflect.ValueOf(slice)) - return nil -} - -func scanFloat64Slice(src interface{}) ([]float64, error) { - if src == nil { - return nil, nil - } - - b, err := toBytes(src) - if err != nil { - return nil, err - } - - slice := make([]float64, 0) - - p := newArrayParser(b) - for p.Next() { - elem := p.Elem() - - if elem == nil { - slice = append(slice, 0) - continue - } - - n, err := strconv.ParseFloat(internal.String(elem), 64) - if err != nil { - return nil, err - } - - slice = append(slice, n) - } - if err := p.Err(); err != nil { - return nil, err - } - return slice, nil -} - -func toBytes(src interface{}) ([]byte, error) { - switch src := src.(type) { - case string: - return internal.Bytes(src), nil - case []byte: - return src, nil - default: - return nil, fmt.Errorf("pgdialect: got %T, wanted []byte or string", src) - } -} diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/array_parser.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/array_parser.go deleted file mode 100644 index 462f8d91d..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/array_parser.go +++ /dev/null @@ -1,93 +0,0 @@ -package pgdialect - -import ( - "bytes" - "fmt" - "io" -) - -type arrayParser struct { - p pgparser - - elem []byte - err error -} - -func newArrayParser(b []byte) *arrayParser { - p := new(arrayParser) - - if len(b) < 2 || b[0] != '{' || b[len(b)-1] != '}' { - p.err = fmt.Errorf("pgdialect: can't parse array: %q", b) - return p - } - - p.p.Reset(b[1 : len(b)-1]) - return p -} - -func (p *arrayParser) Next() bool { - if p.err != nil { - return false - } - p.err = p.readNext() - return p.err == nil -} - -func (p *arrayParser) Err() error { - if p.err != io.EOF { - return p.err - } - return nil -} - -func (p *arrayParser) Elem() []byte { - return p.elem -} - -func (p *arrayParser) readNext() error { - ch := p.p.Read() - if ch == 0 { - return io.EOF - } - - switch ch { - case '}': - return io.EOF - case '"': - b, err := p.p.ReadSubstring(ch) - if err != nil { - return err - } - - if p.p.Peek() == ',' { - p.p.Advance() - } - - p.elem = b - return nil - case '[', '(': - rng, err := p.p.ReadRange(ch) - if err != nil { - return err - } - - if p.p.Peek() == ',' { - p.p.Advance() - } - - p.elem = rng - return nil - default: - lit := p.p.ReadLiteral(ch) - if bytes.Equal(lit, []byte("NULL")) { - lit = nil - } - - if p.p.Peek() == ',' { - p.p.Advance() - } - - p.elem = lit - return nil - } -} diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/dialect.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/dialect.go deleted file mode 100644 index 05c4e371f..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/dialect.go +++ /dev/null @@ -1,160 +0,0 @@ -package pgdialect - -import ( - "database/sql" - "fmt" - "strconv" - "strings" - - "github.com/uptrace/bun" - "github.com/uptrace/bun/dialect" - "github.com/uptrace/bun/dialect/feature" - "github.com/uptrace/bun/dialect/sqltype" - "github.com/uptrace/bun/migrate/sqlschema" - "github.com/uptrace/bun/schema" -) - -var pgDialect = New() - -func init() { - if Version() != bun.Version() { - panic(fmt.Errorf("pgdialect and Bun must have the same version: v%s != v%s", - Version(), bun.Version())) - } -} - -type Dialect struct { - schema.BaseDialect - - tables *schema.Tables - features feature.Feature - uintAsInt bool -} - -var _ schema.Dialect = (*Dialect)(nil) -var _ sqlschema.InspectorDialect = (*Dialect)(nil) -var _ sqlschema.MigratorDialect = (*Dialect)(nil) - -func New(opts ...DialectOption) *Dialect { - d := new(Dialect) - d.tables = schema.NewTables(d) - d.features = feature.CTE | - feature.WithValues | - feature.Returning | - feature.InsertReturning | - feature.DefaultPlaceholder | - feature.DoubleColonCast | - feature.InsertTableAlias | - feature.UpdateTableAlias | - feature.DeleteTableAlias | - feature.TableCascade | - feature.TableIdentity | - feature.TableTruncate | - feature.TableNotExists | - feature.InsertOnConflict | - feature.SelectExists | - feature.GeneratedIdentity | - feature.CompositeIn | - feature.DeleteReturning | - feature.AlterColumnExists - - for _, opt := range opts { - opt(d) - } - - return d -} - -type DialectOption func(d *Dialect) - -func WithoutFeature(other feature.Feature) DialectOption { - return func(d *Dialect) { - d.features = d.features.Remove(other) - } -} - -func WithAppendUintAsInt(on bool) DialectOption { - return func(d *Dialect) { - d.uintAsInt = on - } -} - -func (d *Dialect) Init(*sql.DB) {} - -func (d *Dialect) Name() dialect.Name { - return dialect.PG -} - -func (d *Dialect) Features() feature.Feature { - return d.features -} - -func (d *Dialect) Tables() *schema.Tables { - return d.tables -} - -func (d *Dialect) OnTable(table *schema.Table) { - for _, field := range table.FieldMap { - d.onField(field) - } -} - -func (d *Dialect) onField(field *schema.Field) { - field.DiscoveredSQLType = fieldSQLType(field) - - if field.AutoIncrement && !field.Identity { - switch field.DiscoveredSQLType { - case sqltype.SmallInt: - field.CreateTableSQLType = pgTypeSmallSerial - case sqltype.Integer: - field.CreateTableSQLType = pgTypeSerial - case sqltype.BigInt: - field.CreateTableSQLType = pgTypeBigSerial - } - } - - if field.Tag.HasOption("array") || strings.HasSuffix(field.UserSQLType, "[]") { - field.Append = d.arrayAppender(field.StructField.Type) - field.Scan = arrayScanner(field.StructField.Type) - return - } - - if field.Tag.HasOption("multirange") { - field.Append = d.arrayAppender(field.StructField.Type) - field.Scan = arrayScanner(field.StructField.Type) - return - } - - switch field.DiscoveredSQLType { - case sqltype.HSTORE: - field.Append = d.hstoreAppender(field.StructField.Type) - field.Scan = hstoreScanner(field.StructField.Type) - } -} - -func (d *Dialect) IdentQuote() byte { - return '"' -} - -func (d *Dialect) AppendUint32(b []byte, n uint32) []byte { - if d.uintAsInt { - return strconv.AppendInt(b, int64(int32(n)), 10) - } - return strconv.AppendUint(b, uint64(n), 10) -} - -func (d *Dialect) AppendUint64(b []byte, n uint64) []byte { - if d.uintAsInt { - return strconv.AppendInt(b, int64(n), 10) - } - return strconv.AppendUint(b, n, 10) -} - -func (d *Dialect) AppendSequence(b []byte, _ *schema.Table, _ *schema.Field) []byte { - return appendGeneratedAsIdentity(b) -} - -// appendGeneratedAsIdentity appends GENERATED BY DEFAULT AS IDENTITY to the column definition. -func appendGeneratedAsIdentity(b []byte) []byte { - return append(b, " GENERATED BY DEFAULT AS IDENTITY"...) -} diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/elem.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/elem.go deleted file mode 100644 index 7fbec3778..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/elem.go +++ /dev/null @@ -1,87 +0,0 @@ -package pgdialect - -import ( - "database/sql/driver" - "encoding/hex" - "fmt" - "strconv" - "time" - "unicode/utf8" - - "github.com/uptrace/bun/dialect" -) - -func appendElem(buf []byte, val interface{}) []byte { - switch val := val.(type) { - case int64: - return strconv.AppendInt(buf, val, 10) - case float64: - return arrayAppendFloat64(buf, val) - case bool: - return dialect.AppendBool(buf, val) - case []byte: - return appendBytesElem(buf, val) - case string: - return appendStringElem(buf, val) - case time.Time: - buf = append(buf, '"') - buf = appendTime(buf, val) - buf = append(buf, '"') - return buf - case driver.Valuer: - val2, err := val.Value() - if err != nil { - err := fmt.Errorf("pgdialect: can't append elem value: %w", err) - return dialect.AppendError(buf, err) - } - return appendElem(buf, val2) - default: - err := fmt.Errorf("pgdialect: can't append elem %T", val) - return dialect.AppendError(buf, err) - } -} - -func appendBytesElem(b []byte, bs []byte) []byte { - if bs == nil { - return dialect.AppendNull(b) - } - - b = append(b, `"\\x`...) - - s := len(b) - b = append(b, make([]byte, hex.EncodedLen(len(bs)))...) - hex.Encode(b[s:], bs) - - b = append(b, '"') - - return b -} - -func appendStringElem(b []byte, s string) []byte { - b = append(b, '"') - for _, r := range s { - switch r { - case 0: - // ignore - case '\'': - b = append(b, "''"...) - case '"': - b = append(b, '\\', '"') - case '\\': - b = append(b, '\\', '\\') - default: - if r < utf8.RuneSelf { - b = append(b, byte(r)) - break - } - l := len(b) - if cap(b)-l < utf8.UTFMax { - b = append(b, make([]byte, utf8.UTFMax)...) - } - n := utf8.EncodeRune(b[l:l+utf8.UTFMax], r) - b = b[:l+n] - } - } - b = append(b, '"') - return b -} diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/hstore.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/hstore.go deleted file mode 100644 index 029f7cb6d..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/hstore.go +++ /dev/null @@ -1,73 +0,0 @@ -package pgdialect - -import ( - "database/sql" - "fmt" - "reflect" - - "github.com/uptrace/bun/schema" -) - -type HStoreValue struct { - v reflect.Value - - append schema.AppenderFunc - scan schema.ScannerFunc -} - -// HStore accepts a map[string]string and returns a wrapper for working with PostgreSQL -// hstore data type. -// -// For struct fields you can use hstore tag: -// -// Attrs map[string]string `bun:",hstore"` -func HStore(vi interface{}) *HStoreValue { - v := reflect.ValueOf(vi) - if !v.IsValid() { - panic(fmt.Errorf("bun: HStore(nil)")) - } - - typ := v.Type() - if typ.Kind() == reflect.Ptr { - typ = typ.Elem() - } - if typ.Kind() != reflect.Map { - panic(fmt.Errorf("bun: Hstore(unsupported %s)", typ)) - } - - return &HStoreValue{ - v: v, - - append: pgDialect.hstoreAppender(v.Type()), - scan: hstoreScanner(v.Type()), - } -} - -var ( - _ schema.QueryAppender = (*HStoreValue)(nil) - _ sql.Scanner = (*HStoreValue)(nil) -) - -func (h *HStoreValue) AppendQuery(fmter schema.Formatter, b []byte) ([]byte, error) { - if h.append == nil { - panic(fmt.Errorf("bun: HStore(unsupported %s)", h.v.Type())) - } - return h.append(fmter, b, h.v), nil -} - -func (h *HStoreValue) Scan(src interface{}) error { - if h.scan == nil { - return fmt.Errorf("bun: HStore(unsupported %s)", h.v.Type()) - } - if h.v.Kind() != reflect.Ptr { - return fmt.Errorf("bun: HStore(non-pointer %s)", h.v.Type()) - } - return h.scan(h.v.Elem(), src) -} - -func (h *HStoreValue) Value() interface{} { - if h.v.IsValid() { - return h.v.Interface() - } - return nil -} diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/hstore_parser.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/hstore_parser.go deleted file mode 100644 index fec401786..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/hstore_parser.go +++ /dev/null @@ -1,100 +0,0 @@ -package pgdialect - -import ( - "bytes" - "fmt" - "io" -) - -type hstoreParser struct { - p pgparser - - key string - value string - err error -} - -func newHStoreParser(b []byte) *hstoreParser { - p := new(hstoreParser) - if len(b) != 0 && (len(b) < 6 || b[0] != '"') { - p.err = fmt.Errorf("pgdialect: can't parse hstore: %q", b) - return p - } - p.p.Reset(b) - return p -} - -func (p *hstoreParser) Next() bool { - if p.err != nil { - return false - } - p.err = p.readNext() - return p.err == nil -} - -func (p *hstoreParser) Err() error { - if p.err != io.EOF { - return p.err - } - return nil -} - -func (p *hstoreParser) Key() string { - return p.key -} - -func (p *hstoreParser) Value() string { - return p.value -} - -func (p *hstoreParser) readNext() error { - if !p.p.Valid() { - return io.EOF - } - - if err := p.p.Skip('"'); err != nil { - return err - } - - key, err := p.p.ReadUnescapedSubstring('"') - if err != nil { - return err - } - p.key = string(key) - - if err := p.p.SkipPrefix([]byte("=>")); err != nil { - return err - } - - ch, err := p.p.ReadByte() - if err != nil { - return err - } - - switch ch { - case '"': - value, err := p.p.ReadUnescapedSubstring(ch) - if err != nil { - return err - } - p.skipComma() - p.value = string(value) - return nil - default: - value := p.p.ReadLiteral(ch) - if bytes.Equal(value, []byte("NULL")) { - p.value = "" - } - p.skipComma() - return nil - } -} - -func (p *hstoreParser) skipComma() { - if p.p.Peek() == ',' { - p.p.Advance() - } - if p.p.Peek() == ' ' { - p.p.Advance() - } -} diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/hstore_scan.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/hstore_scan.go deleted file mode 100644 index 62ab89a3a..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/hstore_scan.go +++ /dev/null @@ -1,67 +0,0 @@ -package pgdialect - -import ( - "fmt" - "reflect" - - "github.com/uptrace/bun/schema" -) - -func hstoreScanner(typ reflect.Type) schema.ScannerFunc { - kind := typ.Kind() - - switch kind { - case reflect.Ptr: - if fn := hstoreScanner(typ.Elem()); fn != nil { - return schema.PtrScanner(fn) - } - case reflect.Map: - // ok: - default: - return nil - } - - if typ.Key() == stringType && typ.Elem() == stringType { - return scanMapStringStringValue - } - return func(dest reflect.Value, src interface{}) error { - return fmt.Errorf("bun: Hstore(unsupported %s)", dest.Type()) - } -} - -func scanMapStringStringValue(dest reflect.Value, src interface{}) error { - dest = reflect.Indirect(dest) - if !dest.CanSet() { - return fmt.Errorf("bun: Scan(non-settable %s)", dest.Type()) - } - - m, err := decodeMapStringString(src) - if err != nil { - return err - } - - dest.Set(reflect.ValueOf(m)) - return nil -} - -func decodeMapStringString(src interface{}) (map[string]string, error) { - if src == nil { - return nil, nil - } - - b, err := toBytes(src) - if err != nil { - return nil, err - } - - m := make(map[string]string) - - p := newHStoreParser(b) - for p.Next() { - m[p.Key()] = p.Value() - } - if err := p.Err(); err != nil { - return nil, err - } - return m, nil -} diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/inspector.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/inspector.go deleted file mode 100644 index 040df439c..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/inspector.go +++ /dev/null @@ -1,297 +0,0 @@ -package pgdialect - -import ( - "context" - "strings" - - "github.com/uptrace/bun" - "github.com/uptrace/bun/internal/ordered" - "github.com/uptrace/bun/migrate/sqlschema" -) - -type ( - Schema = sqlschema.BaseDatabase - Table = sqlschema.BaseTable - Column = sqlschema.BaseColumn -) - -func (d *Dialect) NewInspector(db *bun.DB, options ...sqlschema.InspectorOption) sqlschema.Inspector { - return newInspector(db, options...) -} - -type Inspector struct { - sqlschema.InspectorConfig - db *bun.DB -} - -var _ sqlschema.Inspector = (*Inspector)(nil) - -func newInspector(db *bun.DB, options ...sqlschema.InspectorOption) *Inspector { - i := &Inspector{db: db} - sqlschema.ApplyInspectorOptions(&i.InspectorConfig, options...) - return i -} - -func (in *Inspector) Inspect(ctx context.Context) (sqlschema.Database, error) { - dbSchema := Schema{ - Tables: ordered.NewMap[string, sqlschema.Table](), - ForeignKeys: make(map[sqlschema.ForeignKey]string), - } - - exclude := in.ExcludeTables - if len(exclude) == 0 { - // Avoid getting NOT IN (NULL) if bun.In() is called with an empty slice. - exclude = []string{""} - } - - var tables []*InformationSchemaTable - if err := in.db.NewRaw(sqlInspectTables, in.SchemaName, bun.In(exclude)).Scan(ctx, &tables); err != nil { - return dbSchema, err - } - - var fks []*ForeignKey - if err := in.db.NewRaw(sqlInspectForeignKeys, in.SchemaName, bun.In(exclude), bun.In(exclude)).Scan(ctx, &fks); err != nil { - return dbSchema, err - } - dbSchema.ForeignKeys = make(map[sqlschema.ForeignKey]string, len(fks)) - - for _, table := range tables { - var columns []*InformationSchemaColumn - if err := in.db.NewRaw(sqlInspectColumnsQuery, table.Schema, table.Name).Scan(ctx, &columns); err != nil { - return dbSchema, err - } - - colDefs := ordered.NewMap[string, sqlschema.Column]() - uniqueGroups := make(map[string][]string) - - for _, c := range columns { - def := c.Default - if c.IsSerial || c.IsIdentity { - def = "" - } else if !c.IsDefaultLiteral { - def = strings.ToLower(def) - } - - colDefs.Store(c.Name, &Column{ - Name: c.Name, - SQLType: c.DataType, - VarcharLen: c.VarcharLen, - DefaultValue: def, - IsNullable: c.IsNullable, - IsAutoIncrement: c.IsSerial, - IsIdentity: c.IsIdentity, - }) - - for _, group := range c.UniqueGroups { - uniqueGroups[group] = append(uniqueGroups[group], c.Name) - } - } - - var unique []sqlschema.Unique - for name, columns := range uniqueGroups { - unique = append(unique, sqlschema.Unique{ - Name: name, - Columns: sqlschema.NewColumns(columns...), - }) - } - - var pk *sqlschema.PrimaryKey - if len(table.PrimaryKey.Columns) > 0 { - pk = &sqlschema.PrimaryKey{ - Name: table.PrimaryKey.ConstraintName, - Columns: sqlschema.NewColumns(table.PrimaryKey.Columns...), - } - } - - dbSchema.Tables.Store(table.Name, &Table{ - Schema: table.Schema, - Name: table.Name, - Columns: colDefs, - PrimaryKey: pk, - UniqueConstraints: unique, - }) - } - - for _, fk := range fks { - dbSchema.ForeignKeys[sqlschema.ForeignKey{ - From: sqlschema.NewColumnReference(fk.SourceTable, fk.SourceColumns...), - To: sqlschema.NewColumnReference(fk.TargetTable, fk.TargetColumns...), - }] = fk.ConstraintName - } - return dbSchema, nil -} - -type InformationSchemaTable struct { - Schema string `bun:"table_schema,pk"` - Name string `bun:"table_name,pk"` - PrimaryKey PrimaryKey `bun:"embed:primary_key_"` - - Columns []*InformationSchemaColumn `bun:"rel:has-many,join:table_schema=table_schema,join:table_name=table_name"` -} - -type InformationSchemaColumn struct { - Schema string `bun:"table_schema"` - Table string `bun:"table_name"` - Name string `bun:"column_name"` - DataType string `bun:"data_type"` - VarcharLen int `bun:"varchar_len"` - IsArray bool `bun:"is_array"` - ArrayDims int `bun:"array_dims"` - Default string `bun:"default"` - IsDefaultLiteral bool `bun:"default_is_literal_expr"` - IsIdentity bool `bun:"is_identity"` - IndentityType string `bun:"identity_type"` - IsSerial bool `bun:"is_serial"` - IsNullable bool `bun:"is_nullable"` - UniqueGroups []string `bun:"unique_groups,array"` -} - -type ForeignKey struct { - ConstraintName string `bun:"constraint_name"` - SourceSchema string `bun:"schema_name"` - SourceTable string `bun:"table_name"` - SourceColumns []string `bun:"columns,array"` - TargetSchema string `bun:"target_schema"` - TargetTable string `bun:"target_table"` - TargetColumns []string `bun:"target_columns,array"` -} - -type PrimaryKey struct { - ConstraintName string `bun:"name"` - Columns []string `bun:"columns,array"` -} - -const ( - // sqlInspectTables retrieves all user-defined tables in the selected schema. - // Pass bun.In([]string{...}) to exclude tables from this inspection or bun.In([]string{''}) to include all results. - sqlInspectTables = ` -SELECT - "t".table_schema, - "t".table_name, - pk.name AS primary_key_name, - pk.columns AS primary_key_columns -FROM information_schema.tables "t" - LEFT JOIN ( - SELECT i.indrelid, "idx".relname AS "name", ARRAY_AGG("a".attname) AS "columns" - FROM pg_index i - JOIN pg_attribute "a" - ON "a".attrelid = i.indrelid - AND "a".attnum = ANY("i".indkey) - AND i.indisprimary - JOIN pg_class "idx" ON i.indexrelid = "idx".oid - GROUP BY 1, 2 - ) pk - ON ("t".table_schema || '.' || "t".table_name)::regclass = pk.indrelid -WHERE table_type = 'BASE TABLE' - AND "t".table_schema = ? - AND "t".table_schema NOT LIKE 'pg_%' - AND "table_name" NOT IN (?) -ORDER BY "t".table_schema, "t".table_name -` - - // sqlInspectColumnsQuery retrieves column definitions for the specified table. - // Unlike sqlInspectTables and sqlInspectSchema, it should be passed to bun.NewRaw - // with additional args for table_schema and table_name. - sqlInspectColumnsQuery = ` -SELECT - "c".table_schema, - "c".table_name, - "c".column_name, - "c".data_type, - "c".character_maximum_length::integer AS varchar_len, - "c".data_type = 'ARRAY' AS is_array, - COALESCE("c".array_dims, 0) AS array_dims, - CASE - WHEN "c".column_default ~ '^''.*''::.*$' THEN substring("c".column_default FROM '^''(.*)''::.*$') - ELSE "c".column_default - END AS "default", - "c".column_default ~ '^''.*''::.*$' OR "c".column_default ~ '^[0-9\.]+$' AS default_is_literal_expr, - "c".is_identity = 'YES' AS is_identity, - "c".column_default = format('nextval(''%s_%s_seq''::regclass)', "c".table_name, "c".column_name) AS is_serial, - COALESCE("c".identity_type, '') AS identity_type, - "c".is_nullable = 'YES' AS is_nullable, - "c"."unique_groups" AS unique_groups -FROM ( - SELECT - "table_schema", - "table_name", - "column_name", - "c".data_type, - "c".character_maximum_length, - "c".column_default, - "c".is_identity, - "c".is_nullable, - att.array_dims, - att.identity_type, - att."unique_groups", - att."constraint_type" - FROM information_schema.columns "c" - LEFT JOIN ( - SELECT - s.nspname AS "table_schema", - "t".relname AS "table_name", - "c".attname AS "column_name", - "c".attndims AS array_dims, - "c".attidentity AS identity_type, - ARRAY_AGG(con.conname) FILTER (WHERE con.contype = 'u') AS "unique_groups", - ARRAY_AGG(con.contype) AS "constraint_type" - FROM ( - SELECT - conname, - contype, - connamespace, - conrelid, - conrelid AS attrelid, - UNNEST(conkey) AS attnum - FROM pg_constraint - ) con - LEFT JOIN pg_attribute "c" USING (attrelid, attnum) - LEFT JOIN pg_namespace s ON s.oid = con.connamespace - LEFT JOIN pg_class "t" ON "t".oid = con.conrelid - GROUP BY 1, 2, 3, 4, 5 - ) att USING ("table_schema", "table_name", "column_name") - ) "c" -WHERE "table_schema" = ? AND "table_name" = ? -ORDER BY "table_schema", "table_name", "column_name" -` - - // sqlInspectForeignKeys get FK definitions for user-defined tables. - // Pass bun.In([]string{...}) to exclude tables from this inspection or bun.In([]string{''}) to include all results. - sqlInspectForeignKeys = ` -WITH - "schemas" AS ( - SELECT oid, nspname - FROM pg_namespace - ), - "tables" AS ( - SELECT oid, relnamespace, relname, relkind - FROM pg_class - ), - "columns" AS ( - SELECT attrelid, attname, attnum - FROM pg_attribute - WHERE attisdropped = false - ) -SELECT DISTINCT - co.conname AS "constraint_name", - ss.nspname AS schema_name, - s.relname AS "table_name", - ARRAY_AGG(sc.attname) AS "columns", - ts.nspname AS target_schema, - "t".relname AS target_table, - ARRAY_AGG(tc.attname) AS target_columns -FROM pg_constraint co - LEFT JOIN "tables" s ON s.oid = co.conrelid - LEFT JOIN "schemas" ss ON ss.oid = s.relnamespace - LEFT JOIN "columns" sc ON sc.attrelid = s.oid AND sc.attnum = ANY(co.conkey) - LEFT JOIN "tables" t ON t.oid = co.confrelid - LEFT JOIN "schemas" ts ON ts.oid = "t".relnamespace - LEFT JOIN "columns" tc ON tc.attrelid = "t".oid AND tc.attnum = ANY(co.confkey) -WHERE co.contype = 'f' - AND co.conrelid IN (SELECT oid FROM pg_class WHERE relkind = 'r') - AND ARRAY_POSITION(co.conkey, sc.attnum) = ARRAY_POSITION(co.confkey, tc.attnum) - AND ss.nspname = ? - AND s.relname NOT IN (?) AND "t".relname NOT IN (?) -GROUP BY "constraint_name", "schema_name", "table_name", target_schema, target_table -` -) diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/parser.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/parser.go deleted file mode 100644 index 08f4727db..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/parser.go +++ /dev/null @@ -1,107 +0,0 @@ -package pgdialect - -import ( - "bytes" - "encoding/hex" - - "github.com/uptrace/bun/internal/parser" -) - -type pgparser struct { - parser.Parser - buf []byte -} - -func newParser(b []byte) *pgparser { - p := new(pgparser) - p.Reset(b) - return p -} - -func (p *pgparser) ReadLiteral(ch byte) []byte { - p.Unread() - lit, _ := p.ReadSep(',') - return lit -} - -func (p *pgparser) ReadUnescapedSubstring(ch byte) ([]byte, error) { - return p.readSubstring(ch, false) -} - -func (p *pgparser) ReadSubstring(ch byte) ([]byte, error) { - return p.readSubstring(ch, true) -} - -func (p *pgparser) readSubstring(ch byte, escaped bool) ([]byte, error) { - ch, err := p.ReadByte() - if err != nil { - return nil, err - } - - p.buf = p.buf[:0] - for { - if ch == '"' { - break - } - - next, err := p.ReadByte() - if err != nil { - return nil, err - } - - if ch == '\\' { - switch next { - case '\\', '"': - p.buf = append(p.buf, next) - - ch, err = p.ReadByte() - if err != nil { - return nil, err - } - default: - p.buf = append(p.buf, '\\') - ch = next - } - continue - } - - if escaped && ch == '\'' && next == '\'' { - p.buf = append(p.buf, next) - ch, err = p.ReadByte() - if err != nil { - return nil, err - } - continue - } - - p.buf = append(p.buf, ch) - ch = next - } - - if bytes.HasPrefix(p.buf, []byte("\\x")) && len(p.buf)%2 == 0 { - data := p.buf[2:] - buf := make([]byte, hex.DecodedLen(len(data))) - n, err := hex.Decode(buf, data) - if err != nil { - return nil, err - } - return buf[:n], nil - } - - return p.buf, nil -} - -func (p *pgparser) ReadRange(ch byte) ([]byte, error) { - p.buf = p.buf[:0] - p.buf = append(p.buf, ch) - - for p.Valid() { - ch = p.Read() - p.buf = append(p.buf, ch) - if ch == ']' || ch == ')' { - break - } - } - - return p.buf, nil -} diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/range.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/range.go deleted file mode 100644 index 936ad5521..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/range.go +++ /dev/null @@ -1,138 +0,0 @@ -package pgdialect - -import ( - "database/sql" - "fmt" - "io" - "time" - - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type MultiRange[T any] []Range[T] - -type Range[T any] struct { - Lower, Upper T - LowerBound, UpperBound RangeBound -} - -type RangeBound byte - -const ( - RangeBoundInclusiveLeft RangeBound = '[' - RangeBoundInclusiveRight RangeBound = ']' - RangeBoundExclusiveLeft RangeBound = '(' - RangeBoundExclusiveRight RangeBound = ')' -) - -func NewRange[T any](lower, upper T) Range[T] { - return Range[T]{ - Lower: lower, - Upper: upper, - LowerBound: RangeBoundInclusiveLeft, - UpperBound: RangeBoundExclusiveRight, - } -} - -var _ sql.Scanner = (*Range[any])(nil) - -func (r *Range[T]) Scan(anySrc any) (err error) { - src, ok := anySrc.([]byte) - if !ok { - return fmt.Errorf("pgdialect: Range can't scan %T", anySrc) - } - - if len(src) == 0 { - return io.ErrUnexpectedEOF - } - r.LowerBound = RangeBound(src[0]) - src = src[1:] - - src, err = scanElem(&r.Lower, src) - if err != nil { - return err - } - - if len(src) == 0 { - return io.ErrUnexpectedEOF - } - if ch := src[0]; ch != ',' { - return fmt.Errorf("got %q, wanted %q", ch, ',') - } - src = src[1:] - - src, err = scanElem(&r.Upper, src) - if err != nil { - return err - } - - if len(src) == 0 { - return io.ErrUnexpectedEOF - } - r.UpperBound = RangeBound(src[0]) - src = src[1:] - - if len(src) > 0 { - return fmt.Errorf("unread data: %q", src) - } - return nil -} - -var _ schema.QueryAppender = (*Range[any])(nil) - -func (r *Range[T]) AppendQuery(fmt schema.Formatter, buf []byte) ([]byte, error) { - buf = append(buf, byte(r.LowerBound)) - buf = appendElem(buf, r.Lower) - buf = append(buf, ',') - buf = appendElem(buf, r.Upper) - buf = append(buf, byte(r.UpperBound)) - return buf, nil -} - -func scanElem(ptr any, src []byte) ([]byte, error) { - switch ptr := ptr.(type) { - case *time.Time: - src, str, err := readStringLiteral(src) - if err != nil { - return nil, err - } - - tm, err := internal.ParseTime(internal.String(str)) - if err != nil { - return nil, err - } - *ptr = tm - - return src, nil - - case sql.Scanner: - src, str, err := readStringLiteral(src) - if err != nil { - return nil, err - } - if err := ptr.Scan(str); err != nil { - return nil, err - } - return src, nil - - default: - panic(fmt.Errorf("unsupported range type: %T", ptr)) - } -} - -func readStringLiteral(src []byte) ([]byte, []byte, error) { - p := newParser(src) - - if err := p.Skip('"'); err != nil { - return nil, nil, err - } - - str, err := p.ReadSubstring('"') - if err != nil { - return nil, nil, err - } - - src = p.Remaining() - return src, str, nil -} diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/sqltype.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/sqltype.go deleted file mode 100644 index 99075cbc1..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/sqltype.go +++ /dev/null @@ -1,179 +0,0 @@ -package pgdialect - -import ( - "database/sql" - "encoding/json" - "net" - "reflect" - "strings" - - "github.com/uptrace/bun/dialect/sqltype" - "github.com/uptrace/bun/migrate/sqlschema" - "github.com/uptrace/bun/schema" -) - -const ( - // Date / Time - pgTypeTimestamp = "TIMESTAMP" // Timestamp - pgTypeTimestampWithTz = "TIMESTAMP WITH TIME ZONE" // Timestamp with a time zone - pgTypeTimestampTz = "TIMESTAMPTZ" // Timestamp with a time zone (alias) - pgTypeDate = "DATE" // Date - pgTypeTime = "TIME" // Time without a time zone - pgTypeTimeTz = "TIME WITH TIME ZONE" // Time with a time zone - pgTypeInterval = "INTERVAL" // Time interval - - // Network Addresses - pgTypeInet = "INET" // IPv4 or IPv6 hosts and networks - pgTypeCidr = "CIDR" // IPv4 or IPv6 networks - pgTypeMacaddr = "MACADDR" // MAC addresses - - // Serial Types - pgTypeSmallSerial = "SMALLSERIAL" // 2 byte autoincrementing integer - pgTypeSerial = "SERIAL" // 4 byte autoincrementing integer - pgTypeBigSerial = "BIGSERIAL" // 8 byte autoincrementing integer - - // Character Types - pgTypeChar = "CHAR" // fixed length string (blank padded) - pgTypeCharacter = "CHARACTER" // alias for CHAR - pgTypeText = "TEXT" // variable length string without limit - pgTypeVarchar = "VARCHAR" // variable length string with optional limit - pgTypeCharacterVarying = "CHARACTER VARYING" // alias for VARCHAR - - // Binary Data Types - pgTypeBytea = "BYTEA" // binary string -) - -var ( - ipType = reflect.TypeFor[net.IP]() - ipNetType = reflect.TypeFor[net.IPNet]() - jsonRawMessageType = reflect.TypeFor[json.RawMessage]() - nullStringType = reflect.TypeFor[sql.NullString]() -) - -func (d *Dialect) DefaultVarcharLen() int { - return 0 -} - -func (d *Dialect) DefaultSchema() string { - return "public" -} - -func fieldSQLType(field *schema.Field) string { - if field.UserSQLType != "" { - return field.UserSQLType - } - - if v, ok := field.Tag.Option("composite"); ok { - return v - } - if field.Tag.HasOption("hstore") { - return sqltype.HSTORE - } - - if field.Tag.HasOption("array") { - switch field.IndirectType.Kind() { - case reflect.Slice, reflect.Array: - sqlType := sqlType(field.IndirectType.Elem()) - return sqlType + "[]" - } - } - - if field.DiscoveredSQLType == sqltype.Blob { - return pgTypeBytea - } - - return sqlType(field.IndirectType) -} - -func sqlType(typ reflect.Type) string { - switch typ { - case nullStringType: // typ.Kind() == reflect.Struct, test for exact match - return sqltype.VarChar - case ipType: - return pgTypeInet - case ipNetType: - return pgTypeCidr - case jsonRawMessageType: - return sqltype.JSONB - } - - sqlType := schema.DiscoverSQLType(typ) - switch sqlType { - case sqltype.Timestamp: - sqlType = pgTypeTimestampTz - } - - switch typ.Kind() { - case reflect.Map, reflect.Struct: // except typ == nullStringType, see above - if sqlType == sqltype.VarChar { - return sqltype.JSONB - } - return sqlType - case reflect.Array, reflect.Slice: - if typ.Elem().Kind() == reflect.Uint8 { - return pgTypeBytea - } - return sqltype.JSONB - } - - return sqlType -} - -var ( - char = newAliases(pgTypeChar, pgTypeCharacter) - varchar = newAliases(pgTypeVarchar, pgTypeCharacterVarying) - timestampTz = newAliases(sqltype.Timestamp, pgTypeTimestampTz, pgTypeTimestampWithTz) -) - -func (d *Dialect) CompareType(col1, col2 sqlschema.Column) bool { - typ1, typ2 := strings.ToUpper(col1.GetSQLType()), strings.ToUpper(col2.GetSQLType()) - - if typ1 == typ2 { - return checkVarcharLen(col1, col2, d.DefaultVarcharLen()) - } - - switch { - case char.IsAlias(typ1) && char.IsAlias(typ2): - return checkVarcharLen(col1, col2, d.DefaultVarcharLen()) - case varchar.IsAlias(typ1) && varchar.IsAlias(typ2): - return checkVarcharLen(col1, col2, d.DefaultVarcharLen()) - case timestampTz.IsAlias(typ1) && timestampTz.IsAlias(typ2): - return true - } - return false -} - -// checkVarcharLen returns true if columns have the same VarcharLen, or, -// if one specifies no VarcharLen and the other one has the default lenght for pgdialect. -// We assume that the types are otherwise equivalent and that any non-character column -// would have VarcharLen == 0; -func checkVarcharLen(col1, col2 sqlschema.Column, defaultLen int) bool { - vl1, vl2 := col1.GetVarcharLen(), col2.GetVarcharLen() - - if vl1 == vl2 { - return true - } - - if (vl1 == 0 && vl2 == defaultLen) || (vl1 == defaultLen && vl2 == 0) { - return true - } - return false -} - -// typeAlias defines aliases for common data types. It is a lightweight string set implementation. -type typeAlias map[string]struct{} - -// IsAlias checks if typ1 and typ2 are aliases of the same data type. -func (t typeAlias) IsAlias(typ string) bool { - _, ok := t[typ] - return ok -} - -// newAliases creates a set of aliases. -func newAliases(aliases ...string) typeAlias { - types := make(typeAlias) - for _, a := range aliases { - types[a] = struct{}{} - } - return types -} diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/version.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/version.go deleted file mode 100644 index 4e0c5ef36..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/version.go +++ /dev/null @@ -1,6 +0,0 @@ -package pgdialect - -// Version is the current release version. -func Version() string { - return "1.2.9" -} diff --git a/vendor/github.com/uptrace/bun/dialect/sqlitedialect/LICENSE b/vendor/github.com/uptrace/bun/dialect/sqlitedialect/LICENSE deleted file mode 100644 index 7ec81810c..000000000 --- a/vendor/github.com/uptrace/bun/dialect/sqlitedialect/LICENSE +++ /dev/null @@ -1,24 +0,0 @@ -Copyright (c) 2021 Vladimir Mihailenco. 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. diff --git a/vendor/github.com/uptrace/bun/dialect/sqlitedialect/dialect.go b/vendor/github.com/uptrace/bun/dialect/sqlitedialect/dialect.go deleted file mode 100644 index 1280d0d69..000000000 --- a/vendor/github.com/uptrace/bun/dialect/sqlitedialect/dialect.go +++ /dev/null @@ -1,148 +0,0 @@ -package sqlitedialect - -import ( - "database/sql" - "encoding/hex" - "fmt" - - "github.com/uptrace/bun" - "github.com/uptrace/bun/dialect" - "github.com/uptrace/bun/dialect/feature" - "github.com/uptrace/bun/dialect/sqltype" - "github.com/uptrace/bun/schema" -) - -func init() { - if Version() != bun.Version() { - panic(fmt.Errorf("sqlitedialect and Bun must have the same version: v%s != v%s", - Version(), bun.Version())) - } -} - -type Dialect struct { - schema.BaseDialect - - tables *schema.Tables - features feature.Feature -} - -func New(opts ...DialectOption) *Dialect { - d := new(Dialect) - d.tables = schema.NewTables(d) - d.features = feature.CTE | - feature.WithValues | - feature.Returning | - feature.InsertReturning | - feature.InsertTableAlias | - feature.UpdateTableAlias | - feature.DeleteTableAlias | - feature.InsertOnConflict | - feature.TableNotExists | - feature.SelectExists | - feature.AutoIncrement | - feature.CompositeIn | - feature.DeleteReturning - - for _, opt := range opts { - opt(d) - } - - return d -} - -type DialectOption func(d *Dialect) - -func WithoutFeature(other feature.Feature) DialectOption { - return func(d *Dialect) { - d.features = d.features.Remove(other) - } -} - -func (d *Dialect) Init(*sql.DB) {} - -func (d *Dialect) Name() dialect.Name { - return dialect.SQLite -} - -func (d *Dialect) Features() feature.Feature { - return d.features -} - -func (d *Dialect) Tables() *schema.Tables { - return d.tables -} - -func (d *Dialect) OnTable(table *schema.Table) { - for _, field := range table.FieldMap { - d.onField(field) - } -} - -func (d *Dialect) onField(field *schema.Field) { - field.DiscoveredSQLType = fieldSQLType(field) -} - -func (d *Dialect) IdentQuote() byte { - return '"' -} - -func (d *Dialect) AppendBytes(b []byte, bs []byte) []byte { - if bs == nil { - return dialect.AppendNull(b) - } - - b = append(b, `X'`...) - - s := len(b) - b = append(b, make([]byte, hex.EncodedLen(len(bs)))...) - hex.Encode(b[s:], bs) - - b = append(b, '\'') - - return b -} - -func (d *Dialect) DefaultVarcharLen() int { - return 0 -} - -// AppendSequence adds AUTOINCREMENT keyword to the column definition. As per [documentation], -// AUTOINCREMENT is only valid for INTEGER PRIMARY KEY, and this method will be a noop for other columns. -// -// Because this is a valid construct: -// -// CREATE TABLE ("id" INTEGER PRIMARY KEY AUTOINCREMENT); -// -// and this is not: -// -// CREATE TABLE ("id" INTEGER AUTOINCREMENT, PRIMARY KEY ("id")); -// -// AppendSequence adds a primary key constraint as a *side-effect*. Callers should expect it to avoid building invalid SQL. -// SQLite also [does not support] AUTOINCREMENT column in composite primary keys. -// -// [documentation]: https://www.sqlite.org/autoinc.html -// [does not support]: https://stackoverflow.com/a/6793274/14726116 -func (d *Dialect) AppendSequence(b []byte, table *schema.Table, field *schema.Field) []byte { - if field.IsPK && len(table.PKs) == 1 && field.CreateTableSQLType == sqltype.Integer { - b = append(b, " PRIMARY KEY AUTOINCREMENT"...) - } - return b -} - -// DefaultSchemaName is the "schema-name" of the main database. -// The details might differ from other dialects, but for all means and purposes -// "main" is the default schema in an SQLite database. -func (d *Dialect) DefaultSchema() string { - return "main" -} - -func fieldSQLType(field *schema.Field) string { - switch field.DiscoveredSQLType { - case sqltype.SmallInt, sqltype.BigInt: - // INTEGER PRIMARY KEY is an alias for the ROWID. - // It is safe to convert all ints to INTEGER, because SQLite types don't have size. - return sqltype.Integer - default: - return field.DiscoveredSQLType - } -} diff --git a/vendor/github.com/uptrace/bun/dialect/sqlitedialect/version.go b/vendor/github.com/uptrace/bun/dialect/sqlitedialect/version.go deleted file mode 100644 index e42267b8a..000000000 --- a/vendor/github.com/uptrace/bun/dialect/sqlitedialect/version.go +++ /dev/null @@ -1,6 +0,0 @@ -package sqlitedialect - -// Version is the current release version. -func Version() string { - return "1.2.9" -} diff --git a/vendor/github.com/uptrace/bun/dialect/sqltype/sqltype.go b/vendor/github.com/uptrace/bun/dialect/sqltype/sqltype.go deleted file mode 100644 index 1031fd352..000000000 --- a/vendor/github.com/uptrace/bun/dialect/sqltype/sqltype.go +++ /dev/null @@ -1,16 +0,0 @@ -package sqltype - -const ( - Boolean = "BOOLEAN" - SmallInt = "SMALLINT" - Integer = "INTEGER" - BigInt = "BIGINT" - Real = "REAL" - DoublePrecision = "DOUBLE PRECISION" - VarChar = "VARCHAR" - Blob = "BLOB" - Timestamp = "TIMESTAMP" - JSON = "JSON" - JSONB = "JSONB" - HSTORE = "HSTORE" -) diff --git a/vendor/github.com/uptrace/bun/extra/bunjson/json.go b/vendor/github.com/uptrace/bun/extra/bunjson/json.go deleted file mode 100644 index eff9d3f0e..000000000 --- a/vendor/github.com/uptrace/bun/extra/bunjson/json.go +++ /dev/null @@ -1,26 +0,0 @@ -package bunjson - -import ( - "encoding/json" - "io" -) - -var _ Provider = (*StdProvider)(nil) - -type StdProvider struct{} - -func (StdProvider) Marshal(v interface{}) ([]byte, error) { - return json.Marshal(v) -} - -func (StdProvider) Unmarshal(data []byte, v interface{}) error { - return json.Unmarshal(data, v) -} - -func (StdProvider) NewEncoder(w io.Writer) Encoder { - return json.NewEncoder(w) -} - -func (StdProvider) NewDecoder(r io.Reader) Decoder { - return json.NewDecoder(r) -} diff --git a/vendor/github.com/uptrace/bun/extra/bunjson/provider.go b/vendor/github.com/uptrace/bun/extra/bunjson/provider.go deleted file mode 100644 index 7f810e122..000000000 --- a/vendor/github.com/uptrace/bun/extra/bunjson/provider.go +++ /dev/null @@ -1,43 +0,0 @@ -package bunjson - -import ( - "io" -) - -var provider Provider = StdProvider{} - -func SetProvider(p Provider) { - provider = p -} - -type Provider interface { - Marshal(v interface{}) ([]byte, error) - Unmarshal(data []byte, v interface{}) error - NewEncoder(w io.Writer) Encoder - NewDecoder(r io.Reader) Decoder -} - -type Decoder interface { - Decode(v interface{}) error - UseNumber() -} - -type Encoder interface { - Encode(v interface{}) error -} - -func Marshal(v interface{}) ([]byte, error) { - return provider.Marshal(v) -} - -func Unmarshal(data []byte, v interface{}) error { - return provider.Unmarshal(data, v) -} - -func NewEncoder(w io.Writer) Encoder { - return provider.NewEncoder(w) -} - -func NewDecoder(r io.Reader) Decoder { - return provider.NewDecoder(r) -} diff --git a/vendor/github.com/uptrace/bun/extra/bunotel/LICENSE b/vendor/github.com/uptrace/bun/extra/bunotel/LICENSE deleted file mode 100644 index 7ec81810c..000000000 --- a/vendor/github.com/uptrace/bun/extra/bunotel/LICENSE +++ /dev/null @@ -1,24 +0,0 @@ -Copyright (c) 2021 Vladimir Mihailenco. 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. diff --git a/vendor/github.com/uptrace/bun/extra/bunotel/README.md b/vendor/github.com/uptrace/bun/extra/bunotel/README.md deleted file mode 100644 index 1773ecf02..000000000 --- a/vendor/github.com/uptrace/bun/extra/bunotel/README.md +++ /dev/null @@ -1,3 +0,0 @@ -# OpenTelemetry instrumentation for Bun - -See [example](../../example/opentelemetry) for details. diff --git a/vendor/github.com/uptrace/bun/extra/bunotel/option.go b/vendor/github.com/uptrace/bun/extra/bunotel/option.go deleted file mode 100644 index 4c9c90a30..000000000 --- a/vendor/github.com/uptrace/bun/extra/bunotel/option.go +++ /dev/null @@ -1,54 +0,0 @@ -package bunotel - -import ( - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/metric" - semconv "go.opentelemetry.io/otel/semconv/v1.12.0" - "go.opentelemetry.io/otel/trace" -) - -type Option func(h *QueryHook) - -// WithAttributes configures attributes that are used to create a span. -func WithAttributes(attrs ...attribute.KeyValue) Option { - return func(h *QueryHook) { - h.attrs = append(h.attrs, attrs...) - } -} - -// WithDBName configures a db.name attribute. -func WithDBName(name string) Option { - return func(h *QueryHook) { - h.attrs = append(h.attrs, semconv.DBNameKey.String(name)) - } -} - -// WithFormattedQueries enables formatting of the query that is added -// as the statement attribute to the trace. -// This means that all placeholders and arguments will be filled first -// and the query will contain all information as sent to the database. -func WithFormattedQueries(format bool) Option { - return func(h *QueryHook) { - h.formatQueries = format - } -} - -// WithTracerProvider returns an Option to use the TracerProvider when -// creating a Tracer. -func WithTracerProvider(tp trace.TracerProvider) Option { - return func(h *QueryHook) { - if tp != nil { - h.tracer = tp.Tracer("github.com/uptrace/bun") - } - } -} - -// WithMeterProvider returns an Option to use the MeterProvider when -// creating a Meter. -func WithMeterProvider(mp metric.MeterProvider) Option { - return func(h *QueryHook) { - if mp != nil { - h.meter = mp.Meter("github.com/uptrace/bun") - } - } -} diff --git a/vendor/github.com/uptrace/bun/extra/bunotel/otel.go b/vendor/github.com/uptrace/bun/extra/bunotel/otel.go deleted file mode 100644 index 66b88e989..000000000 --- a/vendor/github.com/uptrace/bun/extra/bunotel/otel.go +++ /dev/null @@ -1,192 +0,0 @@ -package bunotel - -import ( - "context" - "database/sql" - "runtime" - "strings" - "time" - - "go.opentelemetry.io/otel" - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/codes" - "go.opentelemetry.io/otel/metric" - semconv "go.opentelemetry.io/otel/semconv/v1.20.0" - "go.opentelemetry.io/otel/trace" - - "github.com/uptrace/bun" - "github.com/uptrace/bun/dialect" - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" - "github.com/uptrace/opentelemetry-go-extra/otelsql" -) - -type QueryHook struct { - attrs []attribute.KeyValue - formatQueries bool - tracer trace.Tracer - meter metric.Meter - queryHistogram metric.Int64Histogram -} - -var _ bun.QueryHook = (*QueryHook)(nil) - -func NewQueryHook(opts ...Option) *QueryHook { - h := new(QueryHook) - for _, opt := range opts { - opt(h) - } - if h.tracer == nil { - h.tracer = otel.Tracer("github.com/uptrace/bun") - } - if h.meter == nil { - h.meter = otel.Meter("github.com/uptrace/bun") - } - h.queryHistogram, _ = h.meter.Int64Histogram( - "go.sql.query_timing", - metric.WithDescription("Timing of processed queries"), - metric.WithUnit("milliseconds"), - ) - return h -} - -func (h *QueryHook) Init(db *bun.DB) { - labels := make([]attribute.KeyValue, 0, len(h.attrs)+1) - labels = append(labels, h.attrs...) - if sys := dbSystem(db); sys.Valid() { - labels = append(labels, sys) - } - - otelsql.ReportDBStatsMetrics(db.DB, otelsql.WithAttributes(labels...)) -} - -func (h *QueryHook) BeforeQuery(ctx context.Context, event *bun.QueryEvent) context.Context { - ctx, _ = h.tracer.Start(ctx, "", trace.WithSpanKind(trace.SpanKindClient)) - return ctx -} - -func (h *QueryHook) AfterQuery(ctx context.Context, event *bun.QueryEvent) { - operation := event.Operation() - dbOperation := semconv.DBOperationKey.String(operation) - - labels := make([]attribute.KeyValue, 0, len(h.attrs)+2) - labels = append(labels, h.attrs...) - labels = append(labels, dbOperation) - if event.IQuery != nil { - if tableName := event.IQuery.GetTableName(); tableName != "" { - labels = append(labels, semconv.DBSQLTableKey.String(tableName)) - } - } - - dur := time.Since(event.StartTime) - h.queryHistogram.Record(ctx, dur.Milliseconds(), metric.WithAttributes(labels...)) - - span := trace.SpanFromContext(ctx) - if !span.IsRecording() { - return - } - - span.SetName(operation) - defer span.End() - - query := h.eventQuery(event) - fn, file, line := funcFileLine("github.com/uptrace/bun") - - attrs := make([]attribute.KeyValue, 0, 10) - attrs = append(attrs, h.attrs...) - attrs = append(attrs, - dbOperation, - semconv.DBStatementKey.String(query), - semconv.CodeFunctionKey.String(fn), - semconv.CodeFilepathKey.String(file), - semconv.CodeLineNumberKey.Int(line), - ) - - if sys := dbSystem(event.DB); sys.Valid() { - attrs = append(attrs, sys) - } - if event.Result != nil { - if n, _ := event.Result.RowsAffected(); n > 0 { - attrs = append(attrs, attribute.Int64("db.rows_affected", n)) - } - } - - switch event.Err { - case nil, sql.ErrNoRows, sql.ErrTxDone: - // ignore - default: - span.RecordError(event.Err) - span.SetStatus(codes.Error, event.Err.Error()) - } - - span.SetAttributes(attrs...) -} - -func funcFileLine(pkg string) (string, string, int) { - const depth = 16 - var pcs [depth]uintptr - n := runtime.Callers(3, pcs[:]) - ff := runtime.CallersFrames(pcs[:n]) - - var fn, file string - var line int - for { - f, ok := ff.Next() - if !ok { - break - } - fn, file, line = f.Function, f.File, f.Line - if !strings.Contains(fn, pkg) { - break - } - } - - if ind := strings.LastIndexByte(fn, '/'); ind != -1 { - fn = fn[ind+1:] - } - - return fn, file, line -} - -func (h *QueryHook) eventQuery(event *bun.QueryEvent) string { - const softQueryLimit = 8000 - const hardQueryLimit = 16000 - - var query string - - if h.formatQueries && len(event.Query) <= softQueryLimit { - query = event.Query - } else { - query = unformattedQuery(event) - } - - if len(query) > hardQueryLimit { - query = query[:hardQueryLimit] - } - - return query -} - -func unformattedQuery(event *bun.QueryEvent) string { - if event.IQuery != nil { - if b, err := event.IQuery.AppendQuery(schema.NewNopFormatter(), nil); err == nil { - return internal.String(b) - } - } - return string(event.QueryTemplate) -} - -func dbSystem(db *bun.DB) attribute.KeyValue { - switch db.Dialect().Name() { - case dialect.PG: - return semconv.DBSystemPostgreSQL - case dialect.MySQL: - return semconv.DBSystemMySQL - case dialect.SQLite: - return semconv.DBSystemSqlite - case dialect.MSSQL: - return semconv.DBSystemMSSQL - default: - return attribute.KeyValue{} - } -} diff --git a/vendor/github.com/uptrace/bun/hook.go b/vendor/github.com/uptrace/bun/hook.go deleted file mode 100644 index 016f06a1a..000000000 --- a/vendor/github.com/uptrace/bun/hook.go +++ /dev/null @@ -1,116 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "strings" - "sync/atomic" - "time" - "unicode" - - "github.com/uptrace/bun/schema" -) - -type QueryEvent struct { - DB *DB - - QueryAppender schema.QueryAppender // DEPRECATED: use IQuery instead - IQuery Query - Query string - QueryTemplate string - QueryArgs []interface{} - Model Model - - StartTime time.Time - Result sql.Result - Err error - - Stash map[interface{}]interface{} -} - -func (e *QueryEvent) Operation() string { - if e.IQuery != nil { - return e.IQuery.Operation() - } - return queryOperation(e.Query) -} - -func queryOperation(query string) string { - queryOp := strings.TrimLeftFunc(query, unicode.IsSpace) - - if idx := strings.IndexByte(queryOp, ' '); idx > 0 { - queryOp = queryOp[:idx] - } - if len(queryOp) > 16 { - queryOp = queryOp[:16] - } - return queryOp -} - -type QueryHook interface { - BeforeQuery(context.Context, *QueryEvent) context.Context - AfterQuery(context.Context, *QueryEvent) -} - -func (db *DB) beforeQuery( - ctx context.Context, - iquery Query, - queryTemplate string, - queryArgs []interface{}, - query string, - model Model, -) (context.Context, *QueryEvent) { - atomic.AddUint32(&db.stats.Queries, 1) - - if len(db.queryHooks) == 0 { - return ctx, nil - } - - event := &QueryEvent{ - DB: db, - - Model: model, - QueryAppender: iquery, - IQuery: iquery, - Query: query, - QueryTemplate: queryTemplate, - QueryArgs: queryArgs, - - StartTime: time.Now(), - } - - for _, hook := range db.queryHooks { - ctx = hook.BeforeQuery(ctx, event) - } - - return ctx, event -} - -func (db *DB) afterQuery( - ctx context.Context, - event *QueryEvent, - res sql.Result, - err error, -) { - switch err { - case nil, sql.ErrNoRows: - // nothing - default: - atomic.AddUint32(&db.stats.Errors, 1) - } - - if event == nil { - return - } - - event.Result = res - event.Err = err - - db.afterQueryFromIndex(ctx, event, len(db.queryHooks)-1) -} - -func (db *DB) afterQueryFromIndex(ctx context.Context, event *QueryEvent, hookIndex int) { - for ; hookIndex >= 0; hookIndex-- { - db.queryHooks[hookIndex].AfterQuery(ctx, event) - } -} diff --git a/vendor/github.com/uptrace/bun/internal/flag.go b/vendor/github.com/uptrace/bun/internal/flag.go deleted file mode 100644 index 22d2db291..000000000 --- a/vendor/github.com/uptrace/bun/internal/flag.go +++ /dev/null @@ -1,16 +0,0 @@ -package internal - -type Flag uint64 - -func (flag Flag) Has(other Flag) bool { - return flag&other != 0 -} - -func (flag Flag) Set(other Flag) Flag { - return flag | other -} - -func (flag Flag) Remove(other Flag) Flag { - flag &= ^other - return flag -} diff --git a/vendor/github.com/uptrace/bun/internal/hex.go b/vendor/github.com/uptrace/bun/internal/hex.go deleted file mode 100644 index 6fae2bb78..000000000 --- a/vendor/github.com/uptrace/bun/internal/hex.go +++ /dev/null @@ -1,43 +0,0 @@ -package internal - -import ( - fasthex "github.com/tmthrgd/go-hex" -) - -type HexEncoder struct { - b []byte - written bool -} - -func NewHexEncoder(b []byte) *HexEncoder { - return &HexEncoder{ - b: b, - } -} - -func (enc *HexEncoder) Bytes() []byte { - return enc.b -} - -func (enc *HexEncoder) Write(b []byte) (int, error) { - if !enc.written { - enc.b = append(enc.b, '\'') - enc.b = append(enc.b, `\x`...) - enc.written = true - } - - i := len(enc.b) - enc.b = append(enc.b, make([]byte, fasthex.EncodedLen(len(b)))...) - fasthex.Encode(enc.b[i:], b) - - return len(b), nil -} - -func (enc *HexEncoder) Close() error { - if enc.written { - enc.b = append(enc.b, '\'') - } else { - enc.b = append(enc.b, "NULL"...) - } - return nil -} diff --git a/vendor/github.com/uptrace/bun/internal/logger.go b/vendor/github.com/uptrace/bun/internal/logger.go deleted file mode 100644 index 9233dfcff..000000000 --- a/vendor/github.com/uptrace/bun/internal/logger.go +++ /dev/null @@ -1,54 +0,0 @@ -package internal - -import ( - "fmt" - "log" - "os" -) - -type Logging interface { - Printf(format string, v ...interface{}) -} - -var defaultLogger = log.New(os.Stderr, "", log.LstdFlags) - -var Logger Logging = &logger{ - log: defaultLogger, -} - -var Warn = &wrapper{ - prefix: "WARN: bun: ", - logger: Logger, -} - -var Deprecated = &wrapper{ - prefix: "DEPRECATED: bun: ", - logger: Logger, -} - -type logger struct { - log *log.Logger -} - -func (l *logger) Printf(format string, v ...interface{}) { - _ = l.log.Output(2, fmt.Sprintf(format, v...)) -} - -type wrapper struct { - prefix string - logger Logging -} - -func (w *wrapper) Printf(format string, v ...interface{}) { - w.logger.Printf(w.prefix+format, v...) -} - -func SetLogger(newLogger Logging) { - if newLogger == nil { - Logger = &logger{log: defaultLogger} - } else { - Logger = newLogger - } - Warn.logger = Logger - Deprecated.logger = Logger -} diff --git a/vendor/github.com/uptrace/bun/internal/map_key.go b/vendor/github.com/uptrace/bun/internal/map_key.go deleted file mode 100644 index d7e4de2b9..000000000 --- a/vendor/github.com/uptrace/bun/internal/map_key.go +++ /dev/null @@ -1,67 +0,0 @@ -package internal - -import "reflect" - -var ifaceType = reflect.TypeFor[interface{}]() - -type MapKey struct { - iface interface{} -} - -func NewMapKey(is []interface{}) MapKey { - return MapKey{ - iface: newMapKey(is), - } -} - -func newMapKey(is []interface{}) interface{} { - switch len(is) { - case 1: - ptr := new([1]interface{}) - copy((*ptr)[:], is) - return *ptr - case 2: - ptr := new([2]interface{}) - copy((*ptr)[:], is) - return *ptr - case 3: - ptr := new([3]interface{}) - copy((*ptr)[:], is) - return *ptr - case 4: - ptr := new([4]interface{}) - copy((*ptr)[:], is) - return *ptr - case 5: - ptr := new([5]interface{}) - copy((*ptr)[:], is) - return *ptr - case 6: - ptr := new([6]interface{}) - copy((*ptr)[:], is) - return *ptr - case 7: - ptr := new([7]interface{}) - copy((*ptr)[:], is) - return *ptr - case 8: - ptr := new([8]interface{}) - copy((*ptr)[:], is) - return *ptr - case 9: - ptr := new([9]interface{}) - copy((*ptr)[:], is) - return *ptr - case 10: - ptr := new([10]interface{}) - copy((*ptr)[:], is) - return *ptr - default: - } - - at := reflect.New(reflect.ArrayOf(len(is), ifaceType)).Elem() - for i, v := range is { - *(at.Index(i).Addr().Interface().(*interface{})) = v - } - return at.Interface() -} diff --git a/vendor/github.com/uptrace/bun/internal/ordered/map.go b/vendor/github.com/uptrace/bun/internal/ordered/map.go deleted file mode 100644 index d5e4f7d9d..000000000 --- a/vendor/github.com/uptrace/bun/internal/ordered/map.go +++ /dev/null @@ -1,125 +0,0 @@ -package ordered - -// Pair represents a key-value pair in the ordered map. -type Pair[K comparable, V any] struct { - Key K - Value V - - next, prev *Pair[K, V] // Pointers to the next and previous pairs in the linked list. -} - -// Map represents an ordered map. -type Map[K comparable, V any] struct { - root *Pair[K, V] // Sentinel node for the circular doubly linked list. - zero V // Zero value for the value type. - - pairs map[K]*Pair[K, V] // Map from keys to pairs. -} - -// NewMap creates a new ordered map with optional initial data. -func NewMap[K comparable, V any](initialData ...Pair[K, V]) *Map[K, V] { - m := &Map[K, V]{} - m.Clear() - for _, pair := range initialData { - m.Store(pair.Key, pair.Value) - } - return m -} - -// Clear removes all pairs from the map. -func (m *Map[K, V]) Clear() { - if m.root != nil { - m.root.next, m.root.prev = nil, nil // avoid memory leaks - } - for _, pair := range m.pairs { - pair.next, pair.prev = nil, nil // avoid memory leaks - } - m.root = &Pair[K, V]{} - m.root.next, m.root.prev = m.root, m.root - m.pairs = make(map[K]*Pair[K, V]) -} - -// Len returns the number of pairs in the map. -func (m *Map[K, V]) Len() int { - return len(m.pairs) -} - -// Load returns the value associated with the key, and a boolean indicating if the key was found. -func (m *Map[K, V]) Load(key K) (V, bool) { - if pair, present := m.pairs[key]; present { - return pair.Value, true - } - return m.zero, false -} - -// Value returns the value associated with the key, or the zero value if the key is not found. -func (m *Map[K, V]) Value(key K) V { - if pair, present := m.pairs[key]; present { - return pair.Value - } - return m.zero -} - -// Store adds or updates a key-value pair in the map. -func (m *Map[K, V]) Store(key K, value V) { - if pair, present := m.pairs[key]; present { - pair.Value = value - return - } - - pair := &Pair[K, V]{Key: key, Value: value} - pair.prev = m.root.prev - m.root.prev.next = pair - m.root.prev = pair - pair.next = m.root - m.pairs[key] = pair -} - -// Delete removes a key-value pair from the map. -func (m *Map[K, V]) Delete(key K) { - if pair, present := m.pairs[key]; present { - pair.prev.next = pair.next - pair.next.prev = pair.prev - pair.next, pair.prev = nil, nil // avoid memory leaks - delete(m.pairs, key) - } -} - -// Range calls the given function for each key-value pair in the map in order. -func (m *Map[K, V]) Range(yield func(key K, value V) bool) { - for pair := m.root.next; pair != m.root; pair = pair.next { - if !yield(pair.Key, pair.Value) { - break - } - } -} - -// Keys returns a slice of all keys in the map in order. -func (m *Map[K, V]) Keys() []K { - keys := make([]K, 0, len(m.pairs)) - m.Range(func(key K, _ V) bool { - keys = append(keys, key) - return true - }) - return keys -} - -// Values returns a slice of all values in the map in order. -func (m *Map[K, V]) Values() []V { - values := make([]V, 0, len(m.pairs)) - m.Range(func(_ K, value V) bool { - values = append(values, value) - return true - }) - return values -} - -// Pairs returns a slice of all key-value pairs in the map in order. -func (m *Map[K, V]) Pairs() []Pair[K, V] { - pairs := make([]Pair[K, V], 0, len(m.pairs)) - m.Range(func(key K, value V) bool { - pairs = append(pairs, Pair[K, V]{Key: key, Value: value}) - return true - }) - return pairs -} diff --git a/vendor/github.com/uptrace/bun/internal/parser/parser.go b/vendor/github.com/uptrace/bun/internal/parser/parser.go deleted file mode 100644 index 1f2704478..000000000 --- a/vendor/github.com/uptrace/bun/internal/parser/parser.go +++ /dev/null @@ -1,169 +0,0 @@ -package parser - -import ( - "bytes" - "fmt" - "io" - "strconv" - - "github.com/uptrace/bun/internal" -) - -type Parser struct { - b []byte - i int -} - -func New(b []byte) *Parser { - return &Parser{ - b: b, - } -} - -func NewString(s string) *Parser { - return New(internal.Bytes(s)) -} - -func (p *Parser) Reset(b []byte) { - p.b = b - p.i = 0 -} - -func (p *Parser) Valid() bool { - return p.i < len(p.b) -} - -func (p *Parser) Remaining() []byte { - return p.b[p.i:] -} - -func (p *Parser) ReadByte() (byte, error) { - if p.Valid() { - ch := p.b[p.i] - p.Advance() - return ch, nil - } - return 0, io.ErrUnexpectedEOF -} - -func (p *Parser) Read() byte { - if p.Valid() { - ch := p.b[p.i] - p.Advance() - return ch - } - return 0 -} - -func (p *Parser) Unread() { - if p.i > 0 { - p.i-- - } -} - -func (p *Parser) Peek() byte { - if p.Valid() { - return p.b[p.i] - } - return 0 -} - -func (p *Parser) Advance() { - p.i++ -} - -func (p *Parser) Skip(skip byte) error { - ch := p.Peek() - if ch == skip { - p.Advance() - return nil - } - return fmt.Errorf("got %q, wanted %q", ch, skip) -} - -func (p *Parser) SkipPrefix(skip []byte) error { - if !bytes.HasPrefix(p.b[p.i:], skip) { - return fmt.Errorf("got %q, wanted prefix %q", p.b, skip) - } - p.i += len(skip) - return nil -} - -func (p *Parser) CutPrefix(skip []byte) bool { - if !bytes.HasPrefix(p.b[p.i:], skip) { - return false - } - p.i += len(skip) - return true -} - -func (p *Parser) ReadSep(sep byte) ([]byte, bool) { - ind := bytes.IndexByte(p.b[p.i:], sep) - if ind == -1 { - b := p.b[p.i:] - p.i = len(p.b) - return b, false - } - - b := p.b[p.i : p.i+ind] - p.i += ind + 1 - return b, true -} - -func (p *Parser) ReadIdentifier() (string, bool) { - if p.i < len(p.b) && p.b[p.i] == '(' { - s := p.i + 1 - if ind := bytes.IndexByte(p.b[s:], ')'); ind != -1 { - b := p.b[s : s+ind] - p.i = s + ind + 1 - return internal.String(b), false - } - } - - ind := len(p.b) - p.i - var alpha bool - for i, c := range p.b[p.i:] { - if isNum(c) { - continue - } - if isAlpha(c) || (i > 0 && alpha && c == '_') { - alpha = true - continue - } - ind = i - break - } - if ind == 0 { - return "", false - } - b := p.b[p.i : p.i+ind] - p.i += ind - return internal.String(b), !alpha -} - -func (p *Parser) ReadNumber() int { - ind := len(p.b) - p.i - for i, c := range p.b[p.i:] { - if !isNum(c) { - ind = i - break - } - } - if ind == 0 { - return 0 - } - n, err := strconv.Atoi(string(p.b[p.i : p.i+ind])) - if err != nil { - panic(err) - } - p.i += ind - return n -} - -func isNum(c byte) bool { - return c >= '0' && c <= '9' -} - -func isAlpha(c byte) bool { - return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') -} diff --git a/vendor/github.com/uptrace/bun/internal/safe.go b/vendor/github.com/uptrace/bun/internal/safe.go deleted file mode 100644 index 862ff0eb3..000000000 --- a/vendor/github.com/uptrace/bun/internal/safe.go +++ /dev/null @@ -1,11 +0,0 @@ -// +build appengine - -package internal - -func String(b []byte) string { - return string(b) -} - -func Bytes(s string) []byte { - return []byte(s) -} diff --git a/vendor/github.com/uptrace/bun/internal/tagparser/parser.go b/vendor/github.com/uptrace/bun/internal/tagparser/parser.go deleted file mode 100644 index a3905853d..000000000 --- a/vendor/github.com/uptrace/bun/internal/tagparser/parser.go +++ /dev/null @@ -1,184 +0,0 @@ -package tagparser - -import ( - "strings" -) - -type Tag struct { - Name string - Options map[string][]string -} - -func (t Tag) IsZero() bool { - return t.Name == "" && t.Options == nil -} - -func (t Tag) HasOption(name string) bool { - _, ok := t.Options[name] - return ok -} - -func (t Tag) Option(name string) (string, bool) { - if vs, ok := t.Options[name]; ok { - return vs[len(vs)-1], true - } - return "", false -} - -func Parse(s string) Tag { - if s == "" { - return Tag{} - } - p := parser{ - s: s, - } - p.parse() - return p.tag -} - -type parser struct { - s string - i int - - tag Tag - seenName bool // for empty names -} - -func (p *parser) setName(name string) { - if p.seenName { - p.addOption(name, "") - } else { - p.seenName = true - p.tag.Name = name - } -} - -func (p *parser) addOption(key, value string) { - p.seenName = true - if key == "" { - return - } - if p.tag.Options == nil { - p.tag.Options = make(map[string][]string) - } - if vs, ok := p.tag.Options[key]; ok { - p.tag.Options[key] = append(vs, value) - } else { - p.tag.Options[key] = []string{value} - } -} - -func (p *parser) parse() { - for p.valid() { - p.parseKeyValue() - if p.peek() == ',' { - p.i++ - } - } -} - -func (p *parser) parseKeyValue() { - start := p.i - - for p.valid() { - switch c := p.read(); c { - case ',': - key := p.s[start : p.i-1] - p.setName(key) - return - case ':': - key := p.s[start : p.i-1] - value := p.parseValue() - p.addOption(key, value) - return - case '"': - key := p.parseQuotedValue() - p.setName(key) - return - } - } - - key := p.s[start:p.i] - p.setName(key) -} - -func (p *parser) parseValue() string { - start := p.i - - for p.valid() { - switch c := p.read(); c { - case '"': - return p.parseQuotedValue() - case ',': - return p.s[start : p.i-1] - case '(': - p.skipPairs('(', ')') - } - } - - if p.i == start { - return "" - } - return p.s[start:p.i] -} - -func (p *parser) parseQuotedValue() string { - if i := strings.IndexByte(p.s[p.i:], '"'); i >= 0 && p.s[p.i+i-1] != '\\' { - s := p.s[p.i : p.i+i] - p.i += i + 1 - return s - } - - b := make([]byte, 0, 16) - - for p.valid() { - switch c := p.read(); c { - case '\\': - b = append(b, p.read()) - case '"': - return string(b) - default: - b = append(b, c) - } - } - - return "" -} - -func (p *parser) skipPairs(start, end byte) { - var lvl int - for p.valid() { - switch c := p.read(); c { - case '"': - _ = p.parseQuotedValue() - case start: - lvl++ - case end: - if lvl == 0 { - return - } - lvl-- - } - } -} - -func (p *parser) valid() bool { - return p.i < len(p.s) -} - -func (p *parser) read() byte { - if !p.valid() { - return 0 - } - c := p.s[p.i] - p.i++ - return c -} - -func (p *parser) peek() byte { - if !p.valid() { - return 0 - } - c := p.s[p.i] - return c -} diff --git a/vendor/github.com/uptrace/bun/internal/time.go b/vendor/github.com/uptrace/bun/internal/time.go deleted file mode 100644 index 2cb69b46a..000000000 --- a/vendor/github.com/uptrace/bun/internal/time.go +++ /dev/null @@ -1,61 +0,0 @@ -package internal - -import ( - "fmt" - "time" -) - -const ( - dateFormat = "2006-01-02" - timeFormat = "15:04:05.999999999" - timetzFormat1 = "15:04:05.999999999-07:00:00" - timetzFormat2 = "15:04:05.999999999-07:00" - timetzFormat3 = "15:04:05.999999999-07" - timestampFormat = "2006-01-02 15:04:05.999999999" - timestamptzFormat1 = "2006-01-02 15:04:05.999999999-07:00:00" - timestamptzFormat2 = "2006-01-02 15:04:05.999999999-07:00" - timestamptzFormat3 = "2006-01-02 15:04:05.999999999-07" -) - -func ParseTime(s string) (time.Time, error) { - l := len(s) - - if l >= len("2006-01-02 15:04:05") { - switch s[10] { - case ' ': - if c := s[l-6]; c == '+' || c == '-' { - return time.Parse(timestamptzFormat2, s) - } - if c := s[l-3]; c == '+' || c == '-' { - return time.Parse(timestamptzFormat3, s) - } - if c := s[l-9]; c == '+' || c == '-' { - return time.Parse(timestamptzFormat1, s) - } - return time.ParseInLocation(timestampFormat, s, time.UTC) - case 'T': - return time.Parse(time.RFC3339Nano, s) - } - } - - if l >= len("15:04:05-07") { - if c := s[l-6]; c == '+' || c == '-' { - return time.Parse(timetzFormat2, s) - } - if c := s[l-3]; c == '+' || c == '-' { - return time.Parse(timetzFormat3, s) - } - if c := s[l-9]; c == '+' || c == '-' { - return time.Parse(timetzFormat1, s) - } - } - - if l < len("15:04:05") { - return time.Time{}, fmt.Errorf("bun: can't parse time=%q", s) - } - - if s[2] == ':' { - return time.ParseInLocation(timeFormat, s, time.UTC) - } - return time.ParseInLocation(dateFormat, s, time.UTC) -} diff --git a/vendor/github.com/uptrace/bun/internal/underscore.go b/vendor/github.com/uptrace/bun/internal/underscore.go deleted file mode 100644 index 9de52fb7b..000000000 --- a/vendor/github.com/uptrace/bun/internal/underscore.go +++ /dev/null @@ -1,67 +0,0 @@ -package internal - -func IsUpper(c byte) bool { - return c >= 'A' && c <= 'Z' -} - -func IsLower(c byte) bool { - return c >= 'a' && c <= 'z' -} - -func ToUpper(c byte) byte { - return c - 32 -} - -func ToLower(c byte) byte { - return c + 32 -} - -// Underscore converts "CamelCasedString" to "camel_cased_string". -func Underscore(s string) string { - r := make([]byte, 0, len(s)+5) - for i := 0; i < len(s); i++ { - c := s[i] - if IsUpper(c) { - if i > 0 && i+1 < len(s) && (IsLower(s[i-1]) || IsLower(s[i+1])) { - r = append(r, '_', ToLower(c)) - } else { - r = append(r, ToLower(c)) - } - } else { - r = append(r, c) - } - } - return string(r) -} - -func CamelCased(s string) string { - r := make([]byte, 0, len(s)) - upperNext := true - for i := 0; i < len(s); i++ { - c := s[i] - if c == '_' { - upperNext = true - continue - } - if upperNext { - if IsLower(c) { - c = ToUpper(c) - } - upperNext = false - } - r = append(r, c) - } - return string(r) -} - -func ToExported(s string) string { - if len(s) == 0 { - return s - } - if c := s[0]; IsLower(c) { - b := []byte(s) - b[0] = ToUpper(c) - return string(b) - } - return s -} diff --git a/vendor/github.com/uptrace/bun/internal/unsafe.go b/vendor/github.com/uptrace/bun/internal/unsafe.go deleted file mode 100644 index 1a0331297..000000000 --- a/vendor/github.com/uptrace/bun/internal/unsafe.go +++ /dev/null @@ -1,22 +0,0 @@ -//go:build !appengine -// +build !appengine - -package internal - -import "unsafe" - -// String converts byte slice to string. -func String(b []byte) string { - if len(b) == 0 { - return "" - } - return unsafe.String(&b[0], len(b)) -} - -// Bytes converts string to byte slice. -func Bytes(s string) []byte { - if s == "" { - return []byte{} - } - return unsafe.Slice(unsafe.StringData(s), len(s)) -} diff --git a/vendor/github.com/uptrace/bun/internal/util.go b/vendor/github.com/uptrace/bun/internal/util.go deleted file mode 100644 index ba1341e61..000000000 --- a/vendor/github.com/uptrace/bun/internal/util.go +++ /dev/null @@ -1,87 +0,0 @@ -package internal - -import ( - "reflect" -) - -func MakeSliceNextElemFunc(v reflect.Value) func() reflect.Value { - if v.Kind() == reflect.Array { - var pos int - return func() reflect.Value { - v := v.Index(pos) - pos++ - return v - } - } - - 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 := reflect.New(elemType) - v.Set(reflect.Append(v, elem)) - return 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) - } -} - -func Unwrap(err error) error { - u, ok := err.(interface { - Unwrap() error - }) - if !ok { - return nil - } - return u.Unwrap() -} - -func FieldByIndexAlloc(v reflect.Value, index []int) reflect.Value { - if len(index) == 1 { - return v.Field(index[0]) - } - - for i, idx := range index { - if i > 0 { - v = indirectNil(v) - } - v = v.Field(idx) - } - return v -} - -func indirectNil(v reflect.Value) reflect.Value { - if v.Kind() == reflect.Ptr { - if v.IsNil() { - v.Set(reflect.New(v.Type().Elem())) - } - v = v.Elem() - } - return v -} - -// MakeQueryBytes returns zero-length byte slice with capacity of 4096. -func MakeQueryBytes() []byte { - // TODO: make this configurable? - return make([]byte, 0, 4096) -} diff --git a/vendor/github.com/uptrace/bun/migrate/auto.go b/vendor/github.com/uptrace/bun/migrate/auto.go deleted file mode 100644 index 16804cd99..000000000 --- a/vendor/github.com/uptrace/bun/migrate/auto.go +++ /dev/null @@ -1,450 +0,0 @@ -package migrate - -import ( - "bytes" - "context" - "errors" - "fmt" - "io" - "os" - "path/filepath" - - "github.com/uptrace/bun" - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/migrate/sqlschema" - "github.com/uptrace/bun/schema" -) - -type AutoMigratorOption func(m *AutoMigrator) - -// WithModel adds a bun.Model to the scope of migrations. -func WithModel(models ...interface{}) AutoMigratorOption { - return func(m *AutoMigrator) { - m.includeModels = append(m.includeModels, models...) - } -} - -// WithExcludeTable tells the AutoMigrator to ignore a table in the database. -// This prevents AutoMigrator from dropping tables which may exist in the schema -// but which are not used by the application. -// -// Do not exclude tables included via WithModel, as BunModelInspector ignores this setting. -func WithExcludeTable(tables ...string) AutoMigratorOption { - return func(m *AutoMigrator) { - m.excludeTables = append(m.excludeTables, tables...) - } -} - -// WithSchemaName changes the default database schema to migrate objects in. -func WithSchemaName(schemaName string) AutoMigratorOption { - return func(m *AutoMigrator) { - m.schemaName = schemaName - } -} - -// WithTableNameAuto overrides default migrations table name. -func WithTableNameAuto(table string) AutoMigratorOption { - return func(m *AutoMigrator) { - m.table = table - m.migratorOpts = append(m.migratorOpts, WithTableName(table)) - } -} - -// WithLocksTableNameAuto overrides default migration locks table name. -func WithLocksTableNameAuto(table string) AutoMigratorOption { - return func(m *AutoMigrator) { - m.locksTable = table - m.migratorOpts = append(m.migratorOpts, WithLocksTableName(table)) - } -} - -// WithMarkAppliedOnSuccessAuto sets the migrator to only mark migrations as applied/unapplied -// when their up/down is successful. -func WithMarkAppliedOnSuccessAuto(enabled bool) AutoMigratorOption { - return func(m *AutoMigrator) { - m.migratorOpts = append(m.migratorOpts, WithMarkAppliedOnSuccess(enabled)) - } -} - -// WithMigrationsDirectoryAuto overrides the default directory for migration files. -func WithMigrationsDirectoryAuto(directory string) AutoMigratorOption { - return func(m *AutoMigrator) { - m.migrationsOpts = append(m.migrationsOpts, WithMigrationsDirectory(directory)) - } -} - -// AutoMigrator performs automated schema migrations. -// -// It is designed to be a drop-in replacement for some Migrator functionality and supports all existing -// configuration options. -// Similarly to Migrator, it has methods to create SQL migrations, write them to a file, and apply them. -// Unlike Migrator, it detects the differences between the state defined by bun models and the current -// database schema automatically. -// -// Usage: -// 1. Generate migrations and apply them au once with AutoMigrator.Migrate(). -// 2. Create up- and down-SQL migration files and apply migrations using Migrator.Migrate(). -// -// While both methods produce complete, reversible migrations (with entries in the database -// and SQL migration files), prefer creating migrations and applying them separately for -// any non-trivial cases to ensure AutoMigrator detects expected changes correctly. -// -// Limitations: -// - AutoMigrator only supports a subset of the possible ALTER TABLE modifications. -// - Some changes are not automatically reversible. For example, you would need to manually -// add a CREATE TABLE query to the .down migration file to revert a DROP TABLE migration. -// - Does not validate most dialect-specific constraints. For example, when changing column -// data type, make sure the data con be auto-casted to the new type. -// - Due to how the schema-state diff is calculated, it is not possible to rename a table and -// modify any of its columns' _data type_ in a single run. This will cause the AutoMigrator -// to drop and re-create the table under a different name; it is better to apply this change in 2 steps. -// Renaming a table and renaming its columns at the same time is possible. -// - Renaming table/column to an existing name, i.e. like this [A->B] [B->C], is not possible due to how -// AutoMigrator distinguishes "rename" and "unchanged" columns. -// -// Dialect must implement both sqlschema.Inspector and sqlschema.Migrator to be used with AutoMigrator. -type AutoMigrator struct { - db *bun.DB - - // dbInspector creates the current state for the target database. - dbInspector sqlschema.Inspector - - // modelInspector creates the desired state based on the model definitions. - modelInspector sqlschema.Inspector - - // dbMigrator executes ALTER TABLE queries. - dbMigrator sqlschema.Migrator - - table string // Migrations table (excluded from database inspection) - locksTable string // Migration locks table (excluded from database inspection) - - // schemaName is the database schema considered for migration. - schemaName string - - // includeModels define the migration scope. - includeModels []interface{} - - // excludeTables are excluded from database inspection. - excludeTables []string - - // diffOpts are passed to detector constructor. - diffOpts []diffOption - - // migratorOpts are passed to Migrator constructor. - migratorOpts []MigratorOption - - // migrationsOpts are passed to Migrations constructor. - migrationsOpts []MigrationsOption -} - -func NewAutoMigrator(db *bun.DB, opts ...AutoMigratorOption) (*AutoMigrator, error) { - am := &AutoMigrator{ - db: db, - table: defaultTable, - locksTable: defaultLocksTable, - schemaName: db.Dialect().DefaultSchema(), - } - - for _, opt := range opts { - opt(am) - } - am.excludeTables = append(am.excludeTables, am.table, am.locksTable) - - dbInspector, err := sqlschema.NewInspector(db, sqlschema.WithSchemaName(am.schemaName), sqlschema.WithExcludeTables(am.excludeTables...)) - if err != nil { - return nil, err - } - am.dbInspector = dbInspector - am.diffOpts = append(am.diffOpts, withCompareTypeFunc(db.Dialect().(sqlschema.InspectorDialect).CompareType)) - - dbMigrator, err := sqlschema.NewMigrator(db, am.schemaName) - if err != nil { - return nil, err - } - am.dbMigrator = dbMigrator - - tables := schema.NewTables(db.Dialect()) - tables.Register(am.includeModels...) - am.modelInspector = sqlschema.NewBunModelInspector(tables, sqlschema.WithSchemaName(am.schemaName)) - - return am, nil -} - -func (am *AutoMigrator) plan(ctx context.Context) (*changeset, error) { - var err error - - got, err := am.dbInspector.Inspect(ctx) - if err != nil { - return nil, err - } - - want, err := am.modelInspector.Inspect(ctx) - if err != nil { - return nil, err - } - - changes := diff(got, want, am.diffOpts...) - if err := changes.ResolveDependencies(); err != nil { - return nil, fmt.Errorf("plan migrations: %w", err) - } - return changes, nil -} - -// Migrate writes required changes to a new migration file and runs the migration. -// This will create and entry in the migrations table, making it possible to revert -// the changes with Migrator.Rollback(). MigrationOptions are passed on to Migrator.Migrate(). -func (am *AutoMigrator) Migrate(ctx context.Context, opts ...MigrationOption) (*MigrationGroup, error) { - migrations, _, err := am.createSQLMigrations(ctx, false) - if err != nil { - if err == errNothingToMigrate { - return new(MigrationGroup), nil - } - return nil, fmt.Errorf("auto migrate: %w", err) - } - - migrator := NewMigrator(am.db, migrations, am.migratorOpts...) - if err := migrator.Init(ctx); err != nil { - return nil, fmt.Errorf("auto migrate: %w", err) - } - - group, err := migrator.Migrate(ctx, opts...) - if err != nil { - return nil, fmt.Errorf("auto migrate: %w", err) - } - return group, nil -} - -// CreateSQLMigration writes required changes to a new migration file. -// Use migrate.Migrator to apply the generated migrations. -func (am *AutoMigrator) CreateSQLMigrations(ctx context.Context) ([]*MigrationFile, error) { - _, files, err := am.createSQLMigrations(ctx, false) - if err == errNothingToMigrate { - return files, nil - } - return files, err -} - -// CreateTxSQLMigration writes required changes to a new migration file making sure they will be executed -// in a transaction when applied. Use migrate.Migrator to apply the generated migrations. -func (am *AutoMigrator) CreateTxSQLMigrations(ctx context.Context) ([]*MigrationFile, error) { - _, files, err := am.createSQLMigrations(ctx, true) - if err == errNothingToMigrate { - return files, nil - } - return files, err -} - -// errNothingToMigrate is a sentinel error which means the database is already in a desired state. -// Should not be returned to the user -- return a nil-error instead. -var errNothingToMigrate = errors.New("nothing to migrate") - -func (am *AutoMigrator) createSQLMigrations(ctx context.Context, transactional bool) (*Migrations, []*MigrationFile, error) { - changes, err := am.plan(ctx) - if err != nil { - return nil, nil, fmt.Errorf("create sql migrations: %w", err) - } - - if changes.Len() == 0 { - return nil, nil, errNothingToMigrate - } - - name, _ := genMigrationName(am.schemaName + "_auto") - migrations := NewMigrations(am.migrationsOpts...) - migrations.Add(Migration{ - Name: name, - Up: changes.Up(am.dbMigrator), - Down: changes.Down(am.dbMigrator), - Comment: "Changes detected by bun.AutoMigrator", - }) - - // Append .tx.up.sql or .up.sql to migration name, dependin if it should be transactional. - fname := func(direction string) string { - return name + map[bool]string{true: ".tx.", false: "."}[transactional] + direction + ".sql" - } - - up, err := am.createSQL(ctx, migrations, fname("up"), changes, transactional) - if err != nil { - return nil, nil, fmt.Errorf("create sql migration up: %w", err) - } - - down, err := am.createSQL(ctx, migrations, fname("down"), changes.GetReverse(), transactional) - if err != nil { - return nil, nil, fmt.Errorf("create sql migration down: %w", err) - } - return migrations, []*MigrationFile{up, down}, nil -} - -func (am *AutoMigrator) createSQL(_ context.Context, migrations *Migrations, fname string, changes *changeset, transactional bool) (*MigrationFile, error) { - var buf bytes.Buffer - - if transactional { - buf.WriteString("SET statement_timeout = 0;") - } - - if err := changes.WriteTo(&buf, am.dbMigrator); err != nil { - return nil, err - } - content := buf.Bytes() - - fpath := filepath.Join(migrations.getDirectory(), fname) - if err := os.WriteFile(fpath, content, 0o644); err != nil { - return nil, err - } - - mf := &MigrationFile{ - Name: fname, - Path: fpath, - Content: string(content), - } - return mf, nil -} - -func (c *changeset) Len() int { - return len(c.operations) -} - -// Func creates a MigrationFunc that applies all operations all the changeset. -func (c *changeset) Func(m sqlschema.Migrator) MigrationFunc { - return func(ctx context.Context, db *bun.DB) error { - return c.apply(ctx, db, m) - } -} - -// GetReverse returns a new changeset with each operation in it "reversed" and in reverse order. -func (c *changeset) GetReverse() *changeset { - var reverse changeset - for i := len(c.operations) - 1; i >= 0; i-- { - reverse.Add(c.operations[i].GetReverse()) - } - return &reverse -} - -// Up is syntactic sugar. -func (c *changeset) Up(m sqlschema.Migrator) MigrationFunc { - return c.Func(m) -} - -// Down is syntactic sugar. -func (c *changeset) Down(m sqlschema.Migrator) MigrationFunc { - return c.GetReverse().Func(m) -} - -// apply generates SQL for each operation and executes it. -func (c *changeset) apply(ctx context.Context, db *bun.DB, m sqlschema.Migrator) error { - if len(c.operations) == 0 { - return nil - } - - for _, op := range c.operations { - if _, isComment := op.(*comment); isComment { - continue - } - - b := internal.MakeQueryBytes() - b, err := m.AppendSQL(b, op) - if err != nil { - return fmt.Errorf("apply changes: %w", err) - } - - query := internal.String(b) - if _, err = db.ExecContext(ctx, query); err != nil { - return fmt.Errorf("apply changes: %w", err) - } - } - return nil -} - -func (c *changeset) WriteTo(w io.Writer, m sqlschema.Migrator) error { - var err error - - b := internal.MakeQueryBytes() - for _, op := range c.operations { - if c, isComment := op.(*comment); isComment { - b = append(b, "/*\n"...) - b = append(b, *c...) - b = append(b, "\n*/"...) - continue - } - - b, err = m.AppendSQL(b, op) - if err != nil { - return fmt.Errorf("write changeset: %w", err) - } - b = append(b, ";\n"...) - } - if _, err := w.Write(b); err != nil { - return fmt.Errorf("write changeset: %w", err) - } - return nil -} - -func (c *changeset) ResolveDependencies() error { - if len(c.operations) <= 1 { - return nil - } - - const ( - unvisited = iota - current - visited - ) - - status := make(map[Operation]int, len(c.operations)) - for _, op := range c.operations { - status[op] = unvisited - } - - var resolved []Operation - var nextOp Operation - var visit func(op Operation) error - - next := func() bool { - for op, s := range status { - if s == unvisited { - nextOp = op - return true - } - } - return false - } - - // visit iterates over c.operations until it finds all operations that depend on the current one - // or runs into cirtular dependency, in which case it will return an error. - visit = func(op Operation) error { - switch status[op] { - case visited: - return nil - case current: - // TODO: add details (circle) to the error message - return errors.New("detected circular dependency") - } - - status[op] = current - - for _, another := range c.operations { - if dop, hasDeps := another.(interface { - DependsOn(Operation) bool - }); another == op || !hasDeps || !dop.DependsOn(op) { - continue - } - if err := visit(another); err != nil { - return err - } - } - - status[op] = visited - - // Any dependent nodes would've already been added to the list by now, so we prepend. - resolved = append([]Operation{op}, resolved...) - return nil - } - - for next() { - if err := visit(nextOp); err != nil { - return err - } - } - - c.operations = resolved - return nil -} diff --git a/vendor/github.com/uptrace/bun/migrate/diff.go b/vendor/github.com/uptrace/bun/migrate/diff.go deleted file mode 100644 index e05d54b7d..000000000 --- a/vendor/github.com/uptrace/bun/migrate/diff.go +++ /dev/null @@ -1,416 +0,0 @@ -package migrate - -import ( - "github.com/uptrace/bun/migrate/sqlschema" -) - -// changeset is a set of changes to the database schema definition. -type changeset struct { - operations []Operation -} - -// Add new operations to the changeset. -func (c *changeset) Add(op ...Operation) { - c.operations = append(c.operations, op...) -} - -// diff calculates the diff between the current database schema and the target state. -// The changeset is not sorted -- the caller should resolve dependencies before applying the changes. -func diff(got, want sqlschema.Database, opts ...diffOption) *changeset { - d := newDetector(got, want, opts...) - return d.detectChanges() -} - -func (d *detector) detectChanges() *changeset { - currentTables := d.current.GetTables() - targetTables := d.target.GetTables() - -RenameCreate: - for _, wantPair := range targetTables.Pairs() { - wantName, wantTable := wantPair.Key, wantPair.Value - // A table with this name exists in the database. We assume that schema objects won't - // be renamed to an already existing name, nor do we support such cases. - // Simply check if the table definition has changed. - if haveTable, ok := currentTables.Load(wantName); ok { - d.detectColumnChanges(haveTable, wantTable, true) - d.detectConstraintChanges(haveTable, wantTable) - continue - } - - // Find all renamed tables. We assume that renamed tables have the same signature. - for _, havePair := range currentTables.Pairs() { - haveName, haveTable := havePair.Key, havePair.Value - if _, exists := targetTables.Load(haveName); !exists && d.canRename(haveTable, wantTable) { - d.changes.Add(&RenameTableOp{ - TableName: haveTable.GetName(), - NewName: wantName, - }) - d.refMap.RenameTable(haveTable.GetName(), wantName) - - // Find renamed columns, if any, and check if constraints (PK, UNIQUE) have been updated. - // We need not check wantTable any further. - d.detectColumnChanges(haveTable, wantTable, false) - d.detectConstraintChanges(haveTable, wantTable) - currentTables.Delete(haveName) - continue RenameCreate - } - } - - // If wantTable does not exist in the database and was not renamed - // then we need to create this table in the database. - additional := wantTable.(*sqlschema.BunTable) - d.changes.Add(&CreateTableOp{ - TableName: wantTable.GetName(), - Model: additional.Model, - }) - } - - // Drop any remaining "current" tables which do not have a model. - for _, tPair := range currentTables.Pairs() { - name, table := tPair.Key, tPair.Value - if _, keep := targetTables.Load(name); !keep { - d.changes.Add(&DropTableOp{ - TableName: table.GetName(), - }) - } - } - - targetFKs := d.target.GetForeignKeys() - currentFKs := d.refMap.Deref() - - for fk := range targetFKs { - if _, ok := currentFKs[fk]; !ok { - d.changes.Add(&AddForeignKeyOp{ - ForeignKey: fk, - ConstraintName: "", // leave empty to let each dialect apply their convention - }) - } - } - - for fk, name := range currentFKs { - if _, ok := targetFKs[fk]; !ok { - d.changes.Add(&DropForeignKeyOp{ - ConstraintName: name, - ForeignKey: fk, - }) - } - } - - return &d.changes -} - -// detechColumnChanges finds renamed columns and, if checkType == true, columns with changed type. -func (d *detector) detectColumnChanges(current, target sqlschema.Table, checkType bool) { - currentColumns := current.GetColumns() - targetColumns := target.GetColumns() - -ChangeRename: - for _, tPair := range targetColumns.Pairs() { - tName, tCol := tPair.Key, tPair.Value - - // This column exists in the database, so it hasn't been renamed, dropped, or added. - // Still, we should not delete(columns, thisColumn), because later we will need to - // check that we do not try to rename a column to an already a name that already exists. - if cCol, ok := currentColumns.Load(tName); ok { - if checkType && !d.equalColumns(cCol, tCol) { - d.changes.Add(&ChangeColumnTypeOp{ - TableName: target.GetName(), - Column: tName, - From: cCol, - To: d.makeTargetColDef(cCol, tCol), - }) - } - continue - } - - // Column tName does not exist in the database -- it's been either renamed or added. - // Find renamed columns first. - for _, cPair := range currentColumns.Pairs() { - cName, cCol := cPair.Key, cPair.Value - // Cannot rename if a column with this name already exists or the types differ. - if _, exists := targetColumns.Load(cName); exists || !d.equalColumns(tCol, cCol) { - continue - } - d.changes.Add(&RenameColumnOp{ - TableName: target.GetName(), - OldName: cName, - NewName: tName, - }) - d.refMap.RenameColumn(target.GetName(), cName, tName) - currentColumns.Delete(cName) // no need to check this column again - - // Update primary key definition to avoid superficially recreating the constraint. - current.GetPrimaryKey().Columns.Replace(cName, tName) - - continue ChangeRename - } - - d.changes.Add(&AddColumnOp{ - TableName: target.GetName(), - ColumnName: tName, - Column: tCol, - }) - } - - // Drop columns which do not exist in the target schema and were not renamed. - for _, cPair := range currentColumns.Pairs() { - cName, cCol := cPair.Key, cPair.Value - if _, keep := targetColumns.Load(cName); !keep { - d.changes.Add(&DropColumnOp{ - TableName: target.GetName(), - ColumnName: cName, - Column: cCol, - }) - } - } -} - -func (d *detector) detectConstraintChanges(current, target sqlschema.Table) { -Add: - for _, want := range target.GetUniqueConstraints() { - for _, got := range current.GetUniqueConstraints() { - if got.Equals(want) { - continue Add - } - } - d.changes.Add(&AddUniqueConstraintOp{ - TableName: target.GetName(), - Unique: want, - }) - } - -Drop: - for _, got := range current.GetUniqueConstraints() { - for _, want := range target.GetUniqueConstraints() { - if got.Equals(want) { - continue Drop - } - } - - d.changes.Add(&DropUniqueConstraintOp{ - TableName: target.GetName(), - Unique: got, - }) - } - - targetPK := target.GetPrimaryKey() - currentPK := current.GetPrimaryKey() - - // Detect primary key changes - if targetPK == nil && currentPK == nil { - return - } - switch { - case targetPK == nil && currentPK != nil: - d.changes.Add(&DropPrimaryKeyOp{ - TableName: target.GetName(), - PrimaryKey: *currentPK, - }) - case currentPK == nil && targetPK != nil: - d.changes.Add(&AddPrimaryKeyOp{ - TableName: target.GetName(), - PrimaryKey: *targetPK, - }) - case targetPK.Columns != currentPK.Columns: - d.changes.Add(&ChangePrimaryKeyOp{ - TableName: target.GetName(), - Old: *currentPK, - New: *targetPK, - }) - } -} - -func newDetector(got, want sqlschema.Database, opts ...diffOption) *detector { - cfg := &detectorConfig{ - cmpType: func(c1, c2 sqlschema.Column) bool { - return c1.GetSQLType() == c2.GetSQLType() && c1.GetVarcharLen() == c2.GetVarcharLen() - }, - } - for _, opt := range opts { - opt(cfg) - } - - return &detector{ - current: got, - target: want, - refMap: newRefMap(got.GetForeignKeys()), - cmpType: cfg.cmpType, - } -} - -type diffOption func(*detectorConfig) - -func withCompareTypeFunc(f CompareTypeFunc) diffOption { - return func(cfg *detectorConfig) { - cfg.cmpType = f - } -} - -// detectorConfig controls how differences in the model states are resolved. -type detectorConfig struct { - cmpType CompareTypeFunc -} - -// detector may modify the passed database schemas, so it isn't safe to re-use them. -type detector struct { - // current state represents the existing database schema. - current sqlschema.Database - - // target state represents the database schema defined in bun models. - target sqlschema.Database - - changes changeset - refMap refMap - - // cmpType determines column type equivalence. - // Default is direct comparison with '==' operator, which is inaccurate - // due to the existence of dialect-specific type aliases. The caller - // should pass a concrete InspectorDialect.EquuivalentType for robust comparison. - cmpType CompareTypeFunc -} - -// canRename checks if t1 can be renamed to t2. -func (d detector) canRename(t1, t2 sqlschema.Table) bool { - return t1.GetSchema() == t2.GetSchema() && equalSignatures(t1, t2, d.equalColumns) -} - -func (d detector) equalColumns(col1, col2 sqlschema.Column) bool { - return d.cmpType(col1, col2) && - col1.GetDefaultValue() == col2.GetDefaultValue() && - col1.GetIsNullable() == col2.GetIsNullable() && - col1.GetIsAutoIncrement() == col2.GetIsAutoIncrement() && - col1.GetIsIdentity() == col2.GetIsIdentity() -} - -func (d detector) makeTargetColDef(current, target sqlschema.Column) sqlschema.Column { - // Avoid unneccessary type-change migrations if the types are equivalent. - if d.cmpType(current, target) { - target = &sqlschema.BaseColumn{ - Name: target.GetName(), - DefaultValue: target.GetDefaultValue(), - IsNullable: target.GetIsNullable(), - IsAutoIncrement: target.GetIsAutoIncrement(), - IsIdentity: target.GetIsIdentity(), - - SQLType: current.GetSQLType(), - VarcharLen: current.GetVarcharLen(), - } - } - return target -} - -type CompareTypeFunc func(sqlschema.Column, sqlschema.Column) bool - -// equalSignatures determines if two tables have the same "signature". -func equalSignatures(t1, t2 sqlschema.Table, eq CompareTypeFunc) bool { - sig1 := newSignature(t1, eq) - sig2 := newSignature(t2, eq) - return sig1.Equals(sig2) -} - -// signature is a set of column definitions, which allows "relation/name-agnostic" comparison between them; -// meaning that two columns are considered equal if their types are the same. -type signature struct { - - // underlying stores the number of occurences for each unique column type. - // It helps to account for the fact that a table might have multiple columns that have the same type. - underlying map[sqlschema.BaseColumn]int - - eq CompareTypeFunc -} - -func newSignature(t sqlschema.Table, eq CompareTypeFunc) signature { - s := signature{ - underlying: make(map[sqlschema.BaseColumn]int), - eq: eq, - } - s.scan(t) - return s -} - -// scan iterates over table's field and counts occurrences of each unique column definition. -func (s *signature) scan(t sqlschema.Table) { - for _, icol := range t.GetColumns().Values() { - scanCol := icol.(*sqlschema.BaseColumn) - // This is slightly more expensive than if the columns could be compared directly - // and we always did s.underlying[col]++, but we get type-equivalence in return. - col, count := s.getCount(*scanCol) - if count == 0 { - s.underlying[*scanCol] = 1 - } else { - s.underlying[col]++ - } - } -} - -// getCount uses CompareTypeFunc to find a column with the same (equivalent) SQL type -// and returns its count. Count 0 means there are no columns with of this type. -func (s *signature) getCount(keyCol sqlschema.BaseColumn) (key sqlschema.BaseColumn, count int) { - for col, cnt := range s.underlying { - if s.eq(&col, &keyCol) { - return col, cnt - } - } - return keyCol, 0 -} - -// Equals returns true if 2 signatures share an identical set of columns. -func (s *signature) Equals(other signature) bool { - if len(s.underlying) != len(other.underlying) { - return false - } - for col, count := range s.underlying { - if _, countOther := other.getCount(col); countOther != count { - return false - } - } - return true -} - -// refMap is a utility for tracking superficial changes in foreign keys, -// which do not require any modificiation in the database. -// Modern SQL dialects automatically updated foreign key constraints whenever -// a column or a table is renamed. Detector can use refMap to ignore any -// differences in foreign keys which were caused by renamed column/table. -type refMap map[*sqlschema.ForeignKey]string - -func newRefMap(fks map[sqlschema.ForeignKey]string) refMap { - rm := make(map[*sqlschema.ForeignKey]string) - for fk, name := range fks { - rm[&fk] = name - } - return rm -} - -// RenameT updates table name in all foreign key definions which depend on it. -func (rm refMap) RenameTable(tableName string, newName string) { - for fk := range rm { - switch tableName { - case fk.From.TableName: - fk.From.TableName = newName - case fk.To.TableName: - fk.To.TableName = newName - } - } -} - -// RenameColumn updates column name in all foreign key definions which depend on it. -func (rm refMap) RenameColumn(tableName string, column, newName string) { - for fk := range rm { - if tableName == fk.From.TableName { - fk.From.Column.Replace(column, newName) - } - if tableName == fk.To.TableName { - fk.To.Column.Replace(column, newName) - } - } -} - -// Deref returns copies of ForeignKey values to a map. -func (rm refMap) Deref() map[sqlschema.ForeignKey]string { - out := make(map[sqlschema.ForeignKey]string) - for fk, name := range rm { - out[*fk] = name - } - return out -} diff --git a/vendor/github.com/uptrace/bun/migrate/migration.go b/vendor/github.com/uptrace/bun/migrate/migration.go deleted file mode 100644 index 3f4076d2b..000000000 --- a/vendor/github.com/uptrace/bun/migrate/migration.go +++ /dev/null @@ -1,302 +0,0 @@ -package migrate - -import ( - "bufio" - "bytes" - "context" - "fmt" - "io" - "io/fs" - "sort" - "strings" - "time" - - "github.com/uptrace/bun" -) - -type Migration struct { - bun.BaseModel - - ID int64 `bun:",pk,autoincrement"` - Name string - Comment string `bun:"-"` - GroupID int64 - MigratedAt time.Time `bun:",notnull,nullzero,default:current_timestamp"` - - Up MigrationFunc `bun:"-"` - Down MigrationFunc `bun:"-"` -} - -func (m Migration) String() string { - return fmt.Sprintf("%s_%s", m.Name, m.Comment) -} - -func (m Migration) IsApplied() bool { - return m.ID > 0 -} - -type MigrationFunc func(ctx context.Context, db *bun.DB) error - -func NewSQLMigrationFunc(fsys fs.FS, name string) MigrationFunc { - return func(ctx context.Context, db *bun.DB) error { - f, err := fsys.Open(name) - if err != nil { - return err - } - - isTx := strings.HasSuffix(name, ".tx.up.sql") || strings.HasSuffix(name, ".tx.down.sql") - return Exec(ctx, db, f, isTx) - } -} - -// Exec reads and executes the SQL migration in the f. -func Exec(ctx context.Context, db *bun.DB, f io.Reader, isTx bool) error { - scanner := bufio.NewScanner(f) - var queries []string - - var query []byte - for scanner.Scan() { - b := scanner.Bytes() - - const prefix = "--bun:" - if bytes.HasPrefix(b, []byte(prefix)) { - b = b[len(prefix):] - if bytes.Equal(b, []byte("split")) { - queries = append(queries, string(query)) - query = query[:0] - continue - } - return fmt.Errorf("bun: unknown directive: %q", b) - } - - query = append(query, b...) - query = append(query, '\n') - } - - if len(query) > 0 { - queries = append(queries, string(query)) - } - if err := scanner.Err(); err != nil { - return err - } - - var idb bun.IConn - - if isTx { - tx, err := db.BeginTx(ctx, nil) - if err != nil { - return err - } - idb = tx - } else { - conn, err := db.Conn(ctx) - if err != nil { - return err - } - idb = conn - } - - var retErr error - var execErr error - - defer func() { - if tx, ok := idb.(bun.Tx); ok { - if execErr != nil { - retErr = tx.Rollback() - } else { - retErr = tx.Commit() - } - return - } - - if conn, ok := idb.(bun.Conn); ok { - retErr = conn.Close() - return - } - - panic("not reached") - }() - - for _, q := range queries { - _, execErr = idb.ExecContext(ctx, q) - if execErr != nil { - return execErr - } - } - - return retErr -} - -const goTemplate = `package %s - -import ( - "context" - "fmt" - - "github.com/uptrace/bun" -) - -func init() { - Migrations.MustRegister(func(ctx context.Context, db *bun.DB) error { - fmt.Print(" [up migration] ") - return nil - }, func(ctx context.Context, db *bun.DB) error { - fmt.Print(" [down migration] ") - return nil - }) -} -` - -const sqlTemplate = `SET statement_timeout = 0; - ---bun:split - -SELECT 1 - ---bun:split - -SELECT 2 -` - -const transactionalSQLTemplate = `SET statement_timeout = 0; - -SELECT 1; -` - -//------------------------------------------------------------------------------ - -type MigrationSlice []Migration - -func (ms MigrationSlice) String() string { - if len(ms) == 0 { - return "empty" - } - - if len(ms) > 5 { - return fmt.Sprintf("%d migrations (%s ... %s)", len(ms), ms[0].Name, ms[len(ms)-1].Name) - } - - var sb strings.Builder - - for i := range ms { - if i > 0 { - sb.WriteString(", ") - } - sb.WriteString(ms[i].String()) - } - - return sb.String() -} - -// Applied returns applied migrations in descending order -// (the order is important and is used in Rollback). -func (ms MigrationSlice) Applied() MigrationSlice { - var applied MigrationSlice - for i := range ms { - if ms[i].IsApplied() { - applied = append(applied, ms[i]) - } - } - sortDesc(applied) - return applied -} - -// Unapplied returns unapplied migrations in ascending order -// (the order is important and is used in Migrate). -func (ms MigrationSlice) Unapplied() MigrationSlice { - var unapplied MigrationSlice - for i := range ms { - if !ms[i].IsApplied() { - unapplied = append(unapplied, ms[i]) - } - } - sortAsc(unapplied) - return unapplied -} - -// LastGroupID returns the last applied migration group id. -// The id is 0 when there are no migration groups. -func (ms MigrationSlice) LastGroupID() int64 { - var lastGroupID int64 - for i := range ms { - groupID := ms[i].GroupID - if groupID > lastGroupID { - lastGroupID = groupID - } - } - return lastGroupID -} - -// LastGroup returns the last applied migration group. -func (ms MigrationSlice) LastGroup() *MigrationGroup { - group := &MigrationGroup{ - ID: ms.LastGroupID(), - } - if group.ID == 0 { - return group - } - for i := range ms { - if ms[i].GroupID == group.ID { - group.Migrations = append(group.Migrations, ms[i]) - } - } - return group -} - -type MigrationGroup struct { - ID int64 - Migrations MigrationSlice -} - -func (g MigrationGroup) IsZero() bool { - return g.ID == 0 && len(g.Migrations) == 0 -} - -func (g MigrationGroup) String() string { - if g.IsZero() { - return "nil" - } - return fmt.Sprintf("group #%d (%s)", g.ID, g.Migrations) -} - -type MigrationFile struct { - Name string - Path string - Content string -} - -//------------------------------------------------------------------------------ - -type migrationConfig struct { - nop bool -} - -func newMigrationConfig(opts []MigrationOption) *migrationConfig { - cfg := new(migrationConfig) - for _, opt := range opts { - opt(cfg) - } - return cfg -} - -type MigrationOption func(cfg *migrationConfig) - -func WithNopMigration() MigrationOption { - return func(cfg *migrationConfig) { - cfg.nop = true - } -} - -//------------------------------------------------------------------------------ - -func sortAsc(ms MigrationSlice) { - sort.Slice(ms, func(i, j int) bool { - return ms[i].Name < ms[j].Name - }) -} - -func sortDesc(ms MigrationSlice) { - sort.Slice(ms, func(i, j int) bool { - return ms[i].Name > ms[j].Name - }) -} diff --git a/vendor/github.com/uptrace/bun/migrate/migrations.go b/vendor/github.com/uptrace/bun/migrate/migrations.go deleted file mode 100644 index 1a7ea5668..000000000 --- a/vendor/github.com/uptrace/bun/migrate/migrations.go +++ /dev/null @@ -1,167 +0,0 @@ -package migrate - -import ( - "errors" - "fmt" - "io/fs" - "os" - "path/filepath" - "regexp" - "runtime" - "strings" -) - -type MigrationsOption func(m *Migrations) - -func WithMigrationsDirectory(directory string) MigrationsOption { - return func(m *Migrations) { - m.explicitDirectory = directory - } -} - -type Migrations struct { - ms MigrationSlice - - explicitDirectory string - implicitDirectory string -} - -func NewMigrations(opts ...MigrationsOption) *Migrations { - m := new(Migrations) - for _, opt := range opts { - opt(m) - } - m.implicitDirectory = filepath.Dir(migrationFile()) - return m -} - -func (m *Migrations) Sorted() MigrationSlice { - migrations := make(MigrationSlice, len(m.ms)) - copy(migrations, m.ms) - sortAsc(migrations) - return migrations -} - -func (m *Migrations) MustRegister(up, down MigrationFunc) { - if err := m.Register(up, down); err != nil { - panic(err) - } -} - -func (m *Migrations) Register(up, down MigrationFunc) error { - fpath := migrationFile() - name, comment, err := extractMigrationName(fpath) - if err != nil { - return err - } - - m.Add(Migration{ - Name: name, - Comment: comment, - Up: up, - Down: down, - }) - - return nil -} - -func (m *Migrations) Add(migration Migration) { - if migration.Name == "" { - panic("migration name is required") - } - m.ms = append(m.ms, migration) -} - -func (m *Migrations) DiscoverCaller() error { - dir := filepath.Dir(migrationFile()) - return m.Discover(os.DirFS(dir)) -} - -func (m *Migrations) Discover(fsys fs.FS) error { - return fs.WalkDir(fsys, ".", func(path string, d fs.DirEntry, err error) error { - if err != nil { - return err - } - if d.IsDir() { - return nil - } - - if !strings.HasSuffix(path, ".up.sql") && !strings.HasSuffix(path, ".down.sql") { - return nil - } - - name, comment, err := extractMigrationName(path) - if err != nil { - return err - } - - migration := m.getOrCreateMigration(name) - migration.Comment = comment - migrationFunc := NewSQLMigrationFunc(fsys, path) - - if strings.HasSuffix(path, ".up.sql") { - migration.Up = migrationFunc - return nil - } - if strings.HasSuffix(path, ".down.sql") { - migration.Down = migrationFunc - return nil - } - - return errors.New("migrate: not reached") - }) -} - -func (m *Migrations) getOrCreateMigration(name string) *Migration { - for i := range m.ms { - m := &m.ms[i] - if m.Name == name { - return m - } - } - - m.ms = append(m.ms, Migration{Name: name}) - return &m.ms[len(m.ms)-1] -} - -func (m *Migrations) getDirectory() string { - if m.explicitDirectory != "" { - return m.explicitDirectory - } - if m.implicitDirectory != "" { - return m.implicitDirectory - } - return filepath.Dir(migrationFile()) -} - -func migrationFile() string { - const depth = 32 - var pcs [depth]uintptr - n := runtime.Callers(1, pcs[:]) - frames := runtime.CallersFrames(pcs[:n]) - - for { - f, ok := frames.Next() - if !ok { - break - } - if !strings.Contains(f.Function, "/bun/migrate.") { - return f.File - } - } - - return "" -} - -var fnameRE = regexp.MustCompile(`^(\d{1,14})_([0-9a-z_\-]+)\.`) - -func extractMigrationName(fpath string) (string, string, error) { - fname := filepath.Base(fpath) - - matches := fnameRE.FindStringSubmatch(fname) - if matches == nil { - return "", "", fmt.Errorf("migrate: unsupported migration name format: %q", fname) - } - - return matches[1], matches[2], nil -} diff --git a/vendor/github.com/uptrace/bun/migrate/migrator.go b/vendor/github.com/uptrace/bun/migrate/migrator.go deleted file mode 100644 index d5a72aec0..000000000 --- a/vendor/github.com/uptrace/bun/migrate/migrator.go +++ /dev/null @@ -1,458 +0,0 @@ -package migrate - -import ( - "context" - "errors" - "fmt" - "os" - "path/filepath" - "regexp" - "time" - - "github.com/uptrace/bun" -) - -const ( - defaultTable = "bun_migrations" - defaultLocksTable = "bun_migration_locks" -) - -type MigratorOption func(m *Migrator) - -// WithTableName overrides default migrations table name. -func WithTableName(table string) MigratorOption { - return func(m *Migrator) { - m.table = table - } -} - -// WithLocksTableName overrides default migration locks table name. -func WithLocksTableName(table string) MigratorOption { - return func(m *Migrator) { - m.locksTable = table - } -} - -// WithMarkAppliedOnSuccess sets the migrator to only mark migrations as applied/unapplied -// when their up/down is successful. -func WithMarkAppliedOnSuccess(enabled bool) MigratorOption { - return func(m *Migrator) { - m.markAppliedOnSuccess = enabled - } -} - -type Migrator struct { - db *bun.DB - migrations *Migrations - - ms MigrationSlice - - table string - locksTable string - markAppliedOnSuccess bool -} - -func NewMigrator(db *bun.DB, migrations *Migrations, opts ...MigratorOption) *Migrator { - m := &Migrator{ - db: db, - migrations: migrations, - - ms: migrations.ms, - - table: defaultTable, - locksTable: defaultLocksTable, - } - for _, opt := range opts { - opt(m) - } - return m -} - -func (m *Migrator) DB() *bun.DB { - return m.db -} - -// MigrationsWithStatus returns migrations with status in ascending order. -func (m *Migrator) MigrationsWithStatus(ctx context.Context) (MigrationSlice, error) { - sorted, _, err := m.migrationsWithStatus(ctx) - return sorted, err -} - -func (m *Migrator) migrationsWithStatus(ctx context.Context) (MigrationSlice, int64, error) { - sorted := m.migrations.Sorted() - - applied, err := m.AppliedMigrations(ctx) - if err != nil { - return nil, 0, err - } - - appliedMap := migrationMap(applied) - for i := range sorted { - m1 := &sorted[i] - if m2, ok := appliedMap[m1.Name]; ok { - m1.ID = m2.ID - m1.GroupID = m2.GroupID - m1.MigratedAt = m2.MigratedAt - } - } - - return sorted, applied.LastGroupID(), nil -} - -func (m *Migrator) Init(ctx context.Context) error { - if _, err := m.db.NewCreateTable(). - Model((*Migration)(nil)). - ModelTableExpr(m.table). - IfNotExists(). - Exec(ctx); err != nil { - return err - } - if _, err := m.db.NewCreateTable(). - Model((*migrationLock)(nil)). - ModelTableExpr(m.locksTable). - IfNotExists(). - Exec(ctx); err != nil { - return err - } - return nil -} - -func (m *Migrator) Reset(ctx context.Context) error { - if _, err := m.db.NewDropTable(). - Model((*Migration)(nil)). - ModelTableExpr(m.table). - IfExists(). - Exec(ctx); err != nil { - return err - } - if _, err := m.db.NewDropTable(). - Model((*migrationLock)(nil)). - ModelTableExpr(m.locksTable). - IfExists(). - Exec(ctx); err != nil { - return err - } - return m.Init(ctx) -} - -// Migrate runs unapplied migrations. If a migration fails, migrate immediately exits. -func (m *Migrator) Migrate(ctx context.Context, opts ...MigrationOption) (*MigrationGroup, error) { - cfg := newMigrationConfig(opts) - - if err := m.validate(); err != nil { - return nil, err - } - - migrations, lastGroupID, err := m.migrationsWithStatus(ctx) - if err != nil { - return nil, err - } - migrations = migrations.Unapplied() - - group := new(MigrationGroup) - if len(migrations) == 0 { - return group, nil - } - group.ID = lastGroupID + 1 - - for i := range migrations { - migration := &migrations[i] - migration.GroupID = group.ID - - if !m.markAppliedOnSuccess { - if err := m.MarkApplied(ctx, migration); err != nil { - return group, err - } - } - - group.Migrations = migrations[:i+1] - - if !cfg.nop && migration.Up != nil { - if err := migration.Up(ctx, m.db); err != nil { - return group, err - } - } - - if m.markAppliedOnSuccess { - if err := m.MarkApplied(ctx, migration); err != nil { - return group, err - } - } - } - - return group, nil -} - -func (m *Migrator) Rollback(ctx context.Context, opts ...MigrationOption) (*MigrationGroup, error) { - cfg := newMigrationConfig(opts) - - if err := m.validate(); err != nil { - return nil, err - } - - migrations, err := m.MigrationsWithStatus(ctx) - if err != nil { - return nil, err - } - - lastGroup := migrations.LastGroup() - - for i := len(lastGroup.Migrations) - 1; i >= 0; i-- { - migration := &lastGroup.Migrations[i] - - if !m.markAppliedOnSuccess { - if err := m.MarkUnapplied(ctx, migration); err != nil { - return lastGroup, err - } - } - - if !cfg.nop && migration.Down != nil { - if err := migration.Down(ctx, m.db); err != nil { - return lastGroup, err - } - } - - if m.markAppliedOnSuccess { - if err := m.MarkUnapplied(ctx, migration); err != nil { - return lastGroup, err - } - } - } - - return lastGroup, nil -} - -type goMigrationConfig struct { - packageName string - goTemplate string -} - -type GoMigrationOption func(cfg *goMigrationConfig) - -func WithPackageName(name string) GoMigrationOption { - return func(cfg *goMigrationConfig) { - cfg.packageName = name - } -} - -func WithGoTemplate(template string) GoMigrationOption { - return func(cfg *goMigrationConfig) { - cfg.goTemplate = template - } -} - -// CreateGoMigration creates a Go migration file. -func (m *Migrator) CreateGoMigration( - ctx context.Context, name string, opts ...GoMigrationOption, -) (*MigrationFile, error) { - cfg := &goMigrationConfig{ - packageName: "migrations", - goTemplate: goTemplate, - } - for _, opt := range opts { - opt(cfg) - } - - name, err := genMigrationName(name) - if err != nil { - return nil, err - } - - fname := name + ".go" - fpath := filepath.Join(m.migrations.getDirectory(), fname) - content := fmt.Sprintf(cfg.goTemplate, cfg.packageName) - - if err := os.WriteFile(fpath, []byte(content), 0o644); err != nil { - return nil, err - } - - mf := &MigrationFile{ - Name: fname, - Path: fpath, - Content: content, - } - return mf, nil -} - -// CreateTxSQLMigration creates transactional up and down SQL migration files. -func (m *Migrator) CreateTxSQLMigrations(ctx context.Context, name string) ([]*MigrationFile, error) { - name, err := genMigrationName(name) - if err != nil { - return nil, err - } - - up, err := m.createSQL(ctx, name+".tx.up.sql", true) - if err != nil { - return nil, err - } - - down, err := m.createSQL(ctx, name+".tx.down.sql", true) - if err != nil { - return nil, err - } - - return []*MigrationFile{up, down}, nil -} - -// CreateSQLMigrations creates up and down SQL migration files. -func (m *Migrator) CreateSQLMigrations(ctx context.Context, name string) ([]*MigrationFile, error) { - name, err := genMigrationName(name) - if err != nil { - return nil, err - } - - up, err := m.createSQL(ctx, name+".up.sql", false) - if err != nil { - return nil, err - } - - down, err := m.createSQL(ctx, name+".down.sql", false) - if err != nil { - return nil, err - } - - return []*MigrationFile{up, down}, nil -} - -func (m *Migrator) createSQL(_ context.Context, fname string, transactional bool) (*MigrationFile, error) { - fpath := filepath.Join(m.migrations.getDirectory(), fname) - - template := sqlTemplate - if transactional { - template = transactionalSQLTemplate - } - - if err := os.WriteFile(fpath, []byte(template), 0o644); err != nil { - return nil, err - } - - mf := &MigrationFile{ - Name: fname, - Path: fpath, - Content: goTemplate, - } - return mf, nil -} - -var nameRE = regexp.MustCompile(`^[0-9a-z_\-]+$`) - -func genMigrationName(name string) (string, error) { - const timeFormat = "20060102150405" - - if name == "" { - return "", errors.New("migrate: migration name can't be empty") - } - if !nameRE.MatchString(name) { - return "", fmt.Errorf("migrate: invalid migration name: %q", name) - } - - version := time.Now().UTC().Format(timeFormat) - return fmt.Sprintf("%s_%s", version, name), nil -} - -// MarkApplied marks the migration as applied (completed). -func (m *Migrator) MarkApplied(ctx context.Context, migration *Migration) error { - _, err := m.db.NewInsert().Model(migration). - ModelTableExpr(m.table). - Exec(ctx) - return err -} - -// MarkUnapplied marks the migration as unapplied (new). -func (m *Migrator) MarkUnapplied(ctx context.Context, migration *Migration) error { - _, err := m.db.NewDelete(). - Model(migration). - ModelTableExpr(m.table). - Where("id = ?", migration.ID). - Exec(ctx) - return err -} - -func (m *Migrator) TruncateTable(ctx context.Context) error { - _, err := m.db.NewTruncateTable(). - Model((*Migration)(nil)). - ModelTableExpr(m.table). - Exec(ctx) - return err -} - -// MissingMigrations returns applied migrations that can no longer be found. -func (m *Migrator) MissingMigrations(ctx context.Context) (MigrationSlice, error) { - applied, err := m.AppliedMigrations(ctx) - if err != nil { - return nil, err - } - - existing := migrationMap(m.migrations.ms) - for i := len(applied) - 1; i >= 0; i-- { - m := &applied[i] - if _, ok := existing[m.Name]; ok { - applied = append(applied[:i], applied[i+1:]...) - } - } - - return applied, nil -} - -// AppliedMigrations selects applied (applied) migrations in descending order. -func (m *Migrator) AppliedMigrations(ctx context.Context) (MigrationSlice, error) { - var ms MigrationSlice - if err := m.db.NewSelect(). - ColumnExpr("*"). - Model(&ms). - ModelTableExpr(m.table). - Scan(ctx); err != nil { - return nil, err - } - return ms, nil -} - -func (m *Migrator) formattedTableName(db *bun.DB) string { - return db.Formatter().FormatQuery(m.table) -} - -func (m *Migrator) validate() error { - if len(m.ms) == 0 { - return errors.New("migrate: there are no migrations") - } - return nil -} - -//------------------------------------------------------------------------------ - -type migrationLock struct { - ID int64 `bun:",pk,autoincrement"` - TableName string `bun:",unique"` -} - -func (m *Migrator) Lock(ctx context.Context) error { - lock := &migrationLock{ - TableName: m.formattedTableName(m.db), - } - if _, err := m.db.NewInsert(). - Model(lock). - ModelTableExpr(m.locksTable). - Exec(ctx); err != nil { - return fmt.Errorf("migrate: migrations table is already locked (%w)", err) - } - return nil -} - -func (m *Migrator) Unlock(ctx context.Context) error { - tableName := m.formattedTableName(m.db) - _, err := m.db.NewDelete(). - Model((*migrationLock)(nil)). - ModelTableExpr(m.locksTable). - Where("? = ?", bun.Ident("table_name"), tableName). - Exec(ctx) - return err -} - -func migrationMap(ms MigrationSlice) map[string]*Migration { - mp := make(map[string]*Migration) - for i := range ms { - m := &ms[i] - mp[m.Name] = m - } - return mp -} diff --git a/vendor/github.com/uptrace/bun/migrate/operations.go b/vendor/github.com/uptrace/bun/migrate/operations.go deleted file mode 100644 index 7b749c5a0..000000000 --- a/vendor/github.com/uptrace/bun/migrate/operations.go +++ /dev/null @@ -1,340 +0,0 @@ -package migrate - -import ( - "fmt" - - "github.com/uptrace/bun/migrate/sqlschema" -) - -// Operation encapsulates the request to change a database definition -// and knowns which operation can revert it. -// -// It is useful to define "monolith" Operations whenever possible, -// even though they a dialect may require several distinct steps to apply them. -// For example, changing a primary key involves first dropping the old constraint -// before generating the new one. Yet, this is only an implementation detail and -// passing a higher-level ChangePrimaryKeyOp will give the dialect more information -// about the applied change. -// -// Some operations might be irreversible due to technical limitations. Returning -// a *comment from GetReverse() will add an explanatory note to the generate migation file. -// -// To declare dependency on another Operation, operations should implement -// { DependsOn(Operation) bool } interface, which Changeset will use to resolve dependencies. -type Operation interface { - GetReverse() Operation -} - -// CreateTableOp creates a new table in the schema. -// -// It does not report dependency on any other migration and may be executed first. -// Make sure the dialect does not include FOREIGN KEY constraints in the CREATE TABLE -// statement, as those may potentially reference not-yet-existing columns/tables. -type CreateTableOp struct { - TableName string - Model interface{} -} - -var _ Operation = (*CreateTableOp)(nil) - -func (op *CreateTableOp) GetReverse() Operation { - return &DropTableOp{TableName: op.TableName} -} - -// DropTableOp drops a database table. This operation is not reversible. -type DropTableOp struct { - TableName string -} - -var _ Operation = (*DropTableOp)(nil) - -func (op *DropTableOp) DependsOn(another Operation) bool { - drop, ok := another.(*DropForeignKeyOp) - return ok && drop.ForeignKey.DependsOnTable(op.TableName) -} - -// GetReverse for a DropTable returns a no-op migration. Logically, CreateTable is the reverse, -// but DropTable does not have the table's definition to create one. -func (op *DropTableOp) GetReverse() Operation { - c := comment(fmt.Sprintf("WARNING: \"DROP TABLE %s\" cannot be reversed automatically because table definition is not available", op.TableName)) - return &c -} - -// RenameTableOp renames the table. Changing the "schema" part of the table's FQN (moving tables between schemas) is not allowed. -type RenameTableOp struct { - TableName string - NewName string -} - -var _ Operation = (*RenameTableOp)(nil) - -func (op *RenameTableOp) GetReverse() Operation { - return &RenameTableOp{ - TableName: op.NewName, - NewName: op.TableName, - } -} - -// RenameColumnOp renames a column in the table. If the changeset includes a rename operation -// for the column's table, it should be executed first. -type RenameColumnOp struct { - TableName string - OldName string - NewName string -} - -var _ Operation = (*RenameColumnOp)(nil) - -func (op *RenameColumnOp) GetReverse() Operation { - return &RenameColumnOp{ - TableName: op.TableName, - OldName: op.NewName, - NewName: op.OldName, - } -} - -func (op *RenameColumnOp) DependsOn(another Operation) bool { - rename, ok := another.(*RenameTableOp) - return ok && op.TableName == rename.NewName -} - -// AddColumnOp adds a new column to the table. -type AddColumnOp struct { - TableName string - ColumnName string - Column sqlschema.Column -} - -var _ Operation = (*AddColumnOp)(nil) - -func (op *AddColumnOp) GetReverse() Operation { - return &DropColumnOp{ - TableName: op.TableName, - ColumnName: op.ColumnName, - Column: op.Column, - } -} - -// DropColumnOp drop a column from the table. -// -// While some dialects allow DROP CASCADE to drop dependent constraints, -// explicit handling on constraints is preferred for transparency and debugging. -// DropColumnOp depends on DropForeignKeyOp, DropPrimaryKeyOp, and ChangePrimaryKeyOp -// if any of the constraints is defined on this table. -type DropColumnOp struct { - TableName string - ColumnName string - Column sqlschema.Column -} - -var _ Operation = (*DropColumnOp)(nil) - -func (op *DropColumnOp) GetReverse() Operation { - return &AddColumnOp{ - TableName: op.TableName, - ColumnName: op.ColumnName, - Column: op.Column, - } -} - -func (op *DropColumnOp) DependsOn(another Operation) bool { - switch drop := another.(type) { - case *DropForeignKeyOp: - return drop.ForeignKey.DependsOnColumn(op.TableName, op.ColumnName) - case *DropPrimaryKeyOp: - return op.TableName == drop.TableName && drop.PrimaryKey.Columns.Contains(op.ColumnName) - case *ChangePrimaryKeyOp: - return op.TableName == drop.TableName && drop.Old.Columns.Contains(op.ColumnName) - } - return false -} - -// AddForeignKey adds a new FOREIGN KEY constraint. -type AddForeignKeyOp struct { - ForeignKey sqlschema.ForeignKey - ConstraintName string -} - -var _ Operation = (*AddForeignKeyOp)(nil) - -func (op *AddForeignKeyOp) TableName() string { - return op.ForeignKey.From.TableName -} - -func (op *AddForeignKeyOp) DependsOn(another Operation) bool { - switch another := another.(type) { - case *RenameTableOp: - return op.ForeignKey.DependsOnTable(another.TableName) || op.ForeignKey.DependsOnTable(another.NewName) - case *CreateTableOp: - return op.ForeignKey.DependsOnTable(another.TableName) - } - return false -} - -func (op *AddForeignKeyOp) GetReverse() Operation { - return &DropForeignKeyOp{ - ForeignKey: op.ForeignKey, - ConstraintName: op.ConstraintName, - } -} - -// DropForeignKeyOp drops a FOREIGN KEY constraint. -type DropForeignKeyOp struct { - ForeignKey sqlschema.ForeignKey - ConstraintName string -} - -var _ Operation = (*DropForeignKeyOp)(nil) - -func (op *DropForeignKeyOp) TableName() string { - return op.ForeignKey.From.TableName -} - -func (op *DropForeignKeyOp) GetReverse() Operation { - return &AddForeignKeyOp{ - ForeignKey: op.ForeignKey, - ConstraintName: op.ConstraintName, - } -} - -// AddUniqueConstraintOp adds new UNIQUE constraint to the table. -type AddUniqueConstraintOp struct { - TableName string - Unique sqlschema.Unique -} - -var _ Operation = (*AddUniqueConstraintOp)(nil) - -func (op *AddUniqueConstraintOp) GetReverse() Operation { - return &DropUniqueConstraintOp{ - TableName: op.TableName, - Unique: op.Unique, - } -} - -func (op *AddUniqueConstraintOp) DependsOn(another Operation) bool { - switch another := another.(type) { - case *AddColumnOp: - return op.TableName == another.TableName && op.Unique.Columns.Contains(another.ColumnName) - case *RenameTableOp: - return op.TableName == another.NewName - case *DropUniqueConstraintOp: - // We want to drop the constraint with the same name before adding this one. - return op.TableName == another.TableName && op.Unique.Name == another.Unique.Name - default: - return false - } - -} - -// DropUniqueConstraintOp drops a UNIQUE constraint. -type DropUniqueConstraintOp struct { - TableName string - Unique sqlschema.Unique -} - -var _ Operation = (*DropUniqueConstraintOp)(nil) - -func (op *DropUniqueConstraintOp) DependsOn(another Operation) bool { - if rename, ok := another.(*RenameTableOp); ok { - return op.TableName == rename.NewName - } - return false -} - -func (op *DropUniqueConstraintOp) GetReverse() Operation { - return &AddUniqueConstraintOp{ - TableName: op.TableName, - Unique: op.Unique, - } -} - -// ChangeColumnTypeOp set a new data type for the column. -// The two types should be such that the data can be auto-casted from one to another. -// E.g. reducing VARCHAR lenght is not possible in most dialects. -// AutoMigrator does not enforce or validate these rules. -type ChangeColumnTypeOp struct { - TableName string - Column string - From sqlschema.Column - To sqlschema.Column -} - -var _ Operation = (*ChangeColumnTypeOp)(nil) - -func (op *ChangeColumnTypeOp) GetReverse() Operation { - return &ChangeColumnTypeOp{ - TableName: op.TableName, - Column: op.Column, - From: op.To, - To: op.From, - } -} - -// DropPrimaryKeyOp drops the table's PRIMARY KEY. -type DropPrimaryKeyOp struct { - TableName string - PrimaryKey sqlschema.PrimaryKey -} - -var _ Operation = (*DropPrimaryKeyOp)(nil) - -func (op *DropPrimaryKeyOp) GetReverse() Operation { - return &AddPrimaryKeyOp{ - TableName: op.TableName, - PrimaryKey: op.PrimaryKey, - } -} - -// AddPrimaryKeyOp adds a new PRIMARY KEY to the table. -type AddPrimaryKeyOp struct { - TableName string - PrimaryKey sqlschema.PrimaryKey -} - -var _ Operation = (*AddPrimaryKeyOp)(nil) - -func (op *AddPrimaryKeyOp) GetReverse() Operation { - return &DropPrimaryKeyOp{ - TableName: op.TableName, - PrimaryKey: op.PrimaryKey, - } -} - -func (op *AddPrimaryKeyOp) DependsOn(another Operation) bool { - switch another := another.(type) { - case *AddColumnOp: - return op.TableName == another.TableName && op.PrimaryKey.Columns.Contains(another.ColumnName) - } - return false -} - -// ChangePrimaryKeyOp changes the PRIMARY KEY of the table. -type ChangePrimaryKeyOp struct { - TableName string - Old sqlschema.PrimaryKey - New sqlschema.PrimaryKey -} - -var _ Operation = (*AddPrimaryKeyOp)(nil) - -func (op *ChangePrimaryKeyOp) GetReverse() Operation { - return &ChangePrimaryKeyOp{ - TableName: op.TableName, - Old: op.New, - New: op.Old, - } -} - -// comment denotes an Operation that cannot be executed. -// -// Operations, which cannot be reversed due to current technical limitations, -// may return &comment with a helpful message from their GetReverse() method. -// -// Chnagelog should skip it when applying operations or output as log message, -// and write it as an SQL comment when creating migration files. -type comment string - -var _ Operation = (*comment)(nil) - -func (c *comment) GetReverse() Operation { return c } diff --git a/vendor/github.com/uptrace/bun/migrate/sqlschema/column.go b/vendor/github.com/uptrace/bun/migrate/sqlschema/column.go deleted file mode 100644 index 60f7ea8a6..000000000 --- a/vendor/github.com/uptrace/bun/migrate/sqlschema/column.go +++ /dev/null @@ -1,75 +0,0 @@ -package sqlschema - -import ( - "fmt" - - "github.com/uptrace/bun/schema" -) - -type Column interface { - GetName() string - GetSQLType() string - GetVarcharLen() int - GetDefaultValue() string - GetIsNullable() bool - GetIsAutoIncrement() bool - GetIsIdentity() bool - AppendQuery(schema.Formatter, []byte) ([]byte, error) -} - -var _ Column = (*BaseColumn)(nil) - -// BaseColumn is a base column definition that stores various attributes of a column. -// -// Dialects and only dialects can use it to implement the Column interface. -// Other packages must use the Column interface. -type BaseColumn struct { - Name string - SQLType string - VarcharLen int - DefaultValue string - IsNullable bool - IsAutoIncrement bool - IsIdentity bool - // TODO: add Precision and Cardinality for timestamps/bit-strings/floats and arrays respectively. -} - -func (cd BaseColumn) GetName() string { - return cd.Name -} - -func (cd BaseColumn) GetSQLType() string { - return cd.SQLType -} - -func (cd BaseColumn) GetVarcharLen() int { - return cd.VarcharLen -} - -func (cd BaseColumn) GetDefaultValue() string { - return cd.DefaultValue -} - -func (cd BaseColumn) GetIsNullable() bool { - return cd.IsNullable -} - -func (cd BaseColumn) GetIsAutoIncrement() bool { - return cd.IsAutoIncrement -} - -func (cd BaseColumn) GetIsIdentity() bool { - return cd.IsIdentity -} - -// AppendQuery appends full SQL data type. -func (c *BaseColumn) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { - b = append(b, c.SQLType...) - if c.VarcharLen == 0 { - return b, nil - } - b = append(b, "("...) - b = append(b, fmt.Sprint(c.VarcharLen)...) - b = append(b, ")"...) - return b, nil -} diff --git a/vendor/github.com/uptrace/bun/migrate/sqlschema/database.go b/vendor/github.com/uptrace/bun/migrate/sqlschema/database.go deleted file mode 100644 index eb7476c54..000000000 --- a/vendor/github.com/uptrace/bun/migrate/sqlschema/database.go +++ /dev/null @@ -1,127 +0,0 @@ -package sqlschema - -import ( - "slices" - "strings" - - "github.com/uptrace/bun/internal/ordered" - "github.com/uptrace/bun/schema" -) - -type Database interface { - GetTables() *ordered.Map[string, Table] - GetForeignKeys() map[ForeignKey]string -} - -var _ Database = (*BaseDatabase)(nil) - -// BaseDatabase is a base database definition. -// -// Dialects and only dialects can use it to implement the Database interface. -// Other packages must use the Database interface. -type BaseDatabase struct { - Tables *ordered.Map[string, Table] - ForeignKeys map[ForeignKey]string -} - -func (ds BaseDatabase) GetTables() *ordered.Map[string, Table] { - return ds.Tables -} - -func (ds BaseDatabase) GetForeignKeys() map[ForeignKey]string { - return ds.ForeignKeys -} - -type ForeignKey struct { - From ColumnReference - To ColumnReference -} - -func NewColumnReference(tableName string, columns ...string) ColumnReference { - return ColumnReference{ - TableName: tableName, - Column: NewColumns(columns...), - } -} - -func (fk ForeignKey) DependsOnTable(tableName string) bool { - return fk.From.TableName == tableName || fk.To.TableName == tableName -} - -func (fk ForeignKey) DependsOnColumn(tableName string, column string) bool { - return fk.DependsOnTable(tableName) && - (fk.From.Column.Contains(column) || fk.To.Column.Contains(column)) -} - -// Columns is a hashable representation of []string used to define schema constraints that depend on multiple columns. -// Although having duplicated column references in these constraints is illegal, Columns neither validates nor enforces this constraint on the caller. -type Columns string - -// NewColumns creates a composite column from a slice of column names. -func NewColumns(columns ...string) Columns { - slices.Sort(columns) - return Columns(strings.Join(columns, ",")) -} - -func (c *Columns) String() string { - return string(*c) -} - -func (c *Columns) AppendQuery(fmter schema.Formatter, b []byte) ([]byte, error) { - return schema.Safe(*c).AppendQuery(fmter, b) -} - -// Split returns a slice of column names that make up the composite. -func (c *Columns) Split() []string { - return strings.Split(c.String(), ",") -} - -// ContainsColumns checks that columns in "other" are a subset of current colums. -func (c *Columns) ContainsColumns(other Columns) bool { - columns := c.Split() -Outer: - for _, check := range other.Split() { - for _, column := range columns { - if check == column { - continue Outer - } - } - return false - } - return true -} - -// Contains checks that a composite column contains the current column. -func (c *Columns) Contains(other string) bool { - return c.ContainsColumns(Columns(other)) -} - -// Replace renames a column if it is part of the composite. -// If a composite consists of multiple columns, only one column will be renamed. -func (c *Columns) Replace(oldColumn, newColumn string) bool { - columns := c.Split() - for i, column := range columns { - if column == oldColumn { - columns[i] = newColumn - *c = NewColumns(columns...) - return true - } - } - return false -} - -// Unique represents a unique constraint defined on 1 or more columns. -type Unique struct { - Name string - Columns Columns -} - -// Equals checks that two unique constraint are the same, assuming both are defined for the same table. -func (u Unique) Equals(other Unique) bool { - return u.Columns == other.Columns -} - -type ColumnReference struct { - TableName string - Column Columns -} diff --git a/vendor/github.com/uptrace/bun/migrate/sqlschema/inspector.go b/vendor/github.com/uptrace/bun/migrate/sqlschema/inspector.go deleted file mode 100644 index 19d1dc469..000000000 --- a/vendor/github.com/uptrace/bun/migrate/sqlschema/inspector.go +++ /dev/null @@ -1,242 +0,0 @@ -package sqlschema - -import ( - "context" - "fmt" - "strconv" - "strings" - - "github.com/uptrace/bun" - "github.com/uptrace/bun/internal/ordered" - "github.com/uptrace/bun/schema" -) - -type InspectorDialect interface { - schema.Dialect - - // Inspector returns a new instance of Inspector for the dialect. - // Dialects MAY set their default InspectorConfig values in constructor - // but MUST apply InspectorOptions to ensure they can be overriden. - // - // Use ApplyInspectorOptions to reduce boilerplate. - NewInspector(db *bun.DB, options ...InspectorOption) Inspector - - // CompareType returns true if col1 and co2 SQL types are equivalent, - // i.e. they might use dialect-specifc type aliases (SERIAL ~ SMALLINT) - // or specify the same VARCHAR length differently (VARCHAR(255) ~ VARCHAR). - CompareType(Column, Column) bool -} - -// InspectorConfig controls the scope of migration by limiting the objects Inspector should return. -// Inspectors SHOULD use the configuration directly instead of copying it, or MAY choose to embed it, -// to make sure options are always applied correctly. -type InspectorConfig struct { - // SchemaName limits inspection to tables in a particular schema. - SchemaName string - - // ExcludeTables from inspection. - ExcludeTables []string -} - -// Inspector reads schema state. -type Inspector interface { - Inspect(ctx context.Context) (Database, error) -} - -func WithSchemaName(schemaName string) InspectorOption { - return func(cfg *InspectorConfig) { - cfg.SchemaName = schemaName - } -} - -// WithExcludeTables works in append-only mode, i.e. tables cannot be re-included. -func WithExcludeTables(tables ...string) InspectorOption { - return func(cfg *InspectorConfig) { - cfg.ExcludeTables = append(cfg.ExcludeTables, tables...) - } -} - -// NewInspector creates a new database inspector, if the dialect supports it. -func NewInspector(db *bun.DB, options ...InspectorOption) (Inspector, error) { - dialect, ok := (db.Dialect()).(InspectorDialect) - if !ok { - return nil, fmt.Errorf("%s does not implement sqlschema.Inspector", db.Dialect().Name()) - } - return &inspector{ - Inspector: dialect.NewInspector(db, options...), - }, nil -} - -func NewBunModelInspector(tables *schema.Tables, options ...InspectorOption) *BunModelInspector { - bmi := &BunModelInspector{ - tables: tables, - } - ApplyInspectorOptions(&bmi.InspectorConfig, options...) - return bmi -} - -type InspectorOption func(*InspectorConfig) - -func ApplyInspectorOptions(cfg *InspectorConfig, options ...InspectorOption) { - for _, opt := range options { - opt(cfg) - } -} - -// inspector is opaque pointer to a database inspector. -type inspector struct { - Inspector -} - -// BunModelInspector creates the current project state from the passed bun.Models. -// Do not recycle BunModelInspector for different sets of models, as older models will not be de-registerred before the next run. -type BunModelInspector struct { - InspectorConfig - tables *schema.Tables -} - -var _ Inspector = (*BunModelInspector)(nil) - -func (bmi *BunModelInspector) Inspect(ctx context.Context) (Database, error) { - state := BunModelSchema{ - BaseDatabase: BaseDatabase{ - ForeignKeys: make(map[ForeignKey]string), - }, - Tables: ordered.NewMap[string, Table](), - } - for _, t := range bmi.tables.All() { - if t.Schema != bmi.SchemaName { - continue - } - - columns := ordered.NewMap[string, Column]() - for _, f := range t.Fields { - - sqlType, length, err := parseLen(f.CreateTableSQLType) - if err != nil { - return nil, fmt.Errorf("parse length in %q: %w", f.CreateTableSQLType, err) - } - columns.Store(f.Name, &BaseColumn{ - Name: f.Name, - SQLType: strings.ToLower(sqlType), // TODO(dyma): maybe this is not necessary after Column.Eq() - VarcharLen: length, - DefaultValue: exprOrLiteral(f.SQLDefault), - IsNullable: !f.NotNull, - IsAutoIncrement: f.AutoIncrement, - IsIdentity: f.Identity, - }) - } - - var unique []Unique - for name, group := range t.Unique { - // Create a separate unique index for single-column unique constraints - // let each dialect apply the default naming convention. - if name == "" { - for _, f := range group { - unique = append(unique, Unique{Columns: NewColumns(f.Name)}) - } - continue - } - - // Set the name if it is a "unique group", in which case the user has provided the name. - var columns []string - for _, f := range group { - columns = append(columns, f.Name) - } - unique = append(unique, Unique{Name: name, Columns: NewColumns(columns...)}) - } - - var pk *PrimaryKey - if len(t.PKs) > 0 { - var columns []string - for _, f := range t.PKs { - columns = append(columns, f.Name) - } - pk = &PrimaryKey{Columns: NewColumns(columns...)} - } - - // In cases where a table is defined in a non-default schema in the `bun:table` tag, - // schema.Table only extracts the name of the schema, but passes the entire tag value to t.Name - // for backwads-compatibility. For example, a bun model like this: - // type Model struct { bun.BaseModel `bun:"table:favourite.books` } - // produces - // schema.Table{ Schema: "favourite", Name: "favourite.books" } - tableName := strings.TrimPrefix(t.Name, t.Schema+".") - state.Tables.Store(tableName, &BunTable{ - BaseTable: BaseTable{ - Schema: t.Schema, - Name: tableName, - Columns: columns, - UniqueConstraints: unique, - PrimaryKey: pk, - }, - Model: t.ZeroIface, - }) - - for _, rel := range t.Relations { - // These relations are nominal and do not need a foreign key to be declared in the current table. - // They will be either expressed as N:1 relations in an m2m mapping table, or will be referenced by the other table if it's a 1:N. - if rel.Type == schema.ManyToManyRelation || - rel.Type == schema.HasManyRelation { - continue - } - - var fromCols, toCols []string - for _, f := range rel.BasePKs { - fromCols = append(fromCols, f.Name) - } - for _, f := range rel.JoinPKs { - toCols = append(toCols, f.Name) - } - - target := rel.JoinTable - state.ForeignKeys[ForeignKey{ - From: NewColumnReference(t.Name, fromCols...), - To: NewColumnReference(target.Name, toCols...), - }] = "" - } - } - return state, nil -} - -func parseLen(typ string) (string, int, error) { - paren := strings.Index(typ, "(") - if paren == -1 { - return typ, 0, nil - } - length, err := strconv.Atoi(typ[paren+1 : len(typ)-1]) - if err != nil { - return typ, 0, err - } - return typ[:paren], length, nil -} - -// exprOrLiteral converts string to lowercase, if it does not contain a string literal 'lit' -// and trims the surrounding '' otherwise. -// Use it to ensure that user-defined default values in the models are always comparable -// to those returned by the database inspector, regardless of the case convention in individual drivers. -func exprOrLiteral(s string) string { - if strings.HasPrefix(s, "'") && strings.HasSuffix(s, "'") { - return strings.Trim(s, "'") - } - return strings.ToLower(s) -} - -// BunModelSchema is the schema state derived from bun table models. -type BunModelSchema struct { - BaseDatabase - - Tables *ordered.Map[string, Table] -} - -func (ms BunModelSchema) GetTables() *ordered.Map[string, Table] { - return ms.Tables -} - -// BunTable provides additional table metadata that is only accessible from scanning bun models. -type BunTable struct { - BaseTable - - // Model stores the zero interface to the underlying Go struct. - Model interface{} -} diff --git a/vendor/github.com/uptrace/bun/migrate/sqlschema/migrator.go b/vendor/github.com/uptrace/bun/migrate/sqlschema/migrator.go deleted file mode 100644 index 00500061b..000000000 --- a/vendor/github.com/uptrace/bun/migrate/sqlschema/migrator.go +++ /dev/null @@ -1,49 +0,0 @@ -package sqlschema - -import ( - "fmt" - - "github.com/uptrace/bun" - "github.com/uptrace/bun/schema" -) - -type MigratorDialect interface { - schema.Dialect - NewMigrator(db *bun.DB, schemaName string) Migrator -} - -type Migrator interface { - AppendSQL(b []byte, operation interface{}) ([]byte, error) -} - -// migrator is a dialect-agnostic wrapper for sqlschema.MigratorDialect. -type migrator struct { - Migrator -} - -func NewMigrator(db *bun.DB, schemaName string) (Migrator, error) { - md, ok := db.Dialect().(MigratorDialect) - if !ok { - return nil, fmt.Errorf("%q dialect does not implement sqlschema.Migrator", db.Dialect().Name()) - } - return &migrator{ - Migrator: md.NewMigrator(db, schemaName), - }, nil -} - -// BaseMigrator can be embeded by dialect's Migrator implementations to re-use some of the existing bun queries. -type BaseMigrator struct { - db *bun.DB -} - -func NewBaseMigrator(db *bun.DB) *BaseMigrator { - return &BaseMigrator{db: db} -} - -func (m *BaseMigrator) AppendCreateTable(b []byte, model interface{}) ([]byte, error) { - return m.db.NewCreateTable().Model(model).AppendQuery(m.db.Formatter(), b) -} - -func (m *BaseMigrator) AppendDropTable(b []byte, schemaName, tableName string) ([]byte, error) { - return m.db.NewDropTable().TableExpr("?.?", bun.Ident(schemaName), bun.Ident(tableName)).AppendQuery(m.db.Formatter(), b) -} diff --git a/vendor/github.com/uptrace/bun/migrate/sqlschema/table.go b/vendor/github.com/uptrace/bun/migrate/sqlschema/table.go deleted file mode 100644 index ec9b77f69..000000000 --- a/vendor/github.com/uptrace/bun/migrate/sqlschema/table.go +++ /dev/null @@ -1,60 +0,0 @@ -package sqlschema - -import ( - "github.com/uptrace/bun/internal/ordered" -) - -type Table interface { - GetSchema() string - GetName() string - GetColumns() *ordered.Map[string, Column] - GetPrimaryKey() *PrimaryKey - GetUniqueConstraints() []Unique -} - -var _ Table = (*BaseTable)(nil) - -// BaseTable is a base table definition. -// -// Dialects and only dialects can use it to implement the Table interface. -// Other packages must use the Table interface. -type BaseTable struct { - Schema string - Name string - - // ColumnDefinitions map each column name to the column definition. - Columns *ordered.Map[string, Column] - - // PrimaryKey holds the primary key definition. - // A nil value means that no primary key is defined for the table. - PrimaryKey *PrimaryKey - - // UniqueConstraints defined on the table. - UniqueConstraints []Unique -} - -// PrimaryKey represents a primary key constraint defined on 1 or more columns. -type PrimaryKey struct { - Name string - Columns Columns -} - -func (td *BaseTable) GetSchema() string { - return td.Schema -} - -func (td *BaseTable) GetName() string { - return td.Name -} - -func (td *BaseTable) GetColumns() *ordered.Map[string, Column] { - return td.Columns -} - -func (td *BaseTable) GetPrimaryKey() *PrimaryKey { - return td.PrimaryKey -} - -func (td *BaseTable) GetUniqueConstraints() []Unique { - return td.UniqueConstraints -} diff --git a/vendor/github.com/uptrace/bun/model.go b/vendor/github.com/uptrace/bun/model.go deleted file mode 100644 index 6254fc3ed..000000000 --- a/vendor/github.com/uptrace/bun/model.go +++ /dev/null @@ -1,207 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "errors" - "fmt" - "reflect" - "time" - - "github.com/uptrace/bun/schema" -) - -var errNilModel = errors.New("bun: Model(nil)") - -var ( - timeType = reflect.TypeFor[time.Time]() - bytesType = reflect.TypeFor[[]byte]() -) - -type Model = schema.Model - -type rowScanner interface { - ScanRow(ctx context.Context, rows *sql.Rows) error -} - -type TableModel interface { - Model - - schema.BeforeAppendModelHook - schema.BeforeScanRowHook - schema.AfterScanRowHook - ScanColumn(column string, src interface{}) error - - Table() *schema.Table - Relation() *schema.Relation - - join(string) *relationJoin - getJoin(string) *relationJoin - getJoins() []relationJoin - addJoin(relationJoin) *relationJoin - - rootValue() reflect.Value - parentIndex() []int - mount(reflect.Value) - - updateSoftDeleteField(time.Time) error -} - -func newModel(db *DB, dest []interface{}) (Model, error) { - if len(dest) == 1 { - return _newModel(db, dest[0], true) - } - - values := make([]reflect.Value, len(dest)) - - for i, el := range dest { - v := reflect.ValueOf(el) - if v.Kind() != reflect.Ptr { - return nil, fmt.Errorf("bun: Scan(non-pointer %T)", dest) - } - - v = v.Elem() - if v.Kind() != reflect.Slice { - return newScanModel(db, dest), nil - } - - values[i] = v - } - - return newSliceModel(db, dest, values), nil -} - -func newSingleModel(db *DB, dest interface{}) (Model, error) { - return _newModel(db, dest, false) -} - -func _newModel(db *DB, dest interface{}, scan bool) (Model, error) { - switch dest := dest.(type) { - case nil: - return nil, errNilModel - case Model: - return dest, nil - case sql.Scanner: - if !scan { - return nil, fmt.Errorf("bun: Model(unsupported %T)", dest) - } - return newScanModel(db, []interface{}{dest}), nil - } - - v := reflect.ValueOf(dest) - if !v.IsValid() { - return nil, errNilModel - } - if v.Kind() != reflect.Ptr { - return nil, fmt.Errorf("bun: Model(non-pointer %T)", dest) - } - - if v.IsNil() { - typ := v.Type().Elem() - if typ.Kind() == reflect.Struct { - return newStructTableModel(db, dest, db.Table(typ)), nil - } - return nil, fmt.Errorf("bun: Model(nil %s %T)", typ.Kind(), dest) - } - - v = v.Elem() - typ := v.Type() - - switch typ { - case timeType, bytesType: - return newScanModel(db, []interface{}{dest}), nil - } - - switch v.Kind() { - case reflect.Map: - if err := validMap(typ); err != nil { - return nil, err - } - mapPtr := v.Addr().Interface().(*map[string]interface{}) - return newMapModel(db, mapPtr), nil - case reflect.Struct: - return newStructTableModelValue(db, dest, v), nil - case reflect.Slice: - switch elemType := sliceElemType(v); elemType.Kind() { - case reflect.Struct: - if elemType != timeType { - return newSliceTableModel(db, dest, v, elemType), nil - } - case reflect.Map: - if err := validMap(elemType); err != nil { - return nil, err - } - slicePtr := v.Addr().Interface().(*[]map[string]interface{}) - return newMapSliceModel(db, slicePtr), nil - } - return newSliceModel(db, []interface{}{dest}, []reflect.Value{v}), nil - } - - if scan { - return newScanModel(db, []interface{}{dest}), nil - } - - return nil, fmt.Errorf("bun: Model(unsupported %T)", dest) -} - -func newTableModelIndex( - db *DB, - table *schema.Table, - root reflect.Value, - index []int, - rel *schema.Relation, -) (TableModel, error) { - typ := typeByIndex(table.Type, index) - - if typ.Kind() == reflect.Struct { - return &structTableModel{ - db: db, - table: table.Dialect().Tables().Get(typ), - rel: rel, - - root: root, - index: index, - }, nil - } - - if typ.Kind() == reflect.Slice { - structType := indirectType(typ.Elem()) - if structType.Kind() == reflect.Struct { - m := sliceTableModel{ - structTableModel: structTableModel{ - db: db, - table: table.Dialect().Tables().Get(structType), - rel: rel, - - root: root, - index: index, - }, - } - m.init(typ) - return &m, nil - } - } - - return nil, fmt.Errorf("bun: NewModel(%s)", typ) -} - -func validMap(typ reflect.Type) error { - if typ.Key().Kind() != reflect.String || typ.Elem().Kind() != reflect.Interface { - return fmt.Errorf("bun: Model(unsupported %s) (expected *map[string]interface{})", - typ) - } - return nil -} - -//------------------------------------------------------------------------------ - -func isSingleRowModel(m Model) bool { - switch m.(type) { - case *mapModel, - *structTableModel, - *scanModel: - return true - default: - return false - } -} diff --git a/vendor/github.com/uptrace/bun/model_map.go b/vendor/github.com/uptrace/bun/model_map.go deleted file mode 100644 index d7342576f..000000000 --- a/vendor/github.com/uptrace/bun/model_map.go +++ /dev/null @@ -1,186 +0,0 @@ -package bun - -import ( - "bytes" - "context" - "database/sql" - "reflect" - "sort" - - "github.com/uptrace/bun/schema" -) - -type mapModel struct { - db *DB - - dest *map[string]interface{} - m map[string]interface{} - - rows *sql.Rows - columns []string - _columnTypes []*sql.ColumnType - scanIndex int -} - -var _ Model = (*mapModel)(nil) - -func newMapModel(db *DB, dest *map[string]interface{}) *mapModel { - m := &mapModel{ - db: db, - dest: dest, - } - if dest != nil { - m.m = *dest - } - return m -} - -func (m *mapModel) Value() interface{} { - return m.dest -} - -func (m *mapModel) ScanRows(ctx context.Context, rows *sql.Rows) (int, error) { - if !rows.Next() { - return 0, rows.Err() - } - - columns, err := rows.Columns() - if err != nil { - return 0, err - } - - m.rows = rows - m.columns = columns - dest := makeDest(m, len(columns)) - - if m.m == nil { - m.m = make(map[string]interface{}, len(m.columns)) - } - - m.scanIndex = 0 - if err := rows.Scan(dest...); err != nil { - return 0, err - } - - *m.dest = m.m - - return 1, nil -} - -func (m *mapModel) Scan(src interface{}) error { - if _, ok := src.([]byte); !ok { - return m.scanRaw(src) - } - - columnTypes, err := m.columnTypes() - if err != nil { - return err - } - - scanType := columnTypes[m.scanIndex].ScanType() - switch scanType.Kind() { - case reflect.Interface: - return m.scanRaw(src) - case reflect.Slice: - if scanType.Elem().Kind() == reflect.Uint8 { - // Reference types such as []byte are only valid until the next call to Scan. - src := bytes.Clone(src.([]byte)) - return m.scanRaw(src) - } - } - - dest := reflect.New(scanType).Elem() - if err := schema.Scanner(scanType)(dest, src); err != nil { - return err - } - - return m.scanRaw(dest.Interface()) -} - -func (m *mapModel) columnTypes() ([]*sql.ColumnType, error) { - if m._columnTypes == nil { - columnTypes, err := m.rows.ColumnTypes() - if err != nil { - return nil, err - } - m._columnTypes = columnTypes - } - return m._columnTypes, nil -} - -func (m *mapModel) scanRaw(src interface{}) error { - columnName := m.columns[m.scanIndex] - m.scanIndex++ - m.m[columnName] = src - return nil -} - -func (m *mapModel) appendColumnsValues(fmter schema.Formatter, b []byte) []byte { - keys := make([]string, 0, len(m.m)) - - for k := range m.m { - keys = append(keys, k) - } - sort.Strings(keys) - - b = append(b, " ("...) - - for i, k := range keys { - if i > 0 { - b = append(b, ", "...) - } - b = fmter.AppendIdent(b, k) - } - - b = append(b, ") VALUES ("...) - - isTemplate := fmter.IsNop() - for i, k := range keys { - if i > 0 { - b = append(b, ", "...) - } - if isTemplate { - b = append(b, '?') - } else { - b = schema.Append(fmter, b, m.m[k]) - } - } - - b = append(b, ")"...) - - return b -} - -func (m *mapModel) appendSet(fmter schema.Formatter, b []byte) []byte { - keys := make([]string, 0, len(m.m)) - - for k := range m.m { - keys = append(keys, k) - } - sort.Strings(keys) - - isTemplate := fmter.IsNop() - for i, k := range keys { - if i > 0 { - b = append(b, ", "...) - } - - b = fmter.AppendIdent(b, k) - b = append(b, " = "...) - if isTemplate { - b = append(b, '?') - } else { - b = schema.Append(fmter, b, m.m[k]) - } - } - - return b -} - -func makeDest(v interface{}, n int) []interface{} { - dest := make([]interface{}, n) - for i := range dest { - dest[i] = v - } - return dest -} diff --git a/vendor/github.com/uptrace/bun/model_map_slice.go b/vendor/github.com/uptrace/bun/model_map_slice.go deleted file mode 100644 index 8e4a22f6b..000000000 --- a/vendor/github.com/uptrace/bun/model_map_slice.go +++ /dev/null @@ -1,162 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "errors" - "sort" - - "github.com/uptrace/bun/dialect/feature" - "github.com/uptrace/bun/schema" -) - -type mapSliceModel struct { - mapModel - dest *[]map[string]interface{} - - keys []string -} - -var _ Model = (*mapSliceModel)(nil) - -func newMapSliceModel(db *DB, dest *[]map[string]interface{}) *mapSliceModel { - return &mapSliceModel{ - mapModel: mapModel{ - db: db, - }, - dest: dest, - } -} - -func (m *mapSliceModel) Value() interface{} { - return m.dest -} - -func (m *mapSliceModel) SetCap(cap int) { - if cap > 100 { - cap = 100 - } - if slice := *m.dest; len(slice) < cap { - *m.dest = make([]map[string]interface{}, 0, cap) - } -} - -func (m *mapSliceModel) ScanRows(ctx context.Context, rows *sql.Rows) (int, error) { - columns, err := rows.Columns() - if err != nil { - return 0, err - } - - m.rows = rows - m.columns = columns - dest := makeDest(m, len(columns)) - - slice := *m.dest - if len(slice) > 0 { - slice = slice[:0] - } - - var n int - - for rows.Next() { - m.m = make(map[string]interface{}, len(m.columns)) - - m.scanIndex = 0 - if err := rows.Scan(dest...); err != nil { - return 0, err - } - - slice = append(slice, m.m) - n++ - } - if err := rows.Err(); err != nil { - return 0, err - } - - *m.dest = slice - return n, nil -} - -func (m *mapSliceModel) appendColumns(fmter schema.Formatter, b []byte) (_ []byte, err error) { - if err := m.initKeys(); err != nil { - return nil, err - } - - for i, k := range m.keys { - if i > 0 { - b = append(b, ", "...) - } - b = fmter.AppendIdent(b, k) - } - - return b, nil -} - -func (m *mapSliceModel) appendValues(fmter schema.Formatter, b []byte) (_ []byte, err error) { - if err := m.initKeys(); err != nil { - return nil, err - } - slice := *m.dest - - b = append(b, "VALUES "...) - if m.db.HasFeature(feature.ValuesRow) { - b = append(b, "ROW("...) - } else { - b = append(b, '(') - } - - if fmter.IsNop() { - for i := range m.keys { - if i > 0 { - b = append(b, ", "...) - } - b = append(b, '?') - } - return b, nil - } - - for i, el := range slice { - if i > 0 { - b = append(b, "), "...) - if m.db.HasFeature(feature.ValuesRow) { - b = append(b, "ROW("...) - } else { - b = append(b, '(') - } - } - - for j, key := range m.keys { - if j > 0 { - b = append(b, ", "...) - } - b = schema.Append(fmter, b, el[key]) - } - } - - b = append(b, ')') - - return b, nil -} - -func (m *mapSliceModel) initKeys() error { - if m.keys != nil { - return nil - } - - slice := *m.dest - if len(slice) == 0 { - return errors.New("bun: map slice is empty") - } - - first := slice[0] - keys := make([]string, 0, len(first)) - - for k := range first { - keys = append(keys, k) - } - - sort.Strings(keys) - m.keys = keys - - return nil -} diff --git a/vendor/github.com/uptrace/bun/model_scan.go b/vendor/github.com/uptrace/bun/model_scan.go deleted file mode 100644 index 48149c4b6..000000000 --- a/vendor/github.com/uptrace/bun/model_scan.go +++ /dev/null @@ -1,56 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "reflect" - - "github.com/uptrace/bun/schema" -) - -type scanModel struct { - db *DB - - dest []interface{} - scanIndex int -} - -var _ Model = (*scanModel)(nil) - -func newScanModel(db *DB, dest []interface{}) *scanModel { - return &scanModel{ - db: db, - dest: dest, - } -} - -func (m *scanModel) Value() interface{} { - return m.dest -} - -func (m *scanModel) ScanRows(ctx context.Context, rows *sql.Rows) (int, error) { - if !rows.Next() { - return 0, rows.Err() - } - - dest := makeDest(m, len(m.dest)) - - m.scanIndex = 0 - if err := rows.Scan(dest...); err != nil { - return 0, err - } - - return 1, nil -} - -func (m *scanModel) ScanRow(ctx context.Context, rows *sql.Rows) error { - return rows.Scan(m.dest...) -} - -func (m *scanModel) Scan(src interface{}) error { - dest := reflect.ValueOf(m.dest[m.scanIndex]) - m.scanIndex++ - - scanner := schema.Scanner(dest.Type()) - return scanner(dest, src) -} diff --git a/vendor/github.com/uptrace/bun/model_slice.go b/vendor/github.com/uptrace/bun/model_slice.go deleted file mode 100644 index bc29db41f..000000000 --- a/vendor/github.com/uptrace/bun/model_slice.go +++ /dev/null @@ -1,82 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "reflect" - - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type sliceInfo struct { - nextElem func() reflect.Value - scan schema.ScannerFunc -} - -type sliceModel struct { - dest []interface{} - values []reflect.Value - scanIndex int - info []sliceInfo -} - -var _ Model = (*sliceModel)(nil) - -func newSliceModel(db *DB, dest []interface{}, values []reflect.Value) *sliceModel { - return &sliceModel{ - dest: dest, - values: values, - } -} - -func (m *sliceModel) Value() interface{} { - return m.dest -} - -func (m *sliceModel) ScanRows(ctx context.Context, rows *sql.Rows) (int, error) { - columns, err := rows.Columns() - if err != nil { - return 0, err - } - - m.info = make([]sliceInfo, len(m.values)) - for i, v := range m.values { - if v.IsValid() && v.Len() > 0 { - v.Set(v.Slice(0, 0)) - } - - m.info[i] = sliceInfo{ - nextElem: internal.MakeSliceNextElemFunc(v), - scan: schema.Scanner(v.Type().Elem()), - } - } - - if len(columns) == 0 { - return 0, nil - } - dest := makeDest(m, len(columns)) - - var n int - - for rows.Next() { - m.scanIndex = 0 - if err := rows.Scan(dest...); err != nil { - return 0, err - } - n++ - } - if err := rows.Err(); err != nil { - return 0, err - } - - return n, nil -} - -func (m *sliceModel) Scan(src interface{}) error { - info := m.info[m.scanIndex] - m.scanIndex++ - - dest := info.nextElem() - return info.scan(dest, src) -} diff --git a/vendor/github.com/uptrace/bun/model_table_has_many.go b/vendor/github.com/uptrace/bun/model_table_has_many.go deleted file mode 100644 index c7bdee98a..000000000 --- a/vendor/github.com/uptrace/bun/model_table_has_many.go +++ /dev/null @@ -1,176 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "database/sql/driver" - "fmt" - "reflect" - - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type hasManyModel struct { - *sliceTableModel - baseTable *schema.Table - rel *schema.Relation - - baseValues map[internal.MapKey][]reflect.Value - structKey []interface{} -} - -var _ TableModel = (*hasManyModel)(nil) - -func newHasManyModel(j *relationJoin) *hasManyModel { - baseTable := j.BaseModel.Table() - joinModel := j.JoinModel.(*sliceTableModel) - baseValues := baseValues(joinModel, j.Relation.BasePKs) - if len(baseValues) == 0 { - return nil - } - m := hasManyModel{ - sliceTableModel: joinModel, - baseTable: baseTable, - rel: j.Relation, - - baseValues: baseValues, - } - if !m.sliceOfPtr { - m.strct = reflect.New(m.table.Type).Elem() - } - return &m -} - -func (m *hasManyModel) ScanRows(ctx context.Context, rows *sql.Rows) (int, error) { - columns, err := rows.Columns() - if err != nil { - return 0, err - } - - m.columns = columns - dest := makeDest(m, len(columns)) - - var n int - m.structKey = make([]interface{}, len(m.rel.JoinPKs)) - for rows.Next() { - if m.sliceOfPtr { - m.strct = reflect.New(m.table.Type).Elem() - } else { - m.strct.Set(m.table.ZeroValue) - } - m.structInited = false - m.scanIndex = 0 - - if err := rows.Scan(dest...); err != nil { - return 0, err - } - - if err := m.parkStruct(); err != nil { - return 0, err - } - - n++ - } - if err := rows.Err(); err != nil { - return 0, err - } - - return n, nil -} - -func (m *hasManyModel) Scan(src interface{}) error { - column := m.columns[m.scanIndex] - m.scanIndex++ - - field := m.table.LookupField(column) - if field == nil { - return fmt.Errorf("bun: %s does not have column %q", m.table.TypeName, column) - } - - if err := field.ScanValue(m.strct, src); err != nil { - return err - } - - for i, f := range m.rel.JoinPKs { - if f.Name == column { - m.structKey[i] = indirectAsKey(field.Value(m.strct)) - break - } - } - - return nil -} - -func (m *hasManyModel) parkStruct() error { - - baseValues, ok := m.baseValues[internal.NewMapKey(m.structKey)] - if !ok { - return fmt.Errorf( - "bun: has-many relation=%s does not have base %s with id=%q (check join conditions)", - m.rel.Field.GoName, m.baseTable, m.structKey) - } - - for i, v := range baseValues { - if !m.sliceOfPtr { - v.Set(reflect.Append(v, m.strct)) - continue - } - - if i == 0 { - v.Set(reflect.Append(v, m.strct.Addr())) - continue - } - - clone := reflect.New(m.strct.Type()).Elem() - clone.Set(m.strct) - v.Set(reflect.Append(v, clone.Addr())) - } - - return nil -} - -func baseValues(model TableModel, fields []*schema.Field) map[internal.MapKey][]reflect.Value { - fieldIndex := model.Relation().Field.Index - m := make(map[internal.MapKey][]reflect.Value) - key := make([]interface{}, 0, len(fields)) - walk(model.rootValue(), model.parentIndex(), func(v reflect.Value) { - key = modelKey(key[:0], v, fields) - mapKey := internal.NewMapKey(key) - m[mapKey] = append(m[mapKey], v.FieldByIndex(fieldIndex)) - }) - return m -} - -func modelKey(key []interface{}, strct reflect.Value, fields []*schema.Field) []interface{} { - for _, f := range fields { - key = append(key, indirectAsKey(f.Value(strct))) - } - return key -} - -// indirectAsKey return the field value dereferencing the pointer if necessary. -// The value is then used as a map key. -func indirectAsKey(field reflect.Value) interface{} { - if field.Kind() != reflect.Ptr { - i := field.Interface() - if valuer, ok := i.(driver.Valuer); ok { - if v, err := valuer.Value(); err == nil { - switch reflect.TypeOf(v).Kind() { - case reflect.Array, reflect.Chan, reflect.Func, - reflect.Map, reflect.Ptr, reflect.Slice, reflect.UnsafePointer: - // NOTE #1107, these types cannot be used as map key, - // let us use original logic. - return i - default: - return v - } - } - } - return i - } - if field.IsNil() { - return nil - } - return field.Elem().Interface() -} diff --git a/vendor/github.com/uptrace/bun/model_table_m2m.go b/vendor/github.com/uptrace/bun/model_table_m2m.go deleted file mode 100644 index 1a6b1b46a..000000000 --- a/vendor/github.com/uptrace/bun/model_table_m2m.go +++ /dev/null @@ -1,132 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "fmt" - "reflect" - - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type m2mModel struct { - *sliceTableModel - baseTable *schema.Table - rel *schema.Relation - - baseValues map[internal.MapKey][]reflect.Value - structKey []interface{} -} - -var _ TableModel = (*m2mModel)(nil) - -func newM2MModel(j *relationJoin) *m2mModel { - baseTable := j.BaseModel.Table() - joinModel := j.JoinModel.(*sliceTableModel) - baseValues := baseValues(joinModel, j.Relation.BasePKs) - if len(baseValues) == 0 { - return nil - } - m := &m2mModel{ - sliceTableModel: joinModel, - baseTable: baseTable, - rel: j.Relation, - - baseValues: baseValues, - } - if !m.sliceOfPtr { - m.strct = reflect.New(m.table.Type).Elem() - } - return m -} - -func (m *m2mModel) ScanRows(ctx context.Context, rows *sql.Rows) (int, error) { - columns, err := rows.Columns() - if err != nil { - return 0, err - } - - m.columns = columns - dest := makeDest(m, len(columns)) - - var n int - - for rows.Next() { - if m.sliceOfPtr { - m.strct = reflect.New(m.table.Type).Elem() - } else { - m.strct.Set(m.table.ZeroValue) - } - m.structInited = false - - m.scanIndex = 0 - m.structKey = m.structKey[:0] - if err := rows.Scan(dest...); err != nil { - return 0, err - } - - if err := m.parkStruct(); err != nil { - return 0, err - } - - n++ - } - if err := rows.Err(); err != nil { - return 0, err - } - - return n, nil -} - -func (m *m2mModel) Scan(src interface{}) error { - column := m.columns[m.scanIndex] - m.scanIndex++ - - // Base pks must come first. - if m.scanIndex <= len(m.rel.M2MBasePKs) { - return m.scanM2MColumn(column, src) - } - - if field, ok := m.table.FieldMap[column]; ok { - return field.ScanValue(m.strct, src) - } - - _, err := m.scanColumn(column, src) - return err -} - -func (m *m2mModel) scanM2MColumn(column string, src interface{}) error { - for _, field := range m.rel.M2MBasePKs { - if field.Name == column { - dest := reflect.New(field.IndirectType).Elem() - if err := field.Scan(dest, src); err != nil { - return err - } - m.structKey = append(m.structKey, indirectAsKey(dest)) - break - } - } - - _, err := m.scanColumn(column, src) - return err -} - -func (m *m2mModel) parkStruct() error { - baseValues, ok := m.baseValues[internal.NewMapKey(m.structKey)] - if !ok { - return fmt.Errorf( - "bun: m2m relation=%s does not have base %s with key=%q (check join conditions)", - m.rel.Field.GoName, m.baseTable, m.structKey) - } - - for _, v := range baseValues { - if m.sliceOfPtr { - v.Set(reflect.Append(v, m.strct.Addr())) - } else { - v.Set(reflect.Append(v, m.strct)) - } - } - - return nil -} diff --git a/vendor/github.com/uptrace/bun/model_table_slice.go b/vendor/github.com/uptrace/bun/model_table_slice.go deleted file mode 100644 index 67b421460..000000000 --- a/vendor/github.com/uptrace/bun/model_table_slice.go +++ /dev/null @@ -1,126 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "reflect" - "time" - - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type sliceTableModel struct { - structTableModel - - slice reflect.Value - sliceLen int - sliceOfPtr bool - nextElem func() reflect.Value -} - -var _ TableModel = (*sliceTableModel)(nil) - -func newSliceTableModel( - db *DB, dest interface{}, slice reflect.Value, elemType reflect.Type, -) *sliceTableModel { - m := &sliceTableModel{ - structTableModel: structTableModel{ - db: db, - table: db.Table(elemType), - dest: dest, - root: slice, - }, - - slice: slice, - sliceLen: slice.Len(), - nextElem: internal.MakeSliceNextElemFunc(slice), - } - m.init(slice.Type()) - return m -} - -func (m *sliceTableModel) init(sliceType reflect.Type) { - switch sliceType.Elem().Kind() { - case reflect.Ptr, reflect.Interface: - m.sliceOfPtr = true - } -} - -func (m *sliceTableModel) join(name string) *relationJoin { - return m._join(m.slice, name) -} - -func (m *sliceTableModel) ScanRows(ctx context.Context, rows *sql.Rows) (int, error) { - columns, err := rows.Columns() - if err != nil { - return 0, err - } - - m.columns = columns - dest := makeDest(m, len(columns)) - - if m.slice.IsValid() && m.slice.Len() > 0 { - m.slice.Set(m.slice.Slice(0, 0)) - } - - var n int - - for rows.Next() { - m.strct = m.nextElem() - if m.sliceOfPtr { - m.strct = m.strct.Elem() - } - m.structInited = false - - if err := m.scanRow(ctx, rows, dest); err != nil { - return 0, err - } - - n++ - } - if err := rows.Err(); err != nil { - return 0, err - } - - return n, nil -} - -var _ schema.BeforeAppendModelHook = (*sliceTableModel)(nil) - -func (m *sliceTableModel) BeforeAppendModel(ctx context.Context, query Query) error { - if !m.table.HasBeforeAppendModelHook() || !m.slice.IsValid() { - return nil - } - - sliceLen := m.slice.Len() - for i := 0; i < sliceLen; i++ { - strct := m.slice.Index(i) - if !m.sliceOfPtr { - strct = strct.Addr() - } - err := strct.Interface().(schema.BeforeAppendModelHook).BeforeAppendModel(ctx, query) - if err != nil { - return err - } - } - return nil -} - -// Inherit these hooks from structTableModel. -var ( - _ schema.BeforeScanRowHook = (*sliceTableModel)(nil) - _ schema.AfterScanRowHook = (*sliceTableModel)(nil) -) - -func (m *sliceTableModel) updateSoftDeleteField(tm time.Time) error { - sliceLen := m.slice.Len() - for i := 0; i < sliceLen; i++ { - strct := indirect(m.slice.Index(i)) - fv := m.table.SoftDeleteField.Value(strct) - if err := m.table.UpdateSoftDeleteField(fv, tm); err != nil { - return err - } - } - return nil -} diff --git a/vendor/github.com/uptrace/bun/model_table_struct.go b/vendor/github.com/uptrace/bun/model_table_struct.go deleted file mode 100644 index a8860908e..000000000 --- a/vendor/github.com/uptrace/bun/model_table_struct.go +++ /dev/null @@ -1,356 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "fmt" - "reflect" - "strings" - "time" - - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type structTableModel struct { - db *DB - table *schema.Table - - rel *schema.Relation - joins []relationJoin - - dest interface{} - root reflect.Value - index []int - - strct reflect.Value - structInited bool - structInitErr error - - columns []string - scanIndex int -} - -var _ TableModel = (*structTableModel)(nil) - -func newStructTableModel(db *DB, dest interface{}, table *schema.Table) *structTableModel { - return &structTableModel{ - db: db, - table: table, - dest: dest, - } -} - -func newStructTableModelValue(db *DB, dest interface{}, v reflect.Value) *structTableModel { - return &structTableModel{ - db: db, - table: db.Table(v.Type()), - dest: dest, - root: v, - strct: v, - } -} - -func (m *structTableModel) Value() interface{} { - return m.dest -} - -func (m *structTableModel) Table() *schema.Table { - return m.table -} - -func (m *structTableModel) Relation() *schema.Relation { - return m.rel -} - -func (m *structTableModel) initStruct() error { - if m.structInited { - return m.structInitErr - } - m.structInited = true - - switch m.strct.Kind() { - case reflect.Invalid: - m.structInitErr = errNilModel - return m.structInitErr - case reflect.Interface: - m.strct = m.strct.Elem() - } - - if m.strct.Kind() == reflect.Ptr { - if m.strct.IsNil() { - m.strct.Set(reflect.New(m.strct.Type().Elem())) - m.strct = m.strct.Elem() - } else { - m.strct = m.strct.Elem() - } - } - - m.mountJoins() - - return nil -} - -func (m *structTableModel) mountJoins() { - for i := range m.joins { - j := &m.joins[i] - switch j.Relation.Type { - case schema.HasOneRelation, schema.BelongsToRelation: - j.JoinModel.mount(m.strct) - } - } -} - -var _ schema.BeforeAppendModelHook = (*structTableModel)(nil) - -func (m *structTableModel) BeforeAppendModel(ctx context.Context, query Query) error { - if !m.table.HasBeforeAppendModelHook() || !m.strct.IsValid() { - return nil - } - return m.strct.Addr().Interface().(schema.BeforeAppendModelHook).BeforeAppendModel(ctx, query) -} - -var _ schema.BeforeScanRowHook = (*structTableModel)(nil) - -func (m *structTableModel) BeforeScanRow(ctx context.Context) error { - if m.table.HasBeforeScanRowHook() { - return m.strct.Addr().Interface().(schema.BeforeScanRowHook).BeforeScanRow(ctx) - } - return nil -} - -var _ schema.AfterScanRowHook = (*structTableModel)(nil) - -func (m *structTableModel) AfterScanRow(ctx context.Context) error { - if !m.structInited { - return nil - } - - if m.table.HasAfterScanRowHook() { - firstErr := m.strct.Addr().Interface().(schema.AfterScanRowHook).AfterScanRow(ctx) - - for _, j := range m.joins { - switch j.Relation.Type { - case schema.HasOneRelation, schema.BelongsToRelation: - if err := j.JoinModel.AfterScanRow(ctx); err != nil && firstErr == nil { - firstErr = err - } - } - } - - return firstErr - } - - return nil -} - -func (m *structTableModel) getJoin(name string) *relationJoin { - for i := range m.joins { - j := &m.joins[i] - if j.Relation.Field.Name == name || j.Relation.Field.GoName == name { - return j - } - } - return nil -} - -func (m *structTableModel) getJoins() []relationJoin { - return m.joins -} - -func (m *structTableModel) addJoin(j relationJoin) *relationJoin { - m.joins = append(m.joins, j) - return &m.joins[len(m.joins)-1] -} - -func (m *structTableModel) join(name string) *relationJoin { - return m._join(m.strct, name) -} - -func (m *structTableModel) _join(bind reflect.Value, name string) *relationJoin { - path := strings.Split(name, ".") - index := make([]int, 0, len(path)) - - currJoin := relationJoin{ - BaseModel: m, - JoinModel: m, - } - var lastJoin *relationJoin - - for _, name := range path { - relation, ok := currJoin.JoinModel.Table().Relations[name] - if !ok { - return nil - } - - currJoin.Relation = relation - index = append(index, relation.Field.Index...) - - if j := currJoin.JoinModel.getJoin(name); j != nil { - currJoin.BaseModel = j.BaseModel - currJoin.JoinModel = j.JoinModel - - lastJoin = j - } else { - model, err := newTableModelIndex(m.db, m.table, bind, index, relation) - if err != nil { - return nil - } - - currJoin.Parent = lastJoin - currJoin.BaseModel = currJoin.JoinModel - currJoin.JoinModel = model - - lastJoin = currJoin.BaseModel.addJoin(currJoin) - } - } - - return lastJoin -} - -func (m *structTableModel) rootValue() reflect.Value { - return m.root -} - -func (m *structTableModel) parentIndex() []int { - return m.index[:len(m.index)-len(m.rel.Field.Index)] -} - -func (m *structTableModel) mount(host reflect.Value) { - m.strct = internal.FieldByIndexAlloc(host, m.rel.Field.Index) - m.structInited = false -} - -func (m *structTableModel) updateSoftDeleteField(tm time.Time) error { - if !m.strct.IsValid() { - return nil - } - fv := m.table.SoftDeleteField.Value(m.strct) - return m.table.UpdateSoftDeleteField(fv, tm) -} - -func (m *structTableModel) ScanRows(ctx context.Context, rows *sql.Rows) (int, error) { - if !rows.Next() { - return 0, rows.Err() - } - - var n int - - if err := m.ScanRow(ctx, rows); err != nil { - return 0, err - } - n++ - - // And discard the rest. This is especially important for SQLite3, which can return - // a row like it was inserted successfully and then return an actual error for the next row. - // See issues/100. - for rows.Next() { - n++ - } - if err := rows.Err(); err != nil { - return 0, err - } - - return n, nil -} - -func (m *structTableModel) ScanRow(ctx context.Context, rows *sql.Rows) error { - columns, err := rows.Columns() - if err != nil { - return err - } - - m.columns = columns - dest := makeDest(m, len(columns)) - - return m.scanRow(ctx, rows, dest) -} - -func (m *structTableModel) scanRow(ctx context.Context, rows *sql.Rows, dest []interface{}) error { - if err := m.BeforeScanRow(ctx); err != nil { - return err - } - - m.scanIndex = 0 - if err := rows.Scan(dest...); err != nil { - return err - } - - if err := m.AfterScanRow(ctx); err != nil { - return err - } - - return nil -} - -func (m *structTableModel) Scan(src interface{}) error { - column := m.columns[m.scanIndex] - m.scanIndex++ - - return m.ScanColumn(unquote(column), src) -} - -func (m *structTableModel) ScanColumn(column string, src interface{}) error { - if ok, err := m.scanColumn(column, src); ok { - return err - } - if column == "" || column[0] == '_' || m.db.flags.Has(discardUnknownColumns) { - return nil - } - return fmt.Errorf("bun: %s does not have column %q", m.table.TypeName, column) -} - -func (m *structTableModel) scanColumn(column string, src interface{}) (bool, error) { - if src != nil { - if err := m.initStruct(); err != nil { - return true, err - } - } - - if field := m.table.LookupField(column); field != nil { - if src == nil && m.isNil() { - return true, nil - } - return true, field.ScanValue(m.strct, src) - } - - if joinName, column := splitColumn(column); joinName != "" { - if join := m.getJoin(joinName); join != nil { - return true, join.JoinModel.ScanColumn(column, src) - } - - if m.table.ModelName == joinName { - return true, m.ScanColumn(column, src) - } - } - - return false, nil -} - -func (m *structTableModel) isNil() bool { - return m.strct.Kind() == reflect.Ptr && m.strct.IsNil() -} - -func (m *structTableModel) AppendNamedArg( - fmter schema.Formatter, b []byte, name string, -) ([]byte, bool) { - return m.table.AppendNamedArg(fmter, b, name, m.strct) -} - -// sqlite3 sometimes does not unquote columns. -func unquote(s string) string { - if s == "" { - return s - } - if s[0] == '"' && s[len(s)-1] == '"' { - return s[1 : len(s)-1] - } - return s -} - -func splitColumn(s string) (string, string) { - if i := strings.Index(s, "__"); i >= 0 { - return s[:i], s[i+2:] - } - return "", s -} diff --git a/vendor/github.com/uptrace/bun/package.json b/vendor/github.com/uptrace/bun/package.json deleted file mode 100644 index bedb0ba29..000000000 --- a/vendor/github.com/uptrace/bun/package.json +++ /dev/null @@ -1,8 +0,0 @@ -{ - "name": "gobun", - "version": "1.2.9", - "main": "index.js", - "repository": "git@github.com:uptrace/bun.git", - "author": "Vladimir Mihailenco <vladimir.webdev@gmail.com>", - "license": "BSD-2-clause" -} diff --git a/vendor/github.com/uptrace/bun/query_base.go b/vendor/github.com/uptrace/bun/query_base.go deleted file mode 100644 index b17498742..000000000 --- a/vendor/github.com/uptrace/bun/query_base.go +++ /dev/null @@ -1,1477 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "database/sql/driver" - "errors" - "fmt" - "strconv" - "strings" - "time" - - "github.com/uptrace/bun/dialect" - "github.com/uptrace/bun/dialect/feature" - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -const ( - forceDeleteFlag internal.Flag = 1 << iota - deletedFlag - allWithDeletedFlag -) - -type withQuery struct { - name string - query Query - recursive bool -} - -// IConn is a common interface for *sql.DB, *sql.Conn, and *sql.Tx. -type IConn interface { - QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error) - ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error) - QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row -} - -var ( - _ IConn = (*sql.DB)(nil) - _ IConn = (*sql.Conn)(nil) - _ IConn = (*sql.Tx)(nil) - _ IConn = (*DB)(nil) - _ IConn = (*Conn)(nil) - _ IConn = (*Tx)(nil) -) - -// IDB is a common interface for *bun.DB, bun.Conn, and bun.Tx. -type IDB interface { - IConn - Dialect() schema.Dialect - - NewValues(model interface{}) *ValuesQuery - NewSelect() *SelectQuery - NewInsert() *InsertQuery - NewUpdate() *UpdateQuery - NewDelete() *DeleteQuery - NewMerge() *MergeQuery - NewRaw(query string, args ...interface{}) *RawQuery - NewCreateTable() *CreateTableQuery - NewDropTable() *DropTableQuery - NewCreateIndex() *CreateIndexQuery - NewDropIndex() *DropIndexQuery - NewTruncateTable() *TruncateTableQuery - NewAddColumn() *AddColumnQuery - NewDropColumn() *DropColumnQuery - - BeginTx(ctx context.Context, opts *sql.TxOptions) (Tx, error) - RunInTx(ctx context.Context, opts *sql.TxOptions, f func(ctx context.Context, tx Tx) error) error -} - -var ( - _ IDB = (*DB)(nil) - _ IDB = (*Conn)(nil) - _ IDB = (*Tx)(nil) -) - -// QueryBuilder is used for common query methods -type QueryBuilder interface { - Query - Where(query string, args ...interface{}) QueryBuilder - WhereGroup(sep string, fn func(QueryBuilder) QueryBuilder) QueryBuilder - WhereOr(query string, args ...interface{}) QueryBuilder - WhereDeleted() QueryBuilder - WhereAllWithDeleted() QueryBuilder - WherePK(cols ...string) QueryBuilder - Unwrap() interface{} -} - -var ( - _ QueryBuilder = (*selectQueryBuilder)(nil) - _ QueryBuilder = (*updateQueryBuilder)(nil) - _ QueryBuilder = (*deleteQueryBuilder)(nil) -) - -type baseQuery struct { - db *DB - conn IConn - - model Model - err error - - tableModel TableModel - table *schema.Table - - with []withQuery - modelTableName schema.QueryWithArgs - tables []schema.QueryWithArgs - columns []schema.QueryWithArgs - - flags internal.Flag -} - -func (q *baseQuery) DB() *DB { - return q.db -} - -func (q *baseQuery) resolveConn(query Query) IConn { - if q.conn != nil { - return q.conn - } - if q.db.resolver != nil { - if conn := q.db.resolver.ResolveConn(query); conn != nil { - return conn - } - } - return q.db.DB -} - -func (q *baseQuery) GetModel() Model { - return q.model -} - -func (q *baseQuery) GetTableName() string { - if q.table != nil { - return q.table.Name - } - - for _, wq := range q.with { - if model := wq.query.GetModel(); model != nil { - return wq.query.GetTableName() - } - } - - if q.modelTableName.Query != "" { - return q.modelTableName.Query - } - - if len(q.tables) > 0 { - b, _ := q.tables[0].AppendQuery(q.db.fmter, nil) - if len(b) < 64 { - return string(b) - } - } - - return "" -} - -func (q *baseQuery) setConn(db IConn) { - // Unwrap Bun wrappers to not call query hooks twice. - switch db := db.(type) { - case *DB: - q.conn = db.DB - case Conn: - q.conn = db.Conn - case Tx: - q.conn = db.Tx - default: - q.conn = db - } -} - -func (q *baseQuery) setModel(modeli interface{}) { - model, err := newSingleModel(q.db, modeli) - if err != nil { - q.setErr(err) - return - } - - q.model = model - if tm, ok := model.(TableModel); ok { - q.tableModel = tm - q.table = tm.Table() - } -} - -func (q *baseQuery) setErr(err error) { - if q.err == nil { - q.err = err - } -} - -func (q *baseQuery) getModel(dest []interface{}) (Model, error) { - if len(dest) > 0 { - return newModel(q.db, dest) - } - if q.model != nil { - return q.model, nil - } - return nil, errNilModel -} - -func (q *baseQuery) beforeAppendModel(ctx context.Context, query Query) error { - if q.tableModel != nil { - return q.tableModel.BeforeAppendModel(ctx, query) - } - return nil -} - -func (q *baseQuery) hasFeature(feature feature.Feature) bool { - return q.db.HasFeature(feature) -} - -//------------------------------------------------------------------------------ - -func (q *baseQuery) checkSoftDelete() error { - if q.table == nil { - return errors.New("bun: can't use soft deletes without a table") - } - if q.table.SoftDeleteField == nil { - return fmt.Errorf("%s does not have a soft delete field", q.table) - } - if q.tableModel == nil { - return errors.New("bun: can't use soft deletes without a table model") - } - return nil -} - -// Deleted adds `WHERE deleted_at IS NOT NULL` clause for soft deleted models. -func (q *baseQuery) whereDeleted() { - if err := q.checkSoftDelete(); err != nil { - q.setErr(err) - return - } - q.flags = q.flags.Set(deletedFlag) - q.flags = q.flags.Remove(allWithDeletedFlag) -} - -// AllWithDeleted changes query to return all rows including soft deleted ones. -func (q *baseQuery) whereAllWithDeleted() { - if err := q.checkSoftDelete(); err != nil { - q.setErr(err) - return - } - q.flags = q.flags.Set(allWithDeletedFlag).Remove(deletedFlag) -} - -func (q *baseQuery) isSoftDelete() bool { - if q.table != nil { - return q.table.SoftDeleteField != nil && - !q.flags.Has(allWithDeletedFlag) && - (!q.flags.Has(forceDeleteFlag) || q.flags.Has(deletedFlag)) - } - return false -} - -//------------------------------------------------------------------------------ - -func (q *baseQuery) addWith(name string, query Query, recursive bool) { - q.with = append(q.with, withQuery{ - name: name, - query: query, - recursive: recursive, - }) -} - -func (q *baseQuery) appendWith(fmter schema.Formatter, b []byte) (_ []byte, err error) { - if len(q.with) == 0 { - return b, nil - } - - b = append(b, "WITH "...) - for i, with := range q.with { - if i > 0 { - b = append(b, ", "...) - } - - if with.recursive { - b = append(b, "RECURSIVE "...) - } - - b, err = q.appendCTE(fmter, b, with) - if err != nil { - return nil, err - } - } - b = append(b, ' ') - return b, nil -} - -func (q *baseQuery) appendCTE( - fmter schema.Formatter, b []byte, cte withQuery, -) (_ []byte, err error) { - if !fmter.Dialect().Features().Has(feature.WithValues) { - if values, ok := cte.query.(*ValuesQuery); ok { - return q.appendSelectFromValues(fmter, b, cte, values) - } - } - - b = fmter.AppendIdent(b, cte.name) - - if q, ok := cte.query.(schema.ColumnsAppender); ok { - b = append(b, " ("...) - b, err = q.AppendColumns(fmter, b) - if err != nil { - return nil, err - } - b = append(b, ")"...) - } - - b = append(b, " AS ("...) - - b, err = cte.query.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - - b = append(b, ")"...) - return b, nil -} - -func (q *baseQuery) appendSelectFromValues( - fmter schema.Formatter, b []byte, cte withQuery, values *ValuesQuery, -) (_ []byte, err error) { - b = fmter.AppendIdent(b, cte.name) - b = append(b, " AS (SELECT * FROM ("...) - - b, err = cte.query.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - - b = append(b, ") AS t"...) - if q, ok := cte.query.(schema.ColumnsAppender); ok { - b = append(b, " ("...) - b, err = q.AppendColumns(fmter, b) - if err != nil { - return nil, err - } - b = append(b, ")"...) - } - b = append(b, ")"...) - - return b, nil -} - -//------------------------------------------------------------------------------ - -func (q *baseQuery) addTable(table schema.QueryWithArgs) { - q.tables = append(q.tables, table) -} - -func (q *baseQuery) addColumn(column schema.QueryWithArgs) { - q.columns = append(q.columns, column) -} - -func (q *baseQuery) excludeColumn(columns []string) { - if q.table == nil { - q.setErr(errNilModel) - return - } - - if q.columns == nil { - for _, f := range q.table.Fields { - q.columns = append(q.columns, schema.UnsafeIdent(f.Name)) - } - } - - if len(columns) == 1 && columns[0] == "*" { - q.columns = make([]schema.QueryWithArgs, 0) - return - } - - for _, column := range columns { - if !q._excludeColumn(column) { - q.setErr(fmt.Errorf("bun: can't find column=%q", column)) - return - } - } -} - -func (q *baseQuery) _excludeColumn(column string) bool { - for i, col := range q.columns { - if col.Args == nil && col.Query == column { - q.columns = append(q.columns[:i], q.columns[i+1:]...) - return true - } - } - return false -} - -//------------------------------------------------------------------------------ - -func (q *baseQuery) modelHasTableName() bool { - if !q.modelTableName.IsZero() { - return q.modelTableName.Query != "" - } - return q.table != nil -} - -func (q *baseQuery) hasTables() bool { - return q.modelHasTableName() || len(q.tables) > 0 -} - -func (q *baseQuery) appendTables( - fmter schema.Formatter, b []byte, -) (_ []byte, err error) { - return q._appendTables(fmter, b, false) -} - -func (q *baseQuery) appendTablesWithAlias( - fmter schema.Formatter, b []byte, -) (_ []byte, err error) { - return q._appendTables(fmter, b, true) -} - -func (q *baseQuery) _appendTables( - fmter schema.Formatter, b []byte, withAlias bool, -) (_ []byte, err error) { - startLen := len(b) - - if q.modelHasTableName() { - if !q.modelTableName.IsZero() { - b, err = q.modelTableName.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } else { - b = fmter.AppendQuery(b, string(q.table.SQLNameForSelects)) - if withAlias && q.table.SQLAlias != q.table.SQLNameForSelects { - if q.db.dialect.Name() == dialect.Oracle { - b = append(b, ' ') - } else { - b = append(b, " AS "...) - } - b = append(b, q.table.SQLAlias...) - } - } - } - - for _, table := range q.tables { - if len(b) > startLen { - b = append(b, ", "...) - } - b, err = table.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - - return b, nil -} - -func (q *baseQuery) appendFirstTable(fmter schema.Formatter, b []byte) ([]byte, error) { - return q._appendFirstTable(fmter, b, false) -} - -func (q *baseQuery) appendFirstTableWithAlias( - fmter schema.Formatter, b []byte, -) ([]byte, error) { - return q._appendFirstTable(fmter, b, true) -} - -func (q *baseQuery) _appendFirstTable( - fmter schema.Formatter, b []byte, withAlias bool, -) ([]byte, error) { - if !q.modelTableName.IsZero() { - return q.modelTableName.AppendQuery(fmter, b) - } - - if q.table != nil { - b = fmter.AppendQuery(b, string(q.table.SQLName)) - if withAlias { - b = append(b, " AS "...) - b = append(b, q.table.SQLAlias...) - } - return b, nil - } - - if len(q.tables) > 0 { - return q.tables[0].AppendQuery(fmter, b) - } - - return nil, errors.New("bun: query does not have a table") -} - -func (q *baseQuery) hasMultiTables() bool { - if q.modelHasTableName() { - return len(q.tables) >= 1 - } - return len(q.tables) >= 2 -} - -func (q *baseQuery) appendOtherTables(fmter schema.Formatter, b []byte) (_ []byte, err error) { - tables := q.tables - if !q.modelHasTableName() { - tables = tables[1:] - } - for i, table := range tables { - if i > 0 { - b = append(b, ", "...) - } - b, err = table.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - return b, nil -} - -//------------------------------------------------------------------------------ - -func (q *baseQuery) appendColumns(fmter schema.Formatter, b []byte) (_ []byte, err error) { - for i, f := range q.columns { - if i > 0 { - b = append(b, ", "...) - } - b, err = f.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - return b, nil -} - -func (q *baseQuery) getFields() ([]*schema.Field, error) { - if len(q.columns) == 0 { - if q.table == nil { - return nil, errNilModel - } - return q.table.Fields, nil - } - return q._getFields(false) -} - -func (q *baseQuery) getDataFields() ([]*schema.Field, error) { - if len(q.columns) == 0 { - if q.table == nil { - return nil, errNilModel - } - return q.table.DataFields, nil - } - return q._getFields(true) -} - -func (q *baseQuery) _getFields(omitPK bool) ([]*schema.Field, error) { - fields := make([]*schema.Field, 0, len(q.columns)) - for _, col := range q.columns { - if col.Args != nil { - continue - } - - field, err := q.table.Field(col.Query) - if err != nil { - return nil, err - } - - if omitPK && field.IsPK { - continue - } - - fields = append(fields, field) - } - return fields, nil -} - -func (q *baseQuery) scan( - ctx context.Context, - iquery Query, - query string, - model Model, - hasDest bool, -) (sql.Result, error) { - ctx, event := q.db.beforeQuery(ctx, iquery, query, nil, query, q.model) - res, err := q._scan(ctx, iquery, query, model, hasDest) - q.db.afterQuery(ctx, event, res, err) - return res, err -} - -func (q *baseQuery) _scan( - ctx context.Context, - iquery Query, - query string, - model Model, - hasDest bool, -) (sql.Result, error) { - rows, err := q.resolveConn(iquery).QueryContext(ctx, query) - if err != nil { - return nil, err - } - defer rows.Close() - - numRow, err := model.ScanRows(ctx, rows) - if err != nil { - return nil, err - } - - if numRow == 0 && hasDest && isSingleRowModel(model) { - return nil, sql.ErrNoRows - } - return driver.RowsAffected(numRow), nil -} - -func (q *baseQuery) exec( - ctx context.Context, - iquery Query, - query string, -) (sql.Result, error) { - ctx, event := q.db.beforeQuery(ctx, iquery, query, nil, query, q.model) - res, err := q.resolveConn(iquery).ExecContext(ctx, query) - q.db.afterQuery(ctx, event, res, err) - return res, err -} - -//------------------------------------------------------------------------------ - -func (q *baseQuery) AppendNamedArg(fmter schema.Formatter, b []byte, name string) ([]byte, bool) { - if q.table == nil { - return b, false - } - - if m, ok := q.tableModel.(*structTableModel); ok { - if b, ok := m.AppendNamedArg(fmter, b, name); ok { - return b, ok - } - } - - switch name { - case "TableName": - b = fmter.AppendQuery(b, string(q.table.SQLName)) - return b, true - case "TableAlias": - b = fmter.AppendQuery(b, string(q.table.SQLAlias)) - return b, true - case "PKs": - b = appendColumns(b, "", q.table.PKs) - return b, true - case "TablePKs": - b = appendColumns(b, q.table.SQLAlias, q.table.PKs) - return b, true - case "Columns": - b = appendColumns(b, "", q.table.Fields) - return b, true - case "TableColumns": - b = appendColumns(b, q.table.SQLAlias, q.table.Fields) - return b, true - } - - return b, false -} - -//------------------------------------------------------------------------------ - -func (q *baseQuery) Dialect() schema.Dialect { - return q.db.Dialect() -} - -func (q *baseQuery) NewValues(model interface{}) *ValuesQuery { - return NewValuesQuery(q.db, model).Conn(q.conn) -} - -func (q *baseQuery) NewSelect() *SelectQuery { - return NewSelectQuery(q.db).Conn(q.conn) -} - -func (q *baseQuery) NewInsert() *InsertQuery { - return NewInsertQuery(q.db).Conn(q.conn) -} - -func (q *baseQuery) NewUpdate() *UpdateQuery { - return NewUpdateQuery(q.db).Conn(q.conn) -} - -func (q *baseQuery) NewDelete() *DeleteQuery { - return NewDeleteQuery(q.db).Conn(q.conn) -} - -func (q *baseQuery) NewRaw(query string, args ...interface{}) *RawQuery { - return NewRawQuery(q.db, query, args...).Conn(q.conn) -} - -func (q *baseQuery) NewCreateTable() *CreateTableQuery { - return NewCreateTableQuery(q.db).Conn(q.conn) -} - -func (q *baseQuery) NewDropTable() *DropTableQuery { - return NewDropTableQuery(q.db).Conn(q.conn) -} - -func (q *baseQuery) NewCreateIndex() *CreateIndexQuery { - return NewCreateIndexQuery(q.db).Conn(q.conn) -} - -func (q *baseQuery) NewDropIndex() *DropIndexQuery { - return NewDropIndexQuery(q.db).Conn(q.conn) -} - -func (q *baseQuery) NewTruncateTable() *TruncateTableQuery { - return NewTruncateTableQuery(q.db).Conn(q.conn) -} - -func (q *baseQuery) NewAddColumn() *AddColumnQuery { - return NewAddColumnQuery(q.db).Conn(q.conn) -} - -func (q *baseQuery) NewDropColumn() *DropColumnQuery { - return NewDropColumnQuery(q.db).Conn(q.conn) -} - -//------------------------------------------------------------------------------ - -func appendColumns(b []byte, table schema.Safe, fields []*schema.Field) []byte { - for i, f := range fields { - if i > 0 { - b = append(b, ", "...) - } - - if len(table) > 0 { - b = append(b, table...) - b = append(b, '.') - } - b = append(b, f.SQLName...) - } - return b -} - -func formatterWithModel(fmter schema.Formatter, model schema.NamedArgAppender) schema.Formatter { - if fmter.IsNop() { - return fmter - } - return fmter.WithArg(model) -} - -//------------------------------------------------------------------------------ - -type whereBaseQuery struct { - baseQuery - - where []schema.QueryWithSep - whereFields []*schema.Field -} - -func (q *whereBaseQuery) addWhere(where schema.QueryWithSep) { - q.where = append(q.where, where) -} - -func (q *whereBaseQuery) addWhereGroup(sep string, where []schema.QueryWithSep) { - if len(where) == 0 { - return - } - - q.addWhere(schema.SafeQueryWithSep("", nil, sep)) - q.addWhere(schema.SafeQueryWithSep("", nil, "(")) - - where[0].Sep = "" - q.where = append(q.where, where...) - - q.addWhere(schema.SafeQueryWithSep("", nil, ")")) -} - -func (q *whereBaseQuery) addWhereCols(cols []string) { - if q.table == nil { - err := fmt.Errorf("bun: got %T, but WherePK requires a struct or slice-based model", q.model) - q.setErr(err) - return - } - if q.whereFields != nil { - err := errors.New("bun: WherePK can only be called once") - q.setErr(err) - return - } - - if cols == nil { - if err := q.table.CheckPKs(); err != nil { - q.setErr(err) - return - } - q.whereFields = q.table.PKs - return - } - - q.whereFields = make([]*schema.Field, len(cols)) - for i, col := range cols { - field, err := q.table.Field(col) - if err != nil { - q.setErr(err) - return - } - q.whereFields[i] = field - } -} - -func (q *whereBaseQuery) mustAppendWhere( - fmter schema.Formatter, b []byte, withAlias bool, -) ([]byte, error) { - if len(q.where) == 0 && q.whereFields == nil && !q.flags.Has(deletedFlag) { - err := errors.New("bun: Update and Delete queries require at least one Where") - return nil, err - } - return q.appendWhere(fmter, b, withAlias) -} - -func (q *whereBaseQuery) appendWhere( - fmter schema.Formatter, b []byte, withAlias bool, -) (_ []byte, err error) { - if len(q.where) == 0 && q.whereFields == nil && !q.isSoftDelete() { - return b, nil - } - - b = append(b, " WHERE "...) - startLen := len(b) - - if len(q.where) > 0 { - b, err = appendWhere(fmter, b, q.where) - if err != nil { - return nil, err - } - } - - if q.isSoftDelete() { - if len(b) > startLen { - b = append(b, " AND "...) - } - - if withAlias { - b = append(b, q.tableModel.Table().SQLAlias...) - } else { - b = append(b, q.tableModel.Table().SQLName...) - } - b = append(b, '.') - - field := q.tableModel.Table().SoftDeleteField - b = append(b, field.SQLName...) - - if field.IsPtr || field.NullZero { - if q.flags.Has(deletedFlag) { - b = append(b, " IS NOT NULL"...) - } else { - b = append(b, " IS NULL"...) - } - } else { - if q.flags.Has(deletedFlag) { - b = append(b, " != "...) - } else { - b = append(b, " = "...) - } - b = fmter.Dialect().AppendTime(b, time.Time{}) - } - } - - if q.whereFields != nil { - if len(b) > startLen { - b = append(b, " AND "...) - } - b, err = q.appendWhereFields(fmter, b, q.whereFields, withAlias) - if err != nil { - return nil, err - } - } - - return b, nil -} - -func appendWhere( - fmter schema.Formatter, b []byte, where []schema.QueryWithSep, -) (_ []byte, err error) { - for i, where := range where { - if i > 0 { - b = append(b, where.Sep...) - } - - if where.Query == "" { - continue - } - - b = append(b, '(') - b, err = where.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - b = append(b, ')') - } - return b, nil -} - -func (q *whereBaseQuery) appendWhereFields( - fmter schema.Formatter, b []byte, fields []*schema.Field, withAlias bool, -) (_ []byte, err error) { - if q.table == nil { - err := fmt.Errorf("bun: got %T, but WherePK requires struct or slice-based model", q.model) - return nil, err - } - - switch model := q.tableModel.(type) { - case *structTableModel: - return q.appendWhereStructFields(fmter, b, model, fields, withAlias) - case *sliceTableModel: - return q.appendWhereSliceFields(fmter, b, model, fields, withAlias) - default: - return nil, fmt.Errorf("bun: WhereColumn does not support %T", q.tableModel) - } -} - -func (q *whereBaseQuery) appendWhereStructFields( - fmter schema.Formatter, - b []byte, - model *structTableModel, - fields []*schema.Field, - withAlias bool, -) (_ []byte, err error) { - if !model.strct.IsValid() { - return nil, errNilModel - } - - isTemplate := fmter.IsNop() - b = append(b, '(') - for i, f := range fields { - if i > 0 { - b = append(b, " AND "...) - } - if withAlias { - b = append(b, q.table.SQLAlias...) - b = append(b, '.') - } - b = append(b, f.SQLName...) - b = append(b, " = "...) - if isTemplate { - b = append(b, '?') - } else { - b = f.AppendValue(fmter, b, model.strct) - } - } - b = append(b, ')') - return b, nil -} - -func (q *whereBaseQuery) appendWhereSliceFields( - fmter schema.Formatter, - b []byte, - model *sliceTableModel, - fields []*schema.Field, - withAlias bool, -) (_ []byte, err error) { - if len(fields) > 1 { - b = append(b, '(') - } - if withAlias { - b = appendColumns(b, q.table.SQLAlias, fields) - } else { - b = appendColumns(b, "", fields) - } - if len(fields) > 1 { - b = append(b, ')') - } - - b = append(b, " IN ("...) - - isTemplate := fmter.IsNop() - slice := model.slice - sliceLen := slice.Len() - for i := 0; i < sliceLen; i++ { - if i > 0 { - if isTemplate { - break - } - b = append(b, ", "...) - } - - el := indirect(slice.Index(i)) - - if len(fields) > 1 { - b = append(b, '(') - } - for i, f := range fields { - if i > 0 { - b = append(b, ", "...) - } - if isTemplate { - b = append(b, '?') - } else { - b = f.AppendValue(fmter, b, el) - } - } - if len(fields) > 1 { - b = append(b, ')') - } - } - - b = append(b, ')') - - return b, nil -} - -//------------------------------------------------------------------------------ - -type returningQuery struct { - returning []schema.QueryWithArgs - returningFields []*schema.Field -} - -func (q *returningQuery) addReturning(ret schema.QueryWithArgs) { - q.returning = append(q.returning, ret) -} - -func (q *returningQuery) addReturningField(field *schema.Field) { - if len(q.returning) > 0 { - return - } - for _, f := range q.returningFields { - if f == field { - return - } - } - q.returningFields = append(q.returningFields, field) -} - -func (q *returningQuery) appendReturning( - fmter schema.Formatter, b []byte, -) (_ []byte, err error) { - return q._appendReturning(fmter, b, "") -} - -func (q *returningQuery) appendOutput( - fmter schema.Formatter, b []byte, -) (_ []byte, err error) { - return q._appendReturning(fmter, b, "INSERTED") -} - -func (q *returningQuery) _appendReturning( - fmter schema.Formatter, b []byte, table string, -) (_ []byte, err error) { - for i, f := range q.returning { - if i > 0 { - b = append(b, ", "...) - } - b, err = f.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - - if len(q.returning) > 0 { - return b, nil - } - - b = appendColumns(b, schema.Safe(table), q.returningFields) - return b, nil -} - -func (q *returningQuery) hasReturning() bool { - if len(q.returning) == 1 { - if ret := q.returning[0]; len(ret.Args) == 0 { - switch ret.Query { - case "", "null", "NULL": - return false - } - } - } - return len(q.returning) > 0 || len(q.returningFields) > 0 -} - -//------------------------------------------------------------------------------ - -type columnValue struct { - column string - value schema.QueryWithArgs -} - -type customValueQuery struct { - modelValues map[string]schema.QueryWithArgs - extraValues []columnValue -} - -func (q *customValueQuery) addValue( - table *schema.Table, column string, value string, args []interface{}, -) { - ok := false - if table != nil { - _, ok = table.FieldMap[column] - } - - if ok { - if q.modelValues == nil { - q.modelValues = make(map[string]schema.QueryWithArgs) - } - q.modelValues[column] = schema.SafeQuery(value, args) - } else { - q.extraValues = append(q.extraValues, columnValue{ - column: column, - value: schema.SafeQuery(value, args), - }) - } -} - -//------------------------------------------------------------------------------ - -type setQuery struct { - set []schema.QueryWithArgs -} - -func (q *setQuery) addSet(set schema.QueryWithArgs) { - q.set = append(q.set, set) -} - -func (q setQuery) appendSet(fmter schema.Formatter, b []byte) (_ []byte, err error) { - for i, f := range q.set { - if i > 0 { - b = append(b, ", "...) - } - b, err = f.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - return b, nil -} - -//------------------------------------------------------------------------------ - -type cascadeQuery struct { - cascade bool - restrict bool -} - -func (q cascadeQuery) appendCascade(fmter schema.Formatter, b []byte) []byte { - if !fmter.HasFeature(feature.TableCascade) { - return b - } - if q.cascade { - b = append(b, " CASCADE"...) - } - if q.restrict { - b = append(b, " RESTRICT"...) - } - return b -} - -//------------------------------------------------------------------------------ - -type idxHintsQuery struct { - use *indexHints - ignore *indexHints - force *indexHints -} - -type indexHints struct { - names []schema.QueryWithArgs - forJoin []schema.QueryWithArgs - forOrderBy []schema.QueryWithArgs - forGroupBy []schema.QueryWithArgs -} - -func (ih *idxHintsQuery) lazyUse() *indexHints { - if ih.use == nil { - ih.use = new(indexHints) - } - return ih.use -} - -func (ih *idxHintsQuery) lazyIgnore() *indexHints { - if ih.ignore == nil { - ih.ignore = new(indexHints) - } - return ih.ignore -} - -func (ih *idxHintsQuery) lazyForce() *indexHints { - if ih.force == nil { - ih.force = new(indexHints) - } - return ih.force -} - -func (ih *idxHintsQuery) appendIndexes(hints []schema.QueryWithArgs, indexes ...string) []schema.QueryWithArgs { - for _, idx := range indexes { - hints = append(hints, schema.UnsafeIdent(idx)) - } - return hints -} - -func (ih *idxHintsQuery) addUseIndex(indexes ...string) { - if len(indexes) == 0 { - return - } - ih.lazyUse().names = ih.appendIndexes(ih.use.names, indexes...) -} - -func (ih *idxHintsQuery) addUseIndexForJoin(indexes ...string) { - if len(indexes) == 0 { - return - } - ih.lazyUse().forJoin = ih.appendIndexes(ih.use.forJoin, indexes...) -} - -func (ih *idxHintsQuery) addUseIndexForOrderBy(indexes ...string) { - if len(indexes) == 0 { - return - } - ih.lazyUse().forOrderBy = ih.appendIndexes(ih.use.forOrderBy, indexes...) -} - -func (ih *idxHintsQuery) addUseIndexForGroupBy(indexes ...string) { - if len(indexes) == 0 { - return - } - ih.lazyUse().forGroupBy = ih.appendIndexes(ih.use.forGroupBy, indexes...) -} - -func (ih *idxHintsQuery) addIgnoreIndex(indexes ...string) { - if len(indexes) == 0 { - return - } - ih.lazyIgnore().names = ih.appendIndexes(ih.ignore.names, indexes...) -} - -func (ih *idxHintsQuery) addIgnoreIndexForJoin(indexes ...string) { - if len(indexes) == 0 { - return - } - ih.lazyIgnore().forJoin = ih.appendIndexes(ih.ignore.forJoin, indexes...) -} - -func (ih *idxHintsQuery) addIgnoreIndexForOrderBy(indexes ...string) { - if len(indexes) == 0 { - return - } - ih.lazyIgnore().forOrderBy = ih.appendIndexes(ih.ignore.forOrderBy, indexes...) -} - -func (ih *idxHintsQuery) addIgnoreIndexForGroupBy(indexes ...string) { - if len(indexes) == 0 { - return - } - ih.lazyIgnore().forGroupBy = ih.appendIndexes(ih.ignore.forGroupBy, indexes...) -} - -func (ih *idxHintsQuery) addForceIndex(indexes ...string) { - if len(indexes) == 0 { - return - } - ih.lazyForce().names = ih.appendIndexes(ih.force.names, indexes...) -} - -func (ih *idxHintsQuery) addForceIndexForJoin(indexes ...string) { - if len(indexes) == 0 { - return - } - ih.lazyForce().forJoin = ih.appendIndexes(ih.force.forJoin, indexes...) -} - -func (ih *idxHintsQuery) addForceIndexForOrderBy(indexes ...string) { - if len(indexes) == 0 { - return - } - ih.lazyForce().forOrderBy = ih.appendIndexes(ih.force.forOrderBy, indexes...) -} - -func (ih *idxHintsQuery) addForceIndexForGroupBy(indexes ...string) { - if len(indexes) == 0 { - return - } - ih.lazyForce().forGroupBy = ih.appendIndexes(ih.force.forGroupBy, indexes...) -} - -func (ih *idxHintsQuery) appendIndexHints( - fmter schema.Formatter, b []byte, -) ([]byte, error) { - type IdxHint struct { - Name string - Values []schema.QueryWithArgs - } - - var hints []IdxHint - if ih.use != nil { - hints = append(hints, []IdxHint{ - { - Name: "USE INDEX", - Values: ih.use.names, - }, - { - Name: "USE INDEX FOR JOIN", - Values: ih.use.forJoin, - }, - { - Name: "USE INDEX FOR ORDER BY", - Values: ih.use.forOrderBy, - }, - { - Name: "USE INDEX FOR GROUP BY", - Values: ih.use.forGroupBy, - }, - }...) - } - - if ih.ignore != nil { - hints = append(hints, []IdxHint{ - { - Name: "IGNORE INDEX", - Values: ih.ignore.names, - }, - { - Name: "IGNORE INDEX FOR JOIN", - Values: ih.ignore.forJoin, - }, - { - Name: "IGNORE INDEX FOR ORDER BY", - Values: ih.ignore.forOrderBy, - }, - { - Name: "IGNORE INDEX FOR GROUP BY", - Values: ih.ignore.forGroupBy, - }, - }...) - } - - if ih.force != nil { - hints = append(hints, []IdxHint{ - { - Name: "FORCE INDEX", - Values: ih.force.names, - }, - { - Name: "FORCE INDEX FOR JOIN", - Values: ih.force.forJoin, - }, - { - Name: "FORCE INDEX FOR ORDER BY", - Values: ih.force.forOrderBy, - }, - { - Name: "FORCE INDEX FOR GROUP BY", - Values: ih.force.forGroupBy, - }, - }...) - } - - var err error - for _, h := range hints { - b, err = ih.bufIndexHint(h.Name, h.Values, fmter, b) - if err != nil { - return nil, err - } - } - return b, nil -} - -func (ih *idxHintsQuery) bufIndexHint( - name string, - hints []schema.QueryWithArgs, - fmter schema.Formatter, b []byte, -) ([]byte, error) { - var err error - if len(hints) == 0 { - return b, nil - } - b = append(b, fmt.Sprintf(" %s (", name)...) - for i, f := range hints { - if i > 0 { - b = append(b, ", "...) - } - b, err = f.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - b = append(b, ")"...) - return b, nil -} - -//------------------------------------------------------------------------------ - -type orderLimitOffsetQuery struct { - order []schema.QueryWithArgs - - limit int32 - offset int32 -} - -func (q *orderLimitOffsetQuery) addOrder(orders ...string) { - for _, order := range orders { - if order == "" { - continue - } - - index := strings.IndexByte(order, ' ') - if index == -1 { - q.order = append(q.order, schema.UnsafeIdent(order)) - continue - } - - field := order[:index] - sort := order[index+1:] - - switch strings.ToUpper(sort) { - case "ASC", "DESC", "ASC NULLS FIRST", "DESC NULLS FIRST", - "ASC NULLS LAST", "DESC NULLS LAST": - q.order = append(q.order, schema.SafeQuery("? ?", []interface{}{ - Ident(field), - Safe(sort), - })) - default: - q.order = append(q.order, schema.UnsafeIdent(order)) - } - } - -} - -func (q *orderLimitOffsetQuery) addOrderExpr(query string, args ...interface{}) { - q.order = append(q.order, schema.SafeQuery(query, args)) -} - -func (q *orderLimitOffsetQuery) appendOrder(fmter schema.Formatter, b []byte) (_ []byte, err error) { - if len(q.order) > 0 { - b = append(b, " ORDER BY "...) - - for i, f := range q.order { - if i > 0 { - b = append(b, ", "...) - } - b, err = f.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - - return b, nil - } - - // MSSQL: allows Limit() without Order() as per https://stackoverflow.com/a/36156953 - if q.limit > 0 && fmter.Dialect().Name() == dialect.MSSQL { - return append(b, " ORDER BY _temp_sort"...), nil - } - - return b, nil -} - -func (q *orderLimitOffsetQuery) setLimit(n int) { - q.limit = int32(n) -} - -func (q *orderLimitOffsetQuery) setOffset(n int) { - q.offset = int32(n) -} - -func (q *orderLimitOffsetQuery) appendLimitOffset(fmter schema.Formatter, b []byte) (_ []byte, err error) { - if fmter.Dialect().Features().Has(feature.OffsetFetch) { - if q.limit > 0 && q.offset > 0 { - b = append(b, " OFFSET "...) - b = strconv.AppendInt(b, int64(q.offset), 10) - b = append(b, " ROWS"...) - - b = append(b, " FETCH NEXT "...) - b = strconv.AppendInt(b, int64(q.limit), 10) - b = append(b, " ROWS ONLY"...) - } else if q.limit > 0 { - b = append(b, " OFFSET 0 ROWS"...) - - b = append(b, " FETCH NEXT "...) - b = strconv.AppendInt(b, int64(q.limit), 10) - b = append(b, " ROWS ONLY"...) - } else if q.offset > 0 { - b = append(b, " OFFSET "...) - b = strconv.AppendInt(b, int64(q.offset), 10) - b = append(b, " ROWS"...) - } - } else { - if q.limit > 0 { - b = append(b, " LIMIT "...) - b = strconv.AppendInt(b, int64(q.limit), 10) - } - if q.offset > 0 { - b = append(b, " OFFSET "...) - b = strconv.AppendInt(b, int64(q.offset), 10) - } - } - - return b, nil -} diff --git a/vendor/github.com/uptrace/bun/query_column_add.go b/vendor/github.com/uptrace/bun/query_column_add.go deleted file mode 100644 index c3c781a1d..000000000 --- a/vendor/github.com/uptrace/bun/query_column_add.go +++ /dev/null @@ -1,147 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "fmt" - - "github.com/uptrace/bun/dialect/feature" - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type AddColumnQuery struct { - baseQuery - - ifNotExists bool - comment string -} - -var _ Query = (*AddColumnQuery)(nil) - -func NewAddColumnQuery(db *DB) *AddColumnQuery { - q := &AddColumnQuery{ - baseQuery: baseQuery{ - db: db, - }, - } - return q -} - -func (q *AddColumnQuery) Conn(db IConn) *AddColumnQuery { - q.setConn(db) - return q -} - -func (q *AddColumnQuery) Model(model interface{}) *AddColumnQuery { - q.setModel(model) - return q -} - -func (q *AddColumnQuery) Err(err error) *AddColumnQuery { - q.setErr(err) - return q -} - -// Apply calls each function in fns, passing the AddColumnQuery as an argument. -func (q *AddColumnQuery) Apply(fns ...func(*AddColumnQuery) *AddColumnQuery) *AddColumnQuery { - for _, fn := range fns { - if fn != nil { - q = fn(q) - } - } - return q -} - -//------------------------------------------------------------------------------ - -func (q *AddColumnQuery) Table(tables ...string) *AddColumnQuery { - for _, table := range tables { - q.addTable(schema.UnsafeIdent(table)) - } - return q -} - -func (q *AddColumnQuery) TableExpr(query string, args ...interface{}) *AddColumnQuery { - q.addTable(schema.SafeQuery(query, args)) - return q -} - -func (q *AddColumnQuery) ModelTableExpr(query string, args ...interface{}) *AddColumnQuery { - q.modelTableName = schema.SafeQuery(query, args) - return q -} - -//------------------------------------------------------------------------------ - -func (q *AddColumnQuery) ColumnExpr(query string, args ...interface{}) *AddColumnQuery { - q.addColumn(schema.SafeQuery(query, args)) - return q -} - -func (q *AddColumnQuery) IfNotExists() *AddColumnQuery { - q.ifNotExists = true - return q -} - -//------------------------------------------------------------------------------ - -// Comment adds a comment to the query, wrapped by /* ... */. -func (q *AddColumnQuery) Comment(comment string) *AddColumnQuery { - q.comment = comment - return q -} - -//------------------------------------------------------------------------------ - -func (q *AddColumnQuery) Operation() string { - return "ADD COLUMN" -} - -func (q *AddColumnQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { - if q.err != nil { - return nil, q.err - } - - b = appendComment(b, q.comment) - - if len(q.columns) != 1 { - return nil, fmt.Errorf("bun: AddColumnQuery requires exactly one column") - } - - b = append(b, "ALTER TABLE "...) - - b, err = q.appendFirstTable(fmter, b) - if err != nil { - return nil, err - } - - b = append(b, " ADD "...) - - if q.ifNotExists { - b = append(b, "IF NOT EXISTS "...) - } - - b, err = q.columns[0].AppendQuery(fmter, b) - if err != nil { - return nil, err - } - - return b, nil -} - -//------------------------------------------------------------------------------ - -func (q *AddColumnQuery) Exec(ctx context.Context, dest ...interface{}) (sql.Result, error) { - if q.ifNotExists && !q.hasFeature(feature.AlterColumnExists) { - return nil, feature.NewNotSupportError(feature.AlterColumnExists) - } - - queryBytes, err := q.AppendQuery(q.db.fmter, q.db.makeQueryBytes()) - if err != nil { - return nil, err - } - - query := internal.String(queryBytes) - return q.exec(ctx, q, query) -} diff --git a/vendor/github.com/uptrace/bun/query_column_drop.go b/vendor/github.com/uptrace/bun/query_column_drop.go deleted file mode 100644 index e66e35b9a..000000000 --- a/vendor/github.com/uptrace/bun/query_column_drop.go +++ /dev/null @@ -1,145 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "fmt" - - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type DropColumnQuery struct { - baseQuery - - comment string -} - -var _ Query = (*DropColumnQuery)(nil) - -func NewDropColumnQuery(db *DB) *DropColumnQuery { - q := &DropColumnQuery{ - baseQuery: baseQuery{ - db: db, - }, - } - return q -} - -func (q *DropColumnQuery) Conn(db IConn) *DropColumnQuery { - q.setConn(db) - return q -} - -func (q *DropColumnQuery) Model(model interface{}) *DropColumnQuery { - q.setModel(model) - return q -} - -func (q *DropColumnQuery) Err(err error) *DropColumnQuery { - q.setErr(err) - return q -} - -// Apply calls each function in fns, passing the DropColumnQuery as an argument. -func (q *DropColumnQuery) Apply(fns ...func(*DropColumnQuery) *DropColumnQuery) *DropColumnQuery { - for _, fn := range fns { - if fn != nil { - q = fn(q) - } - } - return q -} - -//------------------------------------------------------------------------------ - -func (q *DropColumnQuery) Table(tables ...string) *DropColumnQuery { - for _, table := range tables { - q.addTable(schema.UnsafeIdent(table)) - } - return q -} - -func (q *DropColumnQuery) TableExpr(query string, args ...interface{}) *DropColumnQuery { - q.addTable(schema.SafeQuery(query, args)) - return q -} - -func (q *DropColumnQuery) ModelTableExpr(query string, args ...interface{}) *DropColumnQuery { - q.modelTableName = schema.SafeQuery(query, args) - return q -} - -//------------------------------------------------------------------------------ - -func (q *DropColumnQuery) Column(columns ...string) *DropColumnQuery { - for _, column := range columns { - q.addColumn(schema.UnsafeIdent(column)) - } - return q -} - -func (q *DropColumnQuery) ColumnExpr(query string, args ...interface{}) *DropColumnQuery { - q.addColumn(schema.SafeQuery(query, args)) - return q -} - -//------------------------------------------------------------------------------ - -// Comment adds a comment to the query, wrapped by /* ... */. -func (q *DropColumnQuery) Comment(comment string) *DropColumnQuery { - q.comment = comment - return q -} - -//------------------------------------------------------------------------------ - -func (q *DropColumnQuery) Operation() string { - return "DROP COLUMN" -} - -func (q *DropColumnQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { - if q.err != nil { - return nil, q.err - } - - b = appendComment(b, q.comment) - - if len(q.columns) != 1 { - return nil, fmt.Errorf("bun: DropColumnQuery requires exactly one column") - } - - b = append(b, "ALTER TABLE "...) - - b, err = q.appendFirstTable(fmter, b) - if err != nil { - return nil, err - } - - b = append(b, " DROP COLUMN "...) - - b, err = q.columns[0].AppendQuery(fmter, b) - if err != nil { - return nil, err - } - - return b, nil -} - -//------------------------------------------------------------------------------ - -func (q *DropColumnQuery) Exec(ctx context.Context, dest ...interface{}) (sql.Result, error) { - queryBytes, err := q.AppendQuery(q.db.fmter, q.db.makeQueryBytes()) - if err != nil { - return nil, err - } - - query := internal.String(queryBytes) - - res, err := q.exec(ctx, q, query) - if err != nil { - return nil, err - } - - return res, nil -} diff --git a/vendor/github.com/uptrace/bun/query_delete.go b/vendor/github.com/uptrace/bun/query_delete.go deleted file mode 100644 index 99ec37bb7..000000000 --- a/vendor/github.com/uptrace/bun/query_delete.go +++ /dev/null @@ -1,443 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "errors" - "time" - - "github.com/uptrace/bun/dialect/feature" - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type DeleteQuery struct { - whereBaseQuery - orderLimitOffsetQuery - returningQuery - - comment string -} - -var _ Query = (*DeleteQuery)(nil) - -func NewDeleteQuery(db *DB) *DeleteQuery { - q := &DeleteQuery{ - whereBaseQuery: whereBaseQuery{ - baseQuery: baseQuery{ - db: db, - }, - }, - } - return q -} - -func (q *DeleteQuery) Conn(db IConn) *DeleteQuery { - q.setConn(db) - return q -} - -func (q *DeleteQuery) Model(model interface{}) *DeleteQuery { - q.setModel(model) - return q -} - -func (q *DeleteQuery) Err(err error) *DeleteQuery { - q.setErr(err) - return q -} - -// Apply calls each function in fns, passing the DeleteQuery as an argument. -func (q *DeleteQuery) Apply(fns ...func(*DeleteQuery) *DeleteQuery) *DeleteQuery { - for _, fn := range fns { - if fn != nil { - q = fn(q) - } - } - return q -} - -func (q *DeleteQuery) With(name string, query Query) *DeleteQuery { - q.addWith(name, query, false) - return q -} - -func (q *DeleteQuery) WithRecursive(name string, query Query) *DeleteQuery { - q.addWith(name, query, true) - return q -} - -func (q *DeleteQuery) Table(tables ...string) *DeleteQuery { - for _, table := range tables { - q.addTable(schema.UnsafeIdent(table)) - } - return q -} - -func (q *DeleteQuery) TableExpr(query string, args ...interface{}) *DeleteQuery { - q.addTable(schema.SafeQuery(query, args)) - return q -} - -func (q *DeleteQuery) ModelTableExpr(query string, args ...interface{}) *DeleteQuery { - q.modelTableName = schema.SafeQuery(query, args) - return q -} - -//------------------------------------------------------------------------------ - -func (q *DeleteQuery) WherePK(cols ...string) *DeleteQuery { - q.addWhereCols(cols) - return q -} - -func (q *DeleteQuery) Where(query string, args ...interface{}) *DeleteQuery { - q.addWhere(schema.SafeQueryWithSep(query, args, " AND ")) - return q -} - -func (q *DeleteQuery) WhereOr(query string, args ...interface{}) *DeleteQuery { - q.addWhere(schema.SafeQueryWithSep(query, args, " OR ")) - return q -} - -func (q *DeleteQuery) WhereGroup(sep string, fn func(*DeleteQuery) *DeleteQuery) *DeleteQuery { - saved := q.where - q.where = nil - - q = fn(q) - - where := q.where - q.where = saved - - q.addWhereGroup(sep, where) - - return q -} - -func (q *DeleteQuery) WhereDeleted() *DeleteQuery { - q.whereDeleted() - return q -} - -func (q *DeleteQuery) WhereAllWithDeleted() *DeleteQuery { - q.whereAllWithDeleted() - return q -} - -func (q *DeleteQuery) Order(orders ...string) *DeleteQuery { - if !q.hasFeature(feature.DeleteOrderLimit) { - q.err = feature.NewNotSupportError(feature.DeleteOrderLimit) - return q - } - q.addOrder(orders...) - return q -} - -func (q *DeleteQuery) OrderExpr(query string, args ...interface{}) *DeleteQuery { - if !q.hasFeature(feature.DeleteOrderLimit) { - q.err = feature.NewNotSupportError(feature.DeleteOrderLimit) - return q - } - q.addOrderExpr(query, args...) - return q -} - -func (q *DeleteQuery) ForceDelete() *DeleteQuery { - q.flags = q.flags.Set(forceDeleteFlag) - return q -} - -// ------------------------------------------------------------------------------ -func (q *DeleteQuery) Limit(n int) *DeleteQuery { - if !q.hasFeature(feature.DeleteOrderLimit) { - q.err = feature.NewNotSupportError(feature.DeleteOrderLimit) - return q - } - q.setLimit(n) - return q -} - -//------------------------------------------------------------------------------ - -// Returning adds a RETURNING clause to the query. -// -// To suppress the auto-generated RETURNING clause, use `Returning("NULL")`. -func (q *DeleteQuery) Returning(query string, args ...interface{}) *DeleteQuery { - if !q.hasFeature(feature.DeleteReturning) { - q.err = feature.NewNotSupportError(feature.DeleteOrderLimit) - return q - } - - q.addReturning(schema.SafeQuery(query, args)) - return q -} - -//------------------------------------------------------------------------------ - -// Comment adds a comment to the query, wrapped by /* ... */. -func (q *DeleteQuery) Comment(comment string) *DeleteQuery { - q.comment = comment - return q -} - -//------------------------------------------------------------------------------ - -func (q *DeleteQuery) Operation() string { - return "DELETE" -} - -func (q *DeleteQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { - if q.err != nil { - return nil, q.err - } - - b = appendComment(b, q.comment) - - fmter = formatterWithModel(fmter, q) - - if q.isSoftDelete() { - now := time.Now() - - if err := q.tableModel.updateSoftDeleteField(now); err != nil { - return nil, err - } - - upd := &UpdateQuery{ - whereBaseQuery: q.whereBaseQuery, - returningQuery: q.returningQuery, - } - upd.Set(q.softDeleteSet(fmter, now)) - - return upd.AppendQuery(fmter, b) - } - - withAlias := q.db.HasFeature(feature.DeleteTableAlias) - - b, err = q.appendWith(fmter, b) - if err != nil { - return nil, err - } - - b = append(b, "DELETE FROM "...) - - if withAlias { - b, err = q.appendFirstTableWithAlias(fmter, b) - } else { - b, err = q.appendFirstTable(fmter, b) - } - if err != nil { - return nil, err - } - - if q.hasMultiTables() { - b = append(b, " USING "...) - b, err = q.appendOtherTables(fmter, b) - if err != nil { - return nil, err - } - } - - if q.hasFeature(feature.Output) && q.hasReturning() { - b = append(b, " OUTPUT "...) - b, err = q.appendOutput(fmter, b) - if err != nil { - return nil, err - } - } - - b, err = q.mustAppendWhere(fmter, b, withAlias) - if err != nil { - return nil, err - } - - if q.hasMultiTables() && (len(q.order) > 0 || q.limit > 0) { - return nil, errors.New("bun: can't use ORDER or LIMIT with multiple tables") - } - - b, err = q.appendOrder(fmter, b) - if err != nil { - return nil, err - } - - b, err = q.appendLimitOffset(fmter, b) - if err != nil { - return nil, err - } - - if q.hasFeature(feature.DeleteReturning) && q.hasReturning() { - b = append(b, " RETURNING "...) - b, err = q.appendReturning(fmter, b) - if err != nil { - return nil, err - } - } - - return b, nil -} - -func (q *DeleteQuery) isSoftDelete() bool { - return q.tableModel != nil && q.table.SoftDeleteField != nil && !q.flags.Has(forceDeleteFlag) -} - -func (q *DeleteQuery) softDeleteSet(fmter schema.Formatter, tm time.Time) string { - b := make([]byte, 0, 32) - if fmter.HasFeature(feature.UpdateMultiTable) { - b = append(b, q.table.SQLAlias...) - b = append(b, '.') - } - b = append(b, q.table.SoftDeleteField.SQLName...) - b = append(b, " = "...) - b = schema.Append(fmter, b, tm) - return internal.String(b) -} - -//------------------------------------------------------------------------------ - -func (q *DeleteQuery) Scan(ctx context.Context, dest ...interface{}) error { - _, err := q.scanOrExec(ctx, dest, true) - return err -} - -func (q *DeleteQuery) Exec(ctx context.Context, dest ...interface{}) (sql.Result, error) { - return q.scanOrExec(ctx, dest, len(dest) > 0) -} - -func (q *DeleteQuery) scanOrExec( - ctx context.Context, dest []interface{}, hasDest bool, -) (sql.Result, error) { - if q.err != nil { - return nil, q.err - } - - if q.table != nil { - if err := q.beforeDeleteHook(ctx); err != nil { - return nil, err - } - } - - // Run append model hooks before generating the query. - if err := q.beforeAppendModel(ctx, q); err != nil { - return nil, err - } - - // Generate the query before checking hasReturning. - queryBytes, err := q.AppendQuery(q.db.fmter, q.db.makeQueryBytes()) - if err != nil { - return nil, err - } - - useScan := hasDest || (q.hasReturning() && q.hasFeature(feature.DeleteReturning|feature.Output)) - var model Model - - if useScan { - var err error - model, err = q.getModel(dest) - if err != nil { - return nil, err - } - } - - query := internal.String(queryBytes) - - var res sql.Result - - if useScan { - res, err = q.scan(ctx, q, query, model, hasDest) - if err != nil { - return nil, err - } - } else { - res, err = q.exec(ctx, q, query) - if err != nil { - return nil, err - } - } - - if q.table != nil { - if err := q.afterDeleteHook(ctx); err != nil { - return nil, err - } - } - - return res, nil -} - -func (q *DeleteQuery) beforeDeleteHook(ctx context.Context) error { - if hook, ok := q.table.ZeroIface.(BeforeDeleteHook); ok { - if err := hook.BeforeDelete(ctx, q); err != nil { - return err - } - } - return nil -} - -func (q *DeleteQuery) afterDeleteHook(ctx context.Context) error { - if hook, ok := q.table.ZeroIface.(AfterDeleteHook); ok { - if err := hook.AfterDelete(ctx, q); err != nil { - return err - } - } - return nil -} - -func (q *DeleteQuery) String() string { - buf, err := q.AppendQuery(q.db.Formatter(), nil) - if err != nil { - panic(err) - } - - return string(buf) -} - -//------------------------------------------------------------------------------ - -func (q *DeleteQuery) QueryBuilder() QueryBuilder { - return &deleteQueryBuilder{q} -} - -func (q *DeleteQuery) ApplyQueryBuilder(fn func(QueryBuilder) QueryBuilder) *DeleteQuery { - return fn(q.QueryBuilder()).Unwrap().(*DeleteQuery) -} - -type deleteQueryBuilder struct { - *DeleteQuery -} - -func (q *deleteQueryBuilder) WhereGroup( - sep string, fn func(QueryBuilder) QueryBuilder, -) QueryBuilder { - q.DeleteQuery = q.DeleteQuery.WhereGroup(sep, func(qs *DeleteQuery) *DeleteQuery { - return fn(q).(*deleteQueryBuilder).DeleteQuery - }) - return q -} - -func (q *deleteQueryBuilder) Where(query string, args ...interface{}) QueryBuilder { - q.DeleteQuery.Where(query, args...) - return q -} - -func (q *deleteQueryBuilder) WhereOr(query string, args ...interface{}) QueryBuilder { - q.DeleteQuery.WhereOr(query, args...) - return q -} - -func (q *deleteQueryBuilder) WhereDeleted() QueryBuilder { - q.DeleteQuery.WhereDeleted() - return q -} - -func (q *deleteQueryBuilder) WhereAllWithDeleted() QueryBuilder { - q.DeleteQuery.WhereAllWithDeleted() - return q -} - -func (q *deleteQueryBuilder) WherePK(cols ...string) QueryBuilder { - q.DeleteQuery.WherePK(cols...) - return q -} - -func (q *deleteQueryBuilder) Unwrap() interface{} { - return q.DeleteQuery -} diff --git a/vendor/github.com/uptrace/bun/query_index_create.go b/vendor/github.com/uptrace/bun/query_index_create.go deleted file mode 100644 index 4ac4ffd10..000000000 --- a/vendor/github.com/uptrace/bun/query_index_create.go +++ /dev/null @@ -1,264 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type CreateIndexQuery struct { - whereBaseQuery - - unique bool - fulltext bool - spatial bool - concurrently bool - ifNotExists bool - - index schema.QueryWithArgs - using schema.QueryWithArgs - include []schema.QueryWithArgs - comment string -} - -var _ Query = (*CreateIndexQuery)(nil) - -func NewCreateIndexQuery(db *DB) *CreateIndexQuery { - q := &CreateIndexQuery{ - whereBaseQuery: whereBaseQuery{ - baseQuery: baseQuery{ - db: db, - }, - }, - } - return q -} - -func (q *CreateIndexQuery) Conn(db IConn) *CreateIndexQuery { - q.setConn(db) - return q -} - -func (q *CreateIndexQuery) Model(model interface{}) *CreateIndexQuery { - q.setModel(model) - return q -} - -func (q *CreateIndexQuery) Err(err error) *CreateIndexQuery { - q.setErr(err) - return q -} - -func (q *CreateIndexQuery) Unique() *CreateIndexQuery { - q.unique = true - return q -} - -func (q *CreateIndexQuery) Concurrently() *CreateIndexQuery { - q.concurrently = true - return q -} - -func (q *CreateIndexQuery) IfNotExists() *CreateIndexQuery { - q.ifNotExists = true - return q -} - -//------------------------------------------------------------------------------ - -func (q *CreateIndexQuery) Index(query string) *CreateIndexQuery { - q.index = schema.UnsafeIdent(query) - return q -} - -func (q *CreateIndexQuery) IndexExpr(query string, args ...interface{}) *CreateIndexQuery { - q.index = schema.SafeQuery(query, args) - return q -} - -//------------------------------------------------------------------------------ - -func (q *CreateIndexQuery) Table(tables ...string) *CreateIndexQuery { - for _, table := range tables { - q.addTable(schema.UnsafeIdent(table)) - } - return q -} - -func (q *CreateIndexQuery) TableExpr(query string, args ...interface{}) *CreateIndexQuery { - q.addTable(schema.SafeQuery(query, args)) - return q -} - -func (q *CreateIndexQuery) ModelTableExpr(query string, args ...interface{}) *CreateIndexQuery { - q.modelTableName = schema.SafeQuery(query, args) - return q -} - -func (q *CreateIndexQuery) Using(query string, args ...interface{}) *CreateIndexQuery { - q.using = schema.SafeQuery(query, args) - return q -} - -//------------------------------------------------------------------------------ - -func (q *CreateIndexQuery) Column(columns ...string) *CreateIndexQuery { - for _, column := range columns { - q.addColumn(schema.UnsafeIdent(column)) - } - return q -} - -func (q *CreateIndexQuery) ColumnExpr(query string, args ...interface{}) *CreateIndexQuery { - q.addColumn(schema.SafeQuery(query, args)) - return q -} - -func (q *CreateIndexQuery) ExcludeColumn(columns ...string) *CreateIndexQuery { - q.excludeColumn(columns) - return q -} - -//------------------------------------------------------------------------------ - -func (q *CreateIndexQuery) Include(columns ...string) *CreateIndexQuery { - for _, column := range columns { - q.include = append(q.include, schema.UnsafeIdent(column)) - } - return q -} - -func (q *CreateIndexQuery) IncludeExpr(query string, args ...interface{}) *CreateIndexQuery { - q.include = append(q.include, schema.SafeQuery(query, args)) - return q -} - -//------------------------------------------------------------------------------ - -func (q *CreateIndexQuery) Where(query string, args ...interface{}) *CreateIndexQuery { - q.addWhere(schema.SafeQueryWithSep(query, args, " AND ")) - return q -} - -func (q *CreateIndexQuery) WhereOr(query string, args ...interface{}) *CreateIndexQuery { - q.addWhere(schema.SafeQueryWithSep(query, args, " OR ")) - return q -} - -//------------------------------------------------------------------------------ - -// Comment adds a comment to the query, wrapped by /* ... */. -func (q *CreateIndexQuery) Comment(comment string) *CreateIndexQuery { - q.comment = comment - return q -} - -//------------------------------------------------------------------------------ - -func (q *CreateIndexQuery) Operation() string { - return "CREATE INDEX" -} - -func (q *CreateIndexQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { - if q.err != nil { - return nil, q.err - } - - b = appendComment(b, q.comment) - - b = append(b, "CREATE "...) - - if q.unique { - b = append(b, "UNIQUE "...) - } - if q.fulltext { - b = append(b, "FULLTEXT "...) - } - if q.spatial { - b = append(b, "SPATIAL "...) - } - - b = append(b, "INDEX "...) - - if q.concurrently { - b = append(b, "CONCURRENTLY "...) - } - if q.ifNotExists { - b = append(b, "IF NOT EXISTS "...) - } - - b, err = q.index.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - - b = append(b, " ON "...) - b, err = q.appendFirstTable(fmter, b) - if err != nil { - return nil, err - } - - if !q.using.IsZero() { - b = append(b, " USING "...) - b, err = q.using.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - - b = append(b, " ("...) - for i, col := range q.columns { - if i > 0 { - b = append(b, ", "...) - } - b, err = col.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - b = append(b, ')') - - if len(q.include) > 0 { - b = append(b, " INCLUDE ("...) - for i, col := range q.include { - if i > 0 { - b = append(b, ", "...) - } - b, err = col.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - b = append(b, ')') - } - - if len(q.where) > 0 { - b = append(b, " WHERE "...) - b, err = appendWhere(fmter, b, q.where) - if err != nil { - return nil, err - } - } - - return b, nil -} - -//------------------------------------------------------------------------------ - -func (q *CreateIndexQuery) Exec(ctx context.Context, dest ...interface{}) (sql.Result, error) { - queryBytes, err := q.AppendQuery(q.db.fmter, q.db.makeQueryBytes()) - if err != nil { - return nil, err - } - - query := internal.String(queryBytes) - - res, err := q.exec(ctx, q, query) - if err != nil { - return nil, err - } - - return res, nil -} diff --git a/vendor/github.com/uptrace/bun/query_index_drop.go b/vendor/github.com/uptrace/bun/query_index_drop.go deleted file mode 100644 index 27c6e7f67..000000000 --- a/vendor/github.com/uptrace/bun/query_index_drop.go +++ /dev/null @@ -1,131 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type DropIndexQuery struct { - baseQuery - cascadeQuery - - concurrently bool - ifExists bool - - index schema.QueryWithArgs - comment string -} - -var _ Query = (*DropIndexQuery)(nil) - -func NewDropIndexQuery(db *DB) *DropIndexQuery { - q := &DropIndexQuery{ - baseQuery: baseQuery{ - db: db, - }, - } - return q -} - -func (q *DropIndexQuery) Conn(db IConn) *DropIndexQuery { - q.setConn(db) - return q -} - -func (q *DropIndexQuery) Model(model interface{}) *DropIndexQuery { - q.setModel(model) - return q -} - -func (q *DropIndexQuery) Err(err error) *DropIndexQuery { - q.setErr(err) - return q -} - -//------------------------------------------------------------------------------ - -func (q *DropIndexQuery) Concurrently() *DropIndexQuery { - q.concurrently = true - return q -} - -func (q *DropIndexQuery) IfExists() *DropIndexQuery { - q.ifExists = true - return q -} - -func (q *DropIndexQuery) Cascade() *DropIndexQuery { - q.cascade = true - return q -} - -func (q *DropIndexQuery) Restrict() *DropIndexQuery { - q.restrict = true - return q -} - -func (q *DropIndexQuery) Index(query string, args ...interface{}) *DropIndexQuery { - q.index = schema.SafeQuery(query, args) - return q -} - -//------------------------------------------------------------------------------ - -// Comment adds a comment to the query, wrapped by /* ... */. -func (q *DropIndexQuery) Comment(comment string) *DropIndexQuery { - q.comment = comment - return q -} - -//------------------------------------------------------------------------------ - -func (q *DropIndexQuery) Operation() string { - return "DROP INDEX" -} - -func (q *DropIndexQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { - if q.err != nil { - return nil, q.err - } - - b = appendComment(b, q.comment) - - b = append(b, "DROP INDEX "...) - - if q.concurrently { - b = append(b, "CONCURRENTLY "...) - } - if q.ifExists { - b = append(b, "IF EXISTS "...) - } - - b, err = q.index.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - - b = q.appendCascade(fmter, b) - - return b, nil -} - -//------------------------------------------------------------------------------ - -func (q *DropIndexQuery) Exec(ctx context.Context, dest ...interface{}) (sql.Result, error) { - queryBytes, err := q.AppendQuery(q.db.fmter, q.db.makeQueryBytes()) - if err != nil { - return nil, err - } - - query := internal.String(queryBytes) - - res, err := q.exec(ctx, q, query) - if err != nil { - return nil, err - } - - return res, nil -} diff --git a/vendor/github.com/uptrace/bun/query_insert.go b/vendor/github.com/uptrace/bun/query_insert.go deleted file mode 100644 index d2e158d77..000000000 --- a/vendor/github.com/uptrace/bun/query_insert.go +++ /dev/null @@ -1,701 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "fmt" - "reflect" - "strings" - - "github.com/uptrace/bun/dialect/feature" - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type InsertQuery struct { - whereBaseQuery - returningQuery - customValueQuery - - on schema.QueryWithArgs - setQuery - - ignore bool - replace bool - comment string -} - -var _ Query = (*InsertQuery)(nil) - -func NewInsertQuery(db *DB) *InsertQuery { - q := &InsertQuery{ - whereBaseQuery: whereBaseQuery{ - baseQuery: baseQuery{ - db: db, - }, - }, - } - return q -} - -func (q *InsertQuery) Conn(db IConn) *InsertQuery { - q.setConn(db) - return q -} - -func (q *InsertQuery) Model(model interface{}) *InsertQuery { - q.setModel(model) - return q -} - -func (q *InsertQuery) Err(err error) *InsertQuery { - q.setErr(err) - return q -} - -// Apply calls each function in fns, passing the InsertQuery as an argument. -func (q *InsertQuery) Apply(fns ...func(*InsertQuery) *InsertQuery) *InsertQuery { - for _, fn := range fns { - if fn != nil { - q = fn(q) - } - } - return q -} - -func (q *InsertQuery) With(name string, query Query) *InsertQuery { - q.addWith(name, query, false) - return q -} - -func (q *InsertQuery) WithRecursive(name string, query Query) *InsertQuery { - q.addWith(name, query, true) - return q -} - -//------------------------------------------------------------------------------ - -func (q *InsertQuery) Table(tables ...string) *InsertQuery { - for _, table := range tables { - q.addTable(schema.UnsafeIdent(table)) - } - return q -} - -func (q *InsertQuery) TableExpr(query string, args ...interface{}) *InsertQuery { - q.addTable(schema.SafeQuery(query, args)) - return q -} - -func (q *InsertQuery) ModelTableExpr(query string, args ...interface{}) *InsertQuery { - q.modelTableName = schema.SafeQuery(query, args) - return q -} - -//------------------------------------------------------------------------------ - -func (q *InsertQuery) Column(columns ...string) *InsertQuery { - for _, column := range columns { - q.addColumn(schema.UnsafeIdent(column)) - } - return q -} - -func (q *InsertQuery) ColumnExpr(query string, args ...interface{}) *InsertQuery { - q.addColumn(schema.SafeQuery(query, args)) - return q -} - -func (q *InsertQuery) ExcludeColumn(columns ...string) *InsertQuery { - q.excludeColumn(columns) - return q -} - -// Value overwrites model value for the column. -func (q *InsertQuery) Value(column string, expr string, args ...interface{}) *InsertQuery { - if q.table == nil { - q.err = errNilModel - return q - } - q.addValue(q.table, column, expr, args) - return q -} - -func (q *InsertQuery) Where(query string, args ...interface{}) *InsertQuery { - q.addWhere(schema.SafeQueryWithSep(query, args, " AND ")) - return q -} - -func (q *InsertQuery) WhereOr(query string, args ...interface{}) *InsertQuery { - q.addWhere(schema.SafeQueryWithSep(query, args, " OR ")) - return q -} - -//------------------------------------------------------------------------------ - -// Returning adds a RETURNING clause to the query. -// -// To suppress the auto-generated RETURNING clause, use `Returning("")`. -func (q *InsertQuery) Returning(query string, args ...interface{}) *InsertQuery { - q.addReturning(schema.SafeQuery(query, args)) - return q -} - -//------------------------------------------------------------------------------ - -// Ignore generates different queries depending on the DBMS: -// - On MySQL, it generates `INSERT IGNORE INTO`. -// - On PostgreSQL, it generates `ON CONFLICT DO NOTHING`. -func (q *InsertQuery) Ignore() *InsertQuery { - if q.db.fmter.HasFeature(feature.InsertOnConflict) { - return q.On("CONFLICT DO NOTHING") - } - if q.db.fmter.HasFeature(feature.InsertIgnore) { - q.ignore = true - } - return q -} - -// Replaces generates a `REPLACE INTO` query (MySQL and MariaDB). -func (q *InsertQuery) Replace() *InsertQuery { - q.replace = true - return q -} - -//------------------------------------------------------------------------------ - -// Comment adds a comment to the query, wrapped by /* ... */. -func (q *InsertQuery) Comment(comment string) *InsertQuery { - q.comment = comment - return q -} - -//------------------------------------------------------------------------------ - -func (q *InsertQuery) Operation() string { - return "INSERT" -} - -func (q *InsertQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { - if q.err != nil { - return nil, q.err - } - - b = appendComment(b, q.comment) - - fmter = formatterWithModel(fmter, q) - - b, err = q.appendWith(fmter, b) - if err != nil { - return nil, err - } - - if q.replace { - b = append(b, "REPLACE "...) - } else { - b = append(b, "INSERT "...) - if q.ignore { - b = append(b, "IGNORE "...) - } - } - b = append(b, "INTO "...) - - if q.db.HasFeature(feature.InsertTableAlias) && !q.on.IsZero() { - b, err = q.appendFirstTableWithAlias(fmter, b) - } else { - b, err = q.appendFirstTable(fmter, b) - } - if err != nil { - return nil, err - } - - b, err = q.appendColumnsValues(fmter, b, false) - if err != nil { - return nil, err - } - - b, err = q.appendOn(fmter, b) - if err != nil { - return nil, err - } - - if q.hasFeature(feature.InsertReturning) && q.hasReturning() { - b = append(b, " RETURNING "...) - b, err = q.appendReturning(fmter, b) - if err != nil { - return nil, err - } - } - - return b, nil -} - -func (q *InsertQuery) appendColumnsValues( - fmter schema.Formatter, b []byte, skipOutput bool, -) (_ []byte, err error) { - if q.hasMultiTables() { - if q.columns != nil { - b = append(b, " ("...) - b, err = q.appendColumns(fmter, b) - if err != nil { - return nil, err - } - b = append(b, ")"...) - } - - if q.hasFeature(feature.Output) && q.hasReturning() { - b = append(b, " OUTPUT "...) - b, err = q.appendOutput(fmter, b) - if err != nil { - return nil, err - } - } - - b = append(b, " SELECT "...) - - if q.columns != nil { - b, err = q.appendColumns(fmter, b) - if err != nil { - return nil, err - } - } else { - b = append(b, "*"...) - } - - b = append(b, " FROM "...) - b, err = q.appendOtherTables(fmter, b) - if err != nil { - return nil, err - } - - return b, nil - } - - if m, ok := q.model.(*mapModel); ok { - return m.appendColumnsValues(fmter, b), nil - } - if _, ok := q.model.(*mapSliceModel); ok { - return nil, fmt.Errorf("Insert(*[]map[string]interface{}) is not supported") - } - - if q.model == nil { - return nil, errNilModel - } - - // Build fields to populate RETURNING clause. - fields, err := q.getFields() - if err != nil { - return nil, err - } - - b = append(b, " ("...) - b = q.appendFields(fmter, b, fields) - b = append(b, ")"...) - - if q.hasFeature(feature.Output) && q.hasReturning() && !skipOutput { - b = append(b, " OUTPUT "...) - b, err = q.appendOutput(fmter, b) - if err != nil { - return nil, err - } - } - - b = append(b, " VALUES ("...) - - switch model := q.tableModel.(type) { - case *structTableModel: - b, err = q.appendStructValues(fmter, b, fields, model.strct) - if err != nil { - return nil, err - } - case *sliceTableModel: - b, err = q.appendSliceValues(fmter, b, fields, model.slice) - if err != nil { - return nil, err - } - default: - return nil, fmt.Errorf("bun: Insert does not support %T", q.tableModel) - } - - b = append(b, ')') - - return b, nil -} - -func (q *InsertQuery) appendStructValues( - fmter schema.Formatter, b []byte, fields []*schema.Field, strct reflect.Value, -) (_ []byte, err error) { - isTemplate := fmter.IsNop() - for i, f := range fields { - if i > 0 { - b = append(b, ", "...) - } - - app, ok := q.modelValues[f.Name] - if ok { - b, err = app.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - q.addReturningField(f) - continue - } - - switch { - case isTemplate: - b = append(b, '?') - case q.marshalsToDefault(f, strct): - if q.db.HasFeature(feature.DefaultPlaceholder) { - b = append(b, "DEFAULT"...) - } else if f.SQLDefault != "" { - b = append(b, f.SQLDefault...) - } else { - b = append(b, "NULL"...) - } - q.addReturningField(f) - default: - b = f.AppendValue(fmter, b, strct) - } - } - - for i, v := range q.extraValues { - if i > 0 || len(fields) > 0 { - b = append(b, ", "...) - } - - b, err = v.value.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - - return b, nil -} - -func (q *InsertQuery) appendSliceValues( - fmter schema.Formatter, b []byte, fields []*schema.Field, slice reflect.Value, -) (_ []byte, err error) { - if fmter.IsNop() { - return q.appendStructValues(fmter, b, fields, reflect.Value{}) - } - - sliceLen := slice.Len() - for i := 0; i < sliceLen; i++ { - if i > 0 { - b = append(b, "), ("...) - } - el := indirect(slice.Index(i)) - b, err = q.appendStructValues(fmter, b, fields, el) - if err != nil { - return nil, err - } - } - - return b, nil -} - -func (q *InsertQuery) getFields() ([]*schema.Field, error) { - hasIdentity := q.db.HasFeature(feature.Identity) - - if len(q.columns) > 0 || q.db.HasFeature(feature.DefaultPlaceholder) && !hasIdentity { - return q.baseQuery.getFields() - } - - var strct reflect.Value - - switch model := q.tableModel.(type) { - case *structTableModel: - strct = model.strct - case *sliceTableModel: - if model.sliceLen == 0 { - return nil, fmt.Errorf("bun: Insert(empty %T)", model.slice.Type()) - } - strct = indirect(model.slice.Index(0)) - default: - return nil, errNilModel - } - - fields := make([]*schema.Field, 0, len(q.table.Fields)) - - for _, f := range q.table.Fields { - if hasIdentity && f.AutoIncrement { - q.addReturningField(f) - continue - } - if f.NotNull && q.marshalsToDefault(f, strct) { - q.addReturningField(f) - continue - } - fields = append(fields, f) - } - - return fields, nil -} - -// marshalsToDefault checks if the value will be marshaled as DEFAULT or NULL (if DEFAULT placeholder is not supported) -// when appending it to the VALUES clause in place of the given field. -func (q InsertQuery) marshalsToDefault(f *schema.Field, v reflect.Value) bool { - return (f.IsPtr && f.HasNilValue(v)) || - (f.HasZeroValue(v) && (f.NullZero || f.SQLDefault != "")) -} - -func (q *InsertQuery) appendFields( - fmter schema.Formatter, b []byte, fields []*schema.Field, -) []byte { - b = appendColumns(b, "", fields) - for i, v := range q.extraValues { - if i > 0 || len(fields) > 0 { - b = append(b, ", "...) - } - b = fmter.AppendIdent(b, v.column) - } - return b -} - -//------------------------------------------------------------------------------ - -func (q *InsertQuery) On(s string, args ...interface{}) *InsertQuery { - q.on = schema.SafeQuery(s, args) - return q -} - -func (q *InsertQuery) Set(query string, args ...interface{}) *InsertQuery { - q.addSet(schema.SafeQuery(query, args)) - return q -} - -func (q *InsertQuery) appendOn(fmter schema.Formatter, b []byte) (_ []byte, err error) { - if q.on.IsZero() { - return b, nil - } - - b = append(b, " ON "...) - b, err = q.on.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - - if len(q.set) > 0 { - if fmter.HasFeature(feature.InsertOnDuplicateKey) { - b = append(b, ' ') - } else { - b = append(b, " SET "...) - } - - b, err = q.appendSet(fmter, b) - if err != nil { - return nil, err - } - } else if q.onConflictDoUpdate() { - fields, err := q.getDataFields() - if err != nil { - return nil, err - } - - if len(fields) == 0 { - fields = q.tableModel.Table().DataFields - } - - b = q.appendSetExcluded(b, fields) - } else if q.onDuplicateKeyUpdate() { - fields, err := q.getDataFields() - if err != nil { - return nil, err - } - - if len(fields) == 0 { - fields = q.tableModel.Table().DataFields - } - - b = q.appendSetValues(b, fields) - } - - if len(q.where) > 0 { - b = append(b, " WHERE "...) - - b, err = appendWhere(fmter, b, q.where) - if err != nil { - return nil, err - } - } - - return b, nil -} - -func (q *InsertQuery) onConflictDoUpdate() bool { - return strings.HasSuffix(strings.ToUpper(q.on.Query), " DO UPDATE") -} - -func (q *InsertQuery) onDuplicateKeyUpdate() bool { - return strings.ToUpper(q.on.Query) == "DUPLICATE KEY UPDATE" -} - -func (q *InsertQuery) appendSetExcluded(b []byte, fields []*schema.Field) []byte { - b = append(b, " SET "...) - for i, f := range fields { - if i > 0 { - b = append(b, ", "...) - } - b = append(b, f.SQLName...) - b = append(b, " = EXCLUDED."...) - b = append(b, f.SQLName...) - } - return b -} - -func (q *InsertQuery) appendSetValues(b []byte, fields []*schema.Field) []byte { - b = append(b, " "...) - for i, f := range fields { - if i > 0 { - b = append(b, ", "...) - } - b = append(b, f.SQLName...) - b = append(b, " = VALUES("...) - b = append(b, f.SQLName...) - b = append(b, ")"...) - } - return b -} - -//------------------------------------------------------------------------------ - -func (q *InsertQuery) Scan(ctx context.Context, dest ...interface{}) error { - _, err := q.scanOrExec(ctx, dest, true) - return err -} - -func (q *InsertQuery) Exec(ctx context.Context, dest ...interface{}) (sql.Result, error) { - return q.scanOrExec(ctx, dest, len(dest) > 0) -} - -func (q *InsertQuery) scanOrExec( - ctx context.Context, dest []interface{}, hasDest bool, -) (sql.Result, error) { - if q.err != nil { - return nil, q.err - } - - if q.table != nil { - if err := q.beforeInsertHook(ctx); err != nil { - return nil, err - } - } - - // Run append model hooks before generating the query. - if err := q.beforeAppendModel(ctx, q); err != nil { - return nil, err - } - - // Generate the query before checking hasReturning. - queryBytes, err := q.AppendQuery(q.db.fmter, q.db.makeQueryBytes()) - if err != nil { - return nil, err - } - - useScan := hasDest || (q.hasReturning() && q.hasFeature(feature.InsertReturning|feature.Output)) - var model Model - - if useScan { - var err error - model, err = q.getModel(dest) - if err != nil { - return nil, err - } - } - - query := internal.String(queryBytes) - var res sql.Result - - if useScan { - res, err = q.scan(ctx, q, query, model, hasDest) - if err != nil { - return nil, err - } - } else { - res, err = q.exec(ctx, q, query) - if err != nil { - return nil, err - } - - if err := q.tryLastInsertID(res, dest); err != nil { - return nil, err - } - } - - if q.table != nil { - if err := q.afterInsertHook(ctx); err != nil { - return nil, err - } - } - - return res, nil -} - -func (q *InsertQuery) beforeInsertHook(ctx context.Context) error { - if hook, ok := q.table.ZeroIface.(BeforeInsertHook); ok { - if err := hook.BeforeInsert(ctx, q); err != nil { - return err - } - } - return nil -} - -func (q *InsertQuery) afterInsertHook(ctx context.Context) error { - if hook, ok := q.table.ZeroIface.(AfterInsertHook); ok { - if err := hook.AfterInsert(ctx, q); err != nil { - return err - } - } - return nil -} - -func (q *InsertQuery) tryLastInsertID(res sql.Result, dest []interface{}) error { - if q.db.HasFeature(feature.Returning) || - q.db.HasFeature(feature.Output) || - q.table == nil || - len(q.table.PKs) != 1 || - !q.table.PKs[0].AutoIncrement { - return nil - } - - id, err := res.LastInsertId() - if err != nil { - return err - } - if id == 0 { - return nil - } - - model, err := q.getModel(dest) - if err != nil { - return err - } - - pk := q.table.PKs[0] - switch model := model.(type) { - case *structTableModel: - if err := pk.ScanValue(model.strct, id); err != nil { - return err - } - case *sliceTableModel: - sliceLen := model.slice.Len() - for i := 0; i < sliceLen; i++ { - strct := indirect(model.slice.Index(i)) - if err := pk.ScanValue(strct, id); err != nil { - return err - } - id++ - } - } - - return nil -} - -func (q *InsertQuery) String() string { - buf, err := q.AppendQuery(q.db.Formatter(), nil) - if err != nil { - panic(err) - } - - return string(buf) -} diff --git a/vendor/github.com/uptrace/bun/query_merge.go b/vendor/github.com/uptrace/bun/query_merge.go deleted file mode 100644 index 0c172f180..000000000 --- a/vendor/github.com/uptrace/bun/query_merge.go +++ /dev/null @@ -1,334 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "errors" - - "github.com/uptrace/bun/dialect" - "github.com/uptrace/bun/dialect/feature" - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type MergeQuery struct { - baseQuery - returningQuery - - using schema.QueryWithArgs - on schema.QueryWithArgs - when []schema.QueryAppender - comment string -} - -var _ Query = (*MergeQuery)(nil) - -func NewMergeQuery(db *DB) *MergeQuery { - q := &MergeQuery{ - baseQuery: baseQuery{ - db: db, - }, - } - if q.db.dialect.Name() != dialect.MSSQL && q.db.dialect.Name() != dialect.PG { - q.err = errors.New("bun: merge not supported for current dialect") - } - return q -} - -func (q *MergeQuery) Conn(db IConn) *MergeQuery { - q.setConn(db) - return q -} - -func (q *MergeQuery) Model(model interface{}) *MergeQuery { - q.setModel(model) - return q -} - -func (q *MergeQuery) Err(err error) *MergeQuery { - q.setErr(err) - return q -} - -// Apply calls each function in fns, passing the MergeQuery as an argument. -func (q *MergeQuery) Apply(fns ...func(*MergeQuery) *MergeQuery) *MergeQuery { - for _, fn := range fns { - if fn != nil { - q = fn(q) - } - } - return q -} - -func (q *MergeQuery) With(name string, query Query) *MergeQuery { - q.addWith(name, query, false) - return q -} - -func (q *MergeQuery) WithRecursive(name string, query Query) *MergeQuery { - q.addWith(name, query, true) - return q -} - -//------------------------------------------------------------------------------ - -func (q *MergeQuery) Table(tables ...string) *MergeQuery { - for _, table := range tables { - q.addTable(schema.UnsafeIdent(table)) - } - return q -} - -func (q *MergeQuery) TableExpr(query string, args ...interface{}) *MergeQuery { - q.addTable(schema.SafeQuery(query, args)) - return q -} - -func (q *MergeQuery) ModelTableExpr(query string, args ...interface{}) *MergeQuery { - q.modelTableName = schema.SafeQuery(query, args) - return q -} - -//------------------------------------------------------------------------------ - -// Returning adds a RETURNING clause to the query. -// -// To suppress the auto-generated RETURNING clause, use `Returning("NULL")`. -// Only for mssql output, postgres not supported returning in merge query -func (q *MergeQuery) Returning(query string, args ...interface{}) *MergeQuery { - q.addReturning(schema.SafeQuery(query, args)) - return q -} - -//------------------------------------------------------------------------------ - -func (q *MergeQuery) Using(s string, args ...interface{}) *MergeQuery { - q.using = schema.SafeQuery(s, args) - return q -} - -func (q *MergeQuery) On(s string, args ...interface{}) *MergeQuery { - q.on = schema.SafeQuery(s, args) - return q -} - -// WhenInsert for when insert clause. -func (q *MergeQuery) WhenInsert(expr string, fn func(q *InsertQuery) *InsertQuery) *MergeQuery { - sq := NewInsertQuery(q.db) - // apply the model as default into sub query, since appendColumnsValues required - if q.model != nil { - sq = sq.Model(q.model) - } - sq = sq.Apply(fn) - q.when = append(q.when, &whenInsert{expr: expr, query: sq}) - return q -} - -// WhenUpdate for when update clause. -func (q *MergeQuery) WhenUpdate(expr string, fn func(q *UpdateQuery) *UpdateQuery) *MergeQuery { - sq := NewUpdateQuery(q.db) - // apply the model as default into sub query - if q.model != nil { - sq = sq.Model(q.model) - } - sq = sq.Apply(fn) - q.when = append(q.when, &whenUpdate{expr: expr, query: sq}) - return q -} - -// WhenDelete for when delete clause. -func (q *MergeQuery) WhenDelete(expr string) *MergeQuery { - q.when = append(q.when, &whenDelete{expr: expr}) - return q -} - -// When for raw expression clause. -func (q *MergeQuery) When(expr string, args ...interface{}) *MergeQuery { - q.when = append(q.when, schema.SafeQuery(expr, args)) - return q -} - -//------------------------------------------------------------------------------ - -// Comment adds a comment to the query, wrapped by /* ... */. -func (q *MergeQuery) Comment(comment string) *MergeQuery { - q.comment = comment - return q -} - -//------------------------------------------------------------------------------ - -func (q *MergeQuery) Operation() string { - return "MERGE" -} - -func (q *MergeQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { - if q.err != nil { - return nil, q.err - } - - b = appendComment(b, q.comment) - - fmter = formatterWithModel(fmter, q) - - b, err = q.appendWith(fmter, b) - if err != nil { - return nil, err - } - - b = append(b, "MERGE "...) - if q.db.dialect.Name() == dialect.PG { - b = append(b, "INTO "...) - } - - b, err = q.appendFirstTableWithAlias(fmter, b) - if err != nil { - return nil, err - } - - b = append(b, " USING "...) - b, err = q.using.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - - b = append(b, " ON "...) - b, err = q.on.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - - for _, w := range q.when { - b = append(b, " WHEN "...) - b, err = w.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - - if q.hasFeature(feature.Output) && q.hasReturning() { - b = append(b, " OUTPUT "...) - b, err = q.appendOutput(fmter, b) - if err != nil { - return nil, err - } - } - - // A MERGE statement must be terminated by a semi-colon (;). - b = append(b, ";"...) - - return b, nil -} - -//------------------------------------------------------------------------------ - -func (q *MergeQuery) Scan(ctx context.Context, dest ...interface{}) error { - _, err := q.scanOrExec(ctx, dest, true) - return err -} - -func (q *MergeQuery) Exec(ctx context.Context, dest ...interface{}) (sql.Result, error) { - return q.scanOrExec(ctx, dest, len(dest) > 0) -} - -func (q *MergeQuery) scanOrExec( - ctx context.Context, dest []interface{}, hasDest bool, -) (sql.Result, error) { - if q.err != nil { - return nil, q.err - } - - // Run append model hooks before generating the query. - if err := q.beforeAppendModel(ctx, q); err != nil { - return nil, err - } - - // Generate the query before checking hasReturning. - queryBytes, err := q.AppendQuery(q.db.fmter, q.db.makeQueryBytes()) - if err != nil { - return nil, err - } - - useScan := hasDest || (q.hasReturning() && q.hasFeature(feature.InsertReturning|feature.Output)) - var model Model - - if useScan { - var err error - model, err = q.getModel(dest) - if err != nil { - return nil, err - } - } - - query := internal.String(queryBytes) - var res sql.Result - - if useScan { - res, err = q.scan(ctx, q, query, model, true) - if err != nil { - return nil, err - } - } else { - res, err = q.exec(ctx, q, query) - if err != nil { - return nil, err - } - } - - return res, nil -} - -func (q *MergeQuery) String() string { - buf, err := q.AppendQuery(q.db.Formatter(), nil) - if err != nil { - panic(err) - } - - return string(buf) -} - -//------------------------------------------------------------------------------ - -type whenInsert struct { - expr string - query *InsertQuery -} - -func (w *whenInsert) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { - b = append(b, w.expr...) - if w.query != nil { - b = append(b, " THEN INSERT"...) - b, err = w.query.appendColumnsValues(fmter, b, true) - if err != nil { - return nil, err - } - } - return b, nil -} - -type whenUpdate struct { - expr string - query *UpdateQuery -} - -func (w *whenUpdate) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { - b = append(b, w.expr...) - if w.query != nil { - b = append(b, " THEN UPDATE SET "...) - b, err = w.query.appendSet(fmter, b) - if err != nil { - return nil, err - } - } - return b, nil -} - -type whenDelete struct { - expr string -} - -func (w *whenDelete) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { - b = append(b, w.expr...) - b = append(b, " THEN DELETE"...) - return b, nil -} diff --git a/vendor/github.com/uptrace/bun/query_raw.go b/vendor/github.com/uptrace/bun/query_raw.go deleted file mode 100644 index 308329567..000000000 --- a/vendor/github.com/uptrace/bun/query_raw.go +++ /dev/null @@ -1,103 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - - "github.com/uptrace/bun/schema" -) - -type RawQuery struct { - baseQuery - - query string - args []interface{} - comment string -} - -func NewRawQuery(db *DB, query string, args ...interface{}) *RawQuery { - return &RawQuery{ - baseQuery: baseQuery{ - db: db, - }, - query: query, - args: args, - } -} - -func (q *RawQuery) Conn(db IConn) *RawQuery { - q.setConn(db) - return q -} - -func (q *RawQuery) Err(err error) *RawQuery { - q.setErr(err) - return q -} - -func (q *RawQuery) Exec(ctx context.Context, dest ...interface{}) (sql.Result, error) { - return q.scanOrExec(ctx, dest, len(dest) > 0) -} - -func (q *RawQuery) Scan(ctx context.Context, dest ...interface{}) error { - _, err := q.scanOrExec(ctx, dest, true) - return err -} - -// Comment adds a comment to the query, wrapped by /* ... */. -func (q *RawQuery) Comment(comment string) *RawQuery { - q.comment = comment - return q -} - -func (q *RawQuery) scanOrExec( - ctx context.Context, dest []interface{}, hasDest bool, -) (sql.Result, error) { - if q.err != nil { - return nil, q.err - } - - var model Model - var err error - - if hasDest { - model, err = q.getModel(dest) - if err != nil { - return nil, err - } - } - - query := q.db.format(q.query, q.args) - var res sql.Result - - if hasDest { - res, err = q.scan(ctx, q, query, model, hasDest) - } else { - res, err = q.exec(ctx, q, query) - } - - if err != nil { - return nil, err - } - - return res, nil -} - -func (q *RawQuery) AppendQuery(fmter schema.Formatter, b []byte) ([]byte, error) { - b = appendComment(b, q.comment) - - return fmter.AppendQuery(b, q.query, q.args...), nil -} - -func (q *RawQuery) Operation() string { - return "SELECT" -} - -func (q *RawQuery) String() string { - buf, err := q.AppendQuery(q.db.Formatter(), nil) - if err != nil { - panic(err) - } - - return string(buf) -} diff --git a/vendor/github.com/uptrace/bun/query_select.go b/vendor/github.com/uptrace/bun/query_select.go deleted file mode 100644 index 1ef7e3bb1..000000000 --- a/vendor/github.com/uptrace/bun/query_select.go +++ /dev/null @@ -1,1223 +0,0 @@ -package bun - -import ( - "bytes" - "context" - "database/sql" - "errors" - "fmt" - "sync" - - "github.com/uptrace/bun/dialect" - - "github.com/uptrace/bun/dialect/feature" - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type union struct { - expr string - query *SelectQuery -} - -type SelectQuery struct { - whereBaseQuery - idxHintsQuery - orderLimitOffsetQuery - - distinctOn []schema.QueryWithArgs - joins []joinQuery - group []schema.QueryWithArgs - having []schema.QueryWithArgs - selFor schema.QueryWithArgs - - union []union - comment string -} - -var _ Query = (*SelectQuery)(nil) - -func NewSelectQuery(db *DB) *SelectQuery { - return &SelectQuery{ - whereBaseQuery: whereBaseQuery{ - baseQuery: baseQuery{ - db: db, - }, - }, - } -} - -func (q *SelectQuery) Conn(db IConn) *SelectQuery { - q.setConn(db) - return q -} - -func (q *SelectQuery) Model(model interface{}) *SelectQuery { - q.setModel(model) - return q -} - -func (q *SelectQuery) Err(err error) *SelectQuery { - q.setErr(err) - return q -} - -// Apply calls each function in fns, passing the SelectQuery as an argument. -func (q *SelectQuery) Apply(fns ...func(*SelectQuery) *SelectQuery) *SelectQuery { - for _, fn := range fns { - if fn != nil { - q = fn(q) - } - } - return q -} - -func (q *SelectQuery) With(name string, query Query) *SelectQuery { - q.addWith(name, query, false) - return q -} - -func (q *SelectQuery) WithRecursive(name string, query Query) *SelectQuery { - q.addWith(name, query, true) - return q -} - -func (q *SelectQuery) Distinct() *SelectQuery { - q.distinctOn = make([]schema.QueryWithArgs, 0) - return q -} - -func (q *SelectQuery) DistinctOn(query string, args ...interface{}) *SelectQuery { - q.distinctOn = append(q.distinctOn, schema.SafeQuery(query, args)) - return q -} - -//------------------------------------------------------------------------------ - -func (q *SelectQuery) Table(tables ...string) *SelectQuery { - for _, table := range tables { - q.addTable(schema.UnsafeIdent(table)) - } - return q -} - -func (q *SelectQuery) TableExpr(query string, args ...interface{}) *SelectQuery { - q.addTable(schema.SafeQuery(query, args)) - return q -} - -func (q *SelectQuery) ModelTableExpr(query string, args ...interface{}) *SelectQuery { - q.modelTableName = schema.SafeQuery(query, args) - return q -} - -//------------------------------------------------------------------------------ - -func (q *SelectQuery) Column(columns ...string) *SelectQuery { - for _, column := range columns { - q.addColumn(schema.UnsafeIdent(column)) - } - return q -} - -func (q *SelectQuery) ColumnExpr(query string, args ...interface{}) *SelectQuery { - q.addColumn(schema.SafeQuery(query, args)) - return q -} - -func (q *SelectQuery) ExcludeColumn(columns ...string) *SelectQuery { - q.excludeColumn(columns) - return q -} - -//------------------------------------------------------------------------------ - -func (q *SelectQuery) WherePK(cols ...string) *SelectQuery { - q.addWhereCols(cols) - return q -} - -func (q *SelectQuery) Where(query string, args ...interface{}) *SelectQuery { - q.addWhere(schema.SafeQueryWithSep(query, args, " AND ")) - return q -} - -func (q *SelectQuery) WhereOr(query string, args ...interface{}) *SelectQuery { - q.addWhere(schema.SafeQueryWithSep(query, args, " OR ")) - return q -} - -func (q *SelectQuery) WhereGroup(sep string, fn func(*SelectQuery) *SelectQuery) *SelectQuery { - saved := q.where - q.where = nil - - q = fn(q) - - where := q.where - q.where = saved - - q.addWhereGroup(sep, where) - - return q -} - -func (q *SelectQuery) WhereDeleted() *SelectQuery { - q.whereDeleted() - return q -} - -func (q *SelectQuery) WhereAllWithDeleted() *SelectQuery { - q.whereAllWithDeleted() - return q -} - -//------------------------------------------------------------------------------ - -func (q *SelectQuery) UseIndex(indexes ...string) *SelectQuery { - if q.db.dialect.Name() == dialect.MySQL { - q.addUseIndex(indexes...) - } - return q -} - -func (q *SelectQuery) UseIndexForJoin(indexes ...string) *SelectQuery { - if q.db.dialect.Name() == dialect.MySQL { - q.addUseIndexForJoin(indexes...) - } - return q -} - -func (q *SelectQuery) UseIndexForOrderBy(indexes ...string) *SelectQuery { - if q.db.dialect.Name() == dialect.MySQL { - q.addUseIndexForOrderBy(indexes...) - } - return q -} - -func (q *SelectQuery) UseIndexForGroupBy(indexes ...string) *SelectQuery { - if q.db.dialect.Name() == dialect.MySQL { - q.addUseIndexForGroupBy(indexes...) - } - return q -} - -func (q *SelectQuery) IgnoreIndex(indexes ...string) *SelectQuery { - if q.db.dialect.Name() == dialect.MySQL { - q.addIgnoreIndex(indexes...) - } - return q -} - -func (q *SelectQuery) IgnoreIndexForJoin(indexes ...string) *SelectQuery { - if q.db.dialect.Name() == dialect.MySQL { - q.addIgnoreIndexForJoin(indexes...) - } - return q -} - -func (q *SelectQuery) IgnoreIndexForOrderBy(indexes ...string) *SelectQuery { - if q.db.dialect.Name() == dialect.MySQL { - q.addIgnoreIndexForOrderBy(indexes...) - } - return q -} - -func (q *SelectQuery) IgnoreIndexForGroupBy(indexes ...string) *SelectQuery { - if q.db.dialect.Name() == dialect.MySQL { - q.addIgnoreIndexForGroupBy(indexes...) - } - return q -} - -func (q *SelectQuery) ForceIndex(indexes ...string) *SelectQuery { - if q.db.dialect.Name() == dialect.MySQL { - q.addForceIndex(indexes...) - } - return q -} - -func (q *SelectQuery) ForceIndexForJoin(indexes ...string) *SelectQuery { - if q.db.dialect.Name() == dialect.MySQL { - q.addForceIndexForJoin(indexes...) - } - return q -} - -func (q *SelectQuery) ForceIndexForOrderBy(indexes ...string) *SelectQuery { - if q.db.dialect.Name() == dialect.MySQL { - q.addForceIndexForOrderBy(indexes...) - } - return q -} - -func (q *SelectQuery) ForceIndexForGroupBy(indexes ...string) *SelectQuery { - if q.db.dialect.Name() == dialect.MySQL { - q.addForceIndexForGroupBy(indexes...) - } - return q -} - -//------------------------------------------------------------------------------ - -func (q *SelectQuery) Group(columns ...string) *SelectQuery { - for _, column := range columns { - q.group = append(q.group, schema.UnsafeIdent(column)) - } - return q -} - -func (q *SelectQuery) GroupExpr(group string, args ...interface{}) *SelectQuery { - q.group = append(q.group, schema.SafeQuery(group, args)) - return q -} - -func (q *SelectQuery) Having(having string, args ...interface{}) *SelectQuery { - q.having = append(q.having, schema.SafeQuery(having, args)) - return q -} - -func (q *SelectQuery) Order(orders ...string) *SelectQuery { - q.addOrder(orders...) - return q -} - -func (q *SelectQuery) OrderExpr(query string, args ...interface{}) *SelectQuery { - q.addOrderExpr(query, args...) - return q -} - -func (q *SelectQuery) Limit(n int) *SelectQuery { - q.setLimit(n) - return q -} - -func (q *SelectQuery) Offset(n int) *SelectQuery { - q.setOffset(n) - return q -} - -func (q *SelectQuery) For(s string, args ...interface{}) *SelectQuery { - q.selFor = schema.SafeQuery(s, args) - return q -} - -//------------------------------------------------------------------------------ - -func (q *SelectQuery) Union(other *SelectQuery) *SelectQuery { - return q.addUnion(" UNION ", other) -} - -func (q *SelectQuery) UnionAll(other *SelectQuery) *SelectQuery { - return q.addUnion(" UNION ALL ", other) -} - -func (q *SelectQuery) Intersect(other *SelectQuery) *SelectQuery { - return q.addUnion(" INTERSECT ", other) -} - -func (q *SelectQuery) IntersectAll(other *SelectQuery) *SelectQuery { - return q.addUnion(" INTERSECT ALL ", other) -} - -func (q *SelectQuery) Except(other *SelectQuery) *SelectQuery { - return q.addUnion(" EXCEPT ", other) -} - -func (q *SelectQuery) ExceptAll(other *SelectQuery) *SelectQuery { - return q.addUnion(" EXCEPT ALL ", other) -} - -func (q *SelectQuery) addUnion(expr string, other *SelectQuery) *SelectQuery { - q.union = append(q.union, union{ - expr: expr, - query: other, - }) - return q -} - -//------------------------------------------------------------------------------ - -func (q *SelectQuery) Join(join string, args ...interface{}) *SelectQuery { - q.joins = append(q.joins, joinQuery{ - join: schema.SafeQuery(join, args), - }) - return q -} - -func (q *SelectQuery) JoinOn(cond string, args ...interface{}) *SelectQuery { - return q.joinOn(cond, args, " AND ") -} - -func (q *SelectQuery) JoinOnOr(cond string, args ...interface{}) *SelectQuery { - return q.joinOn(cond, args, " OR ") -} - -func (q *SelectQuery) joinOn(cond string, args []interface{}, sep string) *SelectQuery { - if len(q.joins) == 0 { - q.err = errors.New("bun: query has no joins") - return q - } - j := &q.joins[len(q.joins)-1] - j.on = append(j.on, schema.SafeQueryWithSep(cond, args, sep)) - return q -} - -//------------------------------------------------------------------------------ - -// Relation adds a relation to the query. -func (q *SelectQuery) Relation(name string, apply ...func(*SelectQuery) *SelectQuery) *SelectQuery { - if len(apply) > 1 { - panic("only one apply function is supported") - } - - if q.tableModel == nil { - q.setErr(errNilModel) - return q - } - - join := q.tableModel.join(name) - if join == nil { - q.setErr(fmt.Errorf("%s does not have relation=%q", q.table, name)) - return q - } - - q.applyToRelation(join, apply...) - - return q -} - -type RelationOpts struct { - // Apply applies additional options to the relation. - Apply func(*SelectQuery) *SelectQuery - // AdditionalJoinOnConditions adds additional conditions to the JOIN ON clause. - AdditionalJoinOnConditions []schema.QueryWithArgs -} - -// RelationWithOpts adds a relation to the query with additional options. -func (q *SelectQuery) RelationWithOpts(name string, opts RelationOpts) *SelectQuery { - if q.tableModel == nil { - q.setErr(errNilModel) - return q - } - - join := q.tableModel.join(name) - if join == nil { - q.setErr(fmt.Errorf("%s does not have relation=%q", q.table, name)) - return q - } - - if opts.Apply != nil { - q.applyToRelation(join, opts.Apply) - } - - if len(opts.AdditionalJoinOnConditions) > 0 { - join.additionalJoinOnConditions = opts.AdditionalJoinOnConditions - } - - return q -} - -func (q *SelectQuery) applyToRelation(join *relationJoin, apply ...func(*SelectQuery) *SelectQuery) { - var apply1, apply2 func(*SelectQuery) *SelectQuery - - if len(join.Relation.Condition) > 0 { - apply1 = func(q *SelectQuery) *SelectQuery { - for _, opt := range join.Relation.Condition { - q.addWhere(schema.SafeQueryWithSep(opt, nil, " AND ")) - } - - return q - } - } - - if len(apply) == 1 { - apply2 = apply[0] - } - - join.apply = func(q *SelectQuery) *SelectQuery { - if apply1 != nil { - q = apply1(q) - } - if apply2 != nil { - q = apply2(q) - } - - return q - } -} - -func (q *SelectQuery) forEachInlineRelJoin(fn func(*relationJoin) error) error { - if q.tableModel == nil { - return nil - } - return q._forEachInlineRelJoin(fn, q.tableModel.getJoins()) -} - -func (q *SelectQuery) _forEachInlineRelJoin(fn func(*relationJoin) error, joins []relationJoin) error { - for i := range joins { - j := &joins[i] - switch j.Relation.Type { - case schema.HasOneRelation, schema.BelongsToRelation: - if err := fn(j); err != nil { - return err - } - if err := q._forEachInlineRelJoin(fn, j.JoinModel.getJoins()); err != nil { - return err - } - } - } - return nil -} - -func (q *SelectQuery) selectJoins(ctx context.Context, joins []relationJoin) error { - for i := range joins { - j := &joins[i] - - var err error - - switch j.Relation.Type { - case schema.HasOneRelation, schema.BelongsToRelation: - err = q.selectJoins(ctx, j.JoinModel.getJoins()) - case schema.HasManyRelation: - err = j.selectMany(ctx, q.db.NewSelect().Conn(q.conn)) - case schema.ManyToManyRelation: - err = j.selectM2M(ctx, q.db.NewSelect().Conn(q.conn)) - default: - panic("not reached") - } - - if err != nil { - return err - } - } - return nil -} - -//------------------------------------------------------------------------------ - -// Comment adds a comment to the query, wrapped by /* ... */. -func (q *SelectQuery) Comment(comment string) *SelectQuery { - q.comment = comment - return q -} - -//------------------------------------------------------------------------------ - -func (q *SelectQuery) Operation() string { - return "SELECT" -} - -func (q *SelectQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { - b = appendComment(b, q.comment) - - return q.appendQuery(fmter, b, false) -} - -func (q *SelectQuery) appendQuery( - fmter schema.Formatter, b []byte, count bool, -) (_ []byte, err error) { - if q.err != nil { - return nil, q.err - } - - fmter = formatterWithModel(fmter, q) - - cteCount := count && (len(q.group) > 0 || q.distinctOn != nil) - if cteCount { - b = append(b, "WITH _count_wrapper AS ("...) - } - - if len(q.union) > 0 { - b = append(b, '(') - } - - b, err = q.appendWith(fmter, b) - if err != nil { - return nil, err - } - - if err := q.forEachInlineRelJoin(func(j *relationJoin) error { - j.applyTo(q) - return nil - }); err != nil { - return nil, err - } - - b = append(b, "SELECT "...) - - if len(q.distinctOn) > 0 { - b = append(b, "DISTINCT ON ("...) - for i, app := range q.distinctOn { - if i > 0 { - b = append(b, ", "...) - } - b, err = app.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - b = append(b, ") "...) - } else if q.distinctOn != nil { - b = append(b, "DISTINCT "...) - } - - if count && !cteCount { - b = append(b, "count(*)"...) - } else { - // MSSQL: allows Limit() without Order() as per https://stackoverflow.com/a/36156953 - if q.limit > 0 && len(q.order) == 0 && fmter.Dialect().Name() == dialect.MSSQL { - b = append(b, "0 AS _temp_sort, "...) - } - - b, err = q.appendColumns(fmter, b) - if err != nil { - return nil, err - } - } - - if q.hasTables() { - b, err = q.appendTables(fmter, b) - if err != nil { - return nil, err - } - } - - b, err = q.appendIndexHints(fmter, b) - if err != nil { - return nil, err - } - - if err := q.forEachInlineRelJoin(func(j *relationJoin) error { - b = append(b, ' ') - b, err = j.appendHasOneJoin(fmter, b, q) - return err - }); err != nil { - return nil, err - } - - for _, join := range q.joins { - b, err = join.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - - b, err = q.appendWhere(fmter, b, true) - if err != nil { - return nil, err - } - - if len(q.group) > 0 { - b = append(b, " GROUP BY "...) - for i, f := range q.group { - if i > 0 { - b = append(b, ", "...) - } - b, err = f.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - } - - if len(q.having) > 0 { - b = append(b, " HAVING "...) - for i, f := range q.having { - if i > 0 { - b = append(b, " AND "...) - } - b = append(b, '(') - b, err = f.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - b = append(b, ')') - } - } - - if !count { - b, err = q.appendOrder(fmter, b) - if err != nil { - return nil, err - } - - b, err = q.appendLimitOffset(fmter, b) - if err != nil { - return nil, err - } - - if !q.selFor.IsZero() { - b = append(b, " FOR "...) - b, err = q.selFor.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - } - - if len(q.union) > 0 { - b = append(b, ')') - - for _, u := range q.union { - b = append(b, u.expr...) - b = append(b, '(') - b, err = u.query.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - b = append(b, ')') - } - } - - if cteCount { - b = append(b, ") SELECT count(*) FROM _count_wrapper"...) - } - - return b, nil -} - -func (q *SelectQuery) appendColumns(fmter schema.Formatter, b []byte) (_ []byte, err error) { - start := len(b) - - switch { - case q.columns != nil: - for i, col := range q.columns { - if i > 0 { - b = append(b, ", "...) - } - - if col.Args == nil && q.table != nil { - if field, ok := q.table.FieldMap[col.Query]; ok { - b = append(b, q.table.SQLAlias...) - b = append(b, '.') - b = append(b, field.SQLName...) - continue - } - } - - b, err = col.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - case q.table != nil: - if len(q.table.Fields) > 10 && fmter.IsNop() { - b = append(b, q.table.SQLAlias...) - b = append(b, '.') - b = fmter.Dialect().AppendString(b, fmt.Sprintf("%d columns", len(q.table.Fields))) - } else { - b = appendColumns(b, q.table.SQLAlias, q.table.Fields) - } - default: - b = append(b, '*') - } - - if err := q.forEachInlineRelJoin(func(join *relationJoin) error { - if len(b) != start { - b = append(b, ", "...) - start = len(b) - } - - b, err = q.appendInlineRelColumns(fmter, b, join) - if err != nil { - return err - } - - return nil - }); err != nil { - return nil, err - } - - b = bytes.TrimSuffix(b, []byte(", ")) - - return b, nil -} - -func (q *SelectQuery) appendInlineRelColumns( - fmter schema.Formatter, b []byte, join *relationJoin, -) (_ []byte, err error) { - if join.columns != nil { - table := join.JoinModel.Table() - for i, col := range join.columns { - if i > 0 { - b = append(b, ", "...) - } - - if col.Args == nil { - if field, ok := table.FieldMap[col.Query]; ok { - b = join.appendAlias(fmter, b) - b = append(b, '.') - b = append(b, field.SQLName...) - b = append(b, " AS "...) - b = join.appendAliasColumn(fmter, b, field.Name) - continue - } - } - - b, err = col.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - return b, nil - } - - for i, field := range join.JoinModel.Table().Fields { - if i > 0 { - b = append(b, ", "...) - } - b = join.appendAlias(fmter, b) - b = append(b, '.') - b = append(b, field.SQLName...) - b = append(b, " AS "...) - b = join.appendAliasColumn(fmter, b, field.Name) - } - return b, nil -} - -func (q *SelectQuery) appendTables(fmter schema.Formatter, b []byte) (_ []byte, err error) { - b = append(b, " FROM "...) - return q.appendTablesWithAlias(fmter, b) -} - -//------------------------------------------------------------------------------ - -func (q *SelectQuery) Rows(ctx context.Context) (*sql.Rows, error) { - if q.err != nil { - return nil, q.err - } - - if err := q.beforeAppendModel(ctx, q); err != nil { - return nil, err - } - - queryBytes, err := q.AppendQuery(q.db.fmter, q.db.makeQueryBytes()) - if err != nil { - return nil, err - } - - query := internal.String(queryBytes) - - ctx, event := q.db.beforeQuery(ctx, q, query, nil, query, q.model) - rows, err := q.resolveConn(q).QueryContext(ctx, query) - q.db.afterQuery(ctx, event, nil, err) - return rows, err -} - -func (q *SelectQuery) Exec(ctx context.Context, dest ...interface{}) (res sql.Result, err error) { - if q.err != nil { - return nil, q.err - } - if err := q.beforeAppendModel(ctx, q); err != nil { - return nil, err - } - - queryBytes, err := q.AppendQuery(q.db.fmter, q.db.makeQueryBytes()) - if err != nil { - return nil, err - } - - query := internal.String(queryBytes) - - if len(dest) > 0 { - model, err := q.getModel(dest) - if err != nil { - return nil, err - } - - res, err = q.scan(ctx, q, query, model, true) - if err != nil { - return nil, err - } - } else { - res, err = q.exec(ctx, q, query) - if err != nil { - return nil, err - } - } - - return res, nil -} - -func (q *SelectQuery) Scan(ctx context.Context, dest ...interface{}) error { - _, err := q.scanResult(ctx, dest...) - return err -} - -func (q *SelectQuery) scanResult(ctx context.Context, dest ...interface{}) (sql.Result, error) { - if q.err != nil { - return nil, q.err - } - - model, err := q.getModel(dest) - if err != nil { - return nil, err - } - if len(dest) > 0 && q.tableModel != nil && len(q.tableModel.getJoins()) > 0 { - for _, j := range q.tableModel.getJoins() { - switch j.Relation.Type { - case schema.HasManyRelation, schema.ManyToManyRelation: - return nil, fmt.Errorf("When querying has-many or many-to-many relationships, you should use Model instead of the dest parameter in Scan.") - } - } - } - - if q.table != nil { - if err := q.beforeSelectHook(ctx); err != nil { - return nil, err - } - } - - if err := q.beforeAppendModel(ctx, q); err != nil { - return nil, err - } - - queryBytes, err := q.AppendQuery(q.db.fmter, q.db.makeQueryBytes()) - if err != nil { - return nil, err - } - - query := internal.String(queryBytes) - - res, err := q.scan(ctx, q, query, model, true) - if err != nil { - return nil, err - } - - if n, _ := res.RowsAffected(); n > 0 { - if tableModel, ok := model.(TableModel); ok { - if err := q.selectJoins(ctx, tableModel.getJoins()); err != nil { - return nil, err - } - } - } - - if q.table != nil { - if err := q.afterSelectHook(ctx); err != nil { - return nil, err - } - } - - return res, nil -} - -func (q *SelectQuery) beforeSelectHook(ctx context.Context) error { - if hook, ok := q.table.ZeroIface.(BeforeSelectHook); ok { - if err := hook.BeforeSelect(ctx, q); err != nil { - return err - } - } - return nil -} - -func (q *SelectQuery) afterSelectHook(ctx context.Context) error { - if hook, ok := q.table.ZeroIface.(AfterSelectHook); ok { - if err := hook.AfterSelect(ctx, q); err != nil { - return err - } - } - return nil -} - -func (q *SelectQuery) Count(ctx context.Context) (int, error) { - if q.err != nil { - return 0, q.err - } - - qq := countQuery{q} - - queryBytes, err := qq.AppendQuery(q.db.fmter, nil) - if err != nil { - return 0, err - } - - query := internal.String(queryBytes) - ctx, event := q.db.beforeQuery(ctx, qq, query, nil, query, q.model) - - var num int - err = q.resolveConn(q).QueryRowContext(ctx, query).Scan(&num) - - q.db.afterQuery(ctx, event, nil, err) - - return num, err -} - -func (q *SelectQuery) ScanAndCount(ctx context.Context, dest ...interface{}) (int, error) { - if q.offset == 0 && q.limit == 0 { - // If there is no limit and offset, we can use a single query to get the count and scan - if res, err := q.scanResult(ctx, dest...); err != nil { - return 0, err - } else if n, err := res.RowsAffected(); err != nil { - return 0, err - } else { - return int(n), nil - } - } - if q.conn == nil { - return q.scanAndCountConcurrently(ctx, dest...) - } - return q.scanAndCountSeq(ctx, dest...) -} - -func (q *SelectQuery) scanAndCountConcurrently( - ctx context.Context, dest ...interface{}, -) (int, error) { - var count int - var wg sync.WaitGroup - var mu sync.Mutex - var firstErr error - - if q.limit >= 0 { - wg.Add(1) - go func() { - defer wg.Done() - - if err := q.Scan(ctx, dest...); err != nil { - mu.Lock() - if firstErr == nil { - firstErr = err - } - mu.Unlock() - } - }() - } - - wg.Add(1) - go func() { - defer wg.Done() - - var err error - count, err = q.Count(ctx) - if err != nil { - mu.Lock() - if firstErr == nil { - firstErr = err - } - mu.Unlock() - } - }() - - wg.Wait() - return count, firstErr -} - -func (q *SelectQuery) scanAndCountSeq(ctx context.Context, dest ...interface{}) (int, error) { - var firstErr error - - if q.limit >= 0 { - firstErr = q.Scan(ctx, dest...) - } - - count, err := q.Count(ctx) - if err != nil && firstErr == nil { - firstErr = err - } - - return count, firstErr -} - -func (q *SelectQuery) Exists(ctx context.Context) (bool, error) { - if q.err != nil { - return false, q.err - } - - if q.hasFeature(feature.SelectExists) { - return q.selectExists(ctx) - } - return q.whereExists(ctx) -} - -func (q *SelectQuery) selectExists(ctx context.Context) (bool, error) { - qq := selectExistsQuery{q} - - queryBytes, err := qq.AppendQuery(q.db.fmter, nil) - if err != nil { - return false, err - } - - query := internal.String(queryBytes) - ctx, event := q.db.beforeQuery(ctx, qq, query, nil, query, q.model) - - var exists bool - err = q.resolveConn(q).QueryRowContext(ctx, query).Scan(&exists) - - q.db.afterQuery(ctx, event, nil, err) - - return exists, err -} - -func (q *SelectQuery) whereExists(ctx context.Context) (bool, error) { - qq := whereExistsQuery{q} - - queryBytes, err := qq.AppendQuery(q.db.fmter, nil) - if err != nil { - return false, err - } - - query := internal.String(queryBytes) - res, err := q.exec(ctx, qq, query) - if err != nil { - return false, err - } - - n, err := res.RowsAffected() - if err != nil { - return false, err - } - - return n == 1, nil -} - -func (q *SelectQuery) String() string { - buf, err := q.AppendQuery(q.db.Formatter(), nil) - if err != nil { - panic(err) - } - - return string(buf) -} - -//------------------------------------------------------------------------------ - -func (q *SelectQuery) QueryBuilder() QueryBuilder { - return &selectQueryBuilder{q} -} - -func (q *SelectQuery) ApplyQueryBuilder(fn func(QueryBuilder) QueryBuilder) *SelectQuery { - return fn(q.QueryBuilder()).Unwrap().(*SelectQuery) -} - -type selectQueryBuilder struct { - *SelectQuery -} - -func (q *selectQueryBuilder) WhereGroup( - sep string, fn func(QueryBuilder) QueryBuilder, -) QueryBuilder { - q.SelectQuery = q.SelectQuery.WhereGroup(sep, func(qs *SelectQuery) *SelectQuery { - return fn(q).(*selectQueryBuilder).SelectQuery - }) - return q -} - -func (q *selectQueryBuilder) Where(query string, args ...interface{}) QueryBuilder { - q.SelectQuery.Where(query, args...) - return q -} - -func (q *selectQueryBuilder) WhereOr(query string, args ...interface{}) QueryBuilder { - q.SelectQuery.WhereOr(query, args...) - return q -} - -func (q *selectQueryBuilder) WhereDeleted() QueryBuilder { - q.SelectQuery.WhereDeleted() - return q -} - -func (q *selectQueryBuilder) WhereAllWithDeleted() QueryBuilder { - q.SelectQuery.WhereAllWithDeleted() - return q -} - -func (q *selectQueryBuilder) WherePK(cols ...string) QueryBuilder { - q.SelectQuery.WherePK(cols...) - return q -} - -func (q *selectQueryBuilder) Unwrap() interface{} { - return q.SelectQuery -} - -//------------------------------------------------------------------------------ - -type joinQuery struct { - join schema.QueryWithArgs - on []schema.QueryWithSep -} - -func (j *joinQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { - b = append(b, ' ') - - b, err = j.join.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - - if len(j.on) > 0 { - b = append(b, " ON "...) - for i, on := range j.on { - if i > 0 { - b = append(b, on.Sep...) - } - - b = append(b, '(') - b, err = on.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - b = append(b, ')') - } - } - - return b, nil -} - -//------------------------------------------------------------------------------ - -type countQuery struct { - *SelectQuery -} - -func (q countQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { - if q.err != nil { - return nil, q.err - } - return q.appendQuery(fmter, b, true) -} - -//------------------------------------------------------------------------------ - -type selectExistsQuery struct { - *SelectQuery -} - -func (q selectExistsQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { - if q.err != nil { - return nil, q.err - } - - b = append(b, "SELECT EXISTS ("...) - - b, err = q.appendQuery(fmter, b, false) - if err != nil { - return nil, err - } - - b = append(b, ")"...) - - return b, nil -} - -//------------------------------------------------------------------------------ - -type whereExistsQuery struct { - *SelectQuery -} - -func (q whereExistsQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { - if q.err != nil { - return nil, q.err - } - - b = append(b, "SELECT 1 WHERE EXISTS ("...) - - b, err = q.appendQuery(fmter, b, false) - if err != nil { - return nil, err - } - - b = append(b, ")"...) - - return b, nil -} diff --git a/vendor/github.com/uptrace/bun/query_table_create.go b/vendor/github.com/uptrace/bun/query_table_create.go deleted file mode 100644 index d8c4566cb..000000000 --- a/vendor/github.com/uptrace/bun/query_table_create.go +++ /dev/null @@ -1,407 +0,0 @@ -package bun - -import ( - "bytes" - "context" - "database/sql" - "fmt" - "sort" - "strconv" - "strings" - - "github.com/uptrace/bun/dialect" - "github.com/uptrace/bun/dialect/feature" - "github.com/uptrace/bun/dialect/sqltype" - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type CreateTableQuery struct { - baseQuery - - temp bool - ifNotExists bool - fksFromRel bool // Create foreign keys captured in table's relations. - - // varchar changes the default length for VARCHAR columns. - // Because some dialects require that length is always specified for VARCHAR type, - // we will use the exact user-defined type if length is set explicitly, as in `bun:",type:varchar(5)"`, - // but assume the new default length when it's omitted, e.g. `bun:",type:varchar"`. - varchar int - - fks []schema.QueryWithArgs - partitionBy schema.QueryWithArgs - tablespace schema.QueryWithArgs - comment string -} - -var _ Query = (*CreateTableQuery)(nil) - -func NewCreateTableQuery(db *DB) *CreateTableQuery { - q := &CreateTableQuery{ - baseQuery: baseQuery{ - db: db, - }, - varchar: db.Dialect().DefaultVarcharLen(), - } - return q -} - -func (q *CreateTableQuery) Conn(db IConn) *CreateTableQuery { - q.setConn(db) - return q -} - -func (q *CreateTableQuery) Model(model interface{}) *CreateTableQuery { - q.setModel(model) - return q -} - -func (q *CreateTableQuery) Err(err error) *CreateTableQuery { - q.setErr(err) - return q -} - -// ------------------------------------------------------------------------------ - -func (q *CreateTableQuery) Table(tables ...string) *CreateTableQuery { - for _, table := range tables { - q.addTable(schema.UnsafeIdent(table)) - } - return q -} - -func (q *CreateTableQuery) TableExpr(query string, args ...interface{}) *CreateTableQuery { - q.addTable(schema.SafeQuery(query, args)) - return q -} - -func (q *CreateTableQuery) ModelTableExpr(query string, args ...interface{}) *CreateTableQuery { - q.modelTableName = schema.SafeQuery(query, args) - return q -} - -func (q *CreateTableQuery) ColumnExpr(query string, args ...interface{}) *CreateTableQuery { - q.addColumn(schema.SafeQuery(query, args)) - return q -} - -// ------------------------------------------------------------------------------ - -func (q *CreateTableQuery) Temp() *CreateTableQuery { - q.temp = true - return q -} - -func (q *CreateTableQuery) IfNotExists() *CreateTableQuery { - q.ifNotExists = true - return q -} - -// Varchar sets default length for VARCHAR columns. -func (q *CreateTableQuery) Varchar(n int) *CreateTableQuery { - if n <= 0 { - q.setErr(fmt.Errorf("bun: illegal VARCHAR length: %d", n)) - return q - } - q.varchar = n - return q -} - -func (q *CreateTableQuery) ForeignKey(query string, args ...interface{}) *CreateTableQuery { - q.fks = append(q.fks, schema.SafeQuery(query, args)) - return q -} - -func (q *CreateTableQuery) PartitionBy(query string, args ...interface{}) *CreateTableQuery { - q.partitionBy = schema.SafeQuery(query, args) - return q -} - -func (q *CreateTableQuery) TableSpace(tablespace string) *CreateTableQuery { - q.tablespace = schema.UnsafeIdent(tablespace) - return q -} - -// WithForeignKeys adds a FOREIGN KEY clause for each of the model's existing relations. -func (q *CreateTableQuery) WithForeignKeys() *CreateTableQuery { - q.fksFromRel = true - return q -} - -//------------------------------------------------------------------------------ - -// Comment adds a comment to the query, wrapped by /* ... */. -func (q *CreateTableQuery) Comment(comment string) *CreateTableQuery { - q.comment = comment - return q -} - -// ------------------------------------------------------------------------------ - -func (q *CreateTableQuery) Operation() string { - return "CREATE TABLE" -} - -func (q *CreateTableQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { - if q.err != nil { - return nil, q.err - } - - b = appendComment(b, q.comment) - - if q.table == nil { - return nil, errNilModel - } - - b = append(b, "CREATE "...) - if q.temp { - b = append(b, "TEMP "...) - } - b = append(b, "TABLE "...) - if q.ifNotExists && fmter.HasFeature(feature.TableNotExists) { - b = append(b, "IF NOT EXISTS "...) - } - b, err = q.appendFirstTable(fmter, b) - if err != nil { - return nil, err - } - - b = append(b, " ("...) - - for i, field := range q.table.Fields { - if i > 0 { - b = append(b, ", "...) - } - - b = append(b, field.SQLName...) - b = append(b, " "...) - b = q.appendSQLType(b, field) - if field.NotNull && q.db.dialect.Name() != dialect.Oracle { - b = append(b, " NOT NULL"...) - } - - if (field.Identity && fmter.HasFeature(feature.GeneratedIdentity)) || - (field.AutoIncrement && (fmter.HasFeature(feature.AutoIncrement) || fmter.HasFeature(feature.Identity))) { - b = q.db.dialect.AppendSequence(b, q.table, field) - } - - if field.SQLDefault != "" { - b = append(b, " DEFAULT "...) - b = append(b, field.SQLDefault...) - } - } - - for i, col := range q.columns { - // Only pre-pend the comma if we are on subsequent iterations, or if there were fields/columns appended before - // this. This way if we are only appending custom column expressions we will not produce a syntax error with a - // leading comma. - if i > 0 || len(q.table.Fields) > 0 { - b = append(b, ", "...) - } - b, err = col.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - - // In SQLite AUTOINCREMENT is only valid for INTEGER PRIMARY KEY columns, so it might be that - // a primary key constraint has already been created in dialect.AppendSequence() call above. - // See sqldialect.Dialect.AppendSequence() for more details. - if len(q.table.PKs) > 0 && !bytes.Contains(b, []byte("PRIMARY KEY")) { - b = q.appendPKConstraint(b, q.table.PKs) - } - b = q.appendUniqueConstraints(fmter, b) - - if q.fksFromRel { - b, err = q.appendFKConstraintsRel(fmter, b) - if err != nil { - return nil, err - } - } - b, err = q.appendFKConstraints(fmter, b) - if err != nil { - return nil, err - } - - b = append(b, ")"...) - - if !q.partitionBy.IsZero() { - b = append(b, " PARTITION BY "...) - b, err = q.partitionBy.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - - if !q.tablespace.IsZero() { - b = append(b, " TABLESPACE "...) - b, err = q.tablespace.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - - return b, nil -} - -func (q *CreateTableQuery) appendSQLType(b []byte, field *schema.Field) []byte { - // Most of the time these two will match, but for the cases where DiscoveredSQLType is dialect-specific, - // e.g. pgdialect would change sqltype.SmallInt to pgTypeSmallSerial for columns that have `bun:",autoincrement"` - if !strings.EqualFold(field.CreateTableSQLType, field.DiscoveredSQLType) { - return append(b, field.CreateTableSQLType...) - } - - // For all common SQL types except VARCHAR, both UserDefinedSQLType and DiscoveredSQLType specify the correct type, - // and we needn't modify it. For VARCHAR columns, we will stop to check if a valid length has been set in .Varchar(int). - if !strings.EqualFold(field.CreateTableSQLType, sqltype.VarChar) || q.varchar <= 0 { - return append(b, field.CreateTableSQLType...) - } - - if q.db.dialect.Name() == dialect.Oracle { - b = append(b, "VARCHAR2"...) - } else { - b = append(b, sqltype.VarChar...) - } - b = append(b, "("...) - b = strconv.AppendInt(b, int64(q.varchar), 10) - b = append(b, ")"...) - return b -} - -func (q *CreateTableQuery) appendUniqueConstraints(fmter schema.Formatter, b []byte) []byte { - unique := q.table.Unique - - keys := make([]string, 0, len(unique)) - for key := range unique { - keys = append(keys, key) - } - sort.Strings(keys) - - for _, key := range keys { - if key == "" { - for _, field := range unique[key] { - b = q.appendUniqueConstraint(fmter, b, key, field) - } - continue - } - b = q.appendUniqueConstraint(fmter, b, key, unique[key]...) - } - - return b -} - -func (q *CreateTableQuery) appendUniqueConstraint( - fmter schema.Formatter, b []byte, name string, fields ...*schema.Field, -) []byte { - if name != "" { - b = append(b, ", CONSTRAINT "...) - b = fmter.AppendIdent(b, name) - } else { - b = append(b, ","...) - } - b = append(b, " UNIQUE ("...) - b = appendColumns(b, "", fields) - b = append(b, ")"...) - return b -} - -// appendFKConstraintsRel appends a FOREIGN KEY clause for each of the model's existing relations. -func (q *CreateTableQuery) appendFKConstraintsRel(fmter schema.Formatter, b []byte) (_ []byte, err error) { - for _, rel := range q.tableModel.Table().Relations { - if rel.References() { - b, err = q.appendFK(fmter, b, schema.QueryWithArgs{ - Query: "(?) REFERENCES ? (?) ? ?", - Args: []interface{}{ - Safe(appendColumns(nil, "", rel.BasePKs)), - rel.JoinTable.SQLName, - Safe(appendColumns(nil, "", rel.JoinPKs)), - Safe(rel.OnUpdate), - Safe(rel.OnDelete), - }, - }) - if err != nil { - return nil, err - } - } - } - return b, nil -} - -func (q *CreateTableQuery) appendFK(fmter schema.Formatter, b []byte, fk schema.QueryWithArgs) (_ []byte, err error) { - b = append(b, ", FOREIGN KEY "...) - return fk.AppendQuery(fmter, b) -} - -func (q *CreateTableQuery) appendFKConstraints( - fmter schema.Formatter, b []byte, -) (_ []byte, err error) { - for _, fk := range q.fks { - if b, err = q.appendFK(fmter, b, fk); err != nil { - return nil, err - } - } - return b, nil -} - -func (q *CreateTableQuery) appendPKConstraint(b []byte, pks []*schema.Field) []byte { - b = append(b, ", PRIMARY KEY ("...) - b = appendColumns(b, "", pks) - b = append(b, ")"...) - return b -} - -// ------------------------------------------------------------------------------ - -func (q *CreateTableQuery) Exec(ctx context.Context, dest ...interface{}) (sql.Result, error) { - if err := q.beforeCreateTableHook(ctx); err != nil { - return nil, err - } - - queryBytes, err := q.AppendQuery(q.db.fmter, q.db.makeQueryBytes()) - if err != nil { - return nil, err - } - - query := internal.String(queryBytes) - - res, err := q.exec(ctx, q, query) - if err != nil { - return nil, err - } - - if q.table != nil { - if err := q.afterCreateTableHook(ctx); err != nil { - return nil, err - } - } - - return res, nil -} - -func (q *CreateTableQuery) beforeCreateTableHook(ctx context.Context) error { - if hook, ok := q.table.ZeroIface.(BeforeCreateTableHook); ok { - if err := hook.BeforeCreateTable(ctx, q); err != nil { - return err - } - } - return nil -} - -func (q *CreateTableQuery) afterCreateTableHook(ctx context.Context) error { - if hook, ok := q.table.ZeroIface.(AfterCreateTableHook); ok { - if err := hook.AfterCreateTable(ctx, q); err != nil { - return err - } - } - return nil -} - -func (q *CreateTableQuery) String() string { - buf, err := q.AppendQuery(q.db.Formatter(), nil) - if err != nil { - panic(err) - } - - return string(buf) -} diff --git a/vendor/github.com/uptrace/bun/query_table_drop.go b/vendor/github.com/uptrace/bun/query_table_drop.go deleted file mode 100644 index 4e7d305a9..000000000 --- a/vendor/github.com/uptrace/bun/query_table_drop.go +++ /dev/null @@ -1,172 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type DropTableQuery struct { - baseQuery - cascadeQuery - - ifExists bool - comment string -} - -var _ Query = (*DropTableQuery)(nil) - -func NewDropTableQuery(db *DB) *DropTableQuery { - q := &DropTableQuery{ - baseQuery: baseQuery{ - db: db, - }, - } - return q -} - -func (q *DropTableQuery) Conn(db IConn) *DropTableQuery { - q.setConn(db) - return q -} - -func (q *DropTableQuery) Model(model interface{}) *DropTableQuery { - q.setModel(model) - return q -} - -func (q *DropTableQuery) Err(err error) *DropTableQuery { - q.setErr(err) - return q -} - -//------------------------------------------------------------------------------ - -func (q *DropTableQuery) Table(tables ...string) *DropTableQuery { - for _, table := range tables { - q.addTable(schema.UnsafeIdent(table)) - } - return q -} - -func (q *DropTableQuery) TableExpr(query string, args ...interface{}) *DropTableQuery { - q.addTable(schema.SafeQuery(query, args)) - return q -} - -func (q *DropTableQuery) ModelTableExpr(query string, args ...interface{}) *DropTableQuery { - q.modelTableName = schema.SafeQuery(query, args) - return q -} - -//------------------------------------------------------------------------------ - -func (q *DropTableQuery) IfExists() *DropTableQuery { - q.ifExists = true - return q -} - -func (q *DropTableQuery) Cascade() *DropTableQuery { - q.cascade = true - return q -} - -func (q *DropTableQuery) Restrict() *DropTableQuery { - q.restrict = true - return q -} - -//------------------------------------------------------------------------------ - -// Comment adds a comment to the query, wrapped by /* ... */. -func (q *DropTableQuery) Comment(comment string) *DropTableQuery { - q.comment = comment - return q -} - -//------------------------------------------------------------------------------ - -func (q *DropTableQuery) Operation() string { - return "DROP TABLE" -} - -func (q *DropTableQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { - if q.err != nil { - return nil, q.err - } - - b = appendComment(b, q.comment) - - b = append(b, "DROP TABLE "...) - if q.ifExists { - b = append(b, "IF EXISTS "...) - } - - b, err = q.appendTables(fmter, b) - if err != nil { - return nil, err - } - - b = q.appendCascade(fmter, b) - - return b, nil -} - -//------------------------------------------------------------------------------ - -func (q *DropTableQuery) Exec(ctx context.Context, dest ...interface{}) (sql.Result, error) { - if q.table != nil { - if err := q.beforeDropTableHook(ctx); err != nil { - return nil, err - } - } - - queryBytes, err := q.AppendQuery(q.db.fmter, q.db.makeQueryBytes()) - if err != nil { - return nil, err - } - - query := internal.String(queryBytes) - - res, err := q.exec(ctx, q, query) - if err != nil { - return nil, err - } - - if q.table != nil { - if err := q.afterDropTableHook(ctx); err != nil { - return nil, err - } - } - - return res, nil -} - -func (q *DropTableQuery) beforeDropTableHook(ctx context.Context) error { - if hook, ok := q.table.ZeroIface.(BeforeDropTableHook); ok { - if err := hook.BeforeDropTable(ctx, q); err != nil { - return err - } - } - return nil -} - -func (q *DropTableQuery) afterDropTableHook(ctx context.Context) error { - if hook, ok := q.table.ZeroIface.(AfterDropTableHook); ok { - if err := hook.AfterDropTable(ctx, q); err != nil { - return err - } - } - return nil -} - -func (q *DropTableQuery) String() string { - buf, err := q.AppendQuery(q.db.Formatter(), nil) - if err != nil { - panic(err) - } - - return string(buf) -} diff --git a/vendor/github.com/uptrace/bun/query_table_truncate.go b/vendor/github.com/uptrace/bun/query_table_truncate.go deleted file mode 100644 index 0f30a1d04..000000000 --- a/vendor/github.com/uptrace/bun/query_table_truncate.go +++ /dev/null @@ -1,152 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - - "github.com/uptrace/bun/dialect/feature" - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type TruncateTableQuery struct { - baseQuery - cascadeQuery - - continueIdentity bool - comment string -} - -var _ Query = (*TruncateTableQuery)(nil) - -func NewTruncateTableQuery(db *DB) *TruncateTableQuery { - q := &TruncateTableQuery{ - baseQuery: baseQuery{ - db: db, - }, - } - return q -} - -func (q *TruncateTableQuery) Conn(db IConn) *TruncateTableQuery { - q.setConn(db) - return q -} - -func (q *TruncateTableQuery) Model(model interface{}) *TruncateTableQuery { - q.setModel(model) - return q -} - -func (q *TruncateTableQuery) Err(err error) *TruncateTableQuery { - q.setErr(err) - return q -} - -//------------------------------------------------------------------------------ - -func (q *TruncateTableQuery) Table(tables ...string) *TruncateTableQuery { - for _, table := range tables { - q.addTable(schema.UnsafeIdent(table)) - } - return q -} - -func (q *TruncateTableQuery) TableExpr(query string, args ...interface{}) *TruncateTableQuery { - q.addTable(schema.SafeQuery(query, args)) - return q -} - -func (q *TruncateTableQuery) ModelTableExpr(query string, args ...interface{}) *TruncateTableQuery { - q.modelTableName = schema.SafeQuery(query, args) - return q -} - -//------------------------------------------------------------------------------ - -func (q *TruncateTableQuery) ContinueIdentity() *TruncateTableQuery { - q.continueIdentity = true - return q -} - -func (q *TruncateTableQuery) Cascade() *TruncateTableQuery { - q.cascade = true - return q -} - -func (q *TruncateTableQuery) Restrict() *TruncateTableQuery { - q.restrict = true - return q -} - -//------------------------------------------------------------------------------ - -// Comment adds a comment to the query, wrapped by /* ... */. -func (q *TruncateTableQuery) Comment(comment string) *TruncateTableQuery { - q.comment = comment - return q -} - -//------------------------------------------------------------------------------ - -func (q *TruncateTableQuery) Operation() string { - return "TRUNCATE TABLE" -} - -func (q *TruncateTableQuery) AppendQuery( - fmter schema.Formatter, b []byte, -) (_ []byte, err error) { - if q.err != nil { - return nil, q.err - } - - b = appendComment(b, q.comment) - - if !fmter.HasFeature(feature.TableTruncate) { - b = append(b, "DELETE FROM "...) - - b, err = q.appendTables(fmter, b) - if err != nil { - return nil, err - } - - return b, nil - } - - b = append(b, "TRUNCATE TABLE "...) - - b, err = q.appendTables(fmter, b) - if err != nil { - return nil, err - } - - if q.db.HasFeature(feature.TableIdentity) { - if q.continueIdentity { - b = append(b, " CONTINUE IDENTITY"...) - } else { - b = append(b, " RESTART IDENTITY"...) - } - } - - b = q.appendCascade(fmter, b) - - return b, nil -} - -//------------------------------------------------------------------------------ - -func (q *TruncateTableQuery) Exec(ctx context.Context, dest ...interface{}) (sql.Result, error) { - queryBytes, err := q.AppendQuery(q.db.fmter, q.db.makeQueryBytes()) - if err != nil { - return nil, err - } - - query := internal.String(queryBytes) - - res, err := q.exec(ctx, q, query) - if err != nil { - return nil, err - } - - return res, nil -} diff --git a/vendor/github.com/uptrace/bun/query_update.go b/vendor/github.com/uptrace/bun/query_update.go deleted file mode 100644 index b700f2180..000000000 --- a/vendor/github.com/uptrace/bun/query_update.go +++ /dev/null @@ -1,717 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "errors" - "fmt" - - "github.com/uptrace/bun/dialect" - - "github.com/uptrace/bun/dialect/feature" - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type UpdateQuery struct { - whereBaseQuery - orderLimitOffsetQuery - returningQuery - customValueQuery - setQuery - idxHintsQuery - - joins []joinQuery - omitZero bool - comment string -} - -var _ Query = (*UpdateQuery)(nil) - -func NewUpdateQuery(db *DB) *UpdateQuery { - q := &UpdateQuery{ - whereBaseQuery: whereBaseQuery{ - baseQuery: baseQuery{ - db: db, - }, - }, - } - return q -} - -func (q *UpdateQuery) Conn(db IConn) *UpdateQuery { - q.setConn(db) - return q -} - -func (q *UpdateQuery) Model(model interface{}) *UpdateQuery { - q.setModel(model) - return q -} - -func (q *UpdateQuery) Err(err error) *UpdateQuery { - q.setErr(err) - return q -} - -// Apply calls each function in fns, passing the UpdateQuery as an argument. -func (q *UpdateQuery) Apply(fns ...func(*UpdateQuery) *UpdateQuery) *UpdateQuery { - for _, fn := range fns { - if fn != nil { - q = fn(q) - } - } - return q -} - -func (q *UpdateQuery) With(name string, query Query) *UpdateQuery { - q.addWith(name, query, false) - return q -} - -func (q *UpdateQuery) WithRecursive(name string, query Query) *UpdateQuery { - q.addWith(name, query, true) - return q -} - -//------------------------------------------------------------------------------ - -func (q *UpdateQuery) Table(tables ...string) *UpdateQuery { - for _, table := range tables { - q.addTable(schema.UnsafeIdent(table)) - } - return q -} - -func (q *UpdateQuery) TableExpr(query string, args ...interface{}) *UpdateQuery { - q.addTable(schema.SafeQuery(query, args)) - return q -} - -func (q *UpdateQuery) ModelTableExpr(query string, args ...interface{}) *UpdateQuery { - q.modelTableName = schema.SafeQuery(query, args) - return q -} - -//------------------------------------------------------------------------------ - -func (q *UpdateQuery) Column(columns ...string) *UpdateQuery { - for _, column := range columns { - q.addColumn(schema.UnsafeIdent(column)) - } - return q -} - -func (q *UpdateQuery) ExcludeColumn(columns ...string) *UpdateQuery { - q.excludeColumn(columns) - return q -} - -func (q *UpdateQuery) Set(query string, args ...interface{}) *UpdateQuery { - q.addSet(schema.SafeQuery(query, args)) - return q -} - -func (q *UpdateQuery) SetColumn(column string, query string, args ...interface{}) *UpdateQuery { - if q.db.HasFeature(feature.UpdateMultiTable) { - column = q.table.Alias + "." + column - } - q.addSet(schema.SafeQuery(column+" = "+query, args)) - return q -} - -// Value overwrites model value for the column. -func (q *UpdateQuery) Value(column string, query string, args ...interface{}) *UpdateQuery { - if q.table == nil { - q.err = errNilModel - return q - } - q.addValue(q.table, column, query, args) - return q -} - -func (q *UpdateQuery) OmitZero() *UpdateQuery { - q.omitZero = true - return q -} - -//------------------------------------------------------------------------------ - -func (q *UpdateQuery) Join(join string, args ...interface{}) *UpdateQuery { - q.joins = append(q.joins, joinQuery{ - join: schema.SafeQuery(join, args), - }) - return q -} - -func (q *UpdateQuery) JoinOn(cond string, args ...interface{}) *UpdateQuery { - return q.joinOn(cond, args, " AND ") -} - -func (q *UpdateQuery) JoinOnOr(cond string, args ...interface{}) *UpdateQuery { - return q.joinOn(cond, args, " OR ") -} - -func (q *UpdateQuery) joinOn(cond string, args []interface{}, sep string) *UpdateQuery { - if len(q.joins) == 0 { - q.err = errors.New("bun: query has no joins") - return q - } - j := &q.joins[len(q.joins)-1] - j.on = append(j.on, schema.SafeQueryWithSep(cond, args, sep)) - return q -} - -//------------------------------------------------------------------------------ - -func (q *UpdateQuery) WherePK(cols ...string) *UpdateQuery { - q.addWhereCols(cols) - return q -} - -func (q *UpdateQuery) Where(query string, args ...interface{}) *UpdateQuery { - q.addWhere(schema.SafeQueryWithSep(query, args, " AND ")) - return q -} - -func (q *UpdateQuery) WhereOr(query string, args ...interface{}) *UpdateQuery { - q.addWhere(schema.SafeQueryWithSep(query, args, " OR ")) - return q -} - -func (q *UpdateQuery) WhereGroup(sep string, fn func(*UpdateQuery) *UpdateQuery) *UpdateQuery { - saved := q.where - q.where = nil - - q = fn(q) - - where := q.where - q.where = saved - - q.addWhereGroup(sep, where) - - return q -} - -func (q *UpdateQuery) WhereDeleted() *UpdateQuery { - q.whereDeleted() - return q -} - -func (q *UpdateQuery) WhereAllWithDeleted() *UpdateQuery { - q.whereAllWithDeleted() - return q -} - -// ------------------------------------------------------------------------------ -func (q *UpdateQuery) Order(orders ...string) *UpdateQuery { - if !q.hasFeature(feature.UpdateOrderLimit) { - q.err = feature.NewNotSupportError(feature.UpdateOrderLimit) - return q - } - q.addOrder(orders...) - return q -} - -func (q *UpdateQuery) OrderExpr(query string, args ...interface{}) *UpdateQuery { - if !q.hasFeature(feature.UpdateOrderLimit) { - q.err = feature.NewNotSupportError(feature.UpdateOrderLimit) - return q - } - q.addOrderExpr(query, args...) - return q -} - -func (q *UpdateQuery) Limit(n int) *UpdateQuery { - if !q.hasFeature(feature.UpdateOrderLimit) { - q.err = feature.NewNotSupportError(feature.UpdateOrderLimit) - return q - } - q.setLimit(n) - return q -} - -//------------------------------------------------------------------------------ - -// Returning adds a RETURNING clause to the query. -// -// To suppress the auto-generated RETURNING clause, use `Returning("NULL")`. -func (q *UpdateQuery) Returning(query string, args ...interface{}) *UpdateQuery { - q.addReturning(schema.SafeQuery(query, args)) - return q -} - -//------------------------------------------------------------------------------ - -// Comment adds a comment to the query, wrapped by /* ... */. -func (q *UpdateQuery) Comment(comment string) *UpdateQuery { - q.comment = comment - return q -} - -//------------------------------------------------------------------------------ - -func (q *UpdateQuery) Operation() string { - return "UPDATE" -} - -func (q *UpdateQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { - if q.err != nil { - return nil, q.err - } - - b = appendComment(b, q.comment) - - fmter = formatterWithModel(fmter, q) - - b, err = q.appendWith(fmter, b) - if err != nil { - return nil, err - } - - b = append(b, "UPDATE "...) - - if fmter.HasFeature(feature.UpdateMultiTable) { - b, err = q.appendTablesWithAlias(fmter, b) - } else if fmter.HasFeature(feature.UpdateTableAlias) { - b, err = q.appendFirstTableWithAlias(fmter, b) - } else { - b, err = q.appendFirstTable(fmter, b) - } - if err != nil { - return nil, err - } - - b, err = q.appendIndexHints(fmter, b) - if err != nil { - return nil, err - } - - b, err = q.mustAppendSet(fmter, b) - if err != nil { - return nil, err - } - - if !fmter.HasFeature(feature.UpdateMultiTable) { - b, err = q.appendOtherTables(fmter, b) - if err != nil { - return nil, err - } - } - - for _, j := range q.joins { - b, err = j.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - - if q.hasFeature(feature.Output) && q.hasReturning() { - b = append(b, " OUTPUT "...) - b, err = q.appendOutput(fmter, b) - if err != nil { - return nil, err - } - } - - b, err = q.mustAppendWhere(fmter, b, q.hasTableAlias(fmter)) - if err != nil { - return nil, err - } - - b, err = q.appendOrder(fmter, b) - if err != nil { - return nil, err - } - - b, err = q.appendLimitOffset(fmter, b) - if err != nil { - return nil, err - } - - if q.hasFeature(feature.Returning) && q.hasReturning() { - b = append(b, " RETURNING "...) - b, err = q.appendReturning(fmter, b) - if err != nil { - return nil, err - } - } - - return b, nil -} - -func (q *UpdateQuery) mustAppendSet(fmter schema.Formatter, b []byte) (_ []byte, err error) { - b = append(b, " SET "...) - - if len(q.set) > 0 { - return q.appendSet(fmter, b) - } - - if m, ok := q.model.(*mapModel); ok { - return m.appendSet(fmter, b), nil - } - - if q.tableModel == nil { - return nil, errNilModel - } - - switch model := q.tableModel.(type) { - case *structTableModel: - pos := len(b) - b, err = q.appendSetStruct(fmter, b, model) - if err != nil { - return nil, err - } - - // Validate if no values were appended after SET clause. - // e.g. UPDATE users SET WHERE id = 1 - // See issues858 - if len(b) == pos { - return nil, errors.New("bun: empty SET clause is not allowed in the UPDATE query") - } - case *sliceTableModel: - return nil, errors.New("bun: to bulk Update, use CTE and VALUES") - default: - return nil, fmt.Errorf("bun: Update does not support %T", q.tableModel) - } - - return b, nil -} - -func (q *UpdateQuery) appendSetStruct( - fmter schema.Formatter, b []byte, model *structTableModel, -) ([]byte, error) { - fields, err := q.getDataFields() - if err != nil { - return nil, err - } - - isTemplate := fmter.IsNop() - pos := len(b) - for _, f := range fields { - if f.SkipUpdate() { - continue - } - - app, hasValue := q.modelValues[f.Name] - - if !hasValue && q.omitZero && f.HasZeroValue(model.strct) { - continue - } - - if len(b) != pos { - b = append(b, ", "...) - pos = len(b) - } - - b = append(b, f.SQLName...) - b = append(b, " = "...) - - if isTemplate { - b = append(b, '?') - continue - } - - if hasValue { - b, err = app.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } else { - b = f.AppendValue(fmter, b, model.strct) - } - } - - for i, v := range q.extraValues { - if i > 0 || len(fields) > 0 { - b = append(b, ", "...) - } - - b = append(b, v.column...) - b = append(b, " = "...) - - b, err = v.value.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - - return b, nil -} - -func (q *UpdateQuery) appendOtherTables(fmter schema.Formatter, b []byte) (_ []byte, err error) { - if !q.hasMultiTables() { - return b, nil - } - - b = append(b, " FROM "...) - - b, err = q.whereBaseQuery.appendOtherTables(fmter, b) - if err != nil { - return nil, err - } - - return b, nil -} - -//------------------------------------------------------------------------------ - -func (q *UpdateQuery) Bulk() *UpdateQuery { - model, ok := q.model.(*sliceTableModel) - if !ok { - q.setErr(fmt.Errorf("bun: Bulk requires a slice, got %T", q.model)) - return q - } - - set, err := q.updateSliceSet(q.db.fmter, model) - if err != nil { - q.setErr(err) - return q - } - - values := q.db.NewValues(model) - values.customValueQuery = q.customValueQuery - - return q.With("_data", values). - Model(model). - TableExpr("_data"). - Set(set). - Where(q.updateSliceWhere(q.db.fmter, model)) -} - -func (q *UpdateQuery) updateSliceSet( - fmter schema.Formatter, model *sliceTableModel, -) (string, error) { - fields, err := q.getDataFields() - if err != nil { - return "", err - } - - var b []byte - pos := len(b) - for _, field := range fields { - if field.SkipUpdate() { - continue - } - if len(b) != pos { - b = append(b, ", "...) - pos = len(b) - } - if fmter.HasFeature(feature.UpdateMultiTable) { - b = append(b, model.table.SQLAlias...) - b = append(b, '.') - } - b = append(b, field.SQLName...) - b = append(b, " = _data."...) - b = append(b, field.SQLName...) - } - return internal.String(b), nil -} - -func (q *UpdateQuery) updateSliceWhere(fmter schema.Formatter, model *sliceTableModel) string { - var b []byte - for i, pk := range model.table.PKs { - if i > 0 { - b = append(b, " AND "...) - } - if q.hasTableAlias(fmter) { - b = append(b, model.table.SQLAlias...) - } else { - b = append(b, model.table.SQLName...) - } - b = append(b, '.') - b = append(b, pk.SQLName...) - b = append(b, " = _data."...) - b = append(b, pk.SQLName...) - } - return internal.String(b) -} - -//------------------------------------------------------------------------------ - -func (q *UpdateQuery) Scan(ctx context.Context, dest ...interface{}) error { - _, err := q.scanOrExec(ctx, dest, true) - return err -} - -func (q *UpdateQuery) Exec(ctx context.Context, dest ...interface{}) (sql.Result, error) { - return q.scanOrExec(ctx, dest, len(dest) > 0) -} - -func (q *UpdateQuery) scanOrExec( - ctx context.Context, dest []interface{}, hasDest bool, -) (sql.Result, error) { - if q.err != nil { - return nil, q.err - } - - if q.table != nil { - if err := q.beforeUpdateHook(ctx); err != nil { - return nil, err - } - } - - // Run append model hooks before generating the query. - if err := q.beforeAppendModel(ctx, q); err != nil { - return nil, err - } - - // Generate the query before checking hasReturning. - queryBytes, err := q.AppendQuery(q.db.fmter, q.db.makeQueryBytes()) - if err != nil { - return nil, err - } - - useScan := hasDest || (q.hasReturning() && q.hasFeature(feature.Returning|feature.Output)) - var model Model - - if useScan { - var err error - model, err = q.getModel(dest) - if err != nil { - return nil, err - } - } - - query := internal.String(queryBytes) - - var res sql.Result - - if useScan { - res, err = q.scan(ctx, q, query, model, hasDest) - if err != nil { - return nil, err - } - } else { - res, err = q.exec(ctx, q, query) - if err != nil { - return nil, err - } - } - - if q.table != nil { - if err := q.afterUpdateHook(ctx); err != nil { - return nil, err - } - } - - return res, nil -} - -func (q *UpdateQuery) beforeUpdateHook(ctx context.Context) error { - if hook, ok := q.table.ZeroIface.(BeforeUpdateHook); ok { - if err := hook.BeforeUpdate(ctx, q); err != nil { - return err - } - } - return nil -} - -func (q *UpdateQuery) afterUpdateHook(ctx context.Context) error { - if hook, ok := q.table.ZeroIface.(AfterUpdateHook); ok { - if err := hook.AfterUpdate(ctx, q); err != nil { - return err - } - } - return nil -} - -// FQN returns a fully qualified column name, for example, table_name.column_name or -// table_alias.column_alias. -func (q *UpdateQuery) FQN(column string) Ident { - if q.table == nil { - panic("UpdateQuery.FQN requires a model") - } - if q.hasTableAlias(q.db.fmter) { - return Ident(q.table.Alias + "." + column) - } - return Ident(q.table.Name + "." + column) -} - -func (q *UpdateQuery) hasTableAlias(fmter schema.Formatter) bool { - return fmter.HasFeature(feature.UpdateMultiTable | feature.UpdateTableAlias) -} - -func (q *UpdateQuery) String() string { - buf, err := q.AppendQuery(q.db.Formatter(), nil) - if err != nil { - panic(err) - } - - return string(buf) -} - -//------------------------------------------------------------------------------ - -func (q *UpdateQuery) QueryBuilder() QueryBuilder { - return &updateQueryBuilder{q} -} - -func (q *UpdateQuery) ApplyQueryBuilder(fn func(QueryBuilder) QueryBuilder) *UpdateQuery { - return fn(q.QueryBuilder()).Unwrap().(*UpdateQuery) -} - -type updateQueryBuilder struct { - *UpdateQuery -} - -func (q *updateQueryBuilder) WhereGroup( - sep string, fn func(QueryBuilder) QueryBuilder, -) QueryBuilder { - q.UpdateQuery = q.UpdateQuery.WhereGroup(sep, func(qs *UpdateQuery) *UpdateQuery { - return fn(q).(*updateQueryBuilder).UpdateQuery - }) - return q -} - -func (q *updateQueryBuilder) Where(query string, args ...interface{}) QueryBuilder { - q.UpdateQuery.Where(query, args...) - return q -} - -func (q *updateQueryBuilder) WhereOr(query string, args ...interface{}) QueryBuilder { - q.UpdateQuery.WhereOr(query, args...) - return q -} - -func (q *updateQueryBuilder) WhereDeleted() QueryBuilder { - q.UpdateQuery.WhereDeleted() - return q -} - -func (q *updateQueryBuilder) WhereAllWithDeleted() QueryBuilder { - q.UpdateQuery.WhereAllWithDeleted() - return q -} - -func (q *updateQueryBuilder) WherePK(cols ...string) QueryBuilder { - q.UpdateQuery.WherePK(cols...) - return q -} - -func (q *updateQueryBuilder) Unwrap() interface{} { - return q.UpdateQuery -} - -//------------------------------------------------------------------------------ - -func (q *UpdateQuery) UseIndex(indexes ...string) *UpdateQuery { - if q.db.dialect.Name() == dialect.MySQL { - q.addUseIndex(indexes...) - } - return q -} - -func (q *UpdateQuery) IgnoreIndex(indexes ...string) *UpdateQuery { - if q.db.dialect.Name() == dialect.MySQL { - q.addIgnoreIndex(indexes...) - } - return q -} - -func (q *UpdateQuery) ForceIndex(indexes ...string) *UpdateQuery { - if q.db.dialect.Name() == dialect.MySQL { - q.addForceIndex(indexes...) - } - return q -} diff --git a/vendor/github.com/uptrace/bun/query_values.go b/vendor/github.com/uptrace/bun/query_values.go deleted file mode 100644 index db6c852c3..000000000 --- a/vendor/github.com/uptrace/bun/query_values.go +++ /dev/null @@ -1,235 +0,0 @@ -package bun - -import ( - "fmt" - "reflect" - "strconv" - - "github.com/uptrace/bun/dialect/feature" - "github.com/uptrace/bun/schema" -) - -type ValuesQuery struct { - baseQuery - customValueQuery - - withOrder bool - comment string -} - -var ( - _ Query = (*ValuesQuery)(nil) - _ schema.NamedArgAppender = (*ValuesQuery)(nil) -) - -func NewValuesQuery(db *DB, model interface{}) *ValuesQuery { - q := &ValuesQuery{ - baseQuery: baseQuery{ - db: db, - }, - } - q.setModel(model) - return q -} - -func (q *ValuesQuery) Conn(db IConn) *ValuesQuery { - q.setConn(db) - return q -} - -func (q *ValuesQuery) Err(err error) *ValuesQuery { - q.setErr(err) - return q -} - -func (q *ValuesQuery) Column(columns ...string) *ValuesQuery { - for _, column := range columns { - q.addColumn(schema.UnsafeIdent(column)) - } - return q -} - -// Value overwrites model value for the column. -func (q *ValuesQuery) Value(column string, expr string, args ...interface{}) *ValuesQuery { - if q.table == nil { - q.err = errNilModel - return q - } - q.addValue(q.table, column, expr, args) - return q -} - -func (q *ValuesQuery) WithOrder() *ValuesQuery { - q.withOrder = true - return q -} - -// Comment adds a comment to the query, wrapped by /* ... */. -func (q *ValuesQuery) Comment(comment string) *ValuesQuery { - q.comment = comment - return q -} - -func (q *ValuesQuery) AppendNamedArg(fmter schema.Formatter, b []byte, name string) ([]byte, bool) { - switch name { - case "Columns": - bb, err := q.AppendColumns(fmter, b) - if err != nil { - q.setErr(err) - return b, true - } - return bb, true - } - return b, false -} - -// AppendColumns appends the table columns. It is used by CTE. -func (q *ValuesQuery) AppendColumns(fmter schema.Formatter, b []byte) (_ []byte, err error) { - if q.err != nil { - return nil, q.err - } - if q.model == nil { - return nil, errNilModel - } - - if q.tableModel != nil { - fields, err := q.getFields() - if err != nil { - return nil, err - } - - b = appendColumns(b, "", fields) - - if q.withOrder { - b = append(b, ", _order"...) - } - - return b, nil - } - - switch model := q.model.(type) { - case *mapSliceModel: - return model.appendColumns(fmter, b) - } - - return nil, fmt.Errorf("bun: Values does not support %T", q.model) -} - -func (q *ValuesQuery) Operation() string { - return "VALUES" -} - -func (q *ValuesQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { - if q.err != nil { - return nil, q.err - } - if q.model == nil { - return nil, errNilModel - } - - b = appendComment(b, q.comment) - - fmter = formatterWithModel(fmter, q) - - if q.tableModel != nil { - fields, err := q.getFields() - if err != nil { - return nil, err - } - return q.appendQuery(fmter, b, fields) - } - - switch model := q.model.(type) { - case *mapSliceModel: - return model.appendValues(fmter, b) - } - - return nil, fmt.Errorf("bun: Values does not support %T", q.model) -} - -func (q *ValuesQuery) appendQuery( - fmter schema.Formatter, - b []byte, - fields []*schema.Field, -) (_ []byte, err error) { - b = append(b, "VALUES "...) - if q.db.HasFeature(feature.ValuesRow) { - b = append(b, "ROW("...) - } else { - b = append(b, '(') - } - - switch model := q.tableModel.(type) { - case *structTableModel: - b, err = q.appendValues(fmter, b, fields, model.strct) - if err != nil { - return nil, err - } - - if q.withOrder { - b = append(b, ", "...) - b = strconv.AppendInt(b, 0, 10) - } - case *sliceTableModel: - slice := model.slice - sliceLen := slice.Len() - for i := 0; i < sliceLen; i++ { - if i > 0 { - b = append(b, "), "...) - if q.db.HasFeature(feature.ValuesRow) { - b = append(b, "ROW("...) - } else { - b = append(b, '(') - } - } - - b, err = q.appendValues(fmter, b, fields, slice.Index(i)) - if err != nil { - return nil, err - } - - if q.withOrder { - b = append(b, ", "...) - b = strconv.AppendInt(b, int64(i), 10) - } - } - default: - return nil, fmt.Errorf("bun: Values does not support %T", q.model) - } - - b = append(b, ')') - - return b, nil -} - -func (q *ValuesQuery) appendValues( - fmter schema.Formatter, b []byte, fields []*schema.Field, strct reflect.Value, -) (_ []byte, err error) { - isTemplate := fmter.IsNop() - for i, f := range fields { - if i > 0 { - b = append(b, ", "...) - } - - app, ok := q.modelValues[f.Name] - if ok { - b, err = app.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - continue - } - - if isTemplate { - b = append(b, '?') - } else { - b = f.AppendValue(fmter, b, indirect(strct)) - } - - if fmter.HasFeature(feature.DoubleColonCast) { - b = append(b, "::"...) - b = append(b, f.UserSQLType...) - } - } - return b, nil -} diff --git a/vendor/github.com/uptrace/bun/relation_join.go b/vendor/github.com/uptrace/bun/relation_join.go deleted file mode 100644 index 47f27afd5..000000000 --- a/vendor/github.com/uptrace/bun/relation_join.go +++ /dev/null @@ -1,453 +0,0 @@ -package bun - -import ( - "context" - "reflect" - "time" - - "github.com/uptrace/bun/dialect/feature" - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type relationJoin struct { - Parent *relationJoin - BaseModel TableModel - JoinModel TableModel - Relation *schema.Relation - - additionalJoinOnConditions []schema.QueryWithArgs - - apply func(*SelectQuery) *SelectQuery - columns []schema.QueryWithArgs -} - -func (j *relationJoin) applyTo(q *SelectQuery) { - if j.apply == nil { - return - } - - var table *schema.Table - var columns []schema.QueryWithArgs - - // Save state. - table, q.table = q.table, j.JoinModel.Table() - columns, q.columns = q.columns, nil - - q = j.apply(q) - - // Restore state. - q.table = table - j.columns, q.columns = q.columns, columns -} - -func (j *relationJoin) Select(ctx context.Context, q *SelectQuery) error { - switch j.Relation.Type { - } - panic("not reached") -} - -func (j *relationJoin) selectMany(ctx context.Context, q *SelectQuery) error { - q = j.manyQuery(q) - if q == nil { - return nil - } - return q.Scan(ctx) -} - -func (j *relationJoin) manyQuery(q *SelectQuery) *SelectQuery { - hasManyModel := newHasManyModel(j) - if hasManyModel == nil { - return nil - } - - q = q.Model(hasManyModel) - - var where []byte - - if q.db.HasFeature(feature.CompositeIn) { - return j.manyQueryCompositeIn(where, q) - } - return j.manyQueryMulti(where, q) -} - -func (j *relationJoin) manyQueryCompositeIn(where []byte, q *SelectQuery) *SelectQuery { - if len(j.Relation.JoinPKs) > 1 { - where = append(where, '(') - } - where = appendColumns(where, j.JoinModel.Table().SQLAlias, j.Relation.JoinPKs) - if len(j.Relation.JoinPKs) > 1 { - where = append(where, ')') - } - where = append(where, " IN ("...) - where = appendChildValues( - q.db.Formatter(), - where, - j.JoinModel.rootValue(), - j.JoinModel.parentIndex(), - j.Relation.BasePKs, - ) - where = append(where, ")"...) - if len(j.additionalJoinOnConditions) > 0 { - where = append(where, " AND "...) - where = appendAdditionalJoinOnConditions(q.db.Formatter(), where, j.additionalJoinOnConditions) - } - - q = q.Where(internal.String(where)) - - if j.Relation.PolymorphicField != nil { - q = q.Where("? = ?", j.Relation.PolymorphicField.SQLName, j.Relation.PolymorphicValue) - } - - j.applyTo(q) - q = q.Apply(j.hasManyColumns) - - return q -} - -func (j *relationJoin) manyQueryMulti(where []byte, q *SelectQuery) *SelectQuery { - where = appendMultiValues( - q.db.Formatter(), - where, - j.JoinModel.rootValue(), - j.JoinModel.parentIndex(), - j.Relation.BasePKs, - j.Relation.JoinPKs, - j.JoinModel.Table().SQLAlias, - ) - - q = q.Where(internal.String(where)) - - if len(j.additionalJoinOnConditions) > 0 { - q = q.Where(internal.String(appendAdditionalJoinOnConditions(q.db.Formatter(), []byte{}, j.additionalJoinOnConditions))) - } - - if j.Relation.PolymorphicField != nil { - q = q.Where("? = ?", j.Relation.PolymorphicField.SQLName, j.Relation.PolymorphicValue) - } - - j.applyTo(q) - q = q.Apply(j.hasManyColumns) - - return q -} - -func (j *relationJoin) hasManyColumns(q *SelectQuery) *SelectQuery { - b := make([]byte, 0, 32) - - joinTable := j.JoinModel.Table() - if len(j.columns) > 0 { - for i, col := range j.columns { - if i > 0 { - b = append(b, ", "...) - } - - if col.Args == nil { - if field, ok := joinTable.FieldMap[col.Query]; ok { - b = append(b, joinTable.SQLAlias...) - b = append(b, '.') - b = append(b, field.SQLName...) - continue - } - } - - var err error - b, err = col.AppendQuery(q.db.fmter, b) - if err != nil { - q.setErr(err) - return q - } - - } - } else { - b = appendColumns(b, joinTable.SQLAlias, joinTable.Fields) - } - - q = q.ColumnExpr(internal.String(b)) - - return q -} - -func (j *relationJoin) selectM2M(ctx context.Context, q *SelectQuery) error { - q = j.m2mQuery(q) - if q == nil { - return nil - } - return q.Scan(ctx) -} - -func (j *relationJoin) m2mQuery(q *SelectQuery) *SelectQuery { - fmter := q.db.fmter - - m2mModel := newM2MModel(j) - if m2mModel == nil { - return nil - } - q = q.Model(m2mModel) - - index := j.JoinModel.parentIndex() - - if j.Relation.M2MTable != nil { - // We only need base pks to park joined models to the base model. - fields := j.Relation.M2MBasePKs - - b := make([]byte, 0, len(fields)) - b = appendColumns(b, j.Relation.M2MTable.SQLAlias, fields) - - q = q.ColumnExpr(internal.String(b)) - } - - //nolint - var join []byte - join = append(join, "JOIN "...) - join = fmter.AppendQuery(join, string(j.Relation.M2MTable.SQLName)) - join = append(join, " AS "...) - join = append(join, j.Relation.M2MTable.SQLAlias...) - join = append(join, " ON ("...) - for i, col := range j.Relation.M2MBasePKs { - if i > 0 { - join = append(join, ", "...) - } - join = append(join, j.Relation.M2MTable.SQLAlias...) - join = append(join, '.') - join = append(join, col.SQLName...) - } - join = append(join, ") IN ("...) - join = appendChildValues(fmter, join, j.BaseModel.rootValue(), index, j.Relation.BasePKs) - join = append(join, ")"...) - - if len(j.additionalJoinOnConditions) > 0 { - join = append(join, " AND "...) - join = appendAdditionalJoinOnConditions(fmter, join, j.additionalJoinOnConditions) - } - - q = q.Join(internal.String(join)) - - joinTable := j.JoinModel.Table() - for i, m2mJoinField := range j.Relation.M2MJoinPKs { - joinField := j.Relation.JoinPKs[i] - q = q.Where("?.? = ?.?", - joinTable.SQLAlias, joinField.SQLName, - j.Relation.M2MTable.SQLAlias, m2mJoinField.SQLName) - } - - j.applyTo(q) - q = q.Apply(j.hasManyColumns) - - return q -} - -func (j *relationJoin) hasParent() bool { - if j.Parent != nil { - switch j.Parent.Relation.Type { - case schema.HasOneRelation, schema.BelongsToRelation: - return true - } - } - return false -} - -func (j *relationJoin) appendAlias(fmter schema.Formatter, b []byte) []byte { - quote := fmter.IdentQuote() - - b = append(b, quote) - b = appendAlias(b, j) - b = append(b, quote) - return b -} - -func (j *relationJoin) appendAliasColumn(fmter schema.Formatter, b []byte, column string) []byte { - quote := fmter.IdentQuote() - - b = append(b, quote) - b = appendAlias(b, j) - b = append(b, "__"...) - b = append(b, column...) - b = append(b, quote) - return b -} - -func (j *relationJoin) appendBaseAlias(fmter schema.Formatter, b []byte) []byte { - quote := fmter.IdentQuote() - - if j.hasParent() { - b = append(b, quote) - b = appendAlias(b, j.Parent) - b = append(b, quote) - return b - } - return append(b, j.BaseModel.Table().SQLAlias...) -} - -func (j *relationJoin) appendSoftDelete( - fmter schema.Formatter, b []byte, flags internal.Flag, -) []byte { - b = append(b, '.') - - field := j.JoinModel.Table().SoftDeleteField - b = append(b, field.SQLName...) - - if field.IsPtr || field.NullZero { - if flags.Has(deletedFlag) { - b = append(b, " IS NOT NULL"...) - } else { - b = append(b, " IS NULL"...) - } - } else { - if flags.Has(deletedFlag) { - b = append(b, " != "...) - } else { - b = append(b, " = "...) - } - b = fmter.Dialect().AppendTime(b, time.Time{}) - } - - return b -} - -func appendAlias(b []byte, j *relationJoin) []byte { - if j.hasParent() { - b = appendAlias(b, j.Parent) - b = append(b, "__"...) - } - b = append(b, j.Relation.Field.Name...) - return b -} - -func (j *relationJoin) appendHasOneJoin( - fmter schema.Formatter, b []byte, q *SelectQuery, -) (_ []byte, err error) { - isSoftDelete := j.JoinModel.Table().SoftDeleteField != nil && !q.flags.Has(allWithDeletedFlag) - - b = append(b, "LEFT JOIN "...) - b = fmter.AppendQuery(b, string(j.JoinModel.Table().SQLNameForSelects)) - b = append(b, " AS "...) - b = j.appendAlias(fmter, b) - - b = append(b, " ON "...) - - b = append(b, '(') - for i, baseField := range j.Relation.BasePKs { - if i > 0 { - b = append(b, " AND "...) - } - b = j.appendAlias(fmter, b) - b = append(b, '.') - b = append(b, j.Relation.JoinPKs[i].SQLName...) - b = append(b, " = "...) - b = j.appendBaseAlias(fmter, b) - b = append(b, '.') - b = append(b, baseField.SQLName...) - } - b = append(b, ')') - - if isSoftDelete { - b = append(b, " AND "...) - b = j.appendAlias(fmter, b) - b = j.appendSoftDelete(fmter, b, q.flags) - } - - if len(j.additionalJoinOnConditions) > 0 { - b = append(b, " AND "...) - b = appendAdditionalJoinOnConditions(fmter, b, j.additionalJoinOnConditions) - } - - return b, nil -} - -func appendChildValues( - fmter schema.Formatter, b []byte, v reflect.Value, index []int, fields []*schema.Field, -) []byte { - seen := make(map[string]struct{}) - walk(v, index, func(v reflect.Value) { - start := len(b) - - if len(fields) > 1 { - b = append(b, '(') - } - for i, f := range fields { - if i > 0 { - b = append(b, ", "...) - } - b = f.AppendValue(fmter, b, v) - } - if len(fields) > 1 { - b = append(b, ')') - } - b = append(b, ", "...) - - if _, ok := seen[string(b[start:])]; ok { - b = b[:start] - } else { - seen[string(b[start:])] = struct{}{} - } - }) - if len(seen) > 0 { - b = b[:len(b)-2] // trim ", " - } - return b -} - -// appendMultiValues is an alternative to appendChildValues that doesn't use the sql keyword ID -// but instead uses old style ((k1=v1) AND (k2=v2)) OR (...) conditions. -func appendMultiValues( - fmter schema.Formatter, b []byte, v reflect.Value, index []int, baseFields, joinFields []*schema.Field, joinTable schema.Safe, -) []byte { - // This is based on a mix of appendChildValues and query_base.appendColumns - - // These should never mismatch in length but nice to know if it does - if len(joinFields) != len(baseFields) { - panic("not reached") - } - - // walk the relations - b = append(b, '(') - seen := make(map[string]struct{}) - walk(v, index, func(v reflect.Value) { - start := len(b) - for i, f := range baseFields { - if i > 0 { - b = append(b, " AND "...) - } - if len(baseFields) > 1 { - b = append(b, '(') - } - // Field name - b = append(b, joinTable...) - b = append(b, '.') - b = append(b, []byte(joinFields[i].SQLName)...) - - // Equals value - b = append(b, '=') - b = f.AppendValue(fmter, b, v) - if len(baseFields) > 1 { - b = append(b, ')') - } - } - - b = append(b, ") OR ("...) - - if _, ok := seen[string(b[start:])]; ok { - b = b[:start] - } else { - seen[string(b[start:])] = struct{}{} - } - }) - if len(seen) > 0 { - b = b[:len(b)-6] // trim ") OR (" - } - b = append(b, ')') - return b -} - -func appendAdditionalJoinOnConditions( - fmter schema.Formatter, b []byte, conditions []schema.QueryWithArgs, -) []byte { - for i, cond := range conditions { - if i > 0 { - b = append(b, " AND "...) - } - b = fmter.AppendQuery(b, cond.Query, cond.Args...) - } - return b -} diff --git a/vendor/github.com/uptrace/bun/schema/append.go b/vendor/github.com/uptrace/bun/schema/append.go deleted file mode 100644 index 0cfc1180b..000000000 --- a/vendor/github.com/uptrace/bun/schema/append.go +++ /dev/null @@ -1,125 +0,0 @@ -package schema - -import ( - "fmt" - "reflect" - "strconv" - "time" - - "github.com/uptrace/bun/dialect" -) - -func Append(fmter Formatter, b []byte, v interface{}) []byte { - switch v := v.(type) { - case nil: - return dialect.AppendNull(b) - case bool: - return dialect.AppendBool(b, v) - case int: - 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.AppendInt(b, int64(v), 10) - case uint32: - return fmter.Dialect().AppendUint32(b, v) - case uint64: - return fmter.Dialect().AppendUint64(b, v) - case float32: - return dialect.AppendFloat32(b, v) - case float64: - return dialect.AppendFloat64(b, v) - case string: - return fmter.Dialect().AppendString(b, v) - case time.Time: - return fmter.Dialect().AppendTime(b, v) - case []byte: - return fmter.Dialect().AppendBytes(b, v) - case QueryAppender: - return AppendQueryAppender(fmter, b, v) - default: - vv := reflect.ValueOf(v) - if vv.Kind() == reflect.Ptr && vv.IsNil() { - return dialect.AppendNull(b) - } - appender := Appender(fmter.Dialect(), vv.Type()) - return appender(fmter, b, vv) - } -} - -//------------------------------------------------------------------------------ - -func In(slice interface{}) QueryAppender { - v := reflect.ValueOf(slice) - if v.Kind() != reflect.Slice { - return &inValues{ - err: fmt.Errorf("bun: In(non-slice %T)", slice), - } - } - return &inValues{ - slice: v, - } -} - -type inValues struct { - slice reflect.Value - err error -} - -var _ QueryAppender = (*inValues)(nil) - -func (in *inValues) AppendQuery(fmter Formatter, b []byte) (_ []byte, err error) { - if in.err != nil { - return nil, in.err - } - return appendIn(fmter, b, in.slice), nil -} - -func appendIn(fmter Formatter, b []byte, slice reflect.Value) []byte { - sliceLen := slice.Len() - - if sliceLen == 0 { - return dialect.AppendNull(b) - } - - for i := 0; i < sliceLen; i++ { - if i > 0 { - b = append(b, ", "...) - } - - elem := slice.Index(i) - if elem.Kind() == reflect.Interface { - elem = elem.Elem() - } - - if elem.Kind() == reflect.Slice && elem.Type() != bytesType { - b = append(b, '(') - b = appendIn(fmter, b, elem) - b = append(b, ')') - } else { - b = fmter.AppendValue(b, elem) - } - } - return b -} - -//------------------------------------------------------------------------------ - -func NullZero(value interface{}) QueryAppender { - return nullZero{ - value: value, - } -} - -type nullZero struct { - value interface{} -} - -func (nz nullZero) AppendQuery(fmter Formatter, b []byte) (_ []byte, err error) { - if isZero(nz.value) { - return dialect.AppendNull(b), nil - } - return fmter.AppendValue(b, reflect.ValueOf(nz.value)), nil -} diff --git a/vendor/github.com/uptrace/bun/schema/append_value.go b/vendor/github.com/uptrace/bun/schema/append_value.go deleted file mode 100644 index a67b41e38..000000000 --- a/vendor/github.com/uptrace/bun/schema/append_value.go +++ /dev/null @@ -1,316 +0,0 @@ -package schema - -import ( - "database/sql/driver" - "fmt" - "net" - "reflect" - "strconv" - "strings" - "time" - - "github.com/puzpuzpuz/xsync/v3" - "github.com/uptrace/bun/dialect" - "github.com/uptrace/bun/dialect/sqltype" - "github.com/uptrace/bun/extra/bunjson" - "github.com/uptrace/bun/internal" - "github.com/vmihailenco/msgpack/v5" -) - -type ( - AppenderFunc func(fmter Formatter, b []byte, v reflect.Value) []byte - CustomAppender func(typ reflect.Type) AppenderFunc -) - -var appenders = []AppenderFunc{ - reflect.Bool: AppendBoolValue, - reflect.Int: AppendIntValue, - reflect.Int8: AppendIntValue, - reflect.Int16: AppendIntValue, - reflect.Int32: AppendIntValue, - reflect.Int64: AppendIntValue, - reflect.Uint: AppendUintValue, - reflect.Uint8: AppendUintValue, - reflect.Uint16: AppendUintValue, - reflect.Uint32: appendUint32Value, - reflect.Uint64: appendUint64Value, - reflect.Uintptr: nil, - reflect.Float32: AppendFloat32Value, - reflect.Float64: AppendFloat64Value, - reflect.Complex64: nil, - reflect.Complex128: nil, - reflect.Array: AppendJSONValue, - reflect.Chan: nil, - reflect.Func: nil, - reflect.Interface: nil, - reflect.Map: AppendJSONValue, - reflect.Ptr: nil, - reflect.Slice: AppendJSONValue, - reflect.String: AppendStringValue, - reflect.Struct: AppendJSONValue, - reflect.UnsafePointer: nil, -} - -var appenderCache = xsync.NewMapOf[reflect.Type, AppenderFunc]() - -func FieldAppender(dialect Dialect, field *Field) AppenderFunc { - if field.Tag.HasOption("msgpack") { - return appendMsgpack - } - - fieldType := field.StructField.Type - - switch strings.ToUpper(field.UserSQLType) { - case sqltype.JSON, sqltype.JSONB: - if fieldType.Implements(driverValuerType) { - return appendDriverValue - } - - if fieldType.Kind() != reflect.Ptr { - if reflect.PointerTo(fieldType).Implements(driverValuerType) { - return addrAppender(appendDriverValue) - } - } - - return AppendJSONValue - } - - return Appender(dialect, fieldType) -} - -func Appender(dialect Dialect, typ reflect.Type) AppenderFunc { - if v, ok := appenderCache.Load(typ); ok { - return v - } - - fn := appender(dialect, typ) - - if v, ok := appenderCache.LoadOrStore(typ, fn); ok { - return v - } - return fn -} - -func appender(dialect Dialect, typ reflect.Type) AppenderFunc { - switch typ { - case bytesType: - return appendBytesValue - case timeType: - return appendTimeValue - case timePtrType: - return PtrAppender(appendTimeValue) - case ipNetType: - return appendIPNetValue - case ipType, netipPrefixType, netipAddrType: - return appendStringer - case jsonRawMessageType: - return appendJSONRawMessageValue - } - - kind := typ.Kind() - - if typ.Implements(queryAppenderType) { - if kind == reflect.Ptr { - return nilAwareAppender(appendQueryAppenderValue) - } - return appendQueryAppenderValue - } - if typ.Implements(driverValuerType) { - if kind == reflect.Ptr { - return nilAwareAppender(appendDriverValue) - } - return appendDriverValue - } - - if kind != reflect.Ptr { - ptr := reflect.PointerTo(typ) - if ptr.Implements(queryAppenderType) { - return addrAppender(appendQueryAppenderValue) - } - if ptr.Implements(driverValuerType) { - return addrAppender(appendDriverValue) - } - } - - switch kind { - case reflect.Interface: - return ifaceAppenderFunc - case reflect.Ptr: - if typ.Implements(jsonMarshalerType) { - return nilAwareAppender(AppendJSONValue) - } - if fn := Appender(dialect, typ.Elem()); fn != nil { - return PtrAppender(fn) - } - case reflect.Slice: - if typ.Elem().Kind() == reflect.Uint8 { - return appendBytesValue - } - case reflect.Array: - if typ.Elem().Kind() == reflect.Uint8 { - return appendArrayBytesValue - } - } - - return appenders[typ.Kind()] -} - -func ifaceAppenderFunc(fmter Formatter, b []byte, v reflect.Value) []byte { - if v.IsNil() { - return dialect.AppendNull(b) - } - elem := v.Elem() - appender := Appender(fmter.Dialect(), elem.Type()) - return appender(fmter, b, elem) -} - -func nilAwareAppender(fn AppenderFunc) AppenderFunc { - return func(fmter Formatter, b []byte, v reflect.Value) []byte { - if v.IsNil() { - return dialect.AppendNull(b) - } - return fn(fmter, b, v) - } -} - -func PtrAppender(fn AppenderFunc) AppenderFunc { - return func(fmter Formatter, b []byte, v reflect.Value) []byte { - if v.IsNil() { - return dialect.AppendNull(b) - } - return fn(fmter, b, v.Elem()) - } -} - -func AppendBoolValue(fmter Formatter, b []byte, v reflect.Value) []byte { - return fmter.Dialect().AppendBool(b, v.Bool()) -} - -func AppendIntValue(fmter Formatter, b []byte, v reflect.Value) []byte { - return strconv.AppendInt(b, v.Int(), 10) -} - -func AppendUintValue(fmter Formatter, b []byte, v reflect.Value) []byte { - return strconv.AppendUint(b, v.Uint(), 10) -} - -func appendUint32Value(fmter Formatter, b []byte, v reflect.Value) []byte { - return fmter.Dialect().AppendUint32(b, uint32(v.Uint())) -} - -func appendUint64Value(fmter Formatter, b []byte, v reflect.Value) []byte { - return fmter.Dialect().AppendUint64(b, v.Uint()) -} - -func AppendFloat32Value(fmter Formatter, b []byte, v reflect.Value) []byte { - return dialect.AppendFloat32(b, float32(v.Float())) -} - -func AppendFloat64Value(fmter Formatter, b []byte, v reflect.Value) []byte { - return dialect.AppendFloat64(b, float64(v.Float())) -} - -func appendBytesValue(fmter Formatter, b []byte, v reflect.Value) []byte { - return fmter.Dialect().AppendBytes(b, v.Bytes()) -} - -func appendArrayBytesValue(fmter Formatter, b []byte, v reflect.Value) []byte { - if v.CanAddr() { - return fmter.Dialect().AppendBytes(b, v.Slice(0, v.Len()).Bytes()) - } - - tmp := make([]byte, v.Len()) - reflect.Copy(reflect.ValueOf(tmp), v) - b = fmter.Dialect().AppendBytes(b, tmp) - return b -} - -func AppendStringValue(fmter Formatter, b []byte, v reflect.Value) []byte { - return fmter.Dialect().AppendString(b, v.String()) -} - -func AppendJSONValue(fmter Formatter, b []byte, v reflect.Value) []byte { - bb, err := bunjson.Marshal(v.Interface()) - if err != nil { - return dialect.AppendError(b, err) - } - - if len(bb) > 0 && bb[len(bb)-1] == '\n' { - bb = bb[:len(bb)-1] - } - - return fmter.Dialect().AppendJSON(b, bb) -} - -func appendTimeValue(fmter Formatter, b []byte, v reflect.Value) []byte { - tm := v.Interface().(time.Time) - return fmter.Dialect().AppendTime(b, tm) -} - -func appendIPNetValue(fmter Formatter, b []byte, v reflect.Value) []byte { - ipnet := v.Interface().(net.IPNet) - return fmter.Dialect().AppendString(b, ipnet.String()) -} - -func appendStringer(fmter Formatter, b []byte, v reflect.Value) []byte { - return fmter.Dialect().AppendString(b, v.Interface().(fmt.Stringer).String()) -} - -func appendJSONRawMessageValue(fmter Formatter, b []byte, v reflect.Value) []byte { - bytes := v.Bytes() - if bytes == nil { - return dialect.AppendNull(b) - } - return fmter.Dialect().AppendString(b, internal.String(bytes)) -} - -func appendQueryAppenderValue(fmter Formatter, b []byte, v reflect.Value) []byte { - return AppendQueryAppender(fmter, b, v.Interface().(QueryAppender)) -} - -func appendDriverValue(fmter Formatter, b []byte, v reflect.Value) []byte { - value, err := v.Interface().(driver.Valuer).Value() - if err != nil { - return dialect.AppendError(b, err) - } - if _, ok := value.(driver.Valuer); ok { - return dialect.AppendError(b, fmt.Errorf("driver.Valuer returns unsupported type %T", value)) - } - return Append(fmter, b, value) -} - -func addrAppender(fn AppenderFunc) AppenderFunc { - return func(fmter Formatter, b []byte, v reflect.Value) []byte { - if !v.CanAddr() { - err := fmt.Errorf("bun: Append(nonaddressable %T)", v.Interface()) - return dialect.AppendError(b, err) - } - return fn(fmter, b, v.Addr()) - } -} - -func appendMsgpack(fmter Formatter, b []byte, v reflect.Value) []byte { - hexEnc := internal.NewHexEncoder(b) - - enc := msgpack.GetEncoder() - defer msgpack.PutEncoder(enc) - - enc.Reset(hexEnc) - if err := enc.EncodeValue(v); err != nil { - return dialect.AppendError(b, err) - } - - if err := hexEnc.Close(); err != nil { - return dialect.AppendError(b, err) - } - - return hexEnc.Bytes() -} - -func AppendQueryAppender(fmter Formatter, b []byte, app QueryAppender) []byte { - bb, err := app.AppendQuery(fmter, b) - if err != nil { - return dialect.AppendError(b, err) - } - return bb -} diff --git a/vendor/github.com/uptrace/bun/schema/dialect.go b/vendor/github.com/uptrace/bun/schema/dialect.go deleted file mode 100644 index bb40af62b..000000000 --- a/vendor/github.com/uptrace/bun/schema/dialect.go +++ /dev/null @@ -1,194 +0,0 @@ -package schema - -import ( - "database/sql" - "encoding/hex" - "strconv" - "time" - "unicode/utf8" - - "github.com/uptrace/bun/dialect" - "github.com/uptrace/bun/dialect/feature" - "github.com/uptrace/bun/internal/parser" -) - -type Dialect interface { - Init(db *sql.DB) - - Name() dialect.Name - Features() feature.Feature - - Tables() *Tables - OnTable(table *Table) - - IdentQuote() byte - - AppendUint32(b []byte, n uint32) []byte - AppendUint64(b []byte, n uint64) []byte - AppendTime(b []byte, tm time.Time) []byte - AppendString(b []byte, s string) []byte - AppendBytes(b []byte, bs []byte) []byte - AppendJSON(b, jsonb []byte) []byte - AppendBool(b []byte, v bool) []byte - - // AppendSequence adds the appropriate instruction for the driver to create a sequence - // from which (autoincremented) values for the column will be generated. - AppendSequence(b []byte, t *Table, f *Field) []byte - - // DefaultVarcharLen should be returned for dialects in which specifying VARCHAR length - // is mandatory in queries that modify the schema (CREATE TABLE / ADD COLUMN, etc). - // Dialects that do not have such requirement may return 0, which should be interpreted so by the caller. - DefaultVarcharLen() int - - // DefaultSchema should returns the name of the default database schema. - DefaultSchema() string -} - -// ------------------------------------------------------------------------------ - -type BaseDialect struct{} - -func (BaseDialect) AppendUint32(b []byte, n uint32) []byte { - return strconv.AppendUint(b, uint64(n), 10) -} - -func (BaseDialect) AppendUint64(b []byte, n uint64) []byte { - return strconv.AppendUint(b, n, 10) -} - -func (BaseDialect) AppendTime(b []byte, tm time.Time) []byte { - b = append(b, '\'') - b = tm.UTC().AppendFormat(b, "2006-01-02 15:04:05.999999-07:00") - b = append(b, '\'') - return b -} - -func (BaseDialect) AppendString(b []byte, s string) []byte { - b = append(b, '\'') - for _, r := range s { - if r == '\000' { - continue - } - - if r == '\'' { - b = append(b, '\'', '\'') - continue - } - - if r < utf8.RuneSelf { - b = append(b, byte(r)) - continue - } - - l := len(b) - if cap(b)-l < utf8.UTFMax { - b = append(b, make([]byte, utf8.UTFMax)...) - } - n := utf8.EncodeRune(b[l:l+utf8.UTFMax], r) - b = b[:l+n] - } - b = append(b, '\'') - return b -} - -func (BaseDialect) AppendBytes(b, bs []byte) []byte { - if bs == nil { - return dialect.AppendNull(b) - } - - b = append(b, `'\x`...) - - s := len(b) - b = append(b, make([]byte, hex.EncodedLen(len(bs)))...) - hex.Encode(b[s:], bs) - - b = append(b, '\'') - - return b -} - -func (BaseDialect) AppendJSON(b, jsonb []byte) []byte { - b = append(b, '\'') - - p := parser.New(jsonb) - for p.Valid() { - c := p.Read() - switch c { - case '"': - b = append(b, '"') - case '\'': - b = append(b, "''"...) - case '\000': - continue - case '\\': - if p.CutPrefix([]byte("u0000")) { - b = append(b, `\\u0000`...) - } else { - b = append(b, '\\') - if p.Valid() { - b = append(b, p.Read()) - } - } - default: - b = append(b, c) - } - } - - b = append(b, '\'') - - return b -} - -func (BaseDialect) AppendBool(b []byte, v bool) []byte { - return dialect.AppendBool(b, v) -} - -// ------------------------------------------------------------------------------ - -type nopDialect struct { - BaseDialect - - tables *Tables - features feature.Feature -} - -func newNopDialect() *nopDialect { - d := new(nopDialect) - d.tables = NewTables(d) - d.features = feature.Returning - return d -} - -func (d *nopDialect) Init(*sql.DB) {} - -func (d *nopDialect) Name() dialect.Name { - return dialect.Invalid -} - -func (d *nopDialect) Features() feature.Feature { - return d.features -} - -func (d *nopDialect) Tables() *Tables { - return d.tables -} - -func (d *nopDialect) OnField(field *Field) {} - -func (d *nopDialect) OnTable(table *Table) {} - -func (d *nopDialect) IdentQuote() byte { - return '"' -} - -func (d *nopDialect) DefaultVarcharLen() int { - return 0 -} - -func (d *nopDialect) AppendSequence(b []byte, _ *Table, _ *Field) []byte { - return b -} - -func (d *nopDialect) DefaultSchema() string { - return "nop" -} diff --git a/vendor/github.com/uptrace/bun/schema/field.go b/vendor/github.com/uptrace/bun/schema/field.go deleted file mode 100644 index 06d0a5094..000000000 --- a/vendor/github.com/uptrace/bun/schema/field.go +++ /dev/null @@ -1,136 +0,0 @@ -package schema - -import ( - "fmt" - "reflect" - - "github.com/uptrace/bun/dialect" - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/internal/tagparser" -) - -type Field struct { - StructField reflect.StructField - IsPtr bool - - Tag tagparser.Tag - IndirectType reflect.Type - Index []int - - Name string // SQL name, .e.g. id - SQLName Safe // escaped SQL name, e.g. "id" - GoName string // struct field name, e.g. Id - - DiscoveredSQLType string - UserSQLType string - CreateTableSQLType string - SQLDefault string - - OnDelete string - OnUpdate string - - IsPK bool - NotNull bool - NullZero bool - AutoIncrement bool - Identity bool - - Append AppenderFunc - Scan ScannerFunc - IsZero IsZeroerFunc -} - -func (f *Field) String() string { - return f.Name -} - -func (f *Field) WithIndex(path []int) *Field { - if len(path) == 0 { - return f - } - clone := *f - clone.Index = makeIndex(path, f.Index) - return &clone -} - -func (f *Field) Clone() *Field { - cp := *f - cp.Index = cp.Index[:len(f.Index):len(f.Index)] - return &cp -} - -func (f *Field) Value(strct reflect.Value) reflect.Value { - return internal.FieldByIndexAlloc(strct, f.Index) -} - -func (f *Field) HasNilValue(v reflect.Value) bool { - if len(f.Index) == 1 { - return v.Field(f.Index[0]).IsNil() - } - - for _, index := range f.Index { - if v.Kind() == reflect.Ptr { - if v.IsNil() { - return true - } - v = v.Elem() - } - v = v.Field(index) - } - return v.IsNil() -} - -func (f *Field) HasZeroValue(v reflect.Value) bool { - if len(f.Index) == 1 { - return f.IsZero(v.Field(f.Index[0])) - } - - for _, index := range f.Index { - if v.Kind() == reflect.Ptr { - if v.IsNil() { - return true - } - v = v.Elem() - } - v = v.Field(index) - } - return f.IsZero(v) -} - -func (f *Field) AppendValue(fmter Formatter, b []byte, strct reflect.Value) []byte { - fv, ok := fieldByIndex(strct, f.Index) - if !ok { - return dialect.AppendNull(b) - } - - if (f.IsPtr && fv.IsNil()) || (f.NullZero && f.IsZero(fv)) { - return dialect.AppendNull(b) - } - if f.Append == nil { - panic(fmt.Errorf("bun: AppendValue(unsupported %s)", fv.Type())) - } - return f.Append(fmter, b, fv) -} - -func (f *Field) ScanValue(strct reflect.Value, src interface{}) error { - if src == nil { - if fv, ok := fieldByIndex(strct, f.Index); ok { - return f.ScanWithCheck(fv, src) - } - return nil - } - - fv := internal.FieldByIndexAlloc(strct, f.Index) - return f.ScanWithCheck(fv, src) -} - -func (f *Field) ScanWithCheck(fv reflect.Value, src interface{}) error { - if f.Scan == nil { - return fmt.Errorf("bun: Scan(unsupported %s)", f.IndirectType) - } - return f.Scan(fv, src) -} - -func (f *Field) SkipUpdate() bool { - return f.Tag.HasOption("skipupdate") -} diff --git a/vendor/github.com/uptrace/bun/schema/formatter.go b/vendor/github.com/uptrace/bun/schema/formatter.go deleted file mode 100644 index 1d8d9a9ee..000000000 --- a/vendor/github.com/uptrace/bun/schema/formatter.go +++ /dev/null @@ -1,250 +0,0 @@ -package schema - -import ( - "reflect" - "strconv" - "strings" - - "github.com/uptrace/bun/dialect" - "github.com/uptrace/bun/dialect/feature" - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/internal/parser" -) - -var nopFormatter = Formatter{ - dialect: newNopDialect(), -} - -type Formatter struct { - dialect Dialect - args *namedArgList -} - -func NewFormatter(dialect Dialect) Formatter { - return Formatter{ - dialect: dialect, - } -} - -func NewNopFormatter() Formatter { - return nopFormatter -} - -func (f Formatter) IsNop() bool { - return f.dialect.Name() == dialect.Invalid -} - -func (f Formatter) Dialect() Dialect { - return f.dialect -} - -func (f Formatter) IdentQuote() byte { - return f.dialect.IdentQuote() -} - -func (f Formatter) AppendName(b []byte, name string) []byte { - return dialect.AppendName(b, name, f.IdentQuote()) -} - -func (f Formatter) AppendIdent(b []byte, ident string) []byte { - return dialect.AppendIdent(b, ident, f.IdentQuote()) -} - -func (f Formatter) AppendValue(b []byte, v reflect.Value) []byte { - if v.Kind() == reflect.Ptr && v.IsNil() { - return dialect.AppendNull(b) - } - appender := Appender(f.dialect, v.Type()) - return appender(f, b, v) -} - -func (f Formatter) HasFeature(feature feature.Feature) bool { - return f.dialect.Features().Has(feature) -} - -func (f Formatter) WithArg(arg NamedArgAppender) Formatter { - return Formatter{ - dialect: f.dialect, - args: f.args.WithArg(arg), - } -} - -func (f Formatter) WithNamedArg(name string, value interface{}) Formatter { - return Formatter{ - dialect: f.dialect, - args: f.args.WithArg(&namedArg{name: name, value: value}), - } -} - -func (f Formatter) FormatQuery(query string, args ...interface{}) string { - if f.IsNop() || (args == nil && f.args == nil) || strings.IndexByte(query, '?') == -1 { - return query - } - return internal.String(f.AppendQuery(nil, query, args...)) -} - -func (f Formatter) AppendQuery(dst []byte, query string, args ...interface{}) []byte { - if f.IsNop() || (args == nil && f.args == nil) || strings.IndexByte(query, '?') == -1 { - return append(dst, query...) - } - return f.append(dst, parser.NewString(query), args) -} - -func (f Formatter) append(dst []byte, p *parser.Parser, args []interface{}) []byte { - var namedArgs NamedArgAppender - if len(args) == 1 { - if v, ok := args[0].(NamedArgAppender); ok { - namedArgs = v - } else if v, ok := newStructArgs(f, args[0]); ok { - namedArgs = v - } - } - - var argIndex int - for p.Valid() { - b, ok := p.ReadSep('?') - if !ok { - dst = append(dst, b...) - continue - } - if len(b) > 0 && b[len(b)-1] == '\\' { - dst = append(dst, b[:len(b)-1]...) - dst = append(dst, '?') - continue - } - dst = append(dst, b...) - - name, numeric := p.ReadIdentifier() - if name != "" { - if numeric { - idx, err := strconv.Atoi(name) - if err != nil { - goto restore_arg - } - - if idx >= len(args) { - goto restore_arg - } - - dst = f.appendArg(dst, args[idx]) - continue - } - - if namedArgs != nil { - dst, ok = namedArgs.AppendNamedArg(f, dst, name) - if ok { - continue - } - } - - dst, ok = f.args.AppendNamedArg(f, dst, name) - if ok { - continue - } - - restore_arg: - dst = append(dst, '?') - dst = append(dst, name...) - continue - } - - if argIndex >= len(args) { - dst = append(dst, '?') - continue - } - - arg := args[argIndex] - argIndex++ - - dst = f.appendArg(dst, arg) - } - - return dst -} - -func (f Formatter) appendArg(b []byte, arg interface{}) []byte { - switch arg := arg.(type) { - case QueryAppender: - bb, err := arg.AppendQuery(f, b) - if err != nil { - return dialect.AppendError(b, err) - } - return bb - default: - return Append(f, b, arg) - } -} - -//------------------------------------------------------------------------------ - -type NamedArgAppender interface { - AppendNamedArg(fmter Formatter, b []byte, name string) ([]byte, bool) -} - -type namedArgList struct { - arg NamedArgAppender - next *namedArgList -} - -func (l *namedArgList) WithArg(arg NamedArgAppender) *namedArgList { - return &namedArgList{ - arg: arg, - next: l, - } -} - -func (l *namedArgList) AppendNamedArg(fmter Formatter, b []byte, name string) ([]byte, bool) { - for l != nil && l.arg != nil { - if b, ok := l.arg.AppendNamedArg(fmter, b, name); ok { - return b, true - } - l = l.next - } - return b, false -} - -//------------------------------------------------------------------------------ - -type namedArg struct { - name string - value interface{} -} - -var _ NamedArgAppender = (*namedArg)(nil) - -func (a *namedArg) AppendNamedArg(fmter Formatter, b []byte, name string) ([]byte, bool) { - if a.name == name { - return fmter.appendArg(b, a.value), true - } - return b, false -} - -//------------------------------------------------------------------------------ - -type structArgs struct { - table *Table - strct reflect.Value -} - -var _ NamedArgAppender = (*structArgs)(nil) - -func newStructArgs(fmter Formatter, strct interface{}) (*structArgs, bool) { - v := reflect.ValueOf(strct) - if !v.IsValid() { - return nil, false - } - - v = reflect.Indirect(v) - if v.Kind() != reflect.Struct { - return nil, false - } - - return &structArgs{ - table: fmter.Dialect().Tables().Get(v.Type()), - strct: v, - }, true -} - -func (m *structArgs) AppendNamedArg(fmter Formatter, b []byte, name string) ([]byte, bool) { - return m.table.AppendNamedArg(fmter, b, name, m.strct) -} diff --git a/vendor/github.com/uptrace/bun/schema/hook.go b/vendor/github.com/uptrace/bun/schema/hook.go deleted file mode 100644 index f8c32f689..000000000 --- a/vendor/github.com/uptrace/bun/schema/hook.go +++ /dev/null @@ -1,43 +0,0 @@ -package schema - -import ( - "context" - "database/sql" - "reflect" -) - -type Model interface { - ScanRows(ctx context.Context, rows *sql.Rows) (int, error) - Value() interface{} -} - -type Query interface { - QueryAppender - Operation() string - GetModel() Model - GetTableName() string -} - -//------------------------------------------------------------------------------ - -type BeforeAppendModelHook interface { - BeforeAppendModel(ctx context.Context, query Query) error -} - -var beforeAppendModelHookType = reflect.TypeFor[BeforeAppendModelHook]() - -//------------------------------------------------------------------------------ - -type BeforeScanRowHook interface { - BeforeScanRow(context.Context) error -} - -var beforeScanRowHookType = reflect.TypeFor[BeforeScanRowHook]() - -//------------------------------------------------------------------------------ - -type AfterScanRowHook interface { - AfterScanRow(context.Context) error -} - -var afterScanRowHookType = reflect.TypeFor[AfterScanRowHook]() diff --git a/vendor/github.com/uptrace/bun/schema/reflect.go b/vendor/github.com/uptrace/bun/schema/reflect.go deleted file mode 100644 index 3435fa1c8..000000000 --- a/vendor/github.com/uptrace/bun/schema/reflect.go +++ /dev/null @@ -1,51 +0,0 @@ -package schema - -import ( - "database/sql/driver" - "encoding/json" - "net" - "net/netip" - "reflect" - "time" -) - -var ( - bytesType = reflect.TypeFor[[]byte]() - timePtrType = reflect.TypeFor[*time.Time]() - timeType = reflect.TypeFor[time.Time]() - ipType = reflect.TypeFor[net.IP]() - ipNetType = reflect.TypeFor[net.IPNet]() - netipPrefixType = reflect.TypeFor[netip.Prefix]() - netipAddrType = reflect.TypeFor[netip.Addr]() - jsonRawMessageType = reflect.TypeFor[json.RawMessage]() - - driverValuerType = reflect.TypeFor[driver.Valuer]() - queryAppenderType = reflect.TypeFor[QueryAppender]() - jsonMarshalerType = reflect.TypeFor[json.Marshaler]() -) - -func indirectType(t reflect.Type) reflect.Type { - if t.Kind() == reflect.Ptr { - t = t.Elem() - } - return t -} - -func fieldByIndex(v reflect.Value, index []int) (_ reflect.Value, ok bool) { - if len(index) == 1 { - return v.Field(index[0]), true - } - - for i, idx := range index { - if i > 0 { - if v.Kind() == reflect.Ptr { - if v.IsNil() { - return v, false - } - v = v.Elem() - } - } - v = v.Field(idx) - } - return v, true -} diff --git a/vendor/github.com/uptrace/bun/schema/relation.go b/vendor/github.com/uptrace/bun/schema/relation.go deleted file mode 100644 index f653cd7a3..000000000 --- a/vendor/github.com/uptrace/bun/schema/relation.go +++ /dev/null @@ -1,45 +0,0 @@ -package schema - -import ( - "fmt" -) - -const ( - InvalidRelation = iota - HasOneRelation - BelongsToRelation - HasManyRelation - ManyToManyRelation -) - -type Relation struct { - // Base and Join can be explained with this query: - // - // SELECT * FROM base_table JOIN join_table - - Type int - Field *Field - JoinTable *Table - BasePKs []*Field - JoinPKs []*Field - OnUpdate string - OnDelete string - Condition []string - - PolymorphicField *Field - PolymorphicValue string - - M2MTable *Table - M2MBasePKs []*Field - M2MJoinPKs []*Field -} - -// References returns true if the table to which the Relation belongs needs to declare a foreign key constraint to create the relation. -// For other relations, the constraint is created in either the referencing table (1:N, 'has-many' relations) or a mapping table (N:N, 'm2m' relations). -func (r *Relation) References() bool { - return r.Type == HasOneRelation || r.Type == BelongsToRelation -} - -func (r *Relation) String() string { - return fmt.Sprintf("relation=%s", r.Field.GoName) -} diff --git a/vendor/github.com/uptrace/bun/schema/scan.go b/vendor/github.com/uptrace/bun/schema/scan.go deleted file mode 100644 index 9db46cd6f..000000000 --- a/vendor/github.com/uptrace/bun/schema/scan.go +++ /dev/null @@ -1,519 +0,0 @@ -package schema - -import ( - "bytes" - "database/sql" - "fmt" - "net" - "reflect" - "strconv" - "strings" - "time" - - "github.com/puzpuzpuz/xsync/v3" - "github.com/vmihailenco/msgpack/v5" - - "github.com/uptrace/bun/dialect/sqltype" - "github.com/uptrace/bun/extra/bunjson" - "github.com/uptrace/bun/internal" -) - -var scannerType = reflect.TypeFor[sql.Scanner]() - -type ScannerFunc func(dest reflect.Value, src interface{}) error - -var scanners []ScannerFunc - -func init() { - scanners = []ScannerFunc{ - reflect.Bool: scanBool, - reflect.Int: scanInt64, - reflect.Int8: scanInt64, - reflect.Int16: scanInt64, - reflect.Int32: scanInt64, - reflect.Int64: scanInt64, - reflect.Uint: scanUint64, - reflect.Uint8: scanUint64, - reflect.Uint16: scanUint64, - reflect.Uint32: scanUint64, - reflect.Uint64: scanUint64, - reflect.Uintptr: scanUint64, - reflect.Float32: scanFloat, - reflect.Float64: scanFloat, - reflect.Complex64: nil, - reflect.Complex128: nil, - reflect.Array: nil, - reflect.Interface: scanInterface, - reflect.Map: scanJSON, - reflect.Ptr: nil, - reflect.Slice: scanJSON, - reflect.String: scanString, - reflect.Struct: scanJSON, - reflect.UnsafePointer: nil, - } -} - -var scannerCache = xsync.NewMapOf[reflect.Type, ScannerFunc]() - -func FieldScanner(dialect Dialect, field *Field) ScannerFunc { - if field.Tag.HasOption("msgpack") { - return scanMsgpack - } - if field.Tag.HasOption("json_use_number") { - return scanJSONUseNumber - } - if field.StructField.Type.Kind() == reflect.Interface { - switch strings.ToUpper(field.UserSQLType) { - case sqltype.JSON, sqltype.JSONB: - return scanJSONIntoInterface - } - } - return Scanner(field.StructField.Type) -} - -func Scanner(typ reflect.Type) ScannerFunc { - if v, ok := scannerCache.Load(typ); ok { - return v - } - - fn := scanner(typ) - - if v, ok := scannerCache.LoadOrStore(typ, fn); ok { - return v - } - return fn -} - -func scanner(typ reflect.Type) ScannerFunc { - kind := typ.Kind() - - if kind == reflect.Ptr { - if fn := Scanner(typ.Elem()); fn != nil { - return PtrScanner(fn) - } - } - - switch typ { - case bytesType: - return scanBytes - case timeType: - return scanTime - case ipType: - return scanIP - case ipNetType: - return scanIPNet - case jsonRawMessageType: - return scanBytes - } - - if typ.Implements(scannerType) { - return scanScanner - } - - if kind != reflect.Ptr { - ptr := reflect.PointerTo(typ) - if ptr.Implements(scannerType) { - return addrScanner(scanScanner) - } - } - - if typ.Kind() == reflect.Slice && typ.Elem().Kind() == reflect.Uint8 { - return scanBytes - } - - return scanners[kind] -} - -func scanBool(dest reflect.Value, src interface{}) error { - switch src := src.(type) { - case nil: - dest.SetBool(false) - return nil - case bool: - dest.SetBool(src) - return nil - case int64: - dest.SetBool(src != 0) - return nil - case []byte: - f, err := strconv.ParseBool(internal.String(src)) - if err != nil { - return err - } - dest.SetBool(f) - return nil - case string: - f, err := strconv.ParseBool(src) - if err != nil { - return err - } - dest.SetBool(f) - return nil - default: - return scanError(dest.Type(), src) - } -} - -func scanInt64(dest reflect.Value, src interface{}) error { - switch src := src.(type) { - case nil: - dest.SetInt(0) - return nil - case int64: - dest.SetInt(src) - return nil - case uint64: - dest.SetInt(int64(src)) - return nil - case []byte: - n, err := strconv.ParseInt(internal.String(src), 10, 64) - if err != nil { - return err - } - dest.SetInt(n) - return nil - case string: - n, err := strconv.ParseInt(src, 10, 64) - if err != nil { - return err - } - dest.SetInt(n) - return nil - default: - return scanError(dest.Type(), src) - } -} - -func scanUint64(dest reflect.Value, src interface{}) error { - switch src := src.(type) { - case nil: - dest.SetUint(0) - return nil - case uint64: - dest.SetUint(src) - return nil - case int64: - dest.SetUint(uint64(src)) - return nil - case []byte: - n, err := strconv.ParseUint(internal.String(src), 10, 64) - if err != nil { - return err - } - dest.SetUint(n) - return nil - case string: - n, err := strconv.ParseUint(src, 10, 64) - if err != nil { - return err - } - dest.SetUint(n) - return nil - default: - return scanError(dest.Type(), src) - } -} - -func scanFloat(dest reflect.Value, src interface{}) error { - switch src := src.(type) { - case nil: - dest.SetFloat(0) - return nil - case float32: - dest.SetFloat(float64(src)) - return nil - case float64: - dest.SetFloat(src) - return nil - case []byte: - f, err := strconv.ParseFloat(internal.String(src), 64) - if err != nil { - return err - } - dest.SetFloat(f) - return nil - case string: - f, err := strconv.ParseFloat(src, 64) - if err != nil { - return err - } - dest.SetFloat(f) - return nil - default: - return scanError(dest.Type(), src) - } -} - -func scanString(dest reflect.Value, src interface{}) error { - switch src := src.(type) { - case nil: - dest.SetString("") - return nil - case string: - dest.SetString(src) - return nil - case []byte: - dest.SetString(string(src)) - return nil - case time.Time: - dest.SetString(src.Format(time.RFC3339Nano)) - return nil - case int64: - dest.SetString(strconv.FormatInt(src, 10)) - return nil - case uint64: - dest.SetString(strconv.FormatUint(src, 10)) - return nil - case float64: - dest.SetString(strconv.FormatFloat(src, 'G', -1, 64)) - return nil - default: - return scanError(dest.Type(), src) - } -} - -func scanBytes(dest reflect.Value, src interface{}) error { - switch src := src.(type) { - case nil: - dest.SetBytes(nil) - return nil - case string: - dest.SetBytes([]byte(src)) - return nil - case []byte: - clone := make([]byte, len(src)) - copy(clone, src) - - dest.SetBytes(clone) - return nil - default: - return scanError(dest.Type(), src) - } -} - -func scanTime(dest reflect.Value, src interface{}) error { - switch src := src.(type) { - case nil: - destTime := dest.Addr().Interface().(*time.Time) - *destTime = time.Time{} - return nil - case time.Time: - destTime := dest.Addr().Interface().(*time.Time) - *destTime = src - return nil - case string: - srcTime, err := internal.ParseTime(src) - if err != nil { - return err - } - destTime := dest.Addr().Interface().(*time.Time) - *destTime = srcTime - return nil - case []byte: - srcTime, err := internal.ParseTime(internal.String(src)) - if err != nil { - return err - } - destTime := dest.Addr().Interface().(*time.Time) - *destTime = srcTime - return nil - default: - return scanError(dest.Type(), src) - } -} - -func scanScanner(dest reflect.Value, src interface{}) error { - return dest.Interface().(sql.Scanner).Scan(src) -} - -func scanMsgpack(dest reflect.Value, src interface{}) error { - if src == nil { - return scanNull(dest) - } - - b, err := toBytes(src) - if err != nil { - return err - } - - dec := msgpack.GetDecoder() - defer msgpack.PutDecoder(dec) - - dec.Reset(bytes.NewReader(b)) - return dec.DecodeValue(dest) -} - -func scanJSON(dest reflect.Value, src interface{}) error { - if src == nil { - return scanNull(dest) - } - - b, err := toBytes(src) - if err != nil { - return err - } - - return bunjson.Unmarshal(b, dest.Addr().Interface()) -} - -func scanJSONUseNumber(dest reflect.Value, src interface{}) error { - if src == nil { - return scanNull(dest) - } - - b, err := toBytes(src) - if err != nil { - return err - } - - dec := bunjson.NewDecoder(bytes.NewReader(b)) - dec.UseNumber() - return dec.Decode(dest.Addr().Interface()) -} - -func scanIP(dest reflect.Value, src interface{}) error { - if src == nil { - return scanNull(dest) - } - - b, err := toBytes(src) - if err != nil { - return err - } - - ip := net.ParseIP(internal.String(b)) - if ip == nil { - return fmt.Errorf("bun: invalid ip: %q", b) - } - - ptr := dest.Addr().Interface().(*net.IP) - *ptr = ip - - return nil -} - -func scanIPNet(dest reflect.Value, src interface{}) error { - if src == nil { - return scanNull(dest) - } - - b, err := toBytes(src) - if err != nil { - return err - } - - _, ipnet, err := net.ParseCIDR(internal.String(b)) - if err != nil { - return err - } - - ptr := dest.Addr().Interface().(*net.IPNet) - *ptr = *ipnet - - return nil -} - -func addrScanner(fn ScannerFunc) ScannerFunc { - return func(dest reflect.Value, src interface{}) error { - if !dest.CanAddr() { - return fmt.Errorf("bun: Scan(nonaddressable %T)", dest.Interface()) - } - return fn(dest.Addr(), src) - } -} - -func toBytes(src interface{}) ([]byte, error) { - switch src := src.(type) { - case string: - return internal.Bytes(src), nil - case []byte: - return src, nil - default: - return nil, fmt.Errorf("bun: got %T, wanted []byte or string", src) - } -} - -func PtrScanner(fn ScannerFunc) ScannerFunc { - return func(dest reflect.Value, src interface{}) error { - if src == nil { - if !dest.CanAddr() { - if dest.IsNil() { - return nil - } - return fn(dest.Elem(), src) - } - - if !dest.IsNil() { - dest.Set(reflect.New(dest.Type().Elem())) - } - return nil - } - - if dest.IsNil() { - dest.Set(reflect.New(dest.Type().Elem())) - } - - if dest.Kind() == reflect.Map { - return fn(dest, src) - } - - return fn(dest.Elem(), src) - } -} - -func scanNull(dest reflect.Value) error { - if nilable(dest.Kind()) && dest.IsNil() { - return nil - } - dest.Set(reflect.New(dest.Type()).Elem()) - return nil -} - -func scanJSONIntoInterface(dest reflect.Value, src interface{}) error { - if dest.IsNil() { - if src == nil { - return nil - } - - b, err := toBytes(src) - if err != nil { - return err - } - - return bunjson.Unmarshal(b, dest.Addr().Interface()) - } - - dest = dest.Elem() - if fn := Scanner(dest.Type()); fn != nil { - return fn(dest, src) - } - return scanError(dest.Type(), src) -} - -func scanInterface(dest reflect.Value, src interface{}) error { - if dest.IsNil() { - if src == nil { - return nil - } - dest.Set(reflect.ValueOf(src)) - return nil - } - - dest = dest.Elem() - if fn := Scanner(dest.Type()); fn != nil { - return fn(dest, src) - } - return scanError(dest.Type(), src) -} - -func nilable(kind reflect.Kind) bool { - switch kind { - case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: - return true - } - return false -} - -func scanError(dest reflect.Type, src interface{}) error { - return fmt.Errorf("bun: can't scan %#v (%T) into %s", src, src, dest.String()) -} diff --git a/vendor/github.com/uptrace/bun/schema/sqlfmt.go b/vendor/github.com/uptrace/bun/schema/sqlfmt.go deleted file mode 100644 index 7b4a9493f..000000000 --- a/vendor/github.com/uptrace/bun/schema/sqlfmt.go +++ /dev/null @@ -1,99 +0,0 @@ -package schema - -import ( - "strings" - - "github.com/uptrace/bun/internal" -) - -type QueryAppender interface { - AppendQuery(fmter Formatter, b []byte) ([]byte, error) -} - -type ColumnsAppender interface { - AppendColumns(fmter Formatter, b []byte) ([]byte, error) -} - -//------------------------------------------------------------------------------ - -// Safe represents a safe SQL query. -type Safe string - -var _ QueryAppender = (*Safe)(nil) - -func (s Safe) AppendQuery(fmter Formatter, b []byte) ([]byte, error) { - return append(b, s...), nil -} - -//------------------------------------------------------------------------------ - -// Name represents a single SQL name, for example, a column name. -type Name string - -var _ QueryAppender = (*Name)(nil) - -func (s Name) AppendQuery(fmter Formatter, b []byte) ([]byte, error) { - return fmter.AppendName(b, string(s)), nil -} - -//------------------------------------------------------------------------------ - -// Ident represents a SQL identifier, for example, -// a fully qualified column name such as `table_name.col_name`. -type Ident string - -var _ QueryAppender = (*Ident)(nil) - -func (s Ident) AppendQuery(fmter Formatter, b []byte) ([]byte, error) { - return fmter.AppendIdent(b, string(s)), nil -} - -//------------------------------------------------------------------------------ - -type QueryWithArgs struct { - Query string - Args []interface{} -} - -var _ QueryAppender = QueryWithArgs{} - -func SafeQuery(query string, args []interface{}) QueryWithArgs { - if args == nil { - args = make([]interface{}, 0) - } else if len(query) > 0 && strings.IndexByte(query, '?') == -1 { - internal.Warn.Printf("query %q has %v args, but no placeholders", query, args) - } - return QueryWithArgs{ - Query: query, - Args: args, - } -} - -func UnsafeIdent(ident string) QueryWithArgs { - return QueryWithArgs{Query: ident} -} - -func (q QueryWithArgs) IsZero() bool { - return q.Query == "" && q.Args == nil -} - -func (q QueryWithArgs) AppendQuery(fmter Formatter, b []byte) ([]byte, error) { - if q.Args == nil { - return fmter.AppendIdent(b, q.Query), nil - } - return fmter.AppendQuery(b, q.Query, q.Args...), nil -} - -//------------------------------------------------------------------------------ - -type QueryWithSep struct { - QueryWithArgs - Sep string -} - -func SafeQueryWithSep(query string, args []interface{}, sep string) QueryWithSep { - return QueryWithSep{ - QueryWithArgs: SafeQuery(query, args), - Sep: sep, - } -} diff --git a/vendor/github.com/uptrace/bun/schema/sqltype.go b/vendor/github.com/uptrace/bun/schema/sqltype.go deleted file mode 100644 index e96174065..000000000 --- a/vendor/github.com/uptrace/bun/schema/sqltype.go +++ /dev/null @@ -1,141 +0,0 @@ -package schema - -import ( - "bytes" - "database/sql" - "encoding/json" - "reflect" - "time" - - "github.com/uptrace/bun/dialect" - "github.com/uptrace/bun/dialect/sqltype" - "github.com/uptrace/bun/internal" -) - -var ( - bunNullTimeType = reflect.TypeFor[NullTime]() - nullTimeType = reflect.TypeFor[sql.NullTime]() - nullBoolType = reflect.TypeFor[sql.NullBool]() - nullFloatType = reflect.TypeFor[sql.NullFloat64]() - nullIntType = reflect.TypeFor[sql.NullInt64]() - nullStringType = reflect.TypeFor[sql.NullString]() -) - -var sqlTypes = []string{ - reflect.Bool: sqltype.Boolean, - reflect.Int: sqltype.BigInt, - reflect.Int8: sqltype.SmallInt, - reflect.Int16: sqltype.SmallInt, - reflect.Int32: sqltype.Integer, - reflect.Int64: sqltype.BigInt, - reflect.Uint: sqltype.BigInt, - reflect.Uint8: sqltype.SmallInt, - reflect.Uint16: sqltype.SmallInt, - reflect.Uint32: sqltype.Integer, - reflect.Uint64: sqltype.BigInt, - reflect.Uintptr: sqltype.BigInt, - reflect.Float32: sqltype.Real, - reflect.Float64: sqltype.DoublePrecision, - reflect.Complex64: "", - reflect.Complex128: "", - reflect.Array: "", - reflect.Interface: "", - reflect.Map: sqltype.VarChar, - reflect.Ptr: "", - reflect.Slice: sqltype.VarChar, - reflect.String: sqltype.VarChar, - reflect.Struct: sqltype.VarChar, -} - -func DiscoverSQLType(typ reflect.Type) string { - switch typ { - case timeType, nullTimeType, bunNullTimeType: - return sqltype.Timestamp - case nullBoolType: - return sqltype.Boolean - case nullFloatType: - return sqltype.DoublePrecision - case nullIntType: - return sqltype.BigInt - case nullStringType: - return sqltype.VarChar - case jsonRawMessageType: - return sqltype.JSON - } - - switch typ.Kind() { - case reflect.Slice: - if typ.Elem().Kind() == reflect.Uint8 { - return sqltype.Blob - } - } - - return sqlTypes[typ.Kind()] -} - -//------------------------------------------------------------------------------ - -var jsonNull = []byte("null") - -// NullTime is a time.Time wrapper that marshals zero time as JSON null and SQL NULL. -type NullTime struct { - time.Time -} - -var ( - _ json.Marshaler = (*NullTime)(nil) - _ json.Unmarshaler = (*NullTime)(nil) - _ sql.Scanner = (*NullTime)(nil) - _ QueryAppender = (*NullTime)(nil) -) - -func (tm NullTime) MarshalJSON() ([]byte, error) { - if tm.IsZero() { - return jsonNull, nil - } - return tm.Time.MarshalJSON() -} - -func (tm *NullTime) UnmarshalJSON(b []byte) error { - if bytes.Equal(b, jsonNull) { - tm.Time = time.Time{} - return nil - } - return tm.Time.UnmarshalJSON(b) -} - -func (tm NullTime) AppendQuery(fmter Formatter, b []byte) ([]byte, error) { - if tm.IsZero() { - return dialect.AppendNull(b), nil - } - return fmter.Dialect().AppendTime(b, tm.Time), nil -} - -func (tm *NullTime) Scan(src interface{}) error { - if src == nil { - tm.Time = time.Time{} - return nil - } - - switch src := src.(type) { - case time.Time: - tm.Time = src - return nil - case string: - newtm, err := internal.ParseTime(src) - if err != nil { - return err - } - tm.Time = newtm - return nil - case []byte: - newtm, err := internal.ParseTime(internal.String(src)) - if err != nil { - return err - } - tm.Time = newtm - return nil - default: - return scanError(bunNullTimeType, src) - } -} diff --git a/vendor/github.com/uptrace/bun/schema/table.go b/vendor/github.com/uptrace/bun/schema/table.go deleted file mode 100644 index 13b989e4d..000000000 --- a/vendor/github.com/uptrace/bun/schema/table.go +++ /dev/null @@ -1,1094 +0,0 @@ -package schema - -import ( - "database/sql" - "fmt" - "reflect" - "sort" - "strings" - "time" - - "github.com/jinzhu/inflection" - - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/internal/tagparser" -) - -const ( - beforeAppendModelHookFlag internal.Flag = 1 << iota - beforeScanHookFlag - afterScanHookFlag - beforeScanRowHookFlag - afterScanRowHookFlag -) - -var ( - baseModelType = reflect.TypeFor[BaseModel]() - tableNameInflector = inflection.Plural -) - -type BaseModel struct{} - -// SetTableNameInflector overrides the default func that pluralizes -// model name to get table name, e.g. my_article becomes my_articles. -func SetTableNameInflector(fn func(string) string) { - tableNameInflector = fn -} - -// Table represents a SQL table created from Go struct. -type Table struct { - dialect Dialect - - Type reflect.Type - ZeroValue reflect.Value // reflect.Struct - ZeroIface interface{} // struct pointer - - TypeName string - ModelName string - - Schema string - Name string - SQLName Safe - SQLNameForSelects Safe - Alias string - SQLAlias Safe - - allFields []*Field // all fields including scanonly - Fields []*Field // PKs + DataFields - PKs []*Field - DataFields []*Field - relFields []*Field - - FieldMap map[string]*Field - StructMap map[string]*structField - - Relations map[string]*Relation - Unique map[string][]*Field - - SoftDeleteField *Field - UpdateSoftDeleteField func(fv reflect.Value, tm time.Time) error - - flags internal.Flag -} - -type structField struct { - Index []int - Table *Table -} - -func (table *Table) init(dialect Dialect, typ reflect.Type) { - table.dialect = dialect - table.Type = typ - table.ZeroValue = reflect.New(table.Type).Elem() - table.ZeroIface = reflect.New(table.Type).Interface() - table.TypeName = internal.ToExported(table.Type.Name()) - table.ModelName = internal.Underscore(table.Type.Name()) - tableName := tableNameInflector(table.ModelName) - table.setName(tableName) - table.Alias = table.ModelName - table.SQLAlias = table.quoteIdent(table.ModelName) - table.Schema = dialect.DefaultSchema() - - table.Fields = make([]*Field, 0, typ.NumField()) - table.FieldMap = make(map[string]*Field, typ.NumField()) - table.processFields(typ) - - hooks := []struct { - typ reflect.Type - flag internal.Flag - }{ - {beforeAppendModelHookType, beforeAppendModelHookFlag}, - - {beforeScanRowHookType, beforeScanRowHookFlag}, - {afterScanRowHookType, afterScanRowHookFlag}, - } - - typ = reflect.PointerTo(table.Type) - for _, hook := range hooks { - if typ.Implements(hook.typ) { - table.flags = table.flags.Set(hook.flag) - } - } -} - -func (t *Table) processFields(typ reflect.Type) { - type embeddedField struct { - prefix string - index []int - unexported bool - subtable *Table - subfield *Field - } - - names := make(map[string]struct{}) - embedded := make([]embeddedField, 0, 10) - - for i, n := 0, typ.NumField(); i < n; i++ { - sf := typ.Field(i) - unexported := sf.PkgPath != "" - - tagstr := sf.Tag.Get("bun") - if tagstr == "-" { - names[sf.Name] = struct{}{} - continue - } - tag := tagparser.Parse(tagstr) - - if unexported && !sf.Anonymous { // unexported - continue - } - - if sf.Anonymous { - if sf.Name == "BaseModel" && sf.Type == baseModelType { - t.processBaseModelField(sf) - continue - } - - sfType := sf.Type - if sfType.Kind() == reflect.Ptr { - sfType = sfType.Elem() - } - - if sfType.Kind() != reflect.Struct { // ignore unexported non-struct types - continue - } - - subtable := t.dialect.Tables().InProgress(sfType) - - for _, subfield := range subtable.allFields { - embedded = append(embedded, embeddedField{ - index: sf.Index, - unexported: unexported, - subtable: subtable, - subfield: subfield, - }) - } - - if tagstr != "" { - tag := tagparser.Parse(tagstr) - if tag.HasOption("inherit") || tag.HasOption("extend") { - t.Name = subtable.Name - t.TypeName = subtable.TypeName - t.SQLName = subtable.SQLName - t.SQLNameForSelects = subtable.SQLNameForSelects - t.Alias = subtable.Alias - t.SQLAlias = subtable.SQLAlias - t.ModelName = subtable.ModelName - } - } - - continue - } - - if prefix, ok := tag.Option("embed"); ok { - fieldType := indirectType(sf.Type) - if fieldType.Kind() != reflect.Struct { - panic(fmt.Errorf("bun: embed %s.%s: got %s, wanted reflect.Struct", - t.TypeName, sf.Name, fieldType.Kind())) - } - - subtable := t.dialect.Tables().InProgress(fieldType) - for _, subfield := range subtable.allFields { - embedded = append(embedded, embeddedField{ - prefix: prefix, - index: sf.Index, - unexported: unexported, - subtable: subtable, - subfield: subfield, - }) - } - continue - } - - field := t.newField(sf, tag) - t.addField(field) - names[field.Name] = struct{}{} - - if field.IndirectType.Kind() == reflect.Struct { - if t.StructMap == nil { - t.StructMap = make(map[string]*structField) - } - t.StructMap[field.Name] = &structField{ - Index: field.Index, - Table: t.dialect.Tables().InProgress(field.IndirectType), - } - } - } - - // Only unambiguous embedded fields must be serialized. - ambiguousNames := make(map[string]int) - ambiguousTags := make(map[string]int) - - // Embedded types can never override a field that was already present at - // the top-level. - for name := range names { - ambiguousNames[name]++ - ambiguousTags[name]++ - } - - for _, f := range embedded { - ambiguousNames[f.prefix+f.subfield.Name]++ - if !f.subfield.Tag.IsZero() { - ambiguousTags[f.prefix+f.subfield.Name]++ - } - } - - for _, embfield := range embedded { - subfield := embfield.subfield.Clone() - - if ambiguousNames[subfield.Name] > 1 && - !(!subfield.Tag.IsZero() && ambiguousTags[subfield.Name] == 1) { - continue // ambiguous embedded field - } - - subfield.Index = makeIndex(embfield.index, subfield.Index) - if embfield.prefix != "" { - subfield.Name = embfield.prefix + subfield.Name - subfield.SQLName = t.quoteIdent(subfield.Name) - } - t.addField(subfield) - if v, ok := subfield.Tag.Options["unique"]; ok { - t.addUnique(subfield, embfield.prefix, v) - } - } - - if len(embedded) > 0 { - // https://github.com/uptrace/bun/issues/1095 - // < v1.2, all fields follow the order corresponding to the struct - // >= v1.2, < v1.2.8, fields of nested structs have been moved to the end. - // >= v1.2.8, The default behavior remains the same as initially, - sortFieldsByStruct(t.allFields) - sortFieldsByStruct(t.Fields) - sortFieldsByStruct(t.PKs) - sortFieldsByStruct(t.DataFields) - } -} - -func sortFieldsByStruct(fields []*Field) { - sort.Slice(fields, func(i, j int) bool { - left, right := fields[i], fields[j] - for k := 0; k < len(left.Index) && k < len(right.Index); k++ { - if left.Index[k] != right.Index[k] { - return left.Index[k] < right.Index[k] - } - } - // NOTE: should not reach - return true - }) -} - -func (t *Table) addUnique(field *Field, prefix string, tagOptions []string) { - var names []string - if len(tagOptions) == 1 { - // Split the value by comma, this will allow multiple names to be specified. - // We can use this to create multiple named unique constraints where a single column - // might be included in multiple constraints. - names = strings.Split(tagOptions[0], ",") - } else { - names = tagOptions - } - - for _, uname := range names { - if t.Unique == nil { - t.Unique = make(map[string][]*Field) - } - if uname != "" && prefix != "" { - uname = prefix + uname - } - t.Unique[uname] = append(t.Unique[uname], field) - } -} - -func (t *Table) setName(name string) { - t.Name = name - t.SQLName = t.quoteIdent(name) - t.SQLNameForSelects = t.quoteIdent(name) - if t.SQLAlias == "" { - t.Alias = name - t.SQLAlias = t.quoteIdent(name) - } -} - -func (t *Table) String() string { - return "model=" + t.TypeName -} - -func (t *Table) CheckPKs() error { - if len(t.PKs) == 0 { - return fmt.Errorf("bun: %s does not have primary keys", t) - } - return nil -} - -func (t *Table) addField(field *Field) { - t.allFields = append(t.allFields, field) - - if field.Tag.HasOption("rel") || field.Tag.HasOption("m2m") { - t.relFields = append(t.relFields, field) - return - } - - if field.Tag.HasOption("join") { - internal.Warn.Printf( - `%s.%s "join" option must come together with "rel" option`, - t.TypeName, field.GoName, - ) - } - - t.FieldMap[field.Name] = field - if altName, ok := field.Tag.Option("alt"); ok { - t.FieldMap[altName] = field - } - - if field.Tag.HasOption("scanonly") { - return - } - - if _, ok := field.Tag.Options["soft_delete"]; ok { - t.SoftDeleteField = field - t.UpdateSoftDeleteField = softDeleteFieldUpdater(field) - } - - t.Fields = append(t.Fields, field) - if field.IsPK { - t.PKs = append(t.PKs, field) - } else { - t.DataFields = append(t.DataFields, field) - } -} - -func (t *Table) LookupField(name string) *Field { - if field, ok := t.FieldMap[name]; ok { - return field - } - - table := t - var index []int - for { - structName, columnName, ok := strings.Cut(name, "__") - if !ok { - field, ok := table.FieldMap[name] - if !ok { - return nil - } - return field.WithIndex(index) - } - name = columnName - - strct := table.StructMap[structName] - if strct == nil { - return nil - } - table = strct.Table - index = append(index, strct.Index...) - } -} - -func (t *Table) HasField(name string) bool { - _, ok := t.FieldMap[name] - return ok -} - -func (t *Table) Field(name string) (*Field, error) { - field, ok := t.FieldMap[name] - if !ok { - return nil, fmt.Errorf("bun: %s does not have column=%s", t, name) - } - return field, nil -} - -func (t *Table) fieldByGoName(name string) *Field { - for _, f := range t.allFields { - if f.GoName == name { - return f - } - } - return nil -} - -func (t *Table) processBaseModelField(f reflect.StructField) { - tag := tagparser.Parse(f.Tag.Get("bun")) - - if isKnownTableOption(tag.Name) { - internal.Warn.Printf( - "%s.%s tag name %q is also an option name, is it a mistake? Try table:%s.", - t.TypeName, f.Name, tag.Name, tag.Name, - ) - } - - for name := range tag.Options { - if !isKnownTableOption(name) { - internal.Warn.Printf("%s.%s has unknown tag option: %q", t.TypeName, f.Name, name) - } - } - - if tag.Name != "" { - schema, _ := t.schemaFromTagName(tag.Name) - t.Schema = schema - - // Eventually, we should only assign the "table" portion as the table name, - // which will also require a change in how the table name is appended to queries. - // Until that is done, set table name to tag.Name. - t.setName(tag.Name) - } - - if s, ok := tag.Option("table"); ok { - schema, _ := t.schemaFromTagName(s) - t.Schema = schema - t.setName(s) - } - - if s, ok := tag.Option("select"); ok { - t.SQLNameForSelects = t.quoteTableName(s) - } - - if s, ok := tag.Option("alias"); ok { - t.Alias = s - t.SQLAlias = t.quoteIdent(s) - } -} - -// schemaFromTagName splits the bun.BaseModel tag name into schema and table name -// in case it is specified in the "schema"."table" format. -// Assume default schema if one isn't explicitly specified. -func (t *Table) schemaFromTagName(name string) (string, string) { - schema, table := t.dialect.DefaultSchema(), name - if schemaTable := strings.Split(name, "."); len(schemaTable) == 2 { - schema, table = schemaTable[0], schemaTable[1] - } - return schema, table -} - -// nolint -func (t *Table) newField(sf reflect.StructField, tag tagparser.Tag) *Field { - sqlName := internal.Underscore(sf.Name) - if tag.Name != "" && tag.Name != sqlName { - if isKnownFieldOption(tag.Name) { - internal.Warn.Printf( - "%s.%s tag name %q is also an option name, is it a mistake? Try column:%s.", - t.TypeName, sf.Name, tag.Name, tag.Name, - ) - } - sqlName = tag.Name - } - - if s, ok := tag.Option("column"); ok { - sqlName = s - } - - for name := range tag.Options { - if !isKnownFieldOption(name) { - internal.Warn.Printf("%s.%s has unknown tag option: %q", t.TypeName, sf.Name, name) - } - } - - field := &Field{ - StructField: sf, - IsPtr: sf.Type.Kind() == reflect.Ptr, - - Tag: tag, - IndirectType: indirectType(sf.Type), - Index: sf.Index, - - Name: sqlName, - GoName: sf.Name, - SQLName: t.quoteIdent(sqlName), - } - - field.NotNull = tag.HasOption("notnull") - field.NullZero = tag.HasOption("nullzero") - if tag.HasOption("pk") { - field.IsPK = true - field.NotNull = true - } - if tag.HasOption("autoincrement") { - field.AutoIncrement = true - field.NullZero = true - } - if tag.HasOption("identity") { - field.Identity = true - } - - if v, ok := tag.Options["unique"]; ok { - t.addUnique(field, "", v) - } - if s, ok := tag.Option("default"); ok { - field.SQLDefault = s - } - if s, ok := field.Tag.Option("type"); ok { - field.UserSQLType = s - } - field.DiscoveredSQLType = DiscoverSQLType(field.IndirectType) - field.Append = FieldAppender(t.dialect, field) - field.Scan = FieldScanner(t.dialect, field) - field.IsZero = zeroChecker(field.StructField.Type) - - return field -} - -//--------------------------------------------------------------------------------------- - -func (t *Table) initRelations() { - for _, field := range t.relFields { - t.processRelation(field) - } - t.relFields = nil -} - -func (t *Table) processRelation(field *Field) { - if rel, ok := field.Tag.Option("rel"); ok { - t.initRelation(field, rel) - return - } - if field.Tag.HasOption("m2m") { - t.addRelation(t.m2mRelation(field)) - return - } - panic("not reached") -} - -func (t *Table) initRelation(field *Field, rel string) { - switch rel { - case "belongs-to": - t.addRelation(t.belongsToRelation(field)) - case "has-one": - t.addRelation(t.hasOneRelation(field)) - case "has-many": - t.addRelation(t.hasManyRelation(field)) - default: - panic(fmt.Errorf("bun: unknown relation=%s on field=%s", rel, field.GoName)) - } -} - -func (t *Table) addRelation(rel *Relation) { - if t.Relations == nil { - t.Relations = make(map[string]*Relation) - } - _, ok := t.Relations[rel.Field.GoName] - if ok { - panic(fmt.Errorf("%s already has %s", t, rel)) - } - t.Relations[rel.Field.GoName] = rel -} - -func (t *Table) belongsToRelation(field *Field) *Relation { - joinTable := t.dialect.Tables().InProgress(field.IndirectType) - if err := joinTable.CheckPKs(); err != nil { - panic(err) - } - - rel := &Relation{ - Type: BelongsToRelation, - Field: field, - JoinTable: joinTable, - } - - if field.Tag.HasOption("join_on") { - rel.Condition = field.Tag.Options["join_on"] - } - - rel.OnUpdate = "ON UPDATE NO ACTION" - if onUpdate, ok := field.Tag.Options["on_update"]; ok { - if len(onUpdate) > 1 { - panic(fmt.Errorf("bun: %s belongs-to %s: on_update option must be a single field", t.TypeName, field.GoName)) - } - - rule := strings.ToUpper(onUpdate[0]) - if !isKnownFKRule(rule) { - internal.Warn.Printf("bun: %s belongs-to %s: unknown on_update rule %s", t.TypeName, field.GoName, rule) - } - - s := fmt.Sprintf("ON UPDATE %s", rule) - rel.OnUpdate = s - } - - rel.OnDelete = "ON DELETE NO ACTION" - if onDelete, ok := field.Tag.Options["on_delete"]; ok { - if len(onDelete) > 1 { - panic(fmt.Errorf("bun: %s belongs-to %s: on_delete option must be a single field", t.TypeName, field.GoName)) - } - - rule := strings.ToUpper(onDelete[0]) - if !isKnownFKRule(rule) { - internal.Warn.Printf("bun: %s belongs-to %s: unknown on_delete rule %s", t.TypeName, field.GoName, rule) - } - s := fmt.Sprintf("ON DELETE %s", rule) - rel.OnDelete = s - } - - if join, ok := field.Tag.Options["join"]; ok { - baseColumns, joinColumns := parseRelationJoin(join) - for i, baseColumn := range baseColumns { - joinColumn := joinColumns[i] - - if f := t.FieldMap[baseColumn]; f != nil { - rel.BasePKs = append(rel.BasePKs, f) - } else { - panic(fmt.Errorf( - "bun: %s belongs-to %s: %s must have column %s", - t.TypeName, field.GoName, t.TypeName, baseColumn, - )) - } - - if f := joinTable.FieldMap[joinColumn]; f != nil { - rel.JoinPKs = append(rel.JoinPKs, f) - } else { - panic(fmt.Errorf( - "bun: %s belongs-to %s: %s must have column %s", - t.TypeName, field.GoName, joinTable.TypeName, joinColumn, - )) - } - } - return rel - } - - rel.JoinPKs = joinTable.PKs - fkPrefix := internal.Underscore(field.GoName) + "_" - for _, joinPK := range joinTable.PKs { - fkName := fkPrefix + joinPK.Name - if fk := t.FieldMap[fkName]; fk != nil { - rel.BasePKs = append(rel.BasePKs, fk) - continue - } - - if fk := t.FieldMap[joinPK.Name]; fk != nil { - rel.BasePKs = append(rel.BasePKs, fk) - continue - } - - panic(fmt.Errorf( - "bun: %s belongs-to %s: %s must have column %s "+ - "(to override, use join:base_column=join_column tag on %s field)", - t.TypeName, field.GoName, t.TypeName, fkName, field.GoName, - )) - } - return rel -} - -func (t *Table) hasOneRelation(field *Field) *Relation { - if err := t.CheckPKs(); err != nil { - panic(err) - } - - joinTable := t.dialect.Tables().InProgress(field.IndirectType) - rel := &Relation{ - Type: HasOneRelation, - Field: field, - JoinTable: joinTable, - } - - if field.Tag.HasOption("join_on") { - rel.Condition = field.Tag.Options["join_on"] - } - - if join, ok := field.Tag.Options["join"]; ok { - baseColumns, joinColumns := parseRelationJoin(join) - for i, baseColumn := range baseColumns { - if f := t.FieldMap[baseColumn]; f != nil { - rel.BasePKs = append(rel.BasePKs, f) - } else { - panic(fmt.Errorf( - "bun: %s has-one %s: %s must have column %s", - field.GoName, t.TypeName, t.TypeName, baseColumn, - )) - } - - joinColumn := joinColumns[i] - if f := joinTable.FieldMap[joinColumn]; f != nil { - rel.JoinPKs = append(rel.JoinPKs, f) - } else { - panic(fmt.Errorf( - "bun: %s has-one %s: %s must have column %s", - field.GoName, t.TypeName, joinTable.TypeName, joinColumn, - )) - } - } - return rel - } - - rel.BasePKs = t.PKs - fkPrefix := internal.Underscore(t.ModelName) + "_" - for _, pk := range t.PKs { - fkName := fkPrefix + pk.Name - if f := joinTable.FieldMap[fkName]; f != nil { - rel.JoinPKs = append(rel.JoinPKs, f) - continue - } - - if f := joinTable.FieldMap[pk.Name]; f != nil { - rel.JoinPKs = append(rel.JoinPKs, f) - continue - } - - panic(fmt.Errorf( - "bun: %s has-one %s: %s must have column %s "+ - "(to override, use join:base_column=join_column tag on %s field)", - field.GoName, t.TypeName, joinTable.TypeName, fkName, field.GoName, - )) - } - return rel -} - -func (t *Table) hasManyRelation(field *Field) *Relation { - if err := t.CheckPKs(); err != nil { - panic(err) - } - if field.IndirectType.Kind() != reflect.Slice { - panic(fmt.Errorf( - "bun: %s.%s has-many relation requires slice, got %q", - t.TypeName, field.GoName, field.IndirectType.Kind(), - )) - } - - joinTable := t.dialect.Tables().InProgress(indirectType(field.IndirectType.Elem())) - polymorphicValue, isPolymorphic := field.Tag.Option("polymorphic") - rel := &Relation{ - Type: HasManyRelation, - Field: field, - JoinTable: joinTable, - } - - if field.Tag.HasOption("join_on") { - rel.Condition = field.Tag.Options["join_on"] - } - - var polymorphicColumn string - - if join, ok := field.Tag.Options["join"]; ok { - baseColumns, joinColumns := parseRelationJoin(join) - for i, baseColumn := range baseColumns { - joinColumn := joinColumns[i] - - if isPolymorphic && baseColumn == "type" { - polymorphicColumn = joinColumn - continue - } - - if f := t.FieldMap[baseColumn]; f != nil { - rel.BasePKs = append(rel.BasePKs, f) - } else { - panic(fmt.Errorf( - "bun: %s has-many %s: %s must have column %s", - t.TypeName, field.GoName, t.TypeName, baseColumn, - )) - } - - if f := joinTable.FieldMap[joinColumn]; f != nil { - rel.JoinPKs = append(rel.JoinPKs, f) - } else { - panic(fmt.Errorf( - "bun: %s has-many %s: %s must have column %s", - t.TypeName, field.GoName, joinTable.TypeName, joinColumn, - )) - } - } - } else { - rel.BasePKs = t.PKs - fkPrefix := internal.Underscore(t.ModelName) + "_" - if isPolymorphic { - polymorphicColumn = fkPrefix + "type" - } - - for _, pk := range t.PKs { - joinColumn := fkPrefix + pk.Name - if fk := joinTable.FieldMap[joinColumn]; fk != nil { - rel.JoinPKs = append(rel.JoinPKs, fk) - continue - } - - if fk := joinTable.FieldMap[pk.Name]; fk != nil { - rel.JoinPKs = append(rel.JoinPKs, fk) - continue - } - - panic(fmt.Errorf( - "bun: %s has-many %s: %s must have column %s "+ - "(to override, use join:base_column=join_column tag on the field %s)", - t.TypeName, field.GoName, joinTable.TypeName, joinColumn, field.GoName, - )) - } - } - - if isPolymorphic { - rel.PolymorphicField = joinTable.FieldMap[polymorphicColumn] - if rel.PolymorphicField == nil { - panic(fmt.Errorf( - "bun: %s has-many %s: %s must have polymorphic column %s", - t.TypeName, field.GoName, joinTable.TypeName, polymorphicColumn, - )) - } - - if polymorphicValue == "" { - polymorphicValue = t.ModelName - } - rel.PolymorphicValue = polymorphicValue - } - - return rel -} - -func (t *Table) m2mRelation(field *Field) *Relation { - if field.IndirectType.Kind() != reflect.Slice { - panic(fmt.Errorf( - "bun: %s.%s m2m relation requires slice, got %q", - t.TypeName, field.GoName, field.IndirectType.Kind(), - )) - } - joinTable := t.dialect.Tables().InProgress(indirectType(field.IndirectType.Elem())) - - if err := t.CheckPKs(); err != nil { - panic(err) - } - if err := joinTable.CheckPKs(); err != nil { - panic(err) - } - - m2mTableName, ok := field.Tag.Option("m2m") - if !ok { - panic(fmt.Errorf("bun: %s must have m2m tag option", field.GoName)) - } - - m2mTable := t.dialect.Tables().ByName(m2mTableName) - if m2mTable == nil { - panic(fmt.Errorf( - "bun: can't find m2m %s table (use db.RegisterModel)", - m2mTableName, - )) - } - - rel := &Relation{ - Type: ManyToManyRelation, - Field: field, - JoinTable: joinTable, - M2MTable: m2mTable, - } - - if field.Tag.HasOption("join_on") { - rel.Condition = field.Tag.Options["join_on"] - } - - var leftColumn, rightColumn string - - if join, ok := field.Tag.Options["join"]; ok { - left, right := parseRelationJoin(join) - leftColumn = left[0] - rightColumn = right[0] - } else { - leftColumn = t.TypeName - rightColumn = joinTable.TypeName - } - - leftField := m2mTable.fieldByGoName(leftColumn) - if leftField == nil { - panic(fmt.Errorf( - "bun: %s many-to-many %s: %s must have field %s "+ - "(to override, use tag join:LeftField=RightField on field %s.%s", - t.TypeName, field.GoName, m2mTable.TypeName, leftColumn, t.TypeName, field.GoName, - )) - } - - rightField := m2mTable.fieldByGoName(rightColumn) - if rightField == nil { - panic(fmt.Errorf( - "bun: %s many-to-many %s: %s must have field %s "+ - "(to override, use tag join:LeftField=RightField on field %s.%s", - t.TypeName, field.GoName, m2mTable.TypeName, rightColumn, t.TypeName, field.GoName, - )) - } - - leftRel := m2mTable.belongsToRelation(leftField) - rel.BasePKs = leftRel.JoinPKs - rel.M2MBasePKs = leftRel.BasePKs - - rightRel := m2mTable.belongsToRelation(rightField) - rel.JoinPKs = rightRel.JoinPKs - rel.M2MJoinPKs = rightRel.BasePKs - - return rel -} - -//------------------------------------------------------------------------------ - -func (t *Table) Dialect() Dialect { return t.dialect } - -func (t *Table) HasBeforeAppendModelHook() bool { return t.flags.Has(beforeAppendModelHookFlag) } - -// DEPRECATED. Use HasBeforeScanRowHook. -func (t *Table) HasBeforeScanHook() bool { return t.flags.Has(beforeScanHookFlag) } - -// DEPRECATED. Use HasAfterScanRowHook. -func (t *Table) HasAfterScanHook() bool { return t.flags.Has(afterScanHookFlag) } - -func (t *Table) HasBeforeScanRowHook() bool { return t.flags.Has(beforeScanRowHookFlag) } -func (t *Table) HasAfterScanRowHook() bool { return t.flags.Has(afterScanRowHookFlag) } - -//------------------------------------------------------------------------------ - -func (t *Table) AppendNamedArg( - fmter Formatter, b []byte, name string, strct reflect.Value, -) ([]byte, bool) { - if field, ok := t.FieldMap[name]; ok { - return field.AppendValue(fmter, b, strct), true - } - return b, false -} - -func (t *Table) quoteTableName(s string) Safe { - // Don't quote if table name contains placeholder (?) or parentheses. - if strings.IndexByte(s, '?') >= 0 || - strings.IndexByte(s, '(') >= 0 || - strings.IndexByte(s, ')') >= 0 { - return Safe(s) - } - return t.quoteIdent(s) -} - -func (t *Table) quoteIdent(s string) Safe { - return Safe(NewFormatter(t.dialect).AppendIdent(nil, s)) -} - -func isKnownTableOption(name string) bool { - switch name { - case "table", "alias", "select": - return true - } - return false -} - -func isKnownFieldOption(name string) bool { - switch name { - case "column", - "alt", - "type", - "array", - "hstore", - "composite", - "multirange", - "json_use_number", - "msgpack", - "notnull", - "nullzero", - "default", - "unique", - "soft_delete", - "scanonly", - "skipupdate", - - "pk", - "autoincrement", - "rel", - "join", - "join_on", - "on_update", - "on_delete", - "m2m", - "polymorphic", - "identity": - return true - } - return false -} - -func isKnownFKRule(name string) bool { - switch name { - case "CASCADE", - "RESTRICT", - "SET NULL", - "SET DEFAULT": - return true - } - return false -} - -func parseRelationJoin(join []string) ([]string, []string) { - var ss []string - if len(join) == 1 { - ss = strings.Split(join[0], ",") - } else { - ss = join - } - - baseColumns := make([]string, len(ss)) - joinColumns := make([]string, len(ss)) - for i, s := range ss { - ss := strings.Split(strings.TrimSpace(s), "=") - if len(ss) != 2 { - panic(fmt.Errorf("can't parse relation join: %q", join)) - } - baseColumns[i] = ss[0] - joinColumns[i] = ss[1] - } - return baseColumns, joinColumns -} - -//------------------------------------------------------------------------------ - -func softDeleteFieldUpdater(field *Field) func(fv reflect.Value, tm time.Time) error { - typ := field.StructField.Type - - switch typ { - case timeType: - return func(fv reflect.Value, tm time.Time) error { - ptr := fv.Addr().Interface().(*time.Time) - *ptr = tm - return nil - } - case nullTimeType: - return func(fv reflect.Value, tm time.Time) error { - ptr := fv.Addr().Interface().(*sql.NullTime) - *ptr = sql.NullTime{Time: tm} - return nil - } - case nullIntType: - return func(fv reflect.Value, tm time.Time) error { - ptr := fv.Addr().Interface().(*sql.NullInt64) - *ptr = sql.NullInt64{Int64: tm.UnixNano()} - return nil - } - } - - switch field.IndirectType.Kind() { - case reflect.Int64: - return func(fv reflect.Value, tm time.Time) error { - ptr := fv.Addr().Interface().(*int64) - *ptr = tm.UnixNano() - return nil - } - case reflect.Ptr: - typ = typ.Elem() - default: - return softDeleteFieldUpdaterFallback(field) - } - - switch typ { //nolint:gocritic - case timeType: - return func(fv reflect.Value, tm time.Time) error { - fv.Set(reflect.ValueOf(&tm)) - return nil - } - } - - switch typ.Kind() { //nolint:gocritic - case reflect.Int64: - return func(fv reflect.Value, tm time.Time) error { - utime := tm.UnixNano() - fv.Set(reflect.ValueOf(&utime)) - return nil - } - } - - return softDeleteFieldUpdaterFallback(field) -} - -func softDeleteFieldUpdaterFallback(field *Field) func(fv reflect.Value, tm time.Time) error { - return func(fv reflect.Value, tm time.Time) error { - return field.ScanWithCheck(fv, tm) - } -} - -func makeIndex(a, b []int) []int { - dest := make([]int, 0, len(a)+len(b)) - dest = append(dest, a...) - dest = append(dest, b...) - return dest -} diff --git a/vendor/github.com/uptrace/bun/schema/tables.go b/vendor/github.com/uptrace/bun/schema/tables.go deleted file mode 100644 index e215e499d..000000000 --- a/vendor/github.com/uptrace/bun/schema/tables.go +++ /dev/null @@ -1,114 +0,0 @@ -package schema - -import ( - "fmt" - "reflect" - "sync" - - "github.com/puzpuzpuz/xsync/v3" -) - -type Tables struct { - dialect Dialect - - mu sync.Mutex - tables *xsync.MapOf[reflect.Type, *Table] - - inProgress map[reflect.Type]*Table -} - -func NewTables(dialect Dialect) *Tables { - return &Tables{ - dialect: dialect, - tables: xsync.NewMapOf[reflect.Type, *Table](), - inProgress: make(map[reflect.Type]*Table), - } -} - -func (t *Tables) Register(models ...interface{}) { - for _, model := range models { - _ = t.Get(reflect.TypeOf(model).Elem()) - } -} - -func (t *Tables) Get(typ reflect.Type) *Table { - typ = indirectType(typ) - if typ.Kind() != reflect.Struct { - panic(fmt.Errorf("got %s, wanted %s", typ.Kind(), reflect.Struct)) - } - - if v, ok := t.tables.Load(typ); ok { - return v - } - - t.mu.Lock() - defer t.mu.Unlock() - - if v, ok := t.tables.Load(typ); ok { - return v - } - - table := t.InProgress(typ) - table.initRelations() - - t.dialect.OnTable(table) - for _, field := range table.FieldMap { - if field.UserSQLType == "" { - field.UserSQLType = field.DiscoveredSQLType - } - if field.CreateTableSQLType == "" { - field.CreateTableSQLType = field.UserSQLType - } - } - - t.tables.Store(typ, table) - return table -} - -func (t *Tables) InProgress(typ reflect.Type) *Table { - if table, ok := t.inProgress[typ]; ok { - return table - } - - table := new(Table) - t.inProgress[typ] = table - table.init(t.dialect, typ) - - return table -} - -// ByModel gets the table by its Go name. -func (t *Tables) ByModel(name string) *Table { - var found *Table - t.tables.Range(func(typ reflect.Type, table *Table) bool { - if table.TypeName == name { - found = table - return false - } - return true - }) - return found -} - -// ByName gets the table by its SQL name. -func (t *Tables) ByName(name string) *Table { - var found *Table - t.tables.Range(func(typ reflect.Type, table *Table) bool { - if table.Name == name { - found = table - return false - } - return true - }) - return found -} - -// All returns all registered tables. -func (t *Tables) All() []*Table { - var found []*Table - t.tables.Range(func(typ reflect.Type, table *Table) bool { - found = append(found, table) - return true - }) - return found -} diff --git a/vendor/github.com/uptrace/bun/schema/zerochecker.go b/vendor/github.com/uptrace/bun/schema/zerochecker.go deleted file mode 100644 index 7c8418eaf..000000000 --- a/vendor/github.com/uptrace/bun/schema/zerochecker.go +++ /dev/null @@ -1,161 +0,0 @@ -package schema - -import ( - "database/sql/driver" - "reflect" -) - -var isZeroerType = reflect.TypeFor[isZeroer]() - -type isZeroer interface { - IsZero() bool -} - -func isZero(v interface{}) bool { - switch v := v.(type) { - case isZeroer: - return v.IsZero() - case string: - return v == "" - case []byte: - return v == nil - case int: - return v == 0 - case int64: - return v == 0 - case uint: - return v == 0 - case uint64: - return v == 0 - case float32: - return v == 0 - case float64: - return v == 0 - case int8: - return v == 0 - case int16: - return v == 0 - case int32: - return v == 0 - case uint8: - return v == 0 - case uint16: - return v == 0 - case uint32: - return v == 0 - default: - rv := reflect.ValueOf(v) - fn := zeroChecker(rv.Type()) - return fn(rv) - } -} - -type IsZeroerFunc func(reflect.Value) bool - -func zeroChecker(typ reflect.Type) IsZeroerFunc { - if typ.Implements(isZeroerType) { - return isZeroInterface - } - - kind := typ.Kind() - - if kind != reflect.Ptr { - ptr := reflect.PointerTo(typ) - if ptr.Implements(isZeroerType) { - return addrChecker(isZeroInterface) - } - } - - switch kind { - case reflect.Array: - if typ.Elem().Kind() == reflect.Uint8 { - return isZeroBytes - } - return isZeroLen - case reflect.String: - return isZeroLen - case reflect.Bool: - return isZeroBool - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - return isZeroInt - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: - return isZeroUint - case reflect.Float32, reflect.Float64: - return isZeroFloat - case reflect.Interface, reflect.Ptr, reflect.Slice, reflect.Map: - return isNil - } - - if typ.Implements(driverValuerType) { - return isZeroDriverValue - } - - return notZero -} - -func addrChecker(fn IsZeroerFunc) IsZeroerFunc { - return func(v reflect.Value) bool { - if !v.CanAddr() { - return false - } - return fn(v.Addr()) - } -} - -func isZeroInterface(v reflect.Value) bool { - if v.Kind() == reflect.Ptr && v.IsNil() { - return true - } - return v.Interface().(isZeroer).IsZero() -} - -func isZeroDriverValue(v reflect.Value) bool { - if v.Kind() == reflect.Ptr { - return v.IsNil() - } - - valuer := v.Interface().(driver.Valuer) - value, err := valuer.Value() - if err != nil { - return false - } - return value == nil -} - -func isZeroLen(v reflect.Value) bool { - return v.Len() == 0 -} - -func isNil(v reflect.Value) bool { - return v.IsNil() -} - -func isZeroBool(v reflect.Value) bool { - return !v.Bool() -} - -func isZeroInt(v reflect.Value) bool { - return v.Int() == 0 -} - -func isZeroUint(v reflect.Value) bool { - return v.Uint() == 0 -} - -func isZeroFloat(v reflect.Value) bool { - return v.Float() == 0 -} - -func isZeroBytes(v reflect.Value) bool { - b := v.Slice(0, v.Len()).Bytes() - for _, c := range b { - if c != 0 { - return false - } - } - return true -} - -func notZero(v reflect.Value) bool { - return false -} diff --git a/vendor/github.com/uptrace/bun/util.go b/vendor/github.com/uptrace/bun/util.go deleted file mode 100644 index 97ed9228a..000000000 --- a/vendor/github.com/uptrace/bun/util.go +++ /dev/null @@ -1,88 +0,0 @@ -package bun - -import ( - "fmt" - "reflect" - "strings" -) - -func indirect(v reflect.Value) reflect.Value { - switch v.Kind() { - case reflect.Interface: - return indirect(v.Elem()) - case reflect.Ptr: - return v.Elem() - default: - return v - } -} - -func walk(v reflect.Value, index []int, fn func(reflect.Value)) { - v = reflect.Indirect(v) - switch v.Kind() { - case reflect.Slice: - sliceLen := v.Len() - for i := 0; i < sliceLen; i++ { - visitField(v.Index(i), index, fn) - } - default: - visitField(v, index, fn) - } -} - -func visitField(v reflect.Value, index []int, fn func(reflect.Value)) { - v = reflect.Indirect(v) - if len(index) > 0 { - v = v.Field(index[0]) - if v.Kind() == reflect.Ptr && v.IsNil() { - return - } - walk(v, index[1:], fn) - } else { - fn(v) - } -} - -func typeByIndex(t reflect.Type, index []int) reflect.Type { - for _, x := range index { - switch t.Kind() { - case reflect.Ptr: - t = t.Elem() - case reflect.Slice: - t = indirectType(t.Elem()) - } - t = t.Field(x).Type - } - return indirectType(t) -} - -func indirectType(t reflect.Type) reflect.Type { - if t.Kind() == reflect.Ptr { - t = t.Elem() - } - return t -} - -func sliceElemType(v reflect.Value) reflect.Type { - elemType := v.Type().Elem() - if elemType.Kind() == reflect.Interface && v.Len() > 0 { - return indirect(v.Index(0).Elem()).Type() - } - return indirectType(elemType) -} - -// appendComment adds comment in the header of the query into buffer -func appendComment(b []byte, name string) []byte { - if name == "" { - return b - } - name = strings.Map(func(r rune) rune { - if r == '\x00' { - return -1 - } - return r - }, name) - name = strings.ReplaceAll(name, `/*`, `/\*`) - name = strings.ReplaceAll(name, `*/`, `*\/`) - return append(b, fmt.Sprintf("/* %s */ ", name)...) -} diff --git a/vendor/github.com/uptrace/bun/version.go b/vendor/github.com/uptrace/bun/version.go deleted file mode 100644 index e74eba8d4..000000000 --- a/vendor/github.com/uptrace/bun/version.go +++ /dev/null @@ -1,6 +0,0 @@ -package bun - -// Version is the current release version. -func Version() string { - return "1.2.9" -} diff --git a/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/.golangci.yml b/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/.golangci.yml deleted file mode 100644 index 65b3c9e6e..000000000 --- a/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/.golangci.yml +++ /dev/null @@ -1,5 +0,0 @@ -issues: - exclude-rules: - - text: 'Drivers should implement' - linters: - - staticcheck diff --git a/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/LICENSE b/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/LICENSE deleted file mode 100644 index 83bbb00f4..000000000 --- a/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/LICENSE +++ /dev/null @@ -1,24 +0,0 @@ -Copyright (c) 2020 github.com/uptrace/opentelemetry-go-extra Contributors. 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. diff --git a/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/README.md b/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/README.md deleted file mode 100644 index c8886453f..000000000 --- a/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/README.md +++ /dev/null @@ -1,119 +0,0 @@ -[](https://pkg.go.dev/github.com/uptrace/opentelemetry-go-extra/otelsql) - -# database/sql instrumentation for OpenTelemetry Go - -[OpenTelemetry database/sql](https://uptrace.dev/get/instrument/opentelemetry-database-sql.html) -instrumentation records database queries (including `Tx` and `Stmt` queries) and reports `DBStats` -metrics. - -## Installation - -```shell -go get github.com/uptrace/opentelemetry-go-extra/otelsql -``` - -## Usage - -To instrument database/sql, you need to connect to a database using the API provided by otelsql: - -| sql | otelsql | -| --------------------------- | ------------------------------- | -| `sql.Open(driverName, dsn)` | `otelsql.Open(driverName, dsn)` | -| `sql.OpenDB(connector)` | `otelsql.OpenDB(connector)` | - -```go -import ( - "github.com/uptrace/opentelemetry-go-extra/otelsql" - semconv "go.opentelemetry.io/otel/semconv/v1.10.0" -) - -db, err := otelsql.Open("sqlite", "file::memory:?cache=shared", - otelsql.WithAttributes(semconv.DBSystemSqlite), - otelsql.WithDBName("mydb")) -if err != nil { - panic(err) -} - -// db is *sql.DB -``` - -And then use context-aware API to propagate the active span via -[context](https://uptrace.dev/opentelemetry/go-tracing.html#context): - -```go -var num int -if err := db.QueryRowContext(ctx, "SELECT 42").Scan(&num); err != nil { - panic(err) -} -``` - -See [example](/example/) for details. - -## Options - -Both [otelsql.Open](https://pkg.go.dev/github.com/uptrace/opentelemetry-go-extra/otelsql#Open) and -[otelsql.OpenDB](https://pkg.go.dev/github.com/uptrace/opentelemetry-go-extra/otelsql#OpenDB) accept -the same [options](https://pkg.go.dev/github.com/uptrace/opentelemetry-go-extra/otelsql#Option): - -- [WithAttributes](https://pkg.go.dev/github.com/uptrace/opentelemetry-go-extra/otelsql#WithAttributes) - configures attributes that are used to create a span. -- [WithDBName](https://pkg.go.dev/github.com/uptrace/opentelemetry-go-extra/otelsql#WithDBName) - configures a `db.name` attribute. -- [WithDBSystem](https://pkg.go.dev/github.com/uptrace/opentelemetry-go-extra/otelsql#WithDBSystem) - configures a `db.system` attribute. When possible, you should prefer using WithAttributes and - [semconv](https://pkg.go.dev/go.opentelemetry.io/otel/semconv/v1.10.0), for example, - `otelsql.WithAttributes(semconv.DBSystemSqlite)`. - -## sqlboiler - -You can use otelsql to instrument [sqlboiler](https://github.com/volatiletech/sqlboiler) ORM: - -```go -import ( - "github.com/uptrace/opentelemetry-go-extra/otelsql" - semconv "go.opentelemetry.io/otel/semconv/v1.10.0" -) - -db, err := otelsql.Open("postgres", "dbname=fun user=abc", - otelsql.WithAttributes(semconv.DBSystemPostgreSQL)) -if err != nil { - return err -} - -boil.SetDB(db) -``` - -## GORM 1 - -You can use otelsql to instrument [GORM 1](https://v1.gorm.io/): - -```go -import ( - "github.com/jinzhu/gorm" - "github.com/uptrace/opentelemetry-go-extra/otelsql" - semconv "go.opentelemetry.io/otel/semconv/v1.10.0" -) - -// gormOpen is like gorm.Open, but it uses otelsql to instrument the database. -func gormOpen(driverName, dataSourceName string, opts ...otelsql.Option) (*gorm.DB, error) { - db, err := otelsql.Open(driverName, dataSourceName, opts...) - if err != nil { - return nil, err - } - return gorm.Open(driverName, db) -} - -db, err := gormOpen("mysql", "user:password@/dbname", - otelsql.WithAttributes(semconv.DBSystemMySQL)) -if err != nil { - panic(err) -} -``` - -To instrument GORM 2, use -[otelgorm](https://github.com/uptrace/opentelemetry-go-extra/tree/main/otelgorm). - -## Alternatives - -- https://github.com/XSAM/otelsql - different driver registration and no metrics. -- https://github.com/j2gg0s/otsql - like XSAM/otelsql but with Prometheus metrics. diff --git a/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/driver.go b/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/driver.go deleted file mode 100644 index c95cfb7e9..000000000 --- a/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/driver.go +++ /dev/null @@ -1,466 +0,0 @@ -package otelsql - -import ( - "context" - "database/sql" - "database/sql/driver" - "errors" - - "go.opentelemetry.io/otel/trace" -) - -// Open is a wrapper over sql.Open that instruments the sql.DB to record executed queries -// using OpenTelemetry API. -func Open(driverName, dsn string, opts ...Option) (*sql.DB, error) { - db, err := sql.Open(driverName, dsn) - if err != nil { - return nil, err - } - return patchDB(db, dsn, opts...) -} - -func patchDB(db *sql.DB, dsn string, opts ...Option) (*sql.DB, error) { - dbDriver := db.Driver() - - // Close the db since we are about to open a new one. - if err := db.Close(); err != nil { - return nil, err - } - - d := newDriver(dbDriver, opts) - - if _, ok := dbDriver.(driver.DriverContext); ok { - connector, err := d.OpenConnector(dsn) - if err != nil { - return nil, err - } - return sqlOpenDB(connector, d.instrum), nil - } - - return sqlOpenDB(&dsnConnector{ - driver: d, - dsn: dsn, - }, d.instrum), nil -} - -// OpenDB is a wrapper over sql.OpenDB that instruments the sql.DB to record executed queries -// using OpenTelemetry API. -func OpenDB(connector driver.Connector, opts ...Option) *sql.DB { - instrum := newDBInstrum(opts) - c := newConnector(connector.Driver(), connector, instrum) - return sqlOpenDB(c, instrum) -} - -func sqlOpenDB(connector driver.Connector, instrum *dbInstrum) *sql.DB { - db := sql.OpenDB(connector) - ReportDBStatsMetrics(db, WithMeterProvider(instrum.meterProvider), WithAttributes(instrum.attrs...)) - return db -} - -type dsnConnector struct { - driver *otelDriver - dsn string -} - -func (c *dsnConnector) Connect(ctx context.Context) (driver.Conn, error) { - var conn driver.Conn - err := c.driver.instrum.withSpan(ctx, "db.Connect", "", - func(ctx context.Context, span trace.Span) error { - var err error - conn, err = c.driver.Open(c.dsn) - return err - }) - return conn, err -} - -func (c *dsnConnector) Driver() driver.Driver { - return c.driver -} - -//------------------------------------------------------------------------------ - -type otelDriver struct { - driver driver.Driver - driverCtx driver.DriverContext - instrum *dbInstrum -} - -var _ driver.DriverContext = (*otelDriver)(nil) - -func newDriver(dr driver.Driver, opts []Option) *otelDriver { - driverCtx, _ := dr.(driver.DriverContext) - d := &otelDriver{ - driver: dr, - driverCtx: driverCtx, - instrum: newDBInstrum(opts), - } - return d -} - -func (d *otelDriver) Open(name string) (driver.Conn, error) { - conn, err := d.driver.Open(name) - if err != nil { - return nil, err - } - return newConn(conn, d.instrum), nil -} - -func (d *otelDriver) OpenConnector(dsn string) (driver.Connector, error) { - connector, err := d.driverCtx.OpenConnector(dsn) - if err != nil { - return nil, err - } - return newConnector(d, connector, d.instrum), nil -} - -//------------------------------------------------------------------------------ - -type connector struct { - driver.Connector - driver driver.Driver - instrum *dbInstrum -} - -var _ driver.Connector = (*connector)(nil) - -func newConnector(d driver.Driver, c driver.Connector, instrum *dbInstrum) *connector { - return &connector{ - driver: d, - Connector: c, - instrum: instrum, - } -} - -func (c *connector) Connect(ctx context.Context) (driver.Conn, error) { - var conn driver.Conn - if err := c.instrum.withSpan(ctx, "db.Connect", "", - func(ctx context.Context, span trace.Span) error { - var err error - conn, err = c.Connector.Connect(ctx) - return err - }); err != nil { - return nil, err - } - return newConn(conn, c.instrum), nil -} - -func (c *connector) Driver() driver.Driver { - return c.driver -} - -//------------------------------------------------------------------------------ - -type otelConn struct { - driver.Conn - - instrum *dbInstrum - - ping pingFunc - exec execFunc - execCtx execCtxFunc - query queryFunc - queryCtx queryCtxFunc - prepareCtx prepareCtxFunc - beginTx beginTxFunc - resetSession resetSessionFunc - checkNamedValue checkNamedValueFunc -} - -var _ driver.Conn = (*otelConn)(nil) - -func newConn(conn driver.Conn, instrum *dbInstrum) *otelConn { - cn := &otelConn{ - Conn: conn, - instrum: instrum, - } - - cn.ping = cn.createPingFunc(conn) - cn.exec = cn.createExecFunc(conn) - cn.execCtx = cn.createExecCtxFunc(conn) - cn.query = cn.createQueryFunc(conn) - cn.queryCtx = cn.createQueryCtxFunc(conn) - cn.prepareCtx = cn.createPrepareCtxFunc(conn) - cn.beginTx = cn.createBeginTxFunc(conn) - cn.resetSession = cn.createResetSessionFunc(conn) - cn.checkNamedValue = cn.createCheckNamedValueFunc(conn) - - return cn -} - -var _ driver.Pinger = (*otelConn)(nil) - -func (c *otelConn) Ping(ctx context.Context) error { - return c.ping(ctx) -} - -type pingFunc func(ctx context.Context) error - -func (c *otelConn) createPingFunc(conn driver.Conn) pingFunc { - if pinger, ok := conn.(driver.Pinger); ok { - return func(ctx context.Context) error { - return c.instrum.withSpan(ctx, "db.Ping", "", - func(ctx context.Context, span trace.Span) error { - return pinger.Ping(ctx) - }) - } - } - return func(ctx context.Context) error { - return driver.ErrSkip - } -} - -//------------------------------------------------------------------------------ - -var _ driver.Execer = (*otelConn)(nil) - -func (c *otelConn) Exec(query string, args []driver.Value) (driver.Result, error) { - return c.exec(query, args) -} - -type execFunc func(query string, args []driver.Value) (driver.Result, error) - -func (c *otelConn) createExecFunc(conn driver.Conn) execFunc { - if execer, ok := conn.(driver.Execer); ok { - return func(query string, args []driver.Value) (driver.Result, error) { - return execer.Exec(query, args) - } - } - return func(query string, args []driver.Value) (driver.Result, error) { - return nil, driver.ErrSkip - } -} - -//------------------------------------------------------------------------------ - -var _ driver.ExecerContext = (*otelConn)(nil) - -func (c *otelConn) ExecContext( - ctx context.Context, query string, args []driver.NamedValue, -) (driver.Result, error) { - return c.execCtx(ctx, query, args) -} - -type execCtxFunc func(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) - -func (c *otelConn) createExecCtxFunc(conn driver.Conn) execCtxFunc { - var fn execCtxFunc - - if execer, ok := conn.(driver.ExecerContext); ok { - fn = execer.ExecContext - } else { - fn = func(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) { - vArgs, err := namedValueToValue(args) - if err != nil { - return nil, err - } - return c.exec(query, vArgs) - } - } - - return func(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) { - var res driver.Result - if err := c.instrum.withSpan(ctx, "db.Exec", query, - func(ctx context.Context, span trace.Span) error { - var err error - res, err = fn(ctx, query, args) - if err != nil { - return err - } - - if span.IsRecording() { - rows, err := res.RowsAffected() - if err == nil { - span.SetAttributes(dbRowsAffected.Int64(rows)) - } - } - - return nil - }); err != nil { - return nil, err - } - return res, nil - } -} - -//------------------------------------------------------------------------------ - -var _ driver.Queryer = (*otelConn)(nil) - -func (c *otelConn) Query(query string, args []driver.Value) (driver.Rows, error) { - return c.query(query, args) -} - -type queryFunc func(query string, args []driver.Value) (driver.Rows, error) - -func (c *otelConn) createQueryFunc(conn driver.Conn) queryFunc { - if queryer, ok := c.Conn.(driver.Queryer); ok { - return func(query string, args []driver.Value) (driver.Rows, error) { - return queryer.Query(query, args) - } - } - return func(query string, args []driver.Value) (driver.Rows, error) { - return nil, driver.ErrSkip - } -} - -//------------------------------------------------------------------------------ - -var _ driver.QueryerContext = (*otelConn)(nil) - -func (c *otelConn) QueryContext( - ctx context.Context, query string, args []driver.NamedValue, -) (driver.Rows, error) { - return c.queryCtx(ctx, query, args) -} - -type queryCtxFunc func(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) - -func (c *otelConn) createQueryCtxFunc(conn driver.Conn) queryCtxFunc { - var fn queryCtxFunc - - if queryer, ok := c.Conn.(driver.QueryerContext); ok { - fn = queryer.QueryContext - } else { - fn = func(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) { - vArgs, err := namedValueToValue(args) - if err != nil { - return nil, err - } - return c.query(query, vArgs) - } - } - - return func(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) { - var rows driver.Rows - err := c.instrum.withSpan(ctx, "db.Query", query, - func(ctx context.Context, span trace.Span) error { - var err error - rows, err = fn(ctx, query, args) - return err - }) - return rows, err - } -} - -//------------------------------------------------------------------------------ - -var _ driver.ConnPrepareContext = (*otelConn)(nil) - -func (c *otelConn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) { - return c.prepareCtx(ctx, query) -} - -type prepareCtxFunc func(ctx context.Context, query string) (driver.Stmt, error) - -func (c *otelConn) createPrepareCtxFunc(conn driver.Conn) prepareCtxFunc { - var fn prepareCtxFunc - - if preparer, ok := c.Conn.(driver.ConnPrepareContext); ok { - fn = preparer.PrepareContext - } else { - fn = func(ctx context.Context, query string) (driver.Stmt, error) { - return c.Conn.Prepare(query) - } - } - - return func(ctx context.Context, query string) (driver.Stmt, error) { - var stmt driver.Stmt - if err := c.instrum.withSpan(ctx, "db.Prepare", query, - func(ctx context.Context, span trace.Span) error { - var err error - stmt, err = fn(ctx, query) - return err - }); err != nil { - return nil, err - } - return newStmt(stmt, query, c.instrum), nil - } -} - -var _ driver.ConnBeginTx = (*otelConn)(nil) - -func (c *otelConn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) { - return c.beginTx(ctx, opts) -} - -type beginTxFunc func(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) - -func (c *otelConn) createBeginTxFunc(conn driver.Conn) beginTxFunc { - var fn beginTxFunc - - if txor, ok := conn.(driver.ConnBeginTx); ok { - fn = txor.BeginTx - } else { - fn = func(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) { - return conn.Begin() - } - } - - return func(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) { - var tx driver.Tx - if err := c.instrum.withSpan(ctx, "db.Begin", "", - func(ctx context.Context, span trace.Span) error { - var err error - tx, err = fn(ctx, opts) - return err - }); err != nil { - return nil, err - } - return newTx(ctx, tx, c.instrum), nil - } -} - -//------------------------------------------------------------------------------ - -var _ driver.SessionResetter = (*otelConn)(nil) - -func (c *otelConn) ResetSession(ctx context.Context) error { - return c.resetSession(ctx) -} - -type resetSessionFunc func(ctx context.Context) error - -func (c *otelConn) createResetSessionFunc(conn driver.Conn) resetSessionFunc { - if resetter, ok := c.Conn.(driver.SessionResetter); ok { - return func(ctx context.Context) error { - return resetter.ResetSession(ctx) - } - } - return func(ctx context.Context) error { - return driver.ErrSkip - } -} - -//------------------------------------------------------------------------------ - -var _ driver.NamedValueChecker = (*otelConn)(nil) - -func (c *otelConn) CheckNamedValue(value *driver.NamedValue) error { - return c.checkNamedValue(value) -} - -type checkNamedValueFunc func(*driver.NamedValue) error - -func (c *otelConn) createCheckNamedValueFunc(conn driver.Conn) checkNamedValueFunc { - if checker, ok := c.Conn.(driver.NamedValueChecker); ok { - return func(value *driver.NamedValue) error { - return checker.CheckNamedValue(value) - } - } - return func(value *driver.NamedValue) error { - return driver.ErrSkip - } -} - -//------------------------------------------------------------------------------ - -func namedValueToValue(named []driver.NamedValue) ([]driver.Value, error) { - args := make([]driver.Value, len(named)) - for n, param := range named { - if len(param.Name) > 0 { - return nil, errors.New("otelsql: driver does not support named parameters") - } - args[n] = param.Value - } - return args, nil -} diff --git a/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/otel.go b/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/otel.go deleted file mode 100644 index df87fe5a1..000000000 --- a/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/otel.go +++ /dev/null @@ -1,252 +0,0 @@ -package otelsql - -import ( - "context" - "database/sql" - "database/sql/driver" - "io" - "time" - - "go.opentelemetry.io/otel" - "go.opentelemetry.io/otel/attribute" - "go.opentelemetry.io/otel/codes" - "go.opentelemetry.io/otel/metric" - semconv "go.opentelemetry.io/otel/semconv/v1.10.0" - "go.opentelemetry.io/otel/trace" -) - -const instrumName = "github.com/uptrace/opentelemetry-go-extra/otelsql" - -var dbRowsAffected = attribute.Key("db.rows_affected") - -type config struct { - tracerProvider trace.TracerProvider - tracer trace.Tracer //nolint:structcheck - - meterProvider metric.MeterProvider - meter metric.Meter - - attrs []attribute.KeyValue - - queryFormatter func(query string) string -} - -func newConfig(opts []Option) *config { - c := &config{ - tracerProvider: otel.GetTracerProvider(), - meterProvider: otel.GetMeterProvider(), - } - for _, opt := range opts { - opt(c) - } - return c -} - -func (c *config) formatQuery(query string) string { - if c.queryFormatter != nil { - return c.queryFormatter(query) - } - return query -} - -type dbInstrum struct { - *config - - queryHistogram metric.Int64Histogram -} - -func newDBInstrum(opts []Option) *dbInstrum { - t := &dbInstrum{ - config: newConfig(opts), - } - - if t.tracer == nil { - t.tracer = t.tracerProvider.Tracer(instrumName) - } - if t.meter == nil { - t.meter = t.meterProvider.Meter(instrumName) - } - - var err error - t.queryHistogram, err = t.meter.Int64Histogram( - "go.sql.query_timing", - metric.WithDescription("Timing of processed queries"), - metric.WithUnit("milliseconds"), - ) - if err != nil { - panic(err) - } - - return t -} - -func (t *dbInstrum) withSpan( - ctx context.Context, - spanName string, - query string, - fn func(ctx context.Context, span trace.Span) error, -) error { - var startTime time.Time - if query != "" { - startTime = time.Now() - } - - attrs := make([]attribute.KeyValue, 0, len(t.attrs)+1) - attrs = append(attrs, t.attrs...) - if query != "" { - attrs = append(attrs, semconv.DBStatementKey.String(t.formatQuery(query))) - } - - ctx, span := t.tracer.Start(ctx, spanName, - trace.WithSpanKind(trace.SpanKindClient), - trace.WithAttributes(attrs...)) - err := fn(ctx, span) - defer span.End() - - if query != "" { - t.queryHistogram.Record(ctx, time.Since(startTime).Milliseconds(), metric.WithAttributes(t.attrs...)) - } - - if !span.IsRecording() { - return err - } - - switch err { - case nil, - driver.ErrSkip, - io.EOF, // end of rows iterator - sql.ErrNoRows: - // ignore - default: - span.RecordError(err) - span.SetStatus(codes.Error, err.Error()) - } - - return err -} - -type Option func(c *config) - -// WithTracerProvider configures a tracer provider that is used to create a tracer. -func WithTracerProvider(tracerProvider trace.TracerProvider) Option { - return func(c *config) { - c.tracerProvider = tracerProvider - } -} - -// WithAttributes configures attributes that are used to create a span. -func WithAttributes(attrs ...attribute.KeyValue) Option { - return func(c *config) { - c.attrs = append(c.attrs, attrs...) - } -} - -// WithDBSystem configures a db.system attribute. You should prefer using -// WithAttributes and semconv, for example, `otelsql.WithAttributes(semconv.DBSystemSqlite)`. -func WithDBSystem(system string) Option { - return func(c *config) { - c.attrs = append(c.attrs, semconv.DBSystemKey.String(system)) - } -} - -// WithDBName configures a db.name attribute. -func WithDBName(name string) Option { - return func(c *config) { - c.attrs = append(c.attrs, semconv.DBNameKey.String(name)) - } -} - -// WithMeterProvider configures a metric.Meter used to create instruments. -func WithMeterProvider(meterProvider metric.MeterProvider) Option { - return func(c *config) { - c.meterProvider = meterProvider - } -} - -// WithQueryFormatter configures a query formatter -func WithQueryFormatter(queryFormatter func(query string) string) Option { - return func(c *config) { - c.queryFormatter = queryFormatter - } -} - -// ReportDBStatsMetrics reports DBStats metrics using OpenTelemetry Metrics API. -func ReportDBStatsMetrics(db *sql.DB, opts ...Option) { - cfg := newConfig(opts) - - if cfg.meter == nil { - cfg.meter = cfg.meterProvider.Meter(instrumName) - } - - meter := cfg.meter - labels := cfg.attrs - - maxOpenConns, _ := meter.Int64ObservableGauge( - "go.sql.connections_max_open", - metric.WithDescription("Maximum number of open connections to the database"), - ) - openConns, _ := meter.Int64ObservableGauge( - "go.sql.connections_open", - metric.WithDescription("The number of established connections both in use and idle"), - ) - inUseConns, _ := meter.Int64ObservableGauge( - "go.sql.connections_in_use", - metric.WithDescription("The number of connections currently in use"), - ) - idleConns, _ := meter.Int64ObservableGauge( - "go.sql.connections_idle", - metric.WithDescription("The number of idle connections"), - ) - connsWaitCount, _ := meter.Int64ObservableCounter( - "go.sql.connections_wait_count", - metric.WithDescription("The total number of connections waited for"), - ) - connsWaitDuration, _ := meter.Int64ObservableCounter( - "go.sql.connections_wait_duration", - metric.WithDescription("The total time blocked waiting for a new connection"), - metric.WithUnit("nanoseconds"), - ) - connsClosedMaxIdle, _ := meter.Int64ObservableCounter( - "go.sql.connections_closed_max_idle", - metric.WithDescription("The total number of connections closed due to SetMaxIdleConns"), - ) - connsClosedMaxIdleTime, _ := meter.Int64ObservableCounter( - "go.sql.connections_closed_max_idle_time", - metric.WithDescription("The total number of connections closed due to SetConnMaxIdleTime"), - ) - connsClosedMaxLifetime, _ := meter.Int64ObservableCounter( - "go.sql.connections_closed_max_lifetime", - metric.WithDescription("The total number of connections closed due to SetConnMaxLifetime"), - ) - - if _, err := meter.RegisterCallback( - func(ctx context.Context, o metric.Observer) error { - stats := db.Stats() - - o.ObserveInt64(maxOpenConns, int64(stats.MaxOpenConnections), metric.WithAttributes(labels...)) - - o.ObserveInt64(openConns, int64(stats.OpenConnections), metric.WithAttributes(labels...)) - o.ObserveInt64(inUseConns, int64(stats.InUse), metric.WithAttributes(labels...)) - o.ObserveInt64(idleConns, int64(stats.Idle), metric.WithAttributes(labels...)) - - o.ObserveInt64(connsWaitCount, stats.WaitCount, metric.WithAttributes(labels...)) - o.ObserveInt64(connsWaitDuration, int64(stats.WaitDuration), metric.WithAttributes(labels...)) - o.ObserveInt64(connsClosedMaxIdle, stats.MaxIdleClosed, metric.WithAttributes(labels...)) - o.ObserveInt64(connsClosedMaxIdleTime, stats.MaxIdleTimeClosed, metric.WithAttributes(labels...)) - o.ObserveInt64(connsClosedMaxLifetime, stats.MaxLifetimeClosed, metric.WithAttributes(labels...)) - - return nil - }, - maxOpenConns, - openConns, - inUseConns, - idleConns, - connsWaitCount, - connsWaitDuration, - connsClosedMaxIdle, - connsClosedMaxIdleTime, - connsClosedMaxLifetime, - ); err != nil { - panic(err) - } -} diff --git a/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/stmt.go b/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/stmt.go deleted file mode 100644 index e87a1e73f..000000000 --- a/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/stmt.go +++ /dev/null @@ -1,120 +0,0 @@ -package otelsql - -import ( - "context" - "database/sql/driver" - - "go.opentelemetry.io/otel/trace" -) - -type otelStmt struct { - driver.Stmt - - query string - instrum *dbInstrum - - execCtx stmtExecCtxFunc - queryCtx stmtQueryCtxFunc -} - -var _ driver.Stmt = (*otelStmt)(nil) - -func newStmt(stmt driver.Stmt, query string, instrum *dbInstrum) *otelStmt { - s := &otelStmt{ - Stmt: stmt, - query: query, - instrum: instrum, - } - s.execCtx = s.createExecCtxFunc(stmt) - s.queryCtx = s.createQueryCtxFunc(stmt) - return s -} - -//------------------------------------------------------------------------------ - -var _ driver.StmtExecContext = (*otelStmt)(nil) - -func (stmt *otelStmt) ExecContext( - ctx context.Context, args []driver.NamedValue, -) (driver.Result, error) { - return stmt.execCtx(ctx, args) -} - -type stmtExecCtxFunc func(ctx context.Context, args []driver.NamedValue) (driver.Result, error) - -func (s *otelStmt) createExecCtxFunc(stmt driver.Stmt) stmtExecCtxFunc { - var fn stmtExecCtxFunc - - if execer, ok := s.Stmt.(driver.StmtExecContext); ok { - fn = execer.ExecContext - } else { - fn = func(ctx context.Context, args []driver.NamedValue) (driver.Result, error) { - vArgs, err := namedValueToValue(args) - if err != nil { - return nil, err - } - return stmt.Exec(vArgs) - } - } - - return func(ctx context.Context, args []driver.NamedValue) (driver.Result, error) { - var res driver.Result - err := s.instrum.withSpan(ctx, "stmt.Exec", s.query, - func(ctx context.Context, span trace.Span) error { - var err error - res, err = fn(ctx, args) - if err != nil { - return err - } - - if span.IsRecording() { - rows, err := res.RowsAffected() - if err == nil { - span.SetAttributes(dbRowsAffected.Int64(rows)) - } - } - - return nil - }) - return res, err - } -} - -//------------------------------------------------------------------------------ - -var _ driver.StmtQueryContext = (*otelStmt)(nil) - -func (stmt *otelStmt) QueryContext( - ctx context.Context, args []driver.NamedValue, -) (driver.Rows, error) { - return stmt.queryCtx(ctx, args) -} - -type stmtQueryCtxFunc func(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) - -func (s *otelStmt) createQueryCtxFunc(stmt driver.Stmt) stmtQueryCtxFunc { - var fn stmtQueryCtxFunc - - if queryer, ok := s.Stmt.(driver.StmtQueryContext); ok { - fn = queryer.QueryContext - } else { - fn = func(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) { - vArgs, err := namedValueToValue(args) - if err != nil { - return nil, err - } - return s.Query(vArgs) - } - } - - return func(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) { - var rows driver.Rows - err := s.instrum.withSpan(ctx, "stmt.Query", s.query, - func(ctx context.Context, span trace.Span) error { - var err error - rows, err = fn(ctx, args) - return err - }) - return rows, err - } -} diff --git a/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/tx.go b/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/tx.go deleted file mode 100644 index c4bd55e13..000000000 --- a/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/tx.go +++ /dev/null @@ -1,38 +0,0 @@ -package otelsql - -import ( - "context" - "database/sql/driver" - - "go.opentelemetry.io/otel/trace" -) - -type otelTx struct { - ctx context.Context - tx driver.Tx - instrum *dbInstrum -} - -var _ driver.Tx = (*otelTx)(nil) - -func newTx(ctx context.Context, tx driver.Tx, instrum *dbInstrum) *otelTx { - return &otelTx{ - ctx: ctx, - tx: tx, - instrum: instrum, - } -} - -func (tx *otelTx) Commit() error { - return tx.instrum.withSpan(tx.ctx, "tx.Commit", "", - func(ctx context.Context, span trace.Span) error { - return tx.tx.Commit() - }) -} - -func (tx *otelTx) Rollback() error { - return tx.instrum.withSpan(tx.ctx, "tx.Rollback", "", - func(ctx context.Context, span trace.Span) error { - return tx.tx.Rollback() - }) -} diff --git a/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/version.go b/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/version.go deleted file mode 100644 index 2156ada32..000000000 --- a/vendor/github.com/uptrace/opentelemetry-go-extra/otelsql/version.go +++ /dev/null @@ -1,6 +0,0 @@ -package otelsql - -// Version is the current release version. -func Version() string { - return "0.3.2" -} |