diff options
Diffstat (limited to 'vendor/github.com/uptrace')
91 files changed, 0 insertions, 16035 deletions
diff --git a/vendor/github.com/uptrace/bun/.gitignore b/vendor/github.com/uptrace/bun/.gitignore deleted file mode 100644 index 174474c57..000000000 --- a/vendor/github.com/uptrace/bun/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -# Patterns for files created by this project. -# For other files, use global gitignore. -*.s3db 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 1738c901a..000000000 --- a/vendor/github.com/uptrace/bun/CHANGELOG.md +++ /dev/null @@ -1,605 +0,0 @@ -## [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 appeding 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 comming 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 logoutput 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 579b96f8f..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/go-bun/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 690958de0..000000000 --- a/vendor/github.com/uptrace/bun/Makefile +++ /dev/null @@ -1,30 +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 go test && \ - go vet); \ - done - -go_mod_tidy: - go get -u && go mod tidy -go=1.17 - set -e; for dir in $(ALL_GO_MOD_DIRS); do \ - echo "go mod tidy in $${dir}"; \ - (cd "$${dir}" && \ - go get -u ./... && \ - go mod tidy -go=1.17); \ - 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 0d1c2c6c2..000000000 --- a/vendor/github.com/uptrace/bun/README.md +++ /dev/null @@ -1,320 +0,0 @@ -# SQL-first Golang ORM for PostgreSQL, MySQL, MSSQL, and SQLite - -[](https://github.com/uptrace/bun/actions) -[](https://pkg.go.dev/github.com/uptrace/bun) -[](https://bun.uptrace.dev/) -[](https://discord.gg/rWtp5Aj) - -> Bun is brought to you by :star: [**uptrace/uptrace**](https://github.com/uptrace/uptrace). Uptrace -> is an open source and blazingly fast -> [distributed tracing tool](https://get.uptrace.dev/compare/distributed-tracing-tools.html) powered -> by OpenTelemetry and ClickHouse. Give it a star as well! - -## 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). -- [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) - -Projects using Bun: - -- [gotosocial](https://github.com/superseriousbusiness/gotosocial) - Golang fediverse server. -- [alexedwards/scs](https://github.com/alexedwards/scs) - HTTP Session Management for Go. -- [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. -- [RealWorld app](https://github.com/go-bun/bun-realworld-app) -- And hundreds more. - -## Benchmark - -[https://github.com/davars/dbeval](https://github.com/davars/dbeval) - -<details> -<summary>results</summary> - -``` -BenchmarkInsert -BenchmarkInsert/*dbeval.Memory/Authors -BenchmarkInsert/*dbeval.Memory/Authors-4 84450 12104 ns/op 2623 B/op 70 allocs/op -BenchmarkInsert/*dbeval.Xorm/Authors -BenchmarkInsert/*dbeval.Xorm/Authors-4 7291 153505 ns/op 9024 B/op 311 allocs/op -BenchmarkInsert/*dbeval.UpperDB/Authors -BenchmarkInsert/*dbeval.UpperDB/Authors-4 4608 223672 ns/op 24160 B/op 1100 allocs/op -BenchmarkInsert/*dbeval.Bun/Authors -BenchmarkInsert/*dbeval.Bun/Authors-4 6034 186439 ns/op 6818 B/op 80 allocs/op -BenchmarkInsert/*dbeval.PQ/Authors -BenchmarkInsert/*dbeval.PQ/Authors-4 1141 907494 ns/op 6487 B/op 193 allocs/op -BenchmarkInsert/*dbeval.SQLX/Authors -BenchmarkInsert/*dbeval.SQLX/Authors-4 1165 916987 ns/op 10089 B/op 271 allocs/op -BenchmarkInsert/*dbeval.Ozzo/Authors -BenchmarkInsert/*dbeval.Ozzo/Authors-4 1105 1058082 ns/op 27826 B/op 588 allocs/op -BenchmarkInsert/*dbeval.PGXStdlib/Authors -BenchmarkInsert/*dbeval.PGXStdlib/Authors-4 1228 900207 ns/op 6032 B/op 180 allocs/op -BenchmarkInsert/*dbeval.Gorm/Authors -BenchmarkInsert/*dbeval.Gorm/Authors-4 946 1184285 ns/op 35634 B/op 918 allocs/op -BenchmarkInsert/*dbeval.PGX/Authors -BenchmarkInsert/*dbeval.PGX/Authors-4 1116 923728 ns/op 3839 B/op 130 allocs/op -BenchmarkInsert/*dbeval.DBR/Authors -BenchmarkInsert/*dbeval.DBR/Authors-4 5800 183982 ns/op 8646 B/op 230 allocs/op -BenchmarkInsert/*dbeval.GoPG/Authors -BenchmarkInsert/*dbeval.GoPG/Authors-4 6110 173923 ns/op 2906 B/op 87 allocs/op - -BenchmarkInsert/*dbeval.DBR/Articles -BenchmarkInsert/*dbeval.DBR/Articles-4 1706 684466 ns/op 133346 B/op 1614 allocs/op -BenchmarkInsert/*dbeval.PQ/Articles -BenchmarkInsert/*dbeval.PQ/Articles-4 884 1249791 ns/op 100403 B/op 1491 allocs/op -BenchmarkInsert/*dbeval.PGX/Articles -BenchmarkInsert/*dbeval.PGX/Articles-4 916 1288143 ns/op 83539 B/op 1392 allocs/op -BenchmarkInsert/*dbeval.GoPG/Articles -BenchmarkInsert/*dbeval.GoPG/Articles-4 1726 622639 ns/op 78638 B/op 1359 allocs/op -BenchmarkInsert/*dbeval.SQLX/Articles -BenchmarkInsert/*dbeval.SQLX/Articles-4 860 1262599 ns/op 92030 B/op 1574 allocs/op -BenchmarkInsert/*dbeval.Gorm/Articles -BenchmarkInsert/*dbeval.Gorm/Articles-4 782 1421550 ns/op 136534 B/op 2411 allocs/op -BenchmarkInsert/*dbeval.PGXStdlib/Articles -BenchmarkInsert/*dbeval.PGXStdlib/Articles-4 938 1230576 ns/op 86743 B/op 1441 allocs/op -BenchmarkInsert/*dbeval.Bun/Articles -BenchmarkInsert/*dbeval.Bun/Articles-4 1843 626681 ns/op 101610 B/op 1323 allocs/op -BenchmarkInsert/*dbeval.Xorm/Articles -BenchmarkInsert/*dbeval.Xorm/Articles-4 1677 650244 ns/op 126677 B/op 1752 allocs/op -BenchmarkInsert/*dbeval.Memory/Articles -BenchmarkInsert/*dbeval.Memory/Articles-4 1988 1223308 ns/op 77576 B/op 1310 allocs/op -BenchmarkInsert/*dbeval.UpperDB/Articles -BenchmarkInsert/*dbeval.UpperDB/Articles-4 1696 687130 ns/op 139680 B/op 2862 allocs/op -BenchmarkInsert/*dbeval.Ozzo/Articles -BenchmarkInsert/*dbeval.Ozzo/Articles-4 697 1496859 ns/op 114780 B/op 1950 allocs/op - -BenchmarkFindAuthorByID -BenchmarkFindAuthorByID/*dbeval.UpperDB -BenchmarkFindAuthorByID/*dbeval.UpperDB-4 10184 117527 ns/op 9953 B/op 441 allocs/op -BenchmarkFindAuthorByID/*dbeval.Bun -BenchmarkFindAuthorByID/*dbeval.Bun-4 20716 54261 ns/op 5096 B/op 15 allocs/op -BenchmarkFindAuthorByID/*dbeval.Ozzo -BenchmarkFindAuthorByID/*dbeval.Ozzo-4 11166 91043 ns/op 3088 B/op 64 allocs/op -BenchmarkFindAuthorByID/*dbeval.PQ -BenchmarkFindAuthorByID/*dbeval.PQ-4 13875 86171 ns/op 844 B/op 24 allocs/op -BenchmarkFindAuthorByID/*dbeval.PGX -BenchmarkFindAuthorByID/*dbeval.PGX-4 13846 79983 ns/op 719 B/op 15 allocs/op -BenchmarkFindAuthorByID/*dbeval.Memory -BenchmarkFindAuthorByID/*dbeval.Memory-4 14113720 82.33 ns/op 0 B/op 0 allocs/op -BenchmarkFindAuthorByID/*dbeval.Xorm -BenchmarkFindAuthorByID/*dbeval.Xorm-4 12027 98519 ns/op 3633 B/op 106 allocs/op -BenchmarkFindAuthorByID/*dbeval.Gorm -BenchmarkFindAuthorByID/*dbeval.Gorm-4 11521 102241 ns/op 6592 B/op 143 allocs/op -BenchmarkFindAuthorByID/*dbeval.PGXStdlib -BenchmarkFindAuthorByID/*dbeval.PGXStdlib-4 13933 82626 ns/op 1174 B/op 28 allocs/op -BenchmarkFindAuthorByID/*dbeval.DBR -BenchmarkFindAuthorByID/*dbeval.DBR-4 21920 51175 ns/op 1756 B/op 39 allocs/op -BenchmarkFindAuthorByID/*dbeval.SQLX -BenchmarkFindAuthorByID/*dbeval.SQLX-4 13603 80788 ns/op 1327 B/op 32 allocs/op -BenchmarkFindAuthorByID/*dbeval.GoPG -BenchmarkFindAuthorByID/*dbeval.GoPG-4 23174 50042 ns/op 869 B/op 17 allocs/op - -BenchmarkFindAuthorByName -BenchmarkFindAuthorByName/*dbeval.SQLX -BenchmarkFindAuthorByName/*dbeval.SQLX-4 1070 1065272 ns/op 126348 B/op 4018 allocs/op -BenchmarkFindAuthorByName/*dbeval.Bun -BenchmarkFindAuthorByName/*dbeval.Bun-4 877 1231377 ns/op 115803 B/op 5005 allocs/op -BenchmarkFindAuthorByName/*dbeval.Xorm -BenchmarkFindAuthorByName/*dbeval.Xorm-4 471 2345445 ns/op 455711 B/op 19080 allocs/op -BenchmarkFindAuthorByName/*dbeval.DBR -BenchmarkFindAuthorByName/*dbeval.DBR-4 954 1089977 ns/op 120070 B/op 6023 allocs/op -BenchmarkFindAuthorByName/*dbeval.PQ -BenchmarkFindAuthorByName/*dbeval.PQ-4 1333 784400 ns/op 87159 B/op 4006 allocs/op -BenchmarkFindAuthorByName/*dbeval.GoPG -BenchmarkFindAuthorByName/*dbeval.GoPG-4 1580 770966 ns/op 87525 B/op 3028 allocs/op -BenchmarkFindAuthorByName/*dbeval.UpperDB -BenchmarkFindAuthorByName/*dbeval.UpperDB-4 789 1314164 ns/op 190689 B/op 6428 allocs/op -BenchmarkFindAuthorByName/*dbeval.Ozzo -BenchmarkFindAuthorByName/*dbeval.Ozzo-4 948 1255282 ns/op 238764 B/op 6053 allocs/op -BenchmarkFindAuthorByName/*dbeval.PGXStdlib -BenchmarkFindAuthorByName/*dbeval.PGXStdlib-4 1279 920391 ns/op 126163 B/op 4014 allocs/op -BenchmarkFindAuthorByName/*dbeval.PGX -BenchmarkFindAuthorByName/*dbeval.PGX-4 1364 780970 ns/op 101967 B/op 2028 allocs/op -BenchmarkFindAuthorByName/*dbeval.Gorm -BenchmarkFindAuthorByName/*dbeval.Gorm-4 340 3445818 ns/op 1573637 B/op 27102 allocs/op -BenchmarkFindAuthorByName/*dbeval.Memory -BenchmarkFindAuthorByName/*dbeval.Memory-4 38081223 31.24 ns/op 0 B/op 0 allocs/op - -BenchmarkRecentArticles -BenchmarkRecentArticles/*dbeval.PGXStdlib -BenchmarkRecentArticles/*dbeval.PGXStdlib-4 358 3344119 ns/op 3425578 B/op 14177 allocs/op -BenchmarkRecentArticles/*dbeval.GoPG -BenchmarkRecentArticles/*dbeval.GoPG-4 364 3156372 ns/op 1794091 B/op 10032 allocs/op -BenchmarkRecentArticles/*dbeval.Xorm -BenchmarkRecentArticles/*dbeval.Xorm-4 157 7567835 ns/op 5018011 B/op 81425 allocs/op -BenchmarkRecentArticles/*dbeval.Gorm -BenchmarkRecentArticles/*dbeval.Gorm-4 139 7980084 ns/op 6776277 B/op 85418 allocs/op -BenchmarkRecentArticles/*dbeval.SQLX -BenchmarkRecentArticles/*dbeval.SQLX-4 338 3289802 ns/op 3425890 B/op 14181 allocs/op -BenchmarkRecentArticles/*dbeval.Ozzo -BenchmarkRecentArticles/*dbeval.Ozzo-4 320 3508322 ns/op 4025966 B/op 18207 allocs/op -BenchmarkRecentArticles/*dbeval.DBR -BenchmarkRecentArticles/*dbeval.DBR-4 237 5248644 ns/op 3331003 B/op 21370 allocs/op -BenchmarkRecentArticles/*dbeval.Bun -BenchmarkRecentArticles/*dbeval.Bun-4 280 4528582 ns/op 1864362 B/op 15965 allocs/op -BenchmarkRecentArticles/*dbeval.UpperDB -BenchmarkRecentArticles/*dbeval.UpperDB-4 297 3704663 ns/op 3607287 B/op 18542 allocs/op -BenchmarkRecentArticles/*dbeval.PQ -BenchmarkRecentArticles/*dbeval.PQ-4 308 3489229 ns/op 3277050 B/op 17359 allocs/op -BenchmarkRecentArticles/*dbeval.Memory -BenchmarkRecentArticles/*dbeval.Memory-4 29590380 42.27 ns/op 0 B/op 0 allocs/op -BenchmarkRecentArticles/*dbeval.PGX -BenchmarkRecentArticles/*dbeval.PGX-4 356 3345500 ns/op 3297316 B/op 6226 allocs/op -``` - -</details> - -[https://github.com/frederikhors/orm-benchmark](https://github.com/frederikhors/orm-benchmark) - -<details> -<summary>results</summary> - -``` - 4000 times - Insert - raw_stmt: 0.38s 94280 ns/op 718 B/op 14 allocs/op - raw: 0.39s 96719 ns/op 718 B/op 13 allocs/op - beego_orm: 0.48s 118994 ns/op 2411 B/op 56 allocs/op - bun: 0.57s 142285 ns/op 918 B/op 12 allocs/op - pg: 0.58s 145496 ns/op 1235 B/op 12 allocs/op - gorm: 0.70s 175294 ns/op 6665 B/op 88 allocs/op - xorm: 0.76s 189533 ns/op 3032 B/op 94 allocs/op - - 4000 times - MultiInsert 100 row - raw: 4.59s 1147385 ns/op 135155 B/op 916 allocs/op - raw_stmt: 4.59s 1148137 ns/op 131076 B/op 916 allocs/op - beego_orm: 5.50s 1375637 ns/op 179962 B/op 2747 allocs/op - bun: 6.18s 1544648 ns/op 4265 B/op 214 allocs/op - pg: 7.01s 1753495 ns/op 5039 B/op 114 allocs/op - gorm: 9.52s 2379219 ns/op 293956 B/op 3729 allocs/op - xorm: 11.66s 2915478 ns/op 286140 B/op 7422 allocs/op - - 4000 times - Update - raw_stmt: 0.26s 65781 ns/op 773 B/op 14 allocs/op - raw: 0.31s 77209 ns/op 757 B/op 13 allocs/op - beego_orm: 0.43s 107064 ns/op 1802 B/op 47 allocs/op - bun: 0.56s 139839 ns/op 589 B/op 4 allocs/op - pg: 0.60s 149608 ns/op 896 B/op 11 allocs/op - gorm: 0.74s 185970 ns/op 6604 B/op 81 allocs/op - xorm: 0.81s 203240 ns/op 2994 B/op 119 allocs/op - - 4000 times - Read - raw: 0.33s 81671 ns/op 2081 B/op 49 allocs/op - raw_stmt: 0.34s 85847 ns/op 2112 B/op 50 allocs/op - beego_orm: 0.38s 94777 ns/op 2106 B/op 75 allocs/op - pg: 0.42s 106148 ns/op 1526 B/op 22 allocs/op - bun: 0.43s 106904 ns/op 1319 B/op 18 allocs/op - gorm: 0.65s 162221 ns/op 5240 B/op 108 allocs/op - xorm: 1.13s 281738 ns/op 8326 B/op 237 allocs/op - - 4000 times - MultiRead limit 100 - raw: 1.52s 380351 ns/op 38356 B/op 1037 allocs/op - raw_stmt: 1.54s 385541 ns/op 38388 B/op 1038 allocs/op - pg: 1.86s 465468 ns/op 24045 B/op 631 allocs/op - bun: 2.58s 645354 ns/op 30009 B/op 1122 allocs/op - beego_orm: 2.93s 732028 ns/op 55280 B/op 3077 allocs/op - gorm: 4.97s 1241831 ns/op 71628 B/op 3877 allocs/op - xorm: doesn't work -``` - -</details> - -## 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) - -## Contributors - -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 923be3116..000000000 --- a/vendor/github.com/uptrace/bun/bun.go +++ /dev/null @@ -1,84 +0,0 @@ -package bun - -import ( - "context" - - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type ( - Safe = schema.Safe - Ident = schema.Ident - - NullTime = schema.NullTime - BaseModel = schema.BaseModel - Query = schema.Query - - BeforeAppendModelHook = schema.BeforeAppendModelHook - - BeforeScanRowHook = schema.BeforeScanRowHook - AfterScanRowHook = schema.AfterScanRowHook - - // DEPRECATED. Use BeforeScanRowHook instead. - BeforeScanHook = schema.BeforeScanHook - // DEPRECATED. Use AfterScanRowHook instead. - AfterScanHook = schema.AfterScanHook -) - -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 overwriters default Bun logger. -func SetLogger(logger internal.Logging) { - internal.Logger = logger -} - -func In(slice interface{}) schema.QueryAppender { - return schema.In(slice) -} 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 47e654655..000000000 --- a/vendor/github.com/uptrace/bun/db.go +++ /dev/null @@ -1,684 +0,0 @@ -package bun - -import ( - "context" - "crypto/rand" - "database/sql" - "encoding/hex" - "fmt" - "reflect" - "strings" - "sync/atomic" - - "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 WithDiscardUnknownColumns() DBOption { - return func(db *DB) { - db.flags = db.flags.Set(discardUnknownColumns) - } -} - -type DB struct { - *sql.DB - - dialect schema.Dialect - features feature.Feature - - queryHooks []QueryHook - - fmter schema.Formatter - flags internal.Flag - - stats DBStats -} - -func NewDB(sqldb *sql.DB, dialect schema.Dialect, opts ...DBOption) *DB { - dialect.Init(sqldb) - - db := &DB{ - DB: sqldb, - dialect: dialect, - features: dialect.Features(), - 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) 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) 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) 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.fmter.HasFeature(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) 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) 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.Dialect().Features().Has(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.Dialect().Features().Has(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.Dialect().Features().Has(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) 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) 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 { - // TODO: make this configurable? - return make([]byte, 0, 4096) -} 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 0a25ee22d..000000000 --- a/vendor/github.com/uptrace/bun/dialect/append.go +++ /dev/null @@ -1,88 +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, v float32) []byte { - return appendFloat(b, float64(v), 32) -} - -func AppendFloat64(b []byte, v float64) []byte { - return appendFloat(b, v, 64) -} - -func appendFloat(b []byte, v float64, bitSize int) []byte { - switch { - case math.IsNaN(v): - return append(b, "'NaN'"...) - case math.IsInf(v, 1): - return append(b, "'Infinity'"...) - case math.IsInf(v, -1): - return append(b, "'-Infinity'"...) - default: - return strconv.AppendFloat(b, v, 'f', -1, bitSize) - } -} - -//------------------------------------------------------------------------------ - -func AppendIdent(b []byte, field string, quote byte) []byte { - return appendIdent(b, internal.Bytes(field), quote) -} - -func appendIdent(b, src []byte, quote byte) []byte { - var quoted bool -loop: - for _, c := range src { - 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 03b81fbbc..000000000 --- a/vendor/github.com/uptrace/bun/dialect/dialect.go +++ /dev/null @@ -1,26 +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" - default: - return "invalid" - } -} - -const ( - Invalid Name = iota - PG - SQLite - MySQL - MSSQL -) 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 956dc4985..000000000 --- a/vendor/github.com/uptrace/bun/dialect/feature/feature.go +++ /dev/null @@ -1,34 +0,0 @@ -package feature - -import "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 -) 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/append.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/append.go deleted file mode 100644 index a60bf5de2..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/append.go +++ /dev/null @@ -1,364 +0,0 @@ -package pgdialect - -import ( - "database/sql/driver" - "encoding/hex" - "fmt" - "reflect" - "strconv" - "time" - "unicode/utf8" - - "github.com/uptrace/bun/dialect" - "github.com/uptrace/bun/schema" -) - -var ( - driverValuerType = reflect.TypeOf((*driver.Valuer)(nil)).Elem() - - stringType = reflect.TypeOf((*string)(nil)).Elem() - sliceStringType = reflect.TypeOf([]string(nil)) - - intType = reflect.TypeOf((*int)(nil)).Elem() - sliceIntType = reflect.TypeOf([]int(nil)) - - int64Type = reflect.TypeOf((*int64)(nil)).Elem() - sliceInt64Type = reflect.TypeOf([]int64(nil)) - - float64Type = reflect.TypeOf((*float64)(nil)).Elem() - sliceFloat64Type = reflect.TypeOf([]float64(nil)) -) - -func arrayAppend(fmter schema.Formatter, b []byte, v interface{}) []byte { - switch v := v.(type) { - case int64: - return strconv.AppendInt(b, v, 10) - case float64: - return dialect.AppendFloat64(b, v) - case bool: - return dialect.AppendBool(b, v) - case []byte: - return arrayAppendBytes(b, v) - case string: - return arrayAppendString(b, v) - case time.Time: - return fmter.Dialect().AppendTime(b, v) - default: - err := fmt.Errorf("pgdialect: can't append %T", v) - return dialect.AppendError(b, err) - } -} - -func arrayAppendStringValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte { - return arrayAppendString(b, v.String()) -} - -func arrayAppendBytesValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte { - return arrayAppendBytes(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 arrayAppend(fmter, b, iface) -} - -//------------------------------------------------------------------------------ - -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: - // ok: - 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 - } - } - - 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, '\'') - - b = append(b, '{') - for i := 0; i < v.Len(); i++ { - elem := v.Index(i) - b = appendElem(fmter, b, elem) - b = append(b, ',') - } - if v.Len() > 0 { - b[len(b)-1] = '}' // Replace trailing comma. - } else { - b = append(b, '}') - } - - 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 arrayAppendStringValue - case reflect.Slice: - if typ.Elem().Kind() == reflect.Uint8 { - return arrayAppendBytesValue - } - } - return schema.Appender(d, typ) -} - -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 = arrayAppendString(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 = dialect.AppendFloat64(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 arrayAppendBytes(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 arrayAppendString(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 -} - -//------------------------------------------------------------------------------ - -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 = arrayAppendString(b, key) - b = append(b, '=', '>') - b = arrayAppendString(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 281cff733..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/array.go +++ /dev/null @@ -1,65 +0,0 @@ -package pgdialect - -import ( - "database/sql" - "fmt" - "reflect" - - "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 -} 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 a8358337e..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/array_parser.go +++ /dev/null @@ -1,133 +0,0 @@ -package pgdialect - -import ( - "bytes" - "encoding/hex" - "fmt" - "io" -) - -type arrayParser struct { - *streamParser - err error -} - -func newArrayParser(b []byte) *arrayParser { - p := &arrayParser{ - streamParser: newStreamParser(b, 1), - } - if len(b) < 2 || b[0] != '{' || b[len(b)-1] != '}' { - p.err = fmt.Errorf("bun: can't parse array: %q", b) - } - return p -} - -func (p *arrayParser) NextElem() ([]byte, error) { - if p.err != nil { - return nil, p.err - } - - c, err := p.readByte() - if err != nil { - return nil, err - } - - switch c { - case '}': - return nil, io.EOF - case '"': - b, err := p.readSubstring() - if err != nil { - return nil, err - } - - if p.peek() == ',' { - p.skipNext() - } - - return b, nil - default: - b := p.readSimple() - if bytes.Equal(b, []byte("NULL")) { - b = nil - } - - if p.peek() == ',' { - p.skipNext() - } - - return b, nil - } -} - -func (p *arrayParser) readSimple() []byte { - p.unreadByte() - - if i := bytes.IndexByte(p.b[p.i:], ','); i >= 0 { - b := p.b[p.i : p.i+i] - p.i += i - return b - } - - b := p.b[p.i : len(p.b)-1] - p.i = len(p.b) - 1 - return b -} - -func (p *arrayParser) readSubstring() ([]byte, error) { - c, err := p.readByte() - if err != nil { - return nil, err - } - - p.buf = p.buf[:0] - for { - if c == '"' { - break - } - - next, err := p.readByte() - if err != nil { - return nil, err - } - - if c == '\\' { - switch next { - case '\\', '"': - p.buf = append(p.buf, next) - - c, err = p.readByte() - if err != nil { - return nil, err - } - default: - p.buf = append(p.buf, '\\') - c = next - } - continue - } - if c == '\'' && next == '\'' { - p.buf = append(p.buf, next) - c, err = p.readByte() - if err != nil { - return nil, err - } - continue - } - - p.buf = append(p.buf, c) - c = 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 -} diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/array_scan.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/array_scan.go deleted file mode 100644 index a8ff29715..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/array_scan.go +++ /dev/null @@ -1,302 +0,0 @@ -package pgdialect - -import ( - "fmt" - "io" - "reflect" - "strconv" - - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -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)) - } - } - - b, err := toBytes(src) - if err != nil { - return err - } - - p := newArrayParser(b) - nextValue := internal.MakeSliceNextElemFunc(dest) - for { - elem, err := p.NextElem() - if err != nil { - if err == io.EOF { - break - } - return err - } - - elemValue := nextValue() - if err := scanElem(elemValue, elem); err != nil { - return err - } - } - - return nil - } -} - -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 { - elem, err := p.NextElem() - if err != nil { - if err == io.EOF { - break - } - return nil, err - } - slice = append(slice, string(elem)) - } - - 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 { - elem, err := p.NextElem() - if err != nil { - if err == io.EOF { - break - } - return nil, err - } - - if elem == nil { - slice = append(slice, 0) - continue - } - - n, err := strconv.Atoi(bytesToString(elem)) - if err != nil { - return nil, err - } - - slice = append(slice, n) - } - - 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 { - elem, err := p.NextElem() - if err != nil { - if err == io.EOF { - break - } - return nil, err - } - - if elem == nil { - slice = append(slice, 0) - continue - } - - n, err := strconv.ParseInt(bytesToString(elem), 10, 64) - if err != nil { - return nil, err - } - - slice = append(slice, n) - } - - 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 == -1 { - return nil, nil - } - - b, err := toBytes(src) - if err != nil { - return nil, err - } - - slice := make([]float64, 0) - - p := newArrayParser(b) - for { - elem, err := p.NextElem() - if err != nil { - if err == io.EOF { - break - } - return nil, err - } - - if elem == nil { - slice = append(slice, 0) - continue - } - - n, err := strconv.ParseFloat(bytesToString(elem), 64) - if err != nil { - return nil, err - } - - slice = append(slice, n) - } - - return slice, nil -} - -func toBytes(src interface{}) ([]byte, error) { - switch src := src.(type) { - case string: - return stringToBytes(src), nil - case []byte: - return src, nil - default: - return nil, fmt.Errorf("bun: got %T, wanted []byte or string", src) - } -} 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 d524f0a1a..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/dialect.go +++ /dev/null @@ -1,109 +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/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 -} - -func New() *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 - return d -} - -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) - } - - if field.DiscoveredSQLType == 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 { - return strconv.AppendInt(b, int64(int32(n)), 10) -} - -func (d *Dialect) AppendUint64(b []byte, n uint64) []byte { - return strconv.AppendInt(b, int64(n), 10) -} 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 7a18b50b1..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/hstore_parser.go +++ /dev/null @@ -1,142 +0,0 @@ -package pgdialect - -import ( - "bytes" - "fmt" -) - -type hstoreParser struct { - *streamParser - err error -} - -func newHStoreParser(b []byte) *hstoreParser { - p := &hstoreParser{ - streamParser: newStreamParser(b, 0), - } - if len(b) < 6 || b[0] != '"' { - p.err = fmt.Errorf("bun: can't parse hstore: %q", b) - } - return p -} - -func (p *hstoreParser) NextKey() (string, error) { - if p.err != nil { - return "", p.err - } - - err := p.skipByte('"') - if err != nil { - return "", err - } - - key, err := p.readSubstring() - if err != nil { - return "", err - } - - const separator = "=>" - - for i := range separator { - err = p.skipByte(separator[i]) - if err != nil { - return "", err - } - } - - return string(key), nil -} - -func (p *hstoreParser) NextValue() (string, error) { - if p.err != nil { - return "", p.err - } - - c, err := p.readByte() - if err != nil { - return "", err - } - - switch c { - case '"': - value, err := p.readSubstring() - if err != nil { - return "", err - } - - if p.peek() == ',' { - p.skipNext() - } - - if p.peek() == ' ' { - p.skipNext() - } - - return string(value), nil - default: - value := p.readSimple() - if bytes.Equal(value, []byte("NULL")) { - value = nil - } - - if p.peek() == ',' { - p.skipNext() - } - - return string(value), nil - } -} - -func (p *hstoreParser) readSimple() []byte { - p.unreadByte() - - if i := bytes.IndexByte(p.b[p.i:], ','); i >= 0 { - b := p.b[p.i : p.i+i] - p.i += i - return b - } - - b := p.b[p.i:len(p.b)] - p.i = len(p.b) - return b -} - -func (p *hstoreParser) readSubstring() ([]byte, error) { - c, err := p.readByte() - if err != nil { - return nil, err - } - - p.buf = p.buf[:0] - for { - if c == '"' { - break - } - - next, err := p.readByte() - if err != nil { - return nil, err - } - - if c == '\\' { - switch next { - case '\\', '"': - p.buf = append(p.buf, next) - - c, err = p.readByte() - if err != nil { - return nil, err - } - default: - p.buf = append(p.buf, '\\') - c = next - } - continue - } - - p.buf = append(p.buf, c) - c = next - } - - return p.buf, nil -} 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 b10b06b8d..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/hstore_scan.go +++ /dev/null @@ -1,82 +0,0 @@ -package pgdialect - -import ( - "fmt" - "io" - "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 { - key, err := p.NextKey() - if err != nil { - if err == io.EOF { - break - } - return nil, err - } - - value, err := p.NextValue() - if err != nil { - if err == io.EOF { - break - } - return nil, err - } - - m[key] = value - } - - return m, nil -} diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/safe.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/safe.go deleted file mode 100644 index dff30b9c5..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/safe.go +++ /dev/null @@ -1,11 +0,0 @@ -// +build appengine - -package pgdialect - -func bytesToString(b []byte) string { - return string(b) -} - -func stringToBytes(s string) []byte { - return []byte(s) -} diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/scan.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/scan.go deleted file mode 100644 index e06bb8bc2..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/scan.go +++ /dev/null @@ -1,11 +0,0 @@ -package pgdialect - -import ( - "reflect" - - "github.com/uptrace/bun/schema" -) - -func scanner(typ reflect.Type) schema.ScannerFunc { - return schema.Scanner(typ) -} 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 6c6294d71..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/sqltype.go +++ /dev/null @@ -1,105 +0,0 @@ -package pgdialect - -import ( - "encoding/json" - "net" - "reflect" - - "github.com/uptrace/bun/dialect/sqltype" - "github.com/uptrace/bun/schema" -) - -const ( - // Date / Time - pgTypeTimestampTz = "TIMESTAMPTZ" // Timestamp with a time zone - 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) - pgTypeText = "TEXT" // variable length string without limit - - // JSON Types - pgTypeJSON = "JSON" // text representation of json data - pgTypeJSONB = "JSONB" // binary representation of json data - - // Binary Data Types - pgTypeBytea = "BYTEA" // binary string -) - -var ( - ipType = reflect.TypeOf((*net.IP)(nil)).Elem() - ipNetType = reflect.TypeOf((*net.IPNet)(nil)).Elem() - jsonRawMessageType = reflect.TypeOf((*json.RawMessage)(nil)).Elem() -) - -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 ipType: - return pgTypeInet - case ipNetType: - return pgTypeCidr - case jsonRawMessageType: - return pgTypeJSONB - } - - sqlType := schema.DiscoverSQLType(typ) - switch sqlType { - case sqltype.Timestamp: - sqlType = pgTypeTimestampTz - } - - switch typ.Kind() { - case reflect.Map, reflect.Struct: - if sqlType == sqltype.VarChar { - return pgTypeJSONB - } - return sqlType - case reflect.Array, reflect.Slice: - if typ.Elem().Kind() == reflect.Uint8 { - return pgTypeBytea - } - return pgTypeJSONB - } - - return sqlType -} diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/stream_parser.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/stream_parser.go deleted file mode 100644 index 7b9a15f62..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/stream_parser.go +++ /dev/null @@ -1,60 +0,0 @@ -package pgdialect - -import ( - "fmt" - "io" -) - -type streamParser struct { - b []byte - i int - - buf []byte -} - -func newStreamParser(b []byte, start int) *streamParser { - return &streamParser{ - b: b, - i: start, - } -} - -func (p *streamParser) valid() bool { - return p.i < len(p.b) -} - -func (p *streamParser) skipByte(skip byte) error { - c, err := p.readByte() - if err != nil { - return err - } - if c == skip { - return nil - } - p.unreadByte() - return fmt.Errorf("got %q, wanted %q", c, skip) -} - -func (p *streamParser) readByte() (byte, error) { - if p.valid() { - c := p.b[p.i] - p.i++ - return c, nil - } - return 0, io.EOF -} - -func (p *streamParser) unreadByte() { - p.i-- -} - -func (p *streamParser) peek() byte { - if p.valid() { - return p.b[p.i] - } - return 0 -} - -func (p *streamParser) skipNext() { - p.i++ -} diff --git a/vendor/github.com/uptrace/bun/dialect/pgdialect/unsafe.go b/vendor/github.com/uptrace/bun/dialect/pgdialect/unsafe.go deleted file mode 100644 index 2a02a20b1..000000000 --- a/vendor/github.com/uptrace/bun/dialect/pgdialect/unsafe.go +++ /dev/null @@ -1,18 +0,0 @@ -// +build !appengine - -package pgdialect - -import "unsafe" - -func bytesToString(b []byte) string { - return *(*string)(unsafe.Pointer(&b)) -} - -func stringToBytes(s string) []byte { - return *(*[]byte)(unsafe.Pointer( - &struct { - string - Cap int - }{s, len(s)}, - )) -} 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 8ab18b7a7..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.1.7" -} 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 e79dcb004..000000000 --- a/vendor/github.com/uptrace/bun/dialect/sqlitedialect/dialect.go +++ /dev/null @@ -1,98 +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() *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 - return d -} - -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 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/scan.go b/vendor/github.com/uptrace/bun/dialect/sqlitedialect/scan.go deleted file mode 100644 index f6f02b55a..000000000 --- a/vendor/github.com/uptrace/bun/dialect/sqlitedialect/scan.go +++ /dev/null @@ -1,11 +0,0 @@ -package sqlitedialect - -import ( - "reflect" - - "github.com/uptrace/bun/schema" -) - -func scanner(typ reflect.Type) schema.ScannerFunc { - return schema.Scanner(typ) -} 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 8f9def8d0..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.1.7" -} 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/hook.go b/vendor/github.com/uptrace/bun/hook.go deleted file mode 100644 index 81249329a..000000000 --- a/vendor/github.com/uptrace/bun/hook.go +++ /dev/null @@ -1,113 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "strings" - "sync/atomic" - "time" - - "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 { - if idx := strings.IndexByte(query, ' '); idx > 0 { - query = query[:idx] - } - if len(query) > 16 { - query = query[:16] - } - return query -} - -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 2e22a0893..000000000 --- a/vendor/github.com/uptrace/bun/internal/logger.go +++ /dev/null @@ -1,27 +0,0 @@ -package internal - -import ( - "fmt" - "log" - "os" -) - -var Warn = log.New(os.Stderr, "WARN: bun: ", log.LstdFlags) - -var Deprecated = log.New(os.Stderr, "DEPRECATED: bun: ", log.LstdFlags) - -type Logging interface { - Printf(format string, v ...interface{}) -} - -type logger struct { - log *log.Logger -} - -func (l *logger) Printf(format string, v ...interface{}) { - _ = l.log.Output(2, fmt.Sprintf(format, v...)) -} - -var Logger Logging = &logger{ - log: log.New(os.Stderr, "bun: ", log.LstdFlags|log.Lshortfile), -} 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 bb5fcca8c..000000000 --- a/vendor/github.com/uptrace/bun/internal/map_key.go +++ /dev/null @@ -1,67 +0,0 @@ -package internal - -import "reflect" - -var ifaceType = reflect.TypeOf((*interface{})(nil)).Elem() - -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/parser/parser.go b/vendor/github.com/uptrace/bun/internal/parser/parser.go deleted file mode 100644 index cdfc0be16..000000000 --- a/vendor/github.com/uptrace/bun/internal/parser/parser.go +++ /dev/null @@ -1,141 +0,0 @@ -package parser - -import ( - "bytes" - "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) Valid() bool { - return p.i < len(p.b) -} - -func (p *Parser) Bytes() []byte { - return p.b[p.i:] -} - -func (p *Parser) Read() byte { - if p.Valid() { - c := p.b[p.i] - p.Advance() - return c - } - return 0 -} - -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) bool { - if p.Peek() == skip { - p.Advance() - return true - } - return false -} - -func (p *Parser) SkipBytes(skip []byte) bool { - if len(skip) > len(p.b[p.i:]) { - return false - } - if !bytes.Equal(p.b[p.i:p.i+len(skip)], 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 4bc79701f..000000000 --- a/vendor/github.com/uptrace/bun/internal/unsafe.go +++ /dev/null @@ -1,20 +0,0 @@ -// +build !appengine - -package internal - -import "unsafe" - -// String converts byte slice to string. -func String(b []byte) string { - return *(*string)(unsafe.Pointer(&b)) -} - -// Bytes converts string to byte slice. -func Bytes(s string) []byte { - return *(*[]byte)(unsafe.Pointer( - &struct { - string - Cap int - }{s, len(s)}, - )) -} 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 c831dc659..000000000 --- a/vendor/github.com/uptrace/bun/internal/util.go +++ /dev/null @@ -1,57 +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() - } - - elem := reflect.New(elemType) - v.Set(reflect.Append(v, elem)) - return elem.Elem() - } - } - - zero := reflect.Zero(elemType) - return func() reflect.Value { - if v.Len() < v.Cap() { - v.Set(v.Slice(0, v.Len()+1)) - return v.Index(v.Len() - 1) - } - - v.Set(reflect.Append(v, zero)) - return v.Index(v.Len() - 1) - } -} - -func Unwrap(err error) error { - u, ok := err.(interface { - Unwrap() error - }) - if !ok { - return nil - } - return u.Unwrap() -} 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 ae649446d..000000000 --- a/vendor/github.com/uptrace/bun/migrate/migration.go +++ /dev/null @@ -1,286 +0,0 @@ -package migrate - -import ( - "bufio" - "bytes" - "context" - "fmt" - "io/fs" - "sort" - "strings" - "time" - - "github.com/uptrace/bun" -) - -type Migration struct { - bun.BaseModel - - ID int64 `bun:",pk,autoincrement"` - Name string - GroupID int64 - MigratedAt time.Time `bun:",notnull,nullzero,default:current_timestamp"` - - Up MigrationFunc `bun:"-"` - Down MigrationFunc `bun:"-"` -} - -func (m Migration) String() string { - return m.Name -} - -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 { - isTx := strings.HasSuffix(name, ".tx.up.sql") || strings.HasSuffix(name, ".tx.down.sql") - - f, err := fsys.Open(name) - if err != nil { - return err - } - - 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 - - defer func() { - if tx, ok := idb.(bun.Tx); ok { - retErr = tx.Commit() - return - } - - if conn, ok := idb.(bun.Conn); ok { - retErr = conn.Close() - return - } - - panic("not reached") - }() - - for _, q := range queries { - _, err = idb.ExecContext(ctx, q) - if err != nil { - return err - } - } - - 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 -` - -//------------------------------------------------------------------------------ - -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].Name) - } - - 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 9af861048..000000000 --- a/vendor/github.com/uptrace/bun/migrate/migrations.go +++ /dev/null @@ -1,168 +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, err := extractMigrationName(fpath) - if err != nil { - return err - } - - m.Add(Migration{ - Name: name, - 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, err := extractMigrationName(path) - if err != nil { - return err - } - - migration := m.getOrCreateMigration(name) - if err != nil { - return err - } - 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{14})_[0-9a-z_\-]+\.`) - -func extractMigrationName(fpath 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], 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 d0efca2fc..000000000 --- a/vendor/github.com/uptrace/bun/migrate/migrator.go +++ /dev/null @@ -1,402 +0,0 @@ -package migrate - -import ( - "context" - "errors" - "fmt" - "io/ioutil" - "path/filepath" - "regexp" - "time" - - "github.com/uptrace/bun" -) - -type MigratorOption func(m *Migrator) - -func WithTableName(table string) MigratorOption { - return func(m *Migrator) { - m.table = table - } -} - -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: "bun_migrations", - locksTable: "bun_migration_locks", - } - 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.selectAppliedMigrations(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 - } - - if err := m.Lock(ctx); err != nil { - return nil, err - } - defer m.Unlock(ctx) //nolint:errcheck - - 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 - } - - if err := m.Lock(ctx); err != nil { - return nil, err - } - defer m.Unlock(ctx) //nolint:errcheck - - 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 -} - -type GoMigrationOption func(cfg *goMigrationConfig) - -func WithPackageName(name string) GoMigrationOption { - return func(cfg *goMigrationConfig) { - cfg.packageName = name - } -} - -// CreateGoMigration creates a Go migration file. -func (m *Migrator) CreateGoMigration( - ctx context.Context, name string, opts ...GoMigrationOption, -) (*MigrationFile, error) { - cfg := &goMigrationConfig{ - packageName: "migrations", - } - for _, opt := range opts { - opt(cfg) - } - - name, err := m.genMigrationName(name) - if err != nil { - return nil, err - } - - fname := name + ".go" - fpath := filepath.Join(m.migrations.getDirectory(), fname) - content := fmt.Sprintf(goTemplate, cfg.packageName) - - if err := ioutil.WriteFile(fpath, []byte(content), 0o644); err != nil { - return nil, err - } - - mf := &MigrationFile{ - Name: fname, - Path: fpath, - Content: content, - } - return mf, nil -} - -// CreateSQLMigrations creates an up and down SQL migration files. -func (m *Migrator) CreateSQLMigrations(ctx context.Context, name string) ([]*MigrationFile, error) { - name, err := m.genMigrationName(name) - if err != nil { - return nil, err - } - - up, err := m.createSQL(ctx, name+".up.sql") - if err != nil { - return nil, err - } - - down, err := m.createSQL(ctx, name+".down.sql") - if err != nil { - return nil, err - } - - return []*MigrationFile{up, down}, nil -} - -func (m *Migrator) createSQL(ctx context.Context, fname string) (*MigrationFile, error) { - fpath := filepath.Join(m.migrations.getDirectory(), fname) - - if err := ioutil.WriteFile(fpath, []byte(sqlTemplate), 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 (m *Migrator) 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 -} - -// selectAppliedMigrations selects applied (applied) migrations in descending order. -func (m *Migrator) selectAppliedMigrations(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 any 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/model.go b/vendor/github.com/uptrace/bun/model.go deleted file mode 100644 index 88ec48992..000000000 --- a/vendor/github.com/uptrace/bun/model.go +++ /dev/null @@ -1,201 +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.TypeOf((*time.Time)(nil)).Elem() - -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 %T)", dest) - } - - v = v.Elem() - - switch v.Kind() { - case reflect.Map: - typ := v.Type() - if err := validMap(typ); err != nil { - return nil, err - } - mapPtr := v.Addr().Interface().(*map[string]interface{}) - return newMapModel(db, mapPtr), nil - case reflect.Struct: - if v.Type() != timeType { - 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 814d636e6..000000000 --- a/vendor/github.com/uptrace/bun/model_map.go +++ /dev/null @@ -1,183 +0,0 @@ -package bun - -import ( - "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 { - 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 1e96c898c..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.features.Has(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.features.Has(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 4db3ec121..000000000 --- a/vendor/github.com/uptrace/bun/model_table_has_many.go +++ /dev/null @@ -1,149 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "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.BaseFields) - 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 - - 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 *hasManyModel) Scan(src interface{}) error { - column := m.columns[m.scanIndex] - m.scanIndex++ - - field, err := m.table.Field(column) - if err != nil { - return err - } - - if err := field.ScanValue(m.strct, src); err != nil { - return err - } - - for _, f := range m.rel.JoinFields { - if f.Name == field.Name { - m.structKey = append(m.structKey, field.Value(m.strct).Interface()) - 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, f.Value(strct).Interface()) - } - return key -} 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 88d8a1268..000000000 --- a/vendor/github.com/uptrace/bun/model_table_m2m.go +++ /dev/null @@ -1,138 +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, baseTable.PKs) - 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++ - - field, ok := m.table.FieldMap[column] - if !ok { - return m.scanM2MColumn(column, src) - } - - if err := field.ScanValue(m.strct, src); err != nil { - return err - } - - for _, fk := range m.rel.M2MBaseFields { - if fk.Name == field.Name { - m.structKey = append(m.structKey, field.Value(m.strct).Interface()) - break - } - } - - return nil -} - -func (m *m2mModel) scanM2MColumn(column string, src interface{}) error { - for _, field := range m.rel.M2MBaseFields { - 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, dest.Interface()) - 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 97e674515..000000000 --- a/vendor/github.com/uptrace/bun/model_table_slice.go +++ /dev/null @@ -1,122 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "reflect" - "time" - - "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: 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() - 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 fadc9284c..000000000 --- a/vendor/github.com/uptrace/bun/model_table_struct.go +++ /dev/null @@ -1,373 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "fmt" - "reflect" - "strings" - "time" - - "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) - } - if m.table.HasBeforeScanHook() { - return m.strct.Addr().Interface().(schema.BeforeScanHook).BeforeScan(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 - } - - if m.table.HasAfterScanHook() { - firstErr := m.strct.Addr().Interface().(schema.AfterScanHook).AfterScan(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 = host.FieldByIndex(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 sucessfully 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, ok := m.table.FieldMap[column]; ok { - 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 9428ddcd5..000000000 --- a/vendor/github.com/uptrace/bun/package.json +++ /dev/null @@ -1,8 +0,0 @@ -{ - "name": "gobun", - "version": "1.1.7", - "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 45b77f028..000000000 --- a/vendor/github.com/uptrace/bun/query_base.go +++ /dev/null @@ -1,1333 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "database/sql/driver" - "errors" - "fmt" - "time" - - "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 schema.QueryAppender -} - -// 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 - 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) GetConn() IConn { - return q.conn -} - -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 v, ok := wq.query.(Query); ok { - if model := v.GetModel(); model != nil { - return v.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 - } -} - -// TODO: rename to setModel -func (q *baseQuery) setTableModel(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 { - if q.model != nil { - return q.model, nil - } - return nil, errNilModel - } - return newModel(q.db, dest) -} - -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.features.Has(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) - } - return false -} - -//------------------------------------------------------------------------------ - -func (q *baseQuery) addWith(name string, query schema.QueryAppender) { - q.with = append(q.with, withQuery{ - name: name, - query: query, - }) -} - -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, ", "...) - } - - 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 { - 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) - - rows, err := q.conn.QueryContext(ctx, query) - if err != nil { - q.db.afterQuery(ctx, event, nil, err) - return nil, err - } - defer rows.Close() - - numRow, err := model.ScanRows(ctx, rows) - if err != nil { - q.db.afterQuery(ctx, event, nil, err) - return nil, err - } - - if numRow == 0 && hasDest && isSingleRowModel(model) { - err = sql.ErrNoRows - } - - res := driver.RowsAffected(numRow) - q.db.afterQuery(ctx, event, res, err) - - return res, err -} - -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.conn.ExecContext(ctx, query) - q.db.afterQuery(ctx, event, nil, 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) 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 { - 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{}, -) { - if _, ok := table.FieldMap[column]; 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 -} 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 0105fdb38..000000000 --- a/vendor/github.com/uptrace/bun/query_column_add.go +++ /dev/null @@ -1,116 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "fmt" - - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type AddColumnQuery struct { - baseQuery - - ifNotExists bool -} - -var _ Query = (*AddColumnQuery)(nil) - -func NewAddColumnQuery(db *DB) *AddColumnQuery { - q := &AddColumnQuery{ - baseQuery: baseQuery{ - db: db, - conn: db.DB, - }, - } - return q -} - -func (q *AddColumnQuery) Conn(db IConn) *AddColumnQuery { - q.setConn(db) - return q -} - -func (q *AddColumnQuery) Model(model interface{}) *AddColumnQuery { - q.setTableModel(model) - 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 -} - -//------------------------------------------------------------------------------ - -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 - } - 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) { - 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 cff615f68..000000000 --- a/vendor/github.com/uptrace/bun/query_column_drop.go +++ /dev/null @@ -1,118 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "fmt" - - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type DropColumnQuery struct { - baseQuery -} - -var _ Query = (*DropColumnQuery)(nil) - -func NewDropColumnQuery(db *DB) *DropColumnQuery { - q := &DropColumnQuery{ - baseQuery: baseQuery{ - db: db, - conn: db.DB, - }, - } - return q -} - -func (q *DropColumnQuery) Conn(db IConn) *DropColumnQuery { - q.setConn(db) - return q -} - -func (q *DropColumnQuery) Model(model interface{}) *DropColumnQuery { - q.setTableModel(model) - 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 -} - -//------------------------------------------------------------------------------ - -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 - } - 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 5899c9ba6..000000000 --- a/vendor/github.com/uptrace/bun/query_delete.go +++ /dev/null @@ -1,349 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "time" - - "github.com/uptrace/bun/dialect/feature" - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type DeleteQuery struct { - whereBaseQuery - returningQuery -} - -var _ Query = (*DeleteQuery)(nil) - -func NewDeleteQuery(db *DB) *DeleteQuery { - q := &DeleteQuery{ - whereBaseQuery: whereBaseQuery{ - baseQuery: baseQuery{ - db: db, - conn: db.DB, - }, - }, - } - return q -} - -func (q *DeleteQuery) Conn(db IConn) *DeleteQuery { - q.setConn(db) - return q -} - -func (q *DeleteQuery) Model(model interface{}) *DeleteQuery { - q.setTableModel(model) - return q -} - -// Apply calls the fn passing the DeleteQuery as an argument. -func (q *DeleteQuery) Apply(fn func(*DeleteQuery) *DeleteQuery) *DeleteQuery { - return fn(q) -} - -func (q *DeleteQuery) With(name string, query schema.QueryAppender) *DeleteQuery { - q.addWith(name, query) - 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) ForceDelete() *DeleteQuery { - q.flags = q.flags.Set(forceDeleteFlag) - 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 { - q.addReturning(schema.SafeQuery(query, args)) - return q -} - -func (q *DeleteQuery) hasReturning() bool { - if !q.db.features.Has(feature.Returning) { - return false - } - return q.returningQuery.hasReturning() -} - -//------------------------------------------------------------------------------ - -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 - } - - 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) - } - - q = q.WhereDeleted() - withAlias := q.db.features.Has(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 - } - } - - b, err = q.mustAppendWhere(fmter, b, withAlias) - 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 *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) Exec(ctx context.Context, dest ...interface{}) (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 - } - } - - 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) - - var res sql.Result - - if hasDest := len(dest) > 0; hasDest || q.hasReturning() { - model, err := q.getModel(dest) - if err != nil { - return nil, err - } - - 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 8b8fd26a3..000000000 --- a/vendor/github.com/uptrace/bun/query_index_create.go +++ /dev/null @@ -1,249 +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 -} - -var _ Query = (*CreateIndexQuery)(nil) - -func NewCreateIndexQuery(db *DB) *CreateIndexQuery { - q := &CreateIndexQuery{ - whereBaseQuery: whereBaseQuery{ - baseQuery: baseQuery{ - db: db, - conn: db.DB, - }, - }, - } - return q -} - -func (q *CreateIndexQuery) Conn(db IConn) *CreateIndexQuery { - q.setConn(db) - return q -} - -func (q *CreateIndexQuery) Model(model interface{}) *CreateIndexQuery { - q.setTableModel(model) - 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 -} - -//------------------------------------------------------------------------------ - -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 = 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 2f5132833..000000000 --- a/vendor/github.com/uptrace/bun/query_index_drop.go +++ /dev/null @@ -1,116 +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 -} - -var _ Query = (*DropIndexQuery)(nil) - -func NewDropIndexQuery(db *DB) *DropIndexQuery { - q := &DropIndexQuery{ - baseQuery: baseQuery{ - db: db, - conn: db.DB, - }, - } - return q -} - -func (q *DropIndexQuery) Conn(db IConn) *DropIndexQuery { - q.setConn(db) - return q -} - -func (q *DropIndexQuery) Model(model interface{}) *DropIndexQuery { - q.setTableModel(model) - 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 -} - -//------------------------------------------------------------------------------ - -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 = 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 073afea47..000000000 --- a/vendor/github.com/uptrace/bun/query_insert.go +++ /dev/null @@ -1,652 +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 -} - -var _ Query = (*InsertQuery)(nil) - -func NewInsertQuery(db *DB) *InsertQuery { - q := &InsertQuery{ - whereBaseQuery: whereBaseQuery{ - baseQuery: baseQuery{ - db: db, - conn: db.DB, - }, - }, - } - return q -} - -func (q *InsertQuery) Conn(db IConn) *InsertQuery { - q.setConn(db) - return q -} - -func (q *InsertQuery) Model(model interface{}) *InsertQuery { - q.setTableModel(model) - return q -} - -// Apply calls the fn passing the SelectQuery as an argument. -func (q *InsertQuery) Apply(fn func(*InsertQuery) *InsertQuery) *InsertQuery { - return fn(q) -} - -func (q *InsertQuery) With(name string, query schema.QueryAppender) *InsertQuery { - q.addWith(name, query) - 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 -} - -//------------------------------------------------------------------------------ - -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 - } - - 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.features.Has(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) - 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, -) (_ []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() { - 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 (f.IsPtr && f.HasNilValue(strct)) || (f.NullZero && f.HasZeroValue(strct)): - if q.db.features.Has(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.features.Has(feature.Identity) - - if len(q.columns) > 0 || q.db.features.Has(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 && f.SQLDefault == "" { - if (f.IsPtr && f.HasNilValue(strct)) || (f.NullZero && f.HasZeroValue(strct)) { - q.addReturningField(f) - continue - } - } - fields = append(fields, f) - } - - return fields, nil -} - -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) Exec(ctx context.Context, dest ...interface{}) (sql.Result, error) { - if q.table != nil { - if err := q.beforeInsertHook(ctx); err != nil { - return nil, err - } - } - - 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) - var res sql.Result - - if hasDest := len(dest) > 0; hasDest || - (q.hasReturning() && q.hasFeature(feature.InsertReturning|feature.Output)) { - model, err := q.getModel(dest) - if err != nil { - return nil, err - } - - 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.features.Has(feature.Returning) || - q.db.features.Has(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_raw.go b/vendor/github.com/uptrace/bun/query_raw.go deleted file mode 100644 index 30ae77508..000000000 --- a/vendor/github.com/uptrace/bun/query_raw.go +++ /dev/null @@ -1,48 +0,0 @@ -package bun - -import ( - "context" - - "github.com/uptrace/bun/schema" -) - -type RawQuery struct { - baseQuery - - query string - args []interface{} -} - -func (db *DB) Raw(query string, args ...interface{}) *RawQuery { - return &RawQuery{ - baseQuery: baseQuery{ - db: db, - conn: db.DB, - }, - query: query, - args: args, - } -} - -func (q *RawQuery) Scan(ctx context.Context, dest ...interface{}) error { - if q.err != nil { - return q.err - } - - model, err := q.getModel(dest) - if err != nil { - return err - } - - query := q.db.format(q.query, q.args) - _, err = q.scan(ctx, q, query, model, true) - return err -} - -func (q *RawQuery) AppendQuery(fmter schema.Formatter, b []byte) ([]byte, error) { - return fmter.AppendQuery(b, q.query, q.args...), nil -} - -func (q *RawQuery) Operation() string { - return "SELECT" -} 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 b61bcfaf0..000000000 --- a/vendor/github.com/uptrace/bun/query_select.go +++ /dev/null @@ -1,1202 +0,0 @@ -package bun - -import ( - "bytes" - "context" - "database/sql" - "errors" - "fmt" - "strconv" - "strings" - "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 - - distinctOn []schema.QueryWithArgs - joins []joinQuery - group []schema.QueryWithArgs - having []schema.QueryWithArgs - order []schema.QueryWithArgs - limit int32 - offset int32 - selFor schema.QueryWithArgs - - union []union -} - -var _ Query = (*SelectQuery)(nil) - -func NewSelectQuery(db *DB) *SelectQuery { - return &SelectQuery{ - whereBaseQuery: whereBaseQuery{ - baseQuery: baseQuery{ - db: db, - conn: db.DB, - }, - }, - } -} - -func (q *SelectQuery) Conn(db IConn) *SelectQuery { - q.setConn(db) - return q -} - -func (q *SelectQuery) Model(model interface{}) *SelectQuery { - q.setTableModel(model) - return q -} - -// Apply calls the fn passing the SelectQuery as an argument. -func (q *SelectQuery) Apply(fn func(*SelectQuery) *SelectQuery) *SelectQuery { - return fn(q) -} - -func (q *SelectQuery) With(name string, query schema.QueryAppender) *SelectQuery { - q.addWith(name, query) - 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 { - 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)) - } - } - return q -} - -func (q *SelectQuery) OrderExpr(query string, args ...interface{}) *SelectQuery { - q.order = append(q.order, schema.SafeQuery(query, args)) - return q -} - -func (q *SelectQuery) Limit(n int) *SelectQuery { - q.limit = int32(n) - return q -} - -func (q *SelectQuery) Offset(n int) *SelectQuery { - q.offset = int32(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 - } - - 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 - } - - 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 -} - -//------------------------------------------------------------------------------ - -func (q *SelectQuery) Operation() string { - return "SELECT" -} - -func (q *SelectQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []byte, err error) { - 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 - } - - 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 { - 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 - } - } - - 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 _, j := range q.joins { - b, err = j.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - - b, err = q.appendIndexHints(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 - } - - 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) - } - } - - 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) { - join.applyTo(q) - - 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) 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 - } - return b, nil -} - -//------------------------------------------------------------------------------ - -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) - return q.conn.QueryContext(ctx, query) -} - -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 { - if q.err != nil { - return q.err - } - - model, err := q.getModel(dest) - if err != nil { - return err - } - - if q.table != nil { - if err := q.beforeSelectHook(ctx); err != nil { - return err - } - } - - if err := q.beforeAppendModel(ctx, q); err != nil { - return err - } - - queryBytes, err := q.AppendQuery(q.db.fmter, q.db.makeQueryBytes()) - if err != nil { - return err - } - - query := internal.String(queryBytes) - - res, err := q.scan(ctx, q, query, model, true) - if err != nil { - return err - } - - if n, _ := res.RowsAffected(); n > 0 { - if tableModel, ok := model.(TableModel); ok { - if err := q.selectJoins(ctx, tableModel.getJoins()); err != nil { - return err - } - } - } - - if q.table != nil { - if err := q.afterSelectHook(ctx); err != nil { - return err - } - } - - return 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.conn.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 _, ok := q.conn.(*DB); ok { - return q.scanAndCountConc(ctx, dest...) - } - return q.scanAndCountSeq(ctx, dest...) -} - -func (q *SelectQuery) scanAndCountConc(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.conn.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) - ctx, event := q.db.beforeQuery(ctx, qq, query, nil, query, q.model) - - res, err := q.exec(ctx, q, query) - - q.db.afterQuery(ctx, event, nil, err) - - 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 c795e8a97..000000000 --- a/vendor/github.com/uptrace/bun/query_table_create.go +++ /dev/null @@ -1,344 +0,0 @@ -package bun - -import ( - "context" - "database/sql" - "sort" - "strconv" - - "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 - varchar int - - fks []schema.QueryWithArgs - partitionBy schema.QueryWithArgs - tablespace schema.QueryWithArgs -} - -var _ Query = (*CreateTableQuery)(nil) - -func NewCreateTableQuery(db *DB) *CreateTableQuery { - q := &CreateTableQuery{ - baseQuery: baseQuery{ - db: db, - conn: db.DB, - }, - } - return q -} - -func (q *CreateTableQuery) Conn(db IConn) *CreateTableQuery { - q.setConn(db) - return q -} - -func (q *CreateTableQuery) Model(model interface{}) *CreateTableQuery { - q.setTableModel(model) - 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 -} - -func (q *CreateTableQuery) Varchar(n int) *CreateTableQuery { - 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 -} - -func (q *CreateTableQuery) WithForeignKeys() *CreateTableQuery { - for _, relation := range q.tableModel.Table().Relations { - if relation.Type == schema.ManyToManyRelation || - relation.Type == schema.HasManyRelation { - continue - } - - q = q.ForeignKey("(?) REFERENCES ? (?) ? ?", - Safe(appendColumns(nil, "", relation.BaseFields)), - relation.JoinTable.SQLName, - Safe(appendColumns(nil, "", relation.JoinFields)), - Safe(relation.OnUpdate), - Safe(relation.OnDelete), - ) - } - 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 - } - 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.Dialect().Features().Has(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 { - b = append(b, " NOT NULL"...) - } - if field.AutoIncrement { - switch { - case fmter.Dialect().Features().Has(feature.AutoIncrement): - b = append(b, " AUTO_INCREMENT"...) - case fmter.Dialect().Features().Has(feature.Identity): - b = append(b, " IDENTITY"...) - } - } - if field.Identity { - if fmter.Dialect().Features().Has(feature.GeneratedIdentity) { - b = append(b, " GENERATED BY DEFAULT AS IDENTITY"...) - } - } - 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 - } - } - - b = q.appendPKConstraint(b, q.table.PKs) - b = q.appendUniqueConstraints(fmter, b) - 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 { - if field.CreateTableSQLType != field.DiscoveredSQLType { - return append(b, field.CreateTableSQLType...) - } - - if q.varchar > 0 && - field.CreateTableSQLType == sqltype.VarChar { - b = append(b, "varchar("...) - b = strconv.AppendInt(b, int64(q.varchar), 10) - b = append(b, ")"...) - return b - } - - return append(b, field.CreateTableSQLType...) -} - -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 -} - -func (q *CreateTableQuery) appendFKConstraints( - fmter schema.Formatter, b []byte, -) (_ []byte, err error) { - for _, fk := range q.fks { - b = append(b, ", FOREIGN KEY "...) - b, err = fk.AppendQuery(fmter, b) - if err != nil { - return nil, err - } - } - return b, nil -} - -func (q *CreateTableQuery) appendPKConstraint(b []byte, pks []*schema.Field) []byte { - if len(pks) == 0 { - return b - } - - 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 -} 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 bf7ee3031..000000000 --- a/vendor/github.com/uptrace/bun/query_table_drop.go +++ /dev/null @@ -1,148 +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 -} - -var _ Query = (*DropTableQuery)(nil) - -func NewDropTableQuery(db *DB) *DropTableQuery { - q := &DropTableQuery{ - baseQuery: baseQuery{ - db: db, - conn: db.DB, - }, - } - return q -} - -func (q *DropTableQuery) Conn(db IConn) *DropTableQuery { - q.setConn(db) - return q -} - -func (q *DropTableQuery) Model(model interface{}) *DropTableQuery { - q.setTableModel(model) - 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 -} - -//------------------------------------------------------------------------------ - -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 = 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 -} 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 870c776c6..000000000 --- a/vendor/github.com/uptrace/bun/query_table_truncate.go +++ /dev/null @@ -1,132 +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 -} - -var _ Query = (*TruncateTableQuery)(nil) - -func NewTruncateTableQuery(db *DB) *TruncateTableQuery { - q := &TruncateTableQuery{ - baseQuery: baseQuery{ - db: db, - conn: db.DB, - }, - } - return q -} - -func (q *TruncateTableQuery) Conn(db IConn) *TruncateTableQuery { - q.setConn(db) - return q -} - -func (q *TruncateTableQuery) Model(model interface{}) *TruncateTableQuery { - q.setTableModel(model) - 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) 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 -} - -//------------------------------------------------------------------------------ - -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 - } - - 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.features.Has(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 b415ff201..000000000 --- a/vendor/github.com/uptrace/bun/query_update.go +++ /dev/null @@ -1,585 +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 - returningQuery - customValueQuery - setQuery - idxHintsQuery - - omitZero bool -} - -var _ Query = (*UpdateQuery)(nil) - -func NewUpdateQuery(db *DB) *UpdateQuery { - q := &UpdateQuery{ - whereBaseQuery: whereBaseQuery{ - baseQuery: baseQuery{ - db: db, - conn: db.DB, - }, - }, - } - return q -} - -func (q *UpdateQuery) Conn(db IConn) *UpdateQuery { - q.setConn(db) - return q -} - -func (q *UpdateQuery) Model(model interface{}) *UpdateQuery { - q.setTableModel(model) - return q -} - -// Apply calls the fn passing the SelectQuery as an argument. -func (q *UpdateQuery) Apply(fn func(*UpdateQuery) *UpdateQuery) *UpdateQuery { - return fn(q) -} - -func (q *UpdateQuery) With(name string, query schema.QueryAppender) *UpdateQuery { - q.addWith(name, query) - 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) 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 -} - -//------------------------------------------------------------------------------ - -// 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 -} - -func (q *UpdateQuery) hasReturning() bool { - if !q.db.features.Has(feature.Returning) { - return false - } - return q.returningQuery.hasReturning() -} - -//------------------------------------------------------------------------------ - -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 - } - - 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 - } - } - - b, err = q.mustAppendWhere(fmter, b, q.hasTableAlias(fmter)) - 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: - b, err = q.appendSetStruct(fmter, b, model) - if err != nil { - return nil, err - } - 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 - for i, field := range fields { - if i > 0 { - b = append(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) Exec(ctx context.Context, dest ...interface{}) (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 - } - } - - 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) - - var res sql.Result - - if hasDest := len(dest) > 0; hasDest || q.hasReturning() { - model, err := q.getModel(dest) - if err != nil { - return nil, err - } - - 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.SetName 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 dd6b095c6..000000000 --- a/vendor/github.com/uptrace/bun/query_values.go +++ /dev/null @@ -1,222 +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 -} - -var ( - _ Query = (*ValuesQuery)(nil) - _ schema.NamedArgAppender = (*ValuesQuery)(nil) -) - -func NewValuesQuery(db *DB, model interface{}) *ValuesQuery { - q := &ValuesQuery{ - baseQuery: baseQuery{ - db: db, - conn: db.DB, - }, - } - q.setTableModel(model) - return q -} - -func (q *ValuesQuery) Conn(db IConn) *ValuesQuery { - q.setConn(db) - 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 -} - -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 - } - - 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.features.Has(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.features.Has(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 e8074e0c6..000000000 --- a/vendor/github.com/uptrace/bun/relation_join.go +++ /dev/null @@ -1,314 +0,0 @@ -package bun - -import ( - "context" - "reflect" - - "github.com/uptrace/bun/internal" - "github.com/uptrace/bun/schema" -) - -type relationJoin struct { - Parent *relationJoin - BaseModel TableModel - JoinModel TableModel - Relation *schema.Relation - - 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 len(j.Relation.JoinFields) > 1 { - where = append(where, '(') - } - where = appendColumns(where, j.JoinModel.Table().SQLAlias, j.Relation.JoinFields) - if len(j.Relation.JoinFields) > 1 { - where = append(where, ')') - } - where = append(where, " IN ("...) - where = appendChildValues( - q.db.Formatter(), - where, - j.JoinModel.rootValue(), - j.JoinModel.parentIndex(), - j.Relation.BaseFields, - ) - where = append(where, ")"...) - 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) 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() - baseTable := j.BaseModel.Table() - - if j.Relation.M2MTable != nil { - q = q.ColumnExpr(string(j.Relation.M2MTable.SQLAlias) + ".*") - } - - //nolint - var join []byte - join = append(join, "JOIN "...) - join = fmter.AppendQuery(join, string(j.Relation.M2MTable.Name)) - join = append(join, " AS "...) - join = append(join, j.Relation.M2MTable.SQLAlias...) - join = append(join, " ON ("...) - for i, col := range j.Relation.M2MBaseFields { - 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, baseTable.PKs) - join = append(join, ")"...) - q = q.Join(internal.String(join)) - - joinTable := j.JoinModel.Table() - for i, m2mJoinField := range j.Relation.M2MJoinFields { - joinField := j.Relation.JoinFields[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(b []byte, flags internal.Flag) []byte { - b = append(b, '.') - b = append(b, j.JoinModel.Table().SoftDeleteField.SQLName...) - if flags.Has(deletedFlag) { - b = append(b, " IS NOT NULL"...) - } else { - b = append(b, " IS NULL"...) - } - 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.BaseFields { - if i > 0 { - b = append(b, " AND "...) - } - b = j.appendAlias(fmter, b) - b = append(b, '.') - b = append(b, j.Relation.JoinFields[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(b, q.flags) - } - - 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 -} 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 04538c036..000000000 --- a/vendor/github.com/uptrace/bun/schema/append.go +++ /dev/null @@ -1,101 +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() - 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 -} 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 7e9c451db..000000000 --- a/vendor/github.com/uptrace/bun/schema/append_value.go +++ /dev/null @@ -1,314 +0,0 @@ -package schema - -import ( - "database/sql/driver" - "fmt" - "net" - "reflect" - "strconv" - "strings" - "sync" - "time" - - "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 appenderMap sync.Map - -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.PtrTo(fieldType).Implements(driverValuerType) { - return addrAppender(appendDriverValue) - } - } - - return AppendJSONValue - } - - return Appender(dialect, fieldType) -} - -func Appender(dialect Dialect, typ reflect.Type) AppenderFunc { - if v, ok := appenderMap.Load(typ); ok { - return v.(AppenderFunc) - } - - fn := appender(dialect, typ) - - if v, ok := appenderMap.LoadOrStore(typ, fn); ok { - return v.(AppenderFunc) - } - 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 ipType: - return appendIPValue - case ipNetType: - return appendIPNetValue - 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.PtrTo(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 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 appendIPValue(fmter Formatter, b []byte, v reflect.Value) []byte { - ip := v.Interface().(net.IP) - return fmter.Dialect().AppendString(b, ip.String()) -} - -func appendIPNetValue(fmter Formatter, b []byte, v reflect.Value) []byte { - ipnet := v.Interface().(net.IPNet) - return fmter.Dialect().AppendString(b, ipnet.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) - } - 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 134460c3d..000000000 --- a/vendor/github.com/uptrace/bun/schema/dialect.go +++ /dev/null @@ -1,165 +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 -} - -//------------------------------------------------------------------------------ - -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.SkipBytes([]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 -} - -//------------------------------------------------------------------------------ - -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 '"' -} 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 283a3b992..000000000 --- a/vendor/github.com/uptrace/bun/schema/field.go +++ /dev/null @@ -1,138 +0,0 @@ -package schema - -import ( - "fmt" - "reflect" - - "github.com/uptrace/bun/dialect" - "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) 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 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) 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) 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 := fieldByIndexAlloc(strct, f.Index) - return f.ScanWithCheck(fv, src) -} - -func (f *Field) SkipUpdate() bool { - return f.Tag.HasOption("skipupdate") -} - -func indexEqual(ind1, ind2 []int) bool { - if len(ind1) != len(ind2) { - return false - } - for i, ind := range ind1 { - if ind != ind2[i] { - return false - } - } - return true -} 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 1fba1b59e..000000000 --- a/vendor/github.com/uptrace/bun/schema/formatter.go +++ /dev/null @@ -1,246 +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) 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 624601c9f..000000000 --- a/vendor/github.com/uptrace/bun/schema/hook.go +++ /dev/null @@ -1,59 +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.TypeOf((*BeforeAppendModelHook)(nil)).Elem() - -//------------------------------------------------------------------------------ - -type BeforeScanHook interface { - BeforeScan(context.Context) error -} - -var beforeScanHookType = reflect.TypeOf((*BeforeScanHook)(nil)).Elem() - -//------------------------------------------------------------------------------ - -type AfterScanHook interface { - AfterScan(context.Context) error -} - -var afterScanHookType = reflect.TypeOf((*AfterScanHook)(nil)).Elem() - -//------------------------------------------------------------------------------ - -type BeforeScanRowHook interface { - BeforeScanRow(context.Context) error -} - -var beforeScanRowHookType = reflect.TypeOf((*BeforeScanRowHook)(nil)).Elem() - -//------------------------------------------------------------------------------ - -type AfterScanRowHook interface { - AfterScanRow(context.Context) error -} - -var afterScanRowHookType = reflect.TypeOf((*AfterScanRowHook)(nil)).Elem() 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 f13826a6c..000000000 --- a/vendor/github.com/uptrace/bun/schema/reflect.go +++ /dev/null @@ -1,72 +0,0 @@ -package schema - -import ( - "database/sql/driver" - "encoding/json" - "net" - "reflect" - "time" -) - -var ( - bytesType = reflect.TypeOf((*[]byte)(nil)).Elem() - timePtrType = reflect.TypeOf((*time.Time)(nil)) - timeType = timePtrType.Elem() - ipType = reflect.TypeOf((*net.IP)(nil)).Elem() - ipNetType = reflect.TypeOf((*net.IPNet)(nil)).Elem() - jsonRawMessageType = reflect.TypeOf((*json.RawMessage)(nil)).Elem() - - driverValuerType = reflect.TypeOf((*driver.Valuer)(nil)).Elem() - queryAppenderType = reflect.TypeOf((*QueryAppender)(nil)).Elem() - jsonMarshalerType = reflect.TypeOf((*json.Marshaler)(nil)).Elem() -) - -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 -} - -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 -} 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 6636e26a6..000000000 --- a/vendor/github.com/uptrace/bun/schema/relation.go +++ /dev/null @@ -1,35 +0,0 @@ -package schema - -import ( - "fmt" -) - -const ( - InvalidRelation = iota - HasOneRelation - BelongsToRelation - HasManyRelation - ManyToManyRelation -) - -type Relation struct { - Type int - Field *Field - JoinTable *Table - BaseFields []*Field - JoinFields []*Field - OnUpdate string - OnDelete string - Condition []string - - PolymorphicField *Field - PolymorphicValue string - - M2MTable *Table - M2MBaseFields []*Field - M2MJoinFields []*Field -} - -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 96b31caf3..000000000 --- a/vendor/github.com/uptrace/bun/schema/scan.go +++ /dev/null @@ -1,516 +0,0 @@ -package schema - -import ( - "bytes" - "database/sql" - "fmt" - "net" - "reflect" - "strconv" - "strings" - "sync" - "time" - - "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.TypeOf((*sql.Scanner)(nil)).Elem() - -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: scanFloat64, - reflect.Float64: scanFloat64, - 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 scannerMap sync.Map - -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 := scannerMap.Load(typ); ok { - return v.(ScannerFunc) - } - - fn := scanner(typ) - - if v, ok := scannerMap.LoadOrStore(typ, fn); ok { - return v.(ScannerFunc) - } - 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.PtrTo(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 scanFloat64(dest reflect.Value, src interface{}) error { - switch src := src.(type) { - case nil: - dest.SetFloat(0) - 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 a4ed24af6..000000000 --- a/vendor/github.com/uptrace/bun/schema/sqlfmt.go +++ /dev/null @@ -1,87 +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 -} - -//------------------------------------------------------------------------------ - -// Ident represents a SQL identifier, for example, table or column 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 233ba641b..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.TypeOf((*NullTime)(nil)).Elem() - nullTimeType = reflect.TypeOf((*sql.NullTime)(nil)).Elem() - nullBoolType = reflect.TypeOf((*sql.NullBool)(nil)).Elem() - nullFloatType = reflect.TypeOf((*sql.NullFloat64)(nil)).Elem() - nullIntType = reflect.TypeOf((*sql.NullInt64)(nil)).Elem() - nullStringType = reflect.TypeOf((*sql.NullString)(nil)).Elem() -) - -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 9791f8ff1..000000000 --- a/vendor/github.com/uptrace/bun/schema/table.go +++ /dev/null @@ -1,1035 +0,0 @@ -package schema - -import ( - "database/sql" - "fmt" - "reflect" - "strings" - "sync" - "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.TypeOf((*BaseModel)(nil)).Elem() - 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 - - Name string - SQLName Safe - SQLNameForSelects Safe - Alias string - SQLAlias Safe - - Fields []*Field // PKs + DataFields - PKs []*Field - DataFields []*Field - - fieldsMapMu sync.RWMutex - FieldMap map[string]*Field - - Relations map[string]*Relation - Unique map[string][]*Field - - SoftDeleteField *Field - UpdateSoftDeleteField func(fv reflect.Value, tm time.Time) error - - allFields []*Field // read only - - flags internal.Flag -} - -func newTable(dialect Dialect, typ reflect.Type) *Table { - t := new(Table) - t.dialect = dialect - t.Type = typ - t.ZeroValue = reflect.New(t.Type).Elem() - t.ZeroIface = reflect.New(t.Type).Interface() - t.TypeName = internal.ToExported(t.Type.Name()) - t.ModelName = internal.Underscore(t.Type.Name()) - tableName := tableNameInflector(t.ModelName) - t.setName(tableName) - t.Alias = t.ModelName - t.SQLAlias = t.quoteIdent(t.ModelName) - - hooks := []struct { - typ reflect.Type - flag internal.Flag - }{ - {beforeAppendModelHookType, beforeAppendModelHookFlag}, - - {beforeScanHookType, beforeScanHookFlag}, - {afterScanHookType, afterScanHookFlag}, - - {beforeScanRowHookType, beforeScanRowHookFlag}, - {afterScanRowHookType, afterScanRowHookFlag}, - } - - typ = reflect.PtrTo(t.Type) - for _, hook := range hooks { - if typ.Implements(hook.typ) { - t.flags = t.flags.Set(hook.flag) - } - } - - // Deprecated. - deprecatedHooks := []struct { - typ reflect.Type - flag internal.Flag - msg string - }{ - {beforeScanHookType, beforeScanHookFlag, "rename BeforeScan hook to BeforeScanRow"}, - {afterScanHookType, afterScanHookFlag, "rename AfterScan hook to AfterScanRow"}, - } - for _, hook := range deprecatedHooks { - if typ.Implements(hook.typ) { - internal.Deprecated.Printf("%s: %s", t.TypeName, hook.msg) - t.flags = t.flags.Set(hook.flag) - } - } - - return t -} - -func (t *Table) init1() { - t.initFields() -} - -func (t *Table) init2() { - t.initRelations() -} - -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.Fields = append(t.Fields, field) - if field.IsPK { - t.PKs = append(t.PKs, field) - } else { - t.DataFields = append(t.DataFields, field) - } - t.FieldMap[field.Name] = field -} - -func (t *Table) removeField(field *Field) { - t.Fields = removeField(t.Fields, field) - if field.IsPK { - t.PKs = removeField(t.PKs, field) - } else { - t.DataFields = removeField(t.DataFields, field) - } - delete(t.FieldMap, field.Name) -} - -func (t *Table) fieldWithLock(name string) *Field { - t.fieldsMapMu.RLock() - field := t.FieldMap[name] - t.fieldsMapMu.RUnlock() - return field -} - -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) initFields() { - t.Fields = make([]*Field, 0, t.Type.NumField()) - t.FieldMap = make(map[string]*Field, t.Type.NumField()) - t.addFields(t.Type, "", nil) -} - -func (t *Table) addFields(typ reflect.Type, prefix string, index []int) { - for i := 0; i < typ.NumField(); i++ { - f := typ.Field(i) - unexported := f.PkgPath != "" - - if unexported && !f.Anonymous { // unexported - continue - } - if f.Tag.Get("bun") == "-" { - continue - } - - if f.Anonymous { - if f.Name == "BaseModel" && f.Type == baseModelType { - if len(index) == 0 { - t.processBaseModelField(f) - } - continue - } - - // If field is an embedded struct, add each field of the embedded struct. - fieldType := indirectType(f.Type) - if fieldType.Kind() == reflect.Struct { - t.addFields(fieldType, "", withIndex(index, f.Index)) - - tag := tagparser.Parse(f.Tag.Get("bun")) - if tag.HasOption("inherit") || tag.HasOption("extend") { - embeddedTable := t.dialect.Tables().Ref(fieldType) - t.TypeName = embeddedTable.TypeName - t.SQLName = embeddedTable.SQLName - t.SQLNameForSelects = embeddedTable.SQLNameForSelects - t.Alias = embeddedTable.Alias - t.SQLAlias = embeddedTable.SQLAlias - t.ModelName = embeddedTable.ModelName - } - continue - } - } - - // If field is not a struct, add it. - // This will also add any embedded non-struct type as a field. - if field := t.newField(f, prefix, index); field != nil { - t.addField(field) - } - } -} - -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 != "" { - t.setName(tag.Name) - } - - if s, ok := tag.Option("table"); ok { - 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) - } -} - -//nolint -func (t *Table) newField(f reflect.StructField, prefix string, index []int) *Field { - tag := tagparser.Parse(f.Tag.Get("bun")) - - if prefix, ok := tag.Option("embed"); ok { - fieldType := indirectType(f.Type) - if fieldType.Kind() != reflect.Struct { - panic(fmt.Errorf("bun: embed %s.%s: got %s, wanted reflect.Struct", - t.TypeName, f.Name, fieldType.Kind())) - } - t.addFields(fieldType, prefix, withIndex(index, f.Index)) - return nil - } - - sqlName := internal.Underscore(f.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, f.Name, tag.Name, tag.Name, - ) - } - sqlName = tag.Name - } - if s, ok := tag.Option("column"); ok { - sqlName = s - } - sqlName = prefix + sqlName - - for name := range tag.Options { - if !isKnownFieldOption(name) { - internal.Warn.Printf("%s.%s has unknown tag option: %q", t.TypeName, f.Name, name) - } - } - - index = withIndex(index, f.Index) - if field := t.fieldWithLock(sqlName); field != nil { - if indexEqual(field.Index, index) { - return field - } - t.removeField(field) - } - - field := &Field{ - StructField: f, - IsPtr: f.Type.Kind() == reflect.Ptr, - - Tag: tag, - IndirectType: indirectType(f.Type), - Index: index, - - Name: sqlName, - GoName: f.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 { - var names []string - if len(v) == 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(v[0], ",") - } else { - names = v - } - - for _, uniqueName := range names { - if t.Unique == nil { - t.Unique = make(map[string][]*Field) - } - t.Unique[uniqueName] = append(t.Unique[uniqueName], field) - } - } - if s, ok := tag.Option("default"); ok { - field.SQLDefault = s - field.NullZero = true - } - 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) - - if v, ok := tag.Option("alt"); ok { - t.FieldMap[v] = field - } - - t.allFields = append(t.allFields, field) - if tag.HasOption("scanonly") { - t.FieldMap[field.Name] = field - if field.IndirectType.Kind() == reflect.Struct { - t.inlineFields(field, nil) - } - return nil - } - - if _, ok := tag.Options["soft_delete"]; ok { - t.SoftDeleteField = field - t.UpdateSoftDeleteField = softDeleteFieldUpdater(field) - } - - return field -} - -//--------------------------------------------------------------------------------------- - -func (t *Table) initRelations() { - for i := 0; i < len(t.Fields); { - f := t.Fields[i] - if t.tryRelation(f) { - t.Fields = removeField(t.Fields, f) - t.DataFields = removeField(t.DataFields, f) - } else { - i++ - } - - if f.IndirectType.Kind() == reflect.Struct { - t.inlineFields(f, nil) - } - } -} - -func (t *Table) tryRelation(field *Field) bool { - if rel, ok := field.Tag.Option("rel"); ok { - t.initRelation(field, rel) - return true - } - if field.Tag.HasOption("m2m") { - t.addRelation(t.m2mRelation(field)) - return true - } - - if field.Tag.HasOption("join") { - internal.Warn.Printf( - `%s.%s "join" option must come together with "rel" option`, - t.TypeName, field.GoName, - ) - } - - return false -} - -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().Ref(field.IndirectType) - if err := joinTable.CheckPKs(); err != nil { - panic(err) - } - - rel := &Relation{ - Type: HasOneRelation, - 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.fieldWithLock(baseColumn); f != nil { - rel.BaseFields = append(rel.BaseFields, 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.fieldWithLock(joinColumn); f != nil { - rel.JoinFields = append(rel.JoinFields, f) - } else { - panic(fmt.Errorf( - "bun: %s belongs-to %s: %s must have column %s", - t.TypeName, field.GoName, t.TypeName, baseColumn, - )) - } - } - return rel - } - - rel.JoinFields = joinTable.PKs - fkPrefix := internal.Underscore(field.GoName) + "_" - for _, joinPK := range joinTable.PKs { - fkName := fkPrefix + joinPK.Name - if fk := t.fieldWithLock(fkName); fk != nil { - rel.BaseFields = append(rel.BaseFields, fk) - continue - } - - if fk := t.fieldWithLock(joinPK.Name); fk != nil { - rel.BaseFields = append(rel.BaseFields, 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().Ref(field.IndirectType) - rel := &Relation{ - Type: BelongsToRelation, - 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.fieldWithLock(baseColumn); f != nil { - rel.BaseFields = append(rel.BaseFields, f) - } else { - panic(fmt.Errorf( - "bun: %s has-one %s: %s must have column %s", - field.GoName, t.TypeName, joinTable.TypeName, baseColumn, - )) - } - - joinColumn := joinColumns[i] - if f := joinTable.fieldWithLock(joinColumn); f != nil { - rel.JoinFields = append(rel.JoinFields, f) - } else { - panic(fmt.Errorf( - "bun: %s has-one %s: %s must have column %s", - field.GoName, t.TypeName, joinTable.TypeName, baseColumn, - )) - } - } - return rel - } - - rel.BaseFields = t.PKs - fkPrefix := internal.Underscore(t.ModelName) + "_" - for _, pk := range t.PKs { - fkName := fkPrefix + pk.Name - if f := joinTable.fieldWithLock(fkName); f != nil { - rel.JoinFields = append(rel.JoinFields, f) - continue - } - - if f := joinTable.fieldWithLock(pk.Name); f != nil { - rel.JoinFields = append(rel.JoinFields, 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().Ref(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.fieldWithLock(baseColumn); f != nil { - rel.BaseFields = append(rel.BaseFields, 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.fieldWithLock(joinColumn); f != nil { - rel.JoinFields = append(rel.JoinFields, f) - } else { - panic(fmt.Errorf( - "bun: %s has-many %s: %s must have column %s", - t.TypeName, field.GoName, t.TypeName, baseColumn, - )) - } - } - } else { - rel.BaseFields = t.PKs - fkPrefix := internal.Underscore(t.ModelName) + "_" - if isPolymorphic { - polymorphicColumn = fkPrefix + "type" - } - - for _, pk := range t.PKs { - joinColumn := fkPrefix + pk.Name - if fk := joinTable.fieldWithLock(joinColumn); fk != nil { - rel.JoinFields = append(rel.JoinFields, fk) - continue - } - - if fk := joinTable.fieldWithLock(pk.Name); fk != nil { - rel.JoinFields = append(rel.JoinFields, 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.fieldWithLock(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().Ref(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.BaseFields = leftRel.JoinFields - rel.M2MBaseFields = leftRel.BaseFields - - rightRel := m2mTable.belongsToRelation(rightField) - rel.JoinFields = rightRel.JoinFields - rel.M2MJoinFields = rightRel.BaseFields - - return rel -} - -func (t *Table) inlineFields(field *Field, seen map[reflect.Type]struct{}) { - if seen == nil { - seen = map[reflect.Type]struct{}{t.Type: {}} - } - - if _, ok := seen[field.IndirectType]; ok { - return - } - seen[field.IndirectType] = struct{}{} - - joinTable := t.dialect.Tables().Ref(field.IndirectType) - for _, f := range joinTable.allFields { - f = f.Clone() - f.GoName = field.GoName + "_" + f.GoName - f.Name = field.Name + "__" + f.Name - f.SQLName = t.quoteIdent(f.Name) - f.Index = withIndex(field.Index, f.Index) - - t.fieldsMapMu.Lock() - if _, ok := t.FieldMap[f.Name]; !ok { - t.FieldMap[f.Name] = f - } - t.fieldsMapMu.Unlock() - - if f.IndirectType.Kind() != reflect.Struct { - continue - } - - if _, ok := seen[f.IndirectType]; !ok { - t.inlineFields(f, seen) - } - } -} - -//------------------------------------------------------------------------------ - -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", - "alias", - "type", - "array", - "hstore", - "composite", - "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 removeField(fields []*Field, field *Field) []*Field { - for i, f := range fields { - if f == field { - return append(fields[:i], fields[i+1:]...) - } - } - return fields -} - -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 withIndex(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 b6215a14a..000000000 --- a/vendor/github.com/uptrace/bun/schema/tables.go +++ /dev/null @@ -1,151 +0,0 @@ -package schema - -import ( - "fmt" - "reflect" - "sync" -) - -type tableInProgress struct { - table *Table - - init1Once sync.Once - init2Once sync.Once -} - -func newTableInProgress(table *Table) *tableInProgress { - return &tableInProgress{ - table: table, - } -} - -func (inp *tableInProgress) init1() bool { - var inited bool - inp.init1Once.Do(func() { - inp.table.init1() - inited = true - }) - return inited -} - -func (inp *tableInProgress) init2() bool { - var inited bool - inp.init2Once.Do(func() { - inp.table.init2() - inited = true - }) - return inited -} - -type Tables struct { - dialect Dialect - tables sync.Map - - mu sync.RWMutex - inProgress map[reflect.Type]*tableInProgress -} - -func NewTables(dialect Dialect) *Tables { - return &Tables{ - dialect: dialect, - inProgress: make(map[reflect.Type]*tableInProgress), - } -} - -func (t *Tables) Register(models ...interface{}) { - for _, model := range models { - _ = t.Get(reflect.TypeOf(model).Elem()) - } -} - -func (t *Tables) Get(typ reflect.Type) *Table { - return t.table(typ, false) -} - -func (t *Tables) Ref(typ reflect.Type) *Table { - return t.table(typ, true) -} - -func (t *Tables) table(typ reflect.Type, allowInProgress bool) *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.(*Table) - } - - t.mu.Lock() - - if v, ok := t.tables.Load(typ); ok { - t.mu.Unlock() - return v.(*Table) - } - - var table *Table - - inProgress := t.inProgress[typ] - if inProgress == nil { - table = newTable(t.dialect, typ) - inProgress = newTableInProgress(table) - t.inProgress[typ] = inProgress - } else { - table = inProgress.table - } - - t.mu.Unlock() - - inProgress.init1() - if allowInProgress { - return table - } - - if !inProgress.init2() { - return table - } - - t.mu.Lock() - delete(t.inProgress, typ) - t.tables.Store(typ, table) - t.mu.Unlock() - - t.dialect.OnTable(table) - - for _, field := range table.FieldMap { - if field.UserSQLType == "" { - field.UserSQLType = field.DiscoveredSQLType - } - if field.CreateTableSQLType == "" { - field.CreateTableSQLType = field.UserSQLType - } - } - - return table -} - -func (t *Tables) ByModel(name string) *Table { - var found *Table - t.tables.Range(func(key, value interface{}) bool { - t := value.(*Table) - if t.TypeName == name { - found = t - return false - } - return true - }) - return found -} - -func (t *Tables) ByName(name string) *Table { - var found *Table - t.tables.Range(func(key, value interface{}) bool { - t := value.(*Table) - if t.Name == name { - found = t - return false - } - 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 f088b8c2c..000000000 --- a/vendor/github.com/uptrace/bun/schema/zerochecker.go +++ /dev/null @@ -1,122 +0,0 @@ -package schema - -import ( - "database/sql/driver" - "reflect" -) - -var isZeroerType = reflect.TypeOf((*isZeroer)(nil)).Elem() - -type isZeroer interface { - IsZero() bool -} - -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.PtrTo(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 ce56be805..000000000 --- a/vendor/github.com/uptrace/bun/util.go +++ /dev/null @@ -1,114 +0,0 @@ -package bun - -import "reflect" - -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) -} - -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 - } - } - - sliceType := v.Type() - elemType := sliceType.Elem() - - if elemType.Kind() == reflect.Ptr { - elemType = elemType.Elem() - return func() reflect.Value { - if v.Len() < v.Cap() { - v.Set(v.Slice(0, v.Len()+1)) - elem := v.Index(v.Len() - 1) - if elem.IsNil() { - elem.Set(reflect.New(elemType)) - } - return elem.Elem() - } - - elem := reflect.New(elemType) - v.Set(reflect.Append(v, elem)) - return elem.Elem() - } - } - - zero := reflect.Zero(elemType) - return func() reflect.Value { - l := v.Len() - c := v.Cap() - - if l < c { - v.Set(v.Slice(0, l+1)) - return v.Index(l) - } - - v.Set(reflect.Append(v, zero)) - return v.Index(l) - } -} diff --git a/vendor/github.com/uptrace/bun/version.go b/vendor/github.com/uptrace/bun/version.go deleted file mode 100644 index 8d17c97b3..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.1.7" -} |